override virtual functions in parent classes

bluetooth/bluetooth.cpp

@@ -15,6 +15,8 @@
 #include <QBluetoothTransferRequest>
 #include <QBluetoothUuid>
 #include <QByteArray>
+#include <QChildEvent>
+#include <QEvent>
 #include <QIODevice>
 #include <QLowEnergyCharacteristic>
 #include <QLowEnergyController>
@@ -23,6 +25,9 @@
 #include <QMetaObject>
 #include <QObject>
 #include <QString>
+#include <QTime>
+#include <QTimer>
+#include <QTimerEvent>
 #include <QUuid>
 #include <QVariant>
 
@@ -60,6 +65,9 @@ public:
 	void Signal_Error2(QBluetoothDeviceDiscoveryAgent::Error error) { callbackQBluetoothDeviceDiscoveryAgentError2(this->objectName().toUtf8().data(), error); };
 	void Signal_Finished() { callbackQBluetoothDeviceDiscoveryAgentFinished(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothDeviceDiscoveryAgentTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothDeviceDiscoveryAgent::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothDeviceDiscoveryAgentChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothDeviceDiscoveryAgent::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothDeviceDiscoveryAgentCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothDeviceDiscoveryAgent::customEvent(event); }; };
 };
 
 void QBluetoothDeviceDiscoveryAgent_ConnectCanceled(void* ptr){
@@ -209,6 +217,9 @@ public:
 	void Signal_Error(QBluetoothLocalDevice::Error error) { callbackQBluetoothLocalDeviceError(this->objectName().toUtf8().data(), error); };
 	void Signal_HostModeStateChanged(QBluetoothLocalDevice::HostMode state) { callbackQBluetoothLocalDeviceHostModeStateChanged(this->objectName().toUtf8().data(), state); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothLocalDeviceTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothLocalDevice::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothLocalDeviceChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothLocalDevice::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothLocalDeviceCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothLocalDevice::customEvent(event); }; };
 };
 
 void QBluetoothLocalDevice_ConnectError(void* ptr){
@@ -276,6 +287,9 @@ public:
 	void Signal_Error2(QBluetoothServer::Error error) { callbackQBluetoothServerError2(this->objectName().toUtf8().data(), error); };
 	void Signal_NewConnection() { callbackQBluetoothServerNewConnection(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothServerTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServer::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothServerChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServer::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothServerCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServer::customEvent(event); }; };
 };
 
 void* QBluetoothServer_NewQBluetoothServer(int serverType, void* parent){
@@ -340,6 +354,9 @@ public:
 	void Signal_Error2(QBluetoothServiceDiscoveryAgent::Error error) { callbackQBluetoothServiceDiscoveryAgentError2(this->objectName().toUtf8().data(), error); };
 	void Signal_Finished() { callbackQBluetoothServiceDiscoveryAgentFinished(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothServiceDiscoveryAgentTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServiceDiscoveryAgent::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothServiceDiscoveryAgentChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServiceDiscoveryAgent::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothServiceDiscoveryAgentCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothServiceDiscoveryAgent::customEvent(event); }; };
 };
 
 void QBluetoothServiceDiscoveryAgent_ConnectCanceled(void* ptr){
@@ -508,6 +525,9 @@ public:
 	void Signal_StateChanged(QBluetoothSocket::SocketState state) { callbackQBluetoothSocketStateChanged(this->objectName().toUtf8().data(), state); };
 	void close() { if (!callbackQBluetoothSocketClose(this->objectName().toUtf8().data())) { QBluetoothSocket::close(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothSocketTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothSocket::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothSocketChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothSocket::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothSocketCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothSocket::customEvent(event); }; };
 };
 
 void QBluetoothSocket_ConnectConnected(void* ptr){
@@ -626,6 +646,9 @@ class MyQBluetoothTransferManager: public QBluetoothTransferManager {
 public:
 	void Signal_Finished(QBluetoothTransferReply * reply) { callbackQBluetoothTransferManagerFinished(this->objectName().toUtf8().data(), reply); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothTransferManagerTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferManager::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothTransferManagerChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferManager::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothTransferManagerCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferManager::customEvent(event); }; };
 };
 
 void* QBluetoothTransferManager_Put(void* ptr, void* request, void* data){
@@ -654,6 +677,9 @@ public:
 	void Signal_Finished(QBluetoothTransferReply * reply) { callbackQBluetoothTransferReplyFinished(this->objectName().toUtf8().data(), reply); };
 	void Signal_TransferProgress(qint64 bytesTransferred, qint64 bytesTotal) { callbackQBluetoothTransferReplyTransferProgress(this->objectName().toUtf8().data(), static_cast<long long>(bytesTransferred), static_cast<long long>(bytesTotal)); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBluetoothTransferReplyTimerEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferReply::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBluetoothTransferReplyChildEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferReply::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBluetoothTransferReplyCustomEvent(this->objectName().toUtf8().data(), event)) { QBluetoothTransferReply::customEvent(event); }; };
 };
 
 void QBluetoothTransferReply_Abort(void* ptr){
@@ -820,6 +846,9 @@ public:
 	void Signal_Error2(QLowEnergyController::Error newError) { callbackQLowEnergyControllerError2(this->objectName().toUtf8().data(), newError); };
 	void Signal_StateChanged(QLowEnergyController::ControllerState state) { callbackQLowEnergyControllerStateChanged(this->objectName().toUtf8().data(), state); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQLowEnergyControllerTimerEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyController::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQLowEnergyControllerChildEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyController::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQLowEnergyControllerCustomEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyController::customEvent(event); }; };
 };
 
 void QLowEnergyController_ConnectConnected(void* ptr){
@@ -943,6 +972,9 @@ public:
 	void Signal_Error2(QLowEnergyService::ServiceError newError) { callbackQLowEnergyServiceError2(this->objectName().toUtf8().data(), newError); };
 	void Signal_StateChanged(QLowEnergyService::ServiceState newState) { callbackQLowEnergyServiceStateChanged(this->objectName().toUtf8().data(), newState); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQLowEnergyServiceTimerEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyService::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQLowEnergyServiceChildEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyService::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQLowEnergyServiceCustomEvent(this->objectName().toUtf8().data(), event)) { QLowEnergyService::customEvent(event); }; };
 };
 
 void QLowEnergyService_ConnectError2(void* ptr){

bluetooth/qbluetoothdevicediscoveryagent.go

@@ -221,3 +221,93 @@ func (ptr *QBluetoothDeviceDiscoveryAgent) DestroyQBluetoothDeviceDiscoveryAgent
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothDeviceDiscoveryAgent::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothDeviceDiscoveryAgent::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothDeviceDiscoveryAgentTimerEvent
+func callbackQBluetoothDeviceDiscoveryAgentTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothDeviceDiscoveryAgent::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothDeviceDiscoveryAgent::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothDeviceDiscoveryAgent::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothDeviceDiscoveryAgentChildEvent
+func callbackQBluetoothDeviceDiscoveryAgentChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothDeviceDiscoveryAgent::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothDeviceDiscoveryAgent::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothDeviceDiscoveryAgent) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothDeviceDiscoveryAgent::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothDeviceDiscoveryAgentCustomEvent
+func callbackQBluetoothDeviceDiscoveryAgentCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothDeviceDiscoveryAgent::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothlocaldevice.go

@@ -209,3 +209,93 @@ func (ptr *QBluetoothLocalDevice) SetHostMode(mode QBluetoothLocalDevice__HostMo
 		C.QBluetoothLocalDevice_SetHostMode(ptr.Pointer(), C.int(mode))
 	}
 }
+
+func (ptr *QBluetoothLocalDevice) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothLocalDeviceTimerEvent
+func callbackQBluetoothLocalDeviceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothLocalDevice::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothLocalDevice) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothLocalDeviceChildEvent
+func callbackQBluetoothLocalDeviceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothLocalDevice::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothLocalDevice) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothLocalDevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothLocalDevice) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothLocalDevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothLocalDeviceCustomEvent
+func callbackQBluetoothLocalDeviceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothLocalDevice::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothserver.go

@@ -189,3 +189,93 @@ func (ptr *QBluetoothServer) SetMaxPendingConnections(numConnections int) {
 		C.QBluetoothServer_SetMaxPendingConnections(ptr.Pointer(), C.int(numConnections))
 	}
 }
+
+func (ptr *QBluetoothServer) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothServer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServer) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothServer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothServerTimerEvent
+func callbackQBluetoothServerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServer::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothServer) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothServer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServer) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothServer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothServerChildEvent
+func callbackQBluetoothServerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServer::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothServer) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothServer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServer) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothServer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothServerCustomEvent
+func callbackQBluetoothServerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServer::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothservicediscoveryagent.go

@@ -228,3 +228,93 @@ func (ptr *QBluetoothServiceDiscoveryAgent) DestroyQBluetoothServiceDiscoveryAge
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBluetoothServiceDiscoveryAgent) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothServiceDiscoveryAgent::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothServiceDiscoveryAgent::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothServiceDiscoveryAgentTimerEvent
+func callbackQBluetoothServiceDiscoveryAgentTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServiceDiscoveryAgent::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothServiceDiscoveryAgent::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothServiceDiscoveryAgent::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothServiceDiscoveryAgentChildEvent
+func callbackQBluetoothServiceDiscoveryAgentChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServiceDiscoveryAgent::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothServiceDiscoveryAgent::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothServiceDiscoveryAgent) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothServiceDiscoveryAgent::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothServiceDiscoveryAgentCustomEvent
+func callbackQBluetoothServiceDiscoveryAgentCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothServiceDiscoveryAgent::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothsocket.go

@@ -366,3 +366,93 @@ func (ptr *QBluetoothSocket) DestroyQBluetoothSocket() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBluetoothSocket) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothSocket::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothSocket) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothSocket::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothSocketTimerEvent
+func callbackQBluetoothSocketTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothSocket::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothSocket) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothSocket::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothSocket) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothSocket::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothSocketChildEvent
+func callbackQBluetoothSocketChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothSocket::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothSocket) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothSocket::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothSocket) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothSocket::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothSocketCustomEvent
+func callbackQBluetoothSocketCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothSocket::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothtransfermanager.go

@@ -88,3 +88,93 @@ func (ptr *QBluetoothTransferManager) DestroyQBluetoothTransferManager() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBluetoothTransferManager) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferManager::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferManager) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferManager::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothTransferManagerTimerEvent
+func callbackQBluetoothTransferManagerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferManager::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothTransferManager) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferManager::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferManager) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferManager::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothTransferManagerChildEvent
+func callbackQBluetoothTransferManagerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferManager::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothTransferManager) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferManager::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferManager) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferManager::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothTransferManagerCustomEvent
+func callbackQBluetoothTransferManagerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferManager::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qbluetoothtransferreply.go

@@ -196,3 +196,93 @@ func (ptr *QBluetoothTransferReply) DestroyQBluetoothTransferReply() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBluetoothTransferReply) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferReply::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferReply) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferReply::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBluetoothTransferReplyTimerEvent
+func callbackQBluetoothTransferReplyTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferReply::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothTransferReply) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferReply::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferReply) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferReply::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBluetoothTransferReplyChildEvent
+func callbackQBluetoothTransferReplyChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferReply::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBluetoothTransferReply) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QBluetoothTransferReply::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBluetoothTransferReply) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBluetoothTransferReply::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBluetoothTransferReplyCustomEvent
+func callbackQBluetoothTransferReplyCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBluetoothTransferReply::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qlowenergycontroller.go

@@ -309,3 +309,93 @@ func (ptr *QLowEnergyController) DestroyQLowEnergyController() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QLowEnergyController) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QLowEnergyController::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyController) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QLowEnergyController::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQLowEnergyControllerTimerEvent
+func callbackQLowEnergyControllerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyController::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLowEnergyController) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QLowEnergyController::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyController) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QLowEnergyController::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQLowEnergyControllerChildEvent
+func callbackQLowEnergyControllerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyController::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLowEnergyController) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QLowEnergyController::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyController) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QLowEnergyController::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQLowEnergyControllerCustomEvent
+func callbackQLowEnergyControllerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyController::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

bluetooth/qlowenergyservice.go

@@ -234,3 +234,93 @@ func (ptr *QLowEnergyService) DestroyQLowEnergyService() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QLowEnergyService) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QLowEnergyService::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QLowEnergyService::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQLowEnergyServiceTimerEvent
+func callbackQLowEnergyServiceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyService::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLowEnergyService) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QLowEnergyService::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QLowEnergyService::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQLowEnergyServiceChildEvent
+func callbackQLowEnergyServiceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyService::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLowEnergyService) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QLowEnergyService::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QLowEnergyService) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QLowEnergyService::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQLowEnergyServiceCustomEvent
+func callbackQLowEnergyServiceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLowEnergyService::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/core.cpp

@@ -172,6 +172,9 @@ public:
 protected:
 	void updateDirection(QAbstractAnimation::Direction direction) { if (!callbackQAbstractAnimationUpdateDirection(this->objectName().toUtf8().data(), direction)) { QAbstractAnimation::updateDirection(direction); }; };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { if (!callbackQAbstractAnimationUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QAbstractAnimation::updateState(newState, oldState); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractAnimationTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractAnimation::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractAnimationChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractAnimation::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractAnimationCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractAnimation::customEvent(event); }; };
 };
 
 int QAbstractAnimation_CurrentLoop(void* ptr){
@@ -283,6 +286,9 @@ public:
 	void Signal_AboutToBlock() { callbackQAbstractEventDispatcherAboutToBlock(this->objectName().toUtf8().data()); };
 	void Signal_Awake() { callbackQAbstractEventDispatcherAwake(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractEventDispatcherTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractEventDispatcher::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractEventDispatcherChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractEventDispatcher::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractEventDispatcherCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractEventDispatcher::customEvent(event); }; };
 };
 
 void QAbstractEventDispatcher_ConnectAboutToBlock(void* ptr){
@@ -374,6 +380,9 @@ public:
 	void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModelRowsRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), first, last); };
 	void sort(int column, Qt::SortOrder order) { if (!callbackQAbstractItemModelSort(this->objectName().toUtf8().data(), column, order)) { QAbstractItemModel::sort(column, order); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractItemModelTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractItemModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractItemModelChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractItemModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractItemModelCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractItemModel::customEvent(event); }; };
 };
 
 void* QAbstractItemModel_Sibling(void* ptr, int row, int column, void* index){
@@ -646,7 +655,13 @@ void QAbstractItemModel_DestroyQAbstractItemModel(void* ptr){
 
 class MyQAbstractListModel: public QAbstractListModel {
 public:
+	void fetchMore(const QModelIndex & parent) { if (!callbackQAbstractListModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QAbstractListModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQAbstractListModelRevert(this->objectName().toUtf8().data())) { QAbstractListModel::revert(); }; };
+	void sort(int column, Qt::SortOrder order) { if (!callbackQAbstractListModelSort(this->objectName().toUtf8().data(), column, order)) { QAbstractListModel::sort(column, order); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractListModelTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractListModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractListModelChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractListModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractListModelCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractListModel::customEvent(event); }; };
 };
 
 void* QAbstractListModel_Index(void* ptr, int row, int column, void* parent){
@@ -697,6 +712,9 @@ public:
 	void sort(int column, Qt::SortOrder order) { if (!callbackQAbstractProxyModelSort(this->objectName().toUtf8().data(), column, order)) { QAbstractProxyModel::sort(column, order); }; };
 	void Signal_SourceModelChanged() { callbackQAbstractProxyModelSourceModelChanged(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractProxyModelTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractProxyModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractProxyModelChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractProxyModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractProxyModelCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractProxyModel::customEvent(event); }; };
 };
 
 void* QAbstractProxyModel_Buddy(void* ptr, void* index){
@@ -809,6 +827,9 @@ public:
 	void Signal_Entered() { callbackQAbstractStateEntered(this->objectName().toUtf8().data()); };
 	void Signal_Exited() { callbackQAbstractStateExited(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractStateTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractState::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractStateChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractState::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractStateCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractState::customEvent(event); }; };
 };
 
 int QAbstractState_Active(void* ptr){
@@ -853,7 +874,13 @@ void QAbstractState_DestroyQAbstractState(void* ptr){
 
 class MyQAbstractTableModel: public QAbstractTableModel {
 public:
+	void fetchMore(const QModelIndex & parent) { if (!callbackQAbstractTableModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QAbstractTableModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQAbstractTableModelRevert(this->objectName().toUtf8().data())) { QAbstractTableModel::revert(); }; };
+	void sort(int column, Qt::SortOrder order) { if (!callbackQAbstractTableModelSort(this->objectName().toUtf8().data(), column, order)) { QAbstractTableModel::sort(column, order); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractTableModelTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractTableModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractTableModelChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractTableModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractTableModelCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractTableModel::customEvent(event); }; };
 };
 
 void* QAbstractTableModel_Index(void* ptr, int row, int column, void* parent){
@@ -882,6 +909,9 @@ public:
 	void Signal_TargetStatesChanged() { callbackQAbstractTransitionTargetStatesChanged(this->objectName().toUtf8().data()); };
 	void Signal_Triggered() { callbackQAbstractTransitionTriggered(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractTransitionTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractTransition::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractTransitionChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractTransition::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractTransitionCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractTransition::customEvent(event); }; };
 };
 
 void QAbstractTransition_AddAnimation(void* ptr, void* animation){
@@ -1070,6 +1100,9 @@ public:
 	MyQBuffer(QObject *parent) : QBuffer(parent) {};
 	void close() { if (!callbackQBufferClose(this->objectName().toUtf8().data())) { QBuffer::close(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQBufferTimerEvent(this->objectName().toUtf8().data(), event)) { QBuffer::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQBufferChildEvent(this->objectName().toUtf8().data(), event)) { QBuffer::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQBufferCustomEvent(this->objectName().toUtf8().data(), event)) { QBuffer::customEvent(event); }; };
 };
 
 void* QBuffer_NewQBuffer2(void* byteArray, void* parent){
@@ -1885,6 +1918,9 @@ public:
 	MyQCoreApplication(int &argc, char **argv) : QCoreApplication(argc, argv) {};
 	void Signal_AboutToQuit() { callbackQCoreApplicationAboutToQuit(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQCoreApplicationTimerEvent(this->objectName().toUtf8().data(), event)) { QCoreApplication::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQCoreApplicationChildEvent(this->objectName().toUtf8().data(), event)) { QCoreApplication::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQCoreApplicationCustomEvent(this->objectName().toUtf8().data(), event)) { QCoreApplication::customEvent(event); }; };
 };
 
 char* QCoreApplication_QCoreApplication_ApplicationName(){
@@ -2882,6 +2918,9 @@ class MyQEventLoop: public QEventLoop {
 public:
 	MyQEventLoop(QObject *parent) : QEventLoop(parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQEventLoopTimerEvent(this->objectName().toUtf8().data(), event)) { QEventLoop::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQEventLoopChildEvent(this->objectName().toUtf8().data(), event)) { QEventLoop::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQEventLoopCustomEvent(this->objectName().toUtf8().data(), event)) { QEventLoop::customEvent(event); }; };
 };
 
 void* QEventLoop_NewQEventLoop(void* parent){
@@ -2946,6 +2985,9 @@ public:
 	MyQEventTransition(QState *sourceState) : QEventTransition(sourceState) {};
 protected:
 	void onTransition(QEvent * event) { if (!callbackQEventTransitionOnTransition(this->objectName().toUtf8().data(), event)) { QEventTransition::onTransition(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQEventTransitionTimerEvent(this->objectName().toUtf8().data(), event)) { QEventTransition::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQEventTransitionChildEvent(this->objectName().toUtf8().data(), event)) { QEventTransition::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQEventTransitionCustomEvent(this->objectName().toUtf8().data(), event)) { QEventTransition::customEvent(event); }; };
 };
 
 void* QEventTransition_NewQEventTransition2(void* object, int ty, void* sourceState){
@@ -2982,6 +3024,9 @@ public:
 	MyQFile(const QString &name) : QFile(name) {};
 	MyQFile(const QString &name, QObject *parent) : QFile(name, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQFileTimerEvent(this->objectName().toUtf8().data(), event)) { QFile::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQFileChildEvent(this->objectName().toUtf8().data(), event)) { QFile::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQFileCustomEvent(this->objectName().toUtf8().data(), event)) { QFile::customEvent(event); }; };
 };
 
 void* QFile_NewQFile3(void* parent){
@@ -3098,8 +3143,10 @@ void QFile_DestroyQFile(void* ptr){
 
 class MyQFileDevice: public QFileDevice {
 public:
-	void close() { if (!callbackQFileDeviceClose(this->objectName().toUtf8().data())) { QFileDevice::close(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQFileDeviceTimerEvent(this->objectName().toUtf8().data(), event)) { QFileDevice::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQFileDeviceChildEvent(this->objectName().toUtf8().data(), event)) { QFileDevice::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQFileDeviceCustomEvent(this->objectName().toUtf8().data(), event)) { QFileDevice::customEvent(event); }; };
 };
 
 int QFileDevice_Seek(void* ptr, long long pos){
@@ -3391,6 +3438,9 @@ public:
 	void Signal_DirectoryChanged(const QString & path) { callbackQFileSystemWatcherDirectoryChanged(this->objectName().toUtf8().data(), path.toUtf8().data()); };
 	void Signal_FileChanged(const QString & path) { callbackQFileSystemWatcherFileChanged(this->objectName().toUtf8().data(), path.toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQFileSystemWatcherTimerEvent(this->objectName().toUtf8().data(), event)) { QFileSystemWatcher::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQFileSystemWatcherChildEvent(this->objectName().toUtf8().data(), event)) { QFileSystemWatcher::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQFileSystemWatcherCustomEvent(this->objectName().toUtf8().data(), event)) { QFileSystemWatcher::customEvent(event); }; };
 };
 
 char* QFileSystemWatcher_Directories(void* ptr){
@@ -3451,6 +3501,9 @@ public:
 protected:
 	void onEntry(QEvent * event) { if (!callbackQFinalStateOnEntry(this->objectName().toUtf8().data(), event)) { QFinalState::onEntry(event); }; };
 	void onExit(QEvent * event) { if (!callbackQFinalStateOnExit(this->objectName().toUtf8().data(), event)) { QFinalState::onExit(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQFinalStateTimerEvent(this->objectName().toUtf8().data(), event)) { QFinalState::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQFinalStateChildEvent(this->objectName().toUtf8().data(), event)) { QFinalState::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQFinalStateCustomEvent(this->objectName().toUtf8().data(), event)) { QFinalState::customEvent(event); }; };
 };
 
 void* QFinalState_NewQFinalState(void* parent){
@@ -3478,6 +3531,9 @@ public:
 protected:
 	void onEntry(QEvent * event) { if (!callbackQHistoryStateOnEntry(this->objectName().toUtf8().data(), event)) { QHistoryState::onEntry(event); }; };
 	void onExit(QEvent * event) { if (!callbackQHistoryStateOnExit(this->objectName().toUtf8().data(), event)) { QHistoryState::onExit(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQHistoryStateTimerEvent(this->objectName().toUtf8().data(), event)) { QHistoryState::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHistoryStateChildEvent(this->objectName().toUtf8().data(), event)) { QHistoryState::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHistoryStateCustomEvent(this->objectName().toUtf8().data(), event)) { QHistoryState::customEvent(event); }; };
 };
 
 void* QHistoryState_NewQHistoryState2(int ty, void* parent){
@@ -3532,6 +3588,9 @@ public:
 	void Signal_ReadChannelFinished() { callbackQIODeviceReadChannelFinished(this->objectName().toUtf8().data()); };
 	void Signal_ReadyRead() { callbackQIODeviceReadyRead(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQIODeviceTimerEvent(this->objectName().toUtf8().data(), event)) { QIODevice::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQIODeviceChildEvent(this->objectName().toUtf8().data(), event)) { QIODevice::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQIODeviceCustomEvent(this->objectName().toUtf8().data(), event)) { QIODevice::customEvent(event); }; };
 };
 
 int QIODevice_GetChar(void* ptr, char* c){
@@ -3706,7 +3765,13 @@ class MyQIdentityProxyModel: public QIdentityProxyModel {
 public:
 	MyQIdentityProxyModel(QObject *parent) : QIdentityProxyModel(parent) {};
 	void setSourceModel(QAbstractItemModel * newSourceModel) { if (!callbackQIdentityProxyModelSetSourceModel(this->objectName().toUtf8().data(), newSourceModel)) { QIdentityProxyModel::setSourceModel(newSourceModel); }; };
+	void fetchMore(const QModelIndex & parent) { if (!callbackQIdentityProxyModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QIdentityProxyModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQIdentityProxyModelRevert(this->objectName().toUtf8().data())) { QIdentityProxyModel::revert(); }; };
+	void sort(int column, Qt::SortOrder order) { if (!callbackQIdentityProxyModelSort(this->objectName().toUtf8().data(), column, order)) { QIdentityProxyModel::sort(column, order); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQIdentityProxyModelTimerEvent(this->objectName().toUtf8().data(), event)) { QIdentityProxyModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQIdentityProxyModelChildEvent(this->objectName().toUtf8().data(), event)) { QIdentityProxyModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQIdentityProxyModelCustomEvent(this->objectName().toUtf8().data(), event)) { QIdentityProxyModel::customEvent(event); }; };
 };
 
 void* QIdentityProxyModel_NewQIdentityProxyModel(void* parent){
@@ -3811,6 +3876,9 @@ public:
 	void select(const QModelIndex & index, QItemSelectionModel::SelectionFlags command) { if (!callbackQItemSelectionModelSelect(this->objectName().toUtf8().data(), index.internalPointer(), command)) { QItemSelectionModel::select(index, command); }; };
 	void setCurrentIndex(const QModelIndex & index, QItemSelectionModel::SelectionFlags command) { if (!callbackQItemSelectionModelSetCurrentIndex(this->objectName().toUtf8().data(), index.internalPointer(), command)) { QItemSelectionModel::setCurrentIndex(index, command); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQItemSelectionModelTimerEvent(this->objectName().toUtf8().data(), event)) { QItemSelectionModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQItemSelectionModelChildEvent(this->objectName().toUtf8().data(), event)) { QItemSelectionModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQItemSelectionModelCustomEvent(this->objectName().toUtf8().data(), event)) { QItemSelectionModel::customEvent(event); }; };
 };
 
 void* QItemSelectionModel_NewQItemSelectionModel(void* model){
@@ -5281,6 +5349,9 @@ class MyQMimeData: public QMimeData {
 public:
 	MyQMimeData() : QMimeData() {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQMimeDataTimerEvent(this->objectName().toUtf8().data(), event)) { QMimeData::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQMimeDataChildEvent(this->objectName().toUtf8().data(), event)) { QMimeData::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQMimeDataCustomEvent(this->objectName().toUtf8().data(), event)) { QMimeData::customEvent(event); }; };
 };
 
 void* QMimeData_NewQMimeData(){
@@ -5696,6 +5767,9 @@ protected:
 	void updateCurrentTime(int currentTime) { if (!callbackQParallelAnimationGroupUpdateCurrentTime(this->objectName().toUtf8().data(), currentTime)) { QParallelAnimationGroup::updateCurrentTime(currentTime); }; };
 	void updateDirection(QAbstractAnimation::Direction direction) { if (!callbackQParallelAnimationGroupUpdateDirection(this->objectName().toUtf8().data(), direction)) { QParallelAnimationGroup::updateDirection(direction); }; };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { if (!callbackQParallelAnimationGroupUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QParallelAnimationGroup::updateState(newState, oldState); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQParallelAnimationGroupTimerEvent(this->objectName().toUtf8().data(), event)) { QParallelAnimationGroup::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQParallelAnimationGroupChildEvent(this->objectName().toUtf8().data(), event)) { QParallelAnimationGroup::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQParallelAnimationGroupCustomEvent(this->objectName().toUtf8().data(), event)) { QParallelAnimationGroup::customEvent(event); }; };
 };
 
 int QParallelAnimationGroup_Duration(void* ptr){
@@ -5712,6 +5786,11 @@ public:
 	MyQPauseAnimation(int msecs, QObject *parent) : QPauseAnimation(msecs, parent) {};
 protected:
 	void updateCurrentTime(int v) { if (!callbackQPauseAnimationUpdateCurrentTime(this->objectName().toUtf8().data(), v)) { QPauseAnimation::updateCurrentTime(v); }; };
+	void updateDirection(QPauseAnimation::Direction direction) { if (!callbackQPauseAnimationUpdateDirection(this->objectName().toUtf8().data(), direction)) { QPauseAnimation::updateDirection(direction); }; };
+	void updateState(QPauseAnimation::State newState, QPauseAnimation::State oldState) { if (!callbackQPauseAnimationUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QPauseAnimation::updateState(newState, oldState); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQPauseAnimationTimerEvent(this->objectName().toUtf8().data(), event)) { QPauseAnimation::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQPauseAnimationChildEvent(this->objectName().toUtf8().data(), event)) { QPauseAnimation::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQPauseAnimationCustomEvent(this->objectName().toUtf8().data(), event)) { QPauseAnimation::customEvent(event); }; };
 };
 
 int QPauseAnimation_Duration(void* ptr){
@@ -5946,6 +6025,9 @@ public:
 	void Signal_StateChanged(QProcess::ProcessState newState) { callbackQProcessStateChanged(this->objectName().toUtf8().data(), newState); };
 protected:
 	void setupChildProcess() { if (!callbackQProcessSetupChildProcess(this->objectName().toUtf8().data())) { QProcess::setupChildProcess(); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQProcessTimerEvent(this->objectName().toUtf8().data(), event)) { QProcess::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQProcessChildEvent(this->objectName().toUtf8().data(), event)) { QProcess::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQProcessCustomEvent(this->objectName().toUtf8().data(), event)) { QProcess::customEvent(event); }; };
 };
 
 void* QProcess_NewQProcess(void* parent){
@@ -6239,6 +6321,11 @@ public:
 protected:
 	void updateCurrentValue(const QVariant & value) { if (!callbackQPropertyAnimationUpdateCurrentValue(this->objectName().toUtf8().data(), new QVariant(value))) { QPropertyAnimation::updateCurrentValue(value); }; };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { if (!callbackQPropertyAnimationUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QPropertyAnimation::updateState(newState, oldState); }; };
+	void updateCurrentTime(int v) { if (!callbackQPropertyAnimationUpdateCurrentTime(this->objectName().toUtf8().data(), v)) { QPropertyAnimation::updateCurrentTime(v); }; };
+	void updateDirection(QPropertyAnimation::Direction direction) { if (!callbackQPropertyAnimationUpdateDirection(this->objectName().toUtf8().data(), direction)) { QPropertyAnimation::updateDirection(direction); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQPropertyAnimationTimerEvent(this->objectName().toUtf8().data(), event)) { QPropertyAnimation::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQPropertyAnimationChildEvent(this->objectName().toUtf8().data(), event)) { QPropertyAnimation::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQPropertyAnimationCustomEvent(this->objectName().toUtf8().data(), event)) { QPropertyAnimation::customEvent(event); }; };
 };
 
 void* QPropertyAnimation_PropertyName(void* ptr){
@@ -7139,6 +7226,9 @@ public:
 	MyQSaveFile(const QString &name) : QSaveFile(name) {};
 	MyQSaveFile(const QString &name, QObject *parent) : QSaveFile(name, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSaveFileTimerEvent(this->objectName().toUtf8().data(), event)) { QSaveFile::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSaveFileChildEvent(this->objectName().toUtf8().data(), event)) { QSaveFile::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSaveFileCustomEvent(this->objectName().toUtf8().data(), event)) { QSaveFile::customEvent(event); }; };
 };
 
 void* QSaveFile_NewQSaveFile2(void* parent){
@@ -7220,6 +7310,9 @@ protected:
 	void updateCurrentTime(int currentTime) { if (!callbackQSequentialAnimationGroupUpdateCurrentTime(this->objectName().toUtf8().data(), currentTime)) { QSequentialAnimationGroup::updateCurrentTime(currentTime); }; };
 	void updateDirection(QAbstractAnimation::Direction direction) { if (!callbackQSequentialAnimationGroupUpdateDirection(this->objectName().toUtf8().data(), direction)) { QSequentialAnimationGroup::updateDirection(direction); }; };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { if (!callbackQSequentialAnimationGroupUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QSequentialAnimationGroup::updateState(newState, oldState); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQSequentialAnimationGroupTimerEvent(this->objectName().toUtf8().data(), event)) { QSequentialAnimationGroup::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSequentialAnimationGroupChildEvent(this->objectName().toUtf8().data(), event)) { QSequentialAnimationGroup::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSequentialAnimationGroupCustomEvent(this->objectName().toUtf8().data(), event)) { QSequentialAnimationGroup::customEvent(event); }; };
 };
 
 void* QSequentialAnimationGroup_CurrentAnimation(void* ptr){
@@ -7270,6 +7363,9 @@ public:
 	MyQSettings(const QString &fileName, Format format, QObject *parent) : QSettings(fileName, format, parent) {};
 	MyQSettings(const QString &organization, const QString &application, QObject *parent) : QSettings(organization, application, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSettingsTimerEvent(this->objectName().toUtf8().data(), event)) { QSettings::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSettingsChildEvent(this->objectName().toUtf8().data(), event)) { QSettings::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSettingsCustomEvent(this->objectName().toUtf8().data(), event)) { QSettings::customEvent(event); }; };
 };
 
 void* QSettings_NewQSettings3(int format, int scope, char* organization, char* application, void* parent){
@@ -7519,6 +7615,9 @@ public:
 	void Signal_Mapped2(const QString & text) { callbackQSignalMapperMapped2(this->objectName().toUtf8().data(), text.toUtf8().data()); };
 	void Signal_Mapped(int i) { callbackQSignalMapperMapped(this->objectName().toUtf8().data(), i); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSignalMapperTimerEvent(this->objectName().toUtf8().data(), event)) { QSignalMapper::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSignalMapperChildEvent(this->objectName().toUtf8().data(), event)) { QSignalMapper::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSignalMapperCustomEvent(this->objectName().toUtf8().data(), event)) { QSignalMapper::customEvent(event); }; };
 };
 
 void* QSignalMapper_NewQSignalMapper(void* parent){
@@ -7613,6 +7712,9 @@ public:
 	void Signal_SignalChanged() { callbackQSignalTransitionSignalChanged(this->objectName().toUtf8().data()); };
 protected:
 	void onTransition(QEvent * event) { if (!callbackQSignalTransitionOnTransition(this->objectName().toUtf8().data(), event)) { QSignalTransition::onTransition(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQSignalTransitionTimerEvent(this->objectName().toUtf8().data(), event)) { QSignalTransition::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSignalTransitionChildEvent(this->objectName().toUtf8().data(), event)) { QSignalTransition::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSignalTransitionCustomEvent(this->objectName().toUtf8().data(), event)) { QSignalTransition::customEvent(event); }; };
 };
 
 void* QSignalTransition_NewQSignalTransition(void* sourceState){
@@ -7803,6 +7905,9 @@ class MyQSocketNotifier: public QSocketNotifier {
 public:
 	void Signal_Activated(int socket) { callbackQSocketNotifierActivated(this->objectName().toUtf8().data(), socket); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSocketNotifierTimerEvent(this->objectName().toUtf8().data(), event)) { QSocketNotifier::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSocketNotifierChildEvent(this->objectName().toUtf8().data(), event)) { QSocketNotifier::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSocketNotifierCustomEvent(this->objectName().toUtf8().data(), event)) { QSocketNotifier::customEvent(event); }; };
 };
 
 void QSocketNotifier_ConnectActivated(void* ptr){
@@ -7835,7 +7940,11 @@ public:
 	void fetchMore(const QModelIndex & parent) { if (!callbackQSortFilterProxyModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QSortFilterProxyModel::fetchMore(parent); }; };
 	void setSourceModel(QAbstractItemModel * sourceModel) { if (!callbackQSortFilterProxyModelSetSourceModel(this->objectName().toUtf8().data(), sourceModel)) { QSortFilterProxyModel::setSourceModel(sourceModel); }; };
 	void sort(int column, Qt::SortOrder order) { if (!callbackQSortFilterProxyModelSort(this->objectName().toUtf8().data(), column, order)) { QSortFilterProxyModel::sort(column, order); }; };
+	void revert() { if (!callbackQSortFilterProxyModelRevert(this->objectName().toUtf8().data())) { QSortFilterProxyModel::revert(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSortFilterProxyModelTimerEvent(this->objectName().toUtf8().data(), event)) { QSortFilterProxyModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSortFilterProxyModelChildEvent(this->objectName().toUtf8().data(), event)) { QSortFilterProxyModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSortFilterProxyModelCustomEvent(this->objectName().toUtf8().data(), event)) { QSortFilterProxyModel::customEvent(event); }; };
 };
 
 int QSortFilterProxyModel_DynamicSortFilter(void* ptr){
@@ -8078,6 +8187,9 @@ public:
 protected:
 	void onEntry(QEvent * event) { if (!callbackQStateOnEntry(this->objectName().toUtf8().data(), event)) { QState::onEntry(event); }; };
 	void onExit(QEvent * event) { if (!callbackQStateOnExit(this->objectName().toUtf8().data(), event)) { QState::onExit(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQStateTimerEvent(this->objectName().toUtf8().data(), event)) { QState::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQStateChildEvent(this->objectName().toUtf8().data(), event)) { QState::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQStateCustomEvent(this->objectName().toUtf8().data(), event)) { QState::customEvent(event); }; };
 };
 
 void* QState_NewQState2(int childMode, void* parent){
@@ -8186,6 +8298,9 @@ public:
 protected:
 	void onEntry(QEvent * event) { if (!callbackQStateMachineOnEntry(this->objectName().toUtf8().data(), event)) { QStateMachine::onEntry(event); }; };
 	void onExit(QEvent * event) { if (!callbackQStateMachineOnExit(this->objectName().toUtf8().data(), event)) { QStateMachine::onExit(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQStateMachineTimerEvent(this->objectName().toUtf8().data(), event)) { QStateMachine::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQStateMachineChildEvent(this->objectName().toUtf8().data(), event)) { QStateMachine::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQStateMachineCustomEvent(this->objectName().toUtf8().data(), event)) { QStateMachine::customEvent(event); }; };
 };
 
 void* QStateMachine_NewQStateMachine(void* parent){
@@ -8391,7 +8506,12 @@ void QStorageInfo_DestroyQStorageInfo(void* ptr){
 class MyQStringListModel: public QStringListModel {
 public:
 	void sort(int column, Qt::SortOrder order) { if (!callbackQStringListModelSort(this->objectName().toUtf8().data(), column, order)) { QStringListModel::sort(column, order); }; };
+	void fetchMore(const QModelIndex & parent) { if (!callbackQStringListModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QStringListModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQStringListModelRevert(this->objectName().toUtf8().data())) { QStringListModel::revert(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQStringListModelTimerEvent(this->objectName().toUtf8().data(), event)) { QStringListModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQStringListModelChildEvent(this->objectName().toUtf8().data(), event)) { QStringListModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQStringListModelCustomEvent(this->objectName().toUtf8().data(), event)) { QStringListModel::customEvent(event); }; };
 };
 
 void* QStringListModel_Data(void* ptr, void* index, int role){
@@ -8889,6 +9009,9 @@ public:
 	MyQTemporaryFile(const QString &templateName) : QTemporaryFile(templateName) {};
 	MyQTemporaryFile(const QString &templateName, QObject *parent) : QTemporaryFile(templateName, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQTemporaryFileTimerEvent(this->objectName().toUtf8().data(), event)) { QTemporaryFile::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTemporaryFileChildEvent(this->objectName().toUtf8().data(), event)) { QTemporaryFile::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTemporaryFileCustomEvent(this->objectName().toUtf8().data(), event)) { QTemporaryFile::customEvent(event); }; };
 };
 
 void* QTemporaryFile_NewQTemporaryFile(){
@@ -9294,6 +9417,9 @@ public:
 	void Signal_Started() { callbackQThreadStarted(this->objectName().toUtf8().data()); };
 protected:
 	void run() { if (!callbackQThreadRun(this->objectName().toUtf8().data())) { QThread::run(); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQThreadTimerEvent(this->objectName().toUtf8().data(), event)) { QThread::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQThreadChildEvent(this->objectName().toUtf8().data(), event)) { QThread::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQThreadCustomEvent(this->objectName().toUtf8().data(), event)) { QThread::customEvent(event); }; };
 };
 
 void QThread_SetPriority(void* ptr, int priority){
@@ -9529,6 +9655,8 @@ public:
 	void Signal_ValueChanged(qreal value) { callbackQTimeLineValueChanged(this->objectName().toUtf8().data(), static_cast<double>(value)); };
 protected:
 	void timerEvent(QTimerEvent * event) { if (!callbackQTimeLineTimerEvent(this->objectName().toUtf8().data(), event)) { QTimeLine::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTimeLineChildEvent(this->objectName().toUtf8().data(), event)) { QTimeLine::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTimeLineCustomEvent(this->objectName().toUtf8().data(), event)) { QTimeLine::customEvent(event); }; };
 };
 
 int QTimeLine_CurrentTime(void* ptr){
@@ -9801,6 +9929,8 @@ public:
 	void Signal_Timeout() { callbackQTimerTimeout(this->objectName().toUtf8().data()); };
 protected:
 	void timerEvent(QTimerEvent * e) { if (!callbackQTimerTimerEvent(this->objectName().toUtf8().data(), e)) { QTimer::timerEvent(e); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTimerChildEvent(this->objectName().toUtf8().data(), event)) { QTimer::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTimerCustomEvent(this->objectName().toUtf8().data(), event)) { QTimer::customEvent(event); }; };
 };
 
 int QTimer_RemainingTime(void* ptr){
@@ -9887,6 +10017,9 @@ class MyQTranslator: public QTranslator {
 public:
 	MyQTranslator(QObject *parent) : QTranslator(parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQTranslatorTimerEvent(this->objectName().toUtf8().data(), event)) { QTranslator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTranslatorChildEvent(this->objectName().toUtf8().data(), event)) { QTranslator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTranslatorCustomEvent(this->objectName().toUtf8().data(), event)) { QTranslator::customEvent(event); }; };
 };
 
 void* QTranslator_NewQTranslator(void* parent){
@@ -10493,6 +10626,10 @@ protected:
 	void updateCurrentTime(int v) { if (!callbackQVariantAnimationUpdateCurrentTime(this->objectName().toUtf8().data(), v)) { QVariantAnimation::updateCurrentTime(v); }; };
 	void updateCurrentValue(const QVariant & value) { if (!callbackQVariantAnimationUpdateCurrentValue(this->objectName().toUtf8().data(), new QVariant(value))) { QVariantAnimation::updateCurrentValue(value); }; };
 	void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { if (!callbackQVariantAnimationUpdateState(this->objectName().toUtf8().data(), newState, oldState)) { QVariantAnimation::updateState(newState, oldState); }; };
+	void updateDirection(QVariantAnimation::Direction direction) { if (!callbackQVariantAnimationUpdateDirection(this->objectName().toUtf8().data(), direction)) { QVariantAnimation::updateDirection(direction); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQVariantAnimationTimerEvent(this->objectName().toUtf8().data(), event)) { QVariantAnimation::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQVariantAnimationChildEvent(this->objectName().toUtf8().data(), event)) { QVariantAnimation::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQVariantAnimationCustomEvent(this->objectName().toUtf8().data(), event)) { QVariantAnimation::customEvent(event); }; };
 };
 
 void* QVariantAnimation_CurrentValue(void* ptr){

core/qabstractanimation.go

@@ -386,3 +386,93 @@ func (ptr *QAbstractAnimation) DestroyQAbstractAnimation() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractAnimation) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractAnimationTimerEvent
+func callbackQAbstractAnimationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractAnimation::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractAnimation) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractAnimationChildEvent
+func callbackQAbstractAnimationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractAnimation::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractAnimation) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractAnimation) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractAnimationCustomEvent
+func callbackQAbstractAnimationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractAnimation::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstracteventdispatcher.go

@@ -198,3 +198,93 @@ func (ptr *QAbstractEventDispatcher) DestroyQAbstractEventDispatcher() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractEventDispatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractEventDispatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractEventDispatcher) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractEventDispatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractEventDispatcherTimerEvent
+func callbackQAbstractEventDispatcherTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractEventDispatcher::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractEventDispatcher) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractEventDispatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractEventDispatcher) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractEventDispatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractEventDispatcherChildEvent
+func callbackQAbstractEventDispatcherChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractEventDispatcher::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractEventDispatcher) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractEventDispatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractEventDispatcher) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractEventDispatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractEventDispatcherCustomEvent
+func callbackQAbstractEventDispatcherCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractEventDispatcher::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstractitemmodel.go

@@ -861,3 +861,93 @@ func (ptr *QAbstractItemModel) DestroyQAbstractItemModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractItemModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractItemModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractItemModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractItemModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractItemModelTimerEvent
+func callbackQAbstractItemModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractItemModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractItemModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractItemModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractItemModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractItemModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractItemModelChildEvent
+func callbackQAbstractItemModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractItemModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractItemModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractItemModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractItemModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractItemModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractItemModelCustomEvent
+func callbackQAbstractItemModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractItemModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstractlistmodel.go

@@ -80,3 +80,183 @@ func (ptr *QAbstractListModel) DestroyQAbstractListModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractListModel) ConnectFetchMore(f func(parent *QModelIndex)) {
+	defer qt.Recovering("connect QAbstractListModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QAbstractListModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQAbstractListModelFetchMore
+func callbackQAbstractListModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractListModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractListModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QAbstractListModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QAbstractListModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQAbstractListModelRevert
+func callbackQAbstractListModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QAbstractListModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractListModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
+	defer qt.Recovering("connect QAbstractListModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectSort() {
+	defer qt.Recovering("disconnect QAbstractListModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "sort")
+	}
+}
+
+//export callbackQAbstractListModelSort
+func callbackQAbstractListModelSort(ptrName *C.char, column C.int, order C.int) bool {
+	defer qt.Recovering("callback QAbstractListModel::sort")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
+		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractListModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractListModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractListModelTimerEvent
+func callbackQAbstractListModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractListModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractListModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractListModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractListModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractListModelChildEvent
+func callbackQAbstractListModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractListModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractListModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractListModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractListModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractListModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractListModelCustomEvent
+func callbackQAbstractListModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractListModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstractproxymodel.go

@@ -364,3 +364,93 @@ func (ptr *QAbstractProxyModel) DestroyQAbstractProxyModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractProxyModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractProxyModelTimerEvent
+func callbackQAbstractProxyModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractProxyModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractProxyModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractProxyModelChildEvent
+func callbackQAbstractProxyModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractProxyModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractProxyModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractProxyModelCustomEvent
+func callbackQAbstractProxyModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractProxyModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstractstate.go

@@ -155,3 +155,93 @@ func (ptr *QAbstractState) DestroyQAbstractState() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractState) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractState) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractStateTimerEvent
+func callbackQAbstractStateTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractState::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractState) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractState) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractStateChildEvent
+func callbackQAbstractStateChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractState::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractState) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractState) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractStateCustomEvent
+func callbackQAbstractStateCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractState::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstracttablemodel.go

@@ -80,3 +80,183 @@ func (ptr *QAbstractTableModel) DestroyQAbstractTableModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractTableModel) ConnectFetchMore(f func(parent *QModelIndex)) {
+	defer qt.Recovering("connect QAbstractTableModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QAbstractTableModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQAbstractTableModelFetchMore
+func callbackQAbstractTableModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTableModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTableModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QAbstractTableModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QAbstractTableModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQAbstractTableModelRevert
+func callbackQAbstractTableModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QAbstractTableModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTableModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
+	defer qt.Recovering("connect QAbstractTableModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectSort() {
+	defer qt.Recovering("disconnect QAbstractTableModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "sort")
+	}
+}
+
+//export callbackQAbstractTableModelSort
+func callbackQAbstractTableModelSort(ptrName *C.char, column C.int, order C.int) bool {
+	defer qt.Recovering("callback QAbstractTableModel::sort")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
+		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTableModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractTableModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractTableModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractTableModelTimerEvent
+func callbackQAbstractTableModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTableModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTableModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractTableModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractTableModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractTableModelChildEvent
+func callbackQAbstractTableModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTableModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTableModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractTableModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractTableModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractTableModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractTableModelCustomEvent
+func callbackQAbstractTableModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTableModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qabstracttransition.go

@@ -204,3 +204,93 @@ func (ptr *QAbstractTransition) DestroyQAbstractTransition() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QAbstractTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractTransition) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractTransitionTimerEvent
+func callbackQAbstractTransitionTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTransition::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTransition) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QAbstractTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractTransition) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractTransitionChildEvent
+func callbackQAbstractTransitionChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTransition::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTransition) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QAbstractTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractTransition) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractTransitionCustomEvent
+func callbackQAbstractTransitionCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTransition::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qbuffer.go

@@ -191,3 +191,93 @@ func (ptr *QBuffer) DestroyQBuffer() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QBuffer) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QBuffer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QBuffer) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QBuffer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQBufferTimerEvent
+func callbackQBufferTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBuffer::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBuffer) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QBuffer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QBuffer) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QBuffer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQBufferChildEvent
+func callbackQBufferChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBuffer::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QBuffer) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QBuffer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QBuffer) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QBuffer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQBufferCustomEvent
+func callbackQBufferCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QBuffer::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qcoreapplication.go

@@ -344,3 +344,93 @@ func (ptr *QCoreApplication) DestroyQCoreApplication() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QCoreApplication) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QCoreApplication::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QCoreApplication) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QCoreApplication::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQCoreApplicationTimerEvent
+func callbackQCoreApplicationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QCoreApplication::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QCoreApplication) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QCoreApplication::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QCoreApplication) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QCoreApplication::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQCoreApplicationChildEvent
+func callbackQCoreApplicationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QCoreApplication::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QCoreApplication) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QCoreApplication::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QCoreApplication) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QCoreApplication::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQCoreApplicationCustomEvent
+func callbackQCoreApplicationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QCoreApplication::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qeventloop.go

@@ -131,3 +131,93 @@ func (ptr *QEventLoop) DestroyQEventLoop() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QEventLoop) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QEventLoop::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QEventLoop) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QEventLoop::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQEventLoopTimerEvent
+func callbackQEventLoopTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventLoop::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QEventLoop) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QEventLoop::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QEventLoop) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QEventLoop::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQEventLoopChildEvent
+func callbackQEventLoopChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventLoop::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QEventLoop) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QEventLoop::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QEventLoop) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QEventLoop::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQEventLoopCustomEvent
+func callbackQEventLoopCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventLoop::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qeventtransition.go

@@ -120,3 +120,93 @@ func (ptr *QEventTransition) DestroyQEventTransition() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QEventTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QEventTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QEventTransition) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QEventTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQEventTransitionTimerEvent
+func callbackQEventTransitionTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventTransition::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QEventTransition) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QEventTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QEventTransition) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QEventTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQEventTransitionChildEvent
+func callbackQEventTransitionChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventTransition::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QEventTransition) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QEventTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QEventTransition) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QEventTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQEventTransitionCustomEvent
+func callbackQEventTransitionCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QEventTransition::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qfile.go

@@ -244,3 +244,93 @@ func (ptr *QFile) DestroyQFile() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QFile) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQFileTimerEvent
+func callbackQFileTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFile::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFile) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QFile) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQFileChildEvent
+func callbackQFileChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFile::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFile) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QFile) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQFileCustomEvent
+func callbackQFileCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFile::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qfiledevice.go

@@ -109,36 +109,6 @@ func (ptr *QFileDevice) AtEnd() bool {
 	return false
 }
 
-func (ptr *QFileDevice) ConnectClose(f func()) {
-	defer qt.Recovering("connect QFileDevice::close")
-
-	if ptr.Pointer() != nil {
-
-		qt.ConnectSignal(ptr.ObjectName(), "close", f)
-	}
-}
-
-func (ptr *QFileDevice) DisconnectClose() {
-	defer qt.Recovering("disconnect QFileDevice::close")
-
-	if ptr.Pointer() != nil {
-
-		qt.DisconnectSignal(ptr.ObjectName(), "close")
-	}
-}
-
-//export callbackQFileDeviceClose
-func callbackQFileDeviceClose(ptrName *C.char) bool {
-	defer qt.Recovering("callback QFileDevice::close")
-
-	if signal := qt.GetSignal(C.GoString(ptrName), "close"); signal != nil {
-		signal.(func())()
-		return true
-	}
-	return false
-
-}
-
 func (ptr *QFileDevice) Error() QFileDevice__FileError {
 	defer qt.Recovering("QFileDevice::error")
 
@@ -245,3 +215,93 @@ func (ptr *QFileDevice) DestroyQFileDevice() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QFileDevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QFileDevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QFileDevice) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QFileDevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQFileDeviceTimerEvent
+func callbackQFileDeviceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileDevice::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileDevice) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QFileDevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QFileDevice) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QFileDevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQFileDeviceChildEvent
+func callbackQFileDeviceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileDevice::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileDevice) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QFileDevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QFileDevice) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QFileDevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQFileDeviceCustomEvent
+func callbackQFileDeviceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileDevice::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qfileselector.go

@@ -95,3 +95,93 @@ func (ptr *QFileSelector) DestroyQFileSelector() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QFileSelector) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QFileSelector::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QFileSelector) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QFileSelector::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQFileSelectorTimerEvent
+func callbackQFileSelectorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSelector::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileSelector) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QFileSelector::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QFileSelector) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QFileSelector::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQFileSelectorChildEvent
+func callbackQFileSelectorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSelector::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileSelector) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QFileSelector::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QFileSelector) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QFileSelector::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQFileSelectorCustomEvent
+func callbackQFileSelectorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSelector::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qfilesystemwatcher.go

@@ -167,3 +167,93 @@ func (ptr *QFileSystemWatcher) DestroyQFileSystemWatcher() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QFileSystemWatcher) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QFileSystemWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QFileSystemWatcher) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QFileSystemWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQFileSystemWatcherTimerEvent
+func callbackQFileSystemWatcherTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSystemWatcher::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileSystemWatcher) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QFileSystemWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QFileSystemWatcher) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QFileSystemWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQFileSystemWatcherChildEvent
+func callbackQFileSystemWatcherChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSystemWatcher::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFileSystemWatcher) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QFileSystemWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QFileSystemWatcher) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QFileSystemWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQFileSystemWatcherCustomEvent
+func callbackQFileSystemWatcherCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFileSystemWatcher::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qfinalstate.go

@@ -110,3 +110,93 @@ func (ptr *QFinalState) DestroyQFinalState() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QFinalState) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QFinalState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QFinalState) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QFinalState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQFinalStateTimerEvent
+func callbackQFinalStateTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFinalState::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFinalState) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QFinalState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QFinalState) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QFinalState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQFinalStateChildEvent
+func callbackQFinalStateChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFinalState::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QFinalState) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QFinalState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QFinalState) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QFinalState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQFinalStateCustomEvent
+func callbackQFinalStateCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QFinalState::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qhistorystate.go

@@ -214,3 +214,93 @@ func (ptr *QHistoryState) DestroyQHistoryState() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QHistoryState) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QHistoryState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QHistoryState) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QHistoryState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQHistoryStateTimerEvent
+func callbackQHistoryStateTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHistoryState::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHistoryState) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QHistoryState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QHistoryState) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QHistoryState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQHistoryStateChildEvent
+func callbackQHistoryStateChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHistoryState::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHistoryState) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QHistoryState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QHistoryState) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QHistoryState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQHistoryStateCustomEvent
+func callbackQHistoryStateCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHistoryState::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qidentityproxymodel.go

@@ -197,3 +197,183 @@ func (ptr *QIdentityProxyModel) DestroyQIdentityProxyModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QIdentityProxyModel) ConnectFetchMore(f func(parent *QModelIndex)) {
+	defer qt.Recovering("connect QIdentityProxyModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQIdentityProxyModelFetchMore
+func callbackQIdentityProxyModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIdentityProxyModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QIdentityProxyModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQIdentityProxyModelRevert
+func callbackQIdentityProxyModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIdentityProxyModel) ConnectSort(f func(column int, order Qt__SortOrder)) {
+	defer qt.Recovering("connect QIdentityProxyModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectSort() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "sort")
+	}
+}
+
+//export callbackQIdentityProxyModelSort
+func callbackQIdentityProxyModelSort(ptrName *C.char, column C.int, order C.int) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::sort")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
+		signal.(func(int, Qt__SortOrder))(int(column), Qt__SortOrder(order))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIdentityProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QIdentityProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQIdentityProxyModelTimerEvent
+func callbackQIdentityProxyModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIdentityProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QIdentityProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQIdentityProxyModelChildEvent
+func callbackQIdentityProxyModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIdentityProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QIdentityProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QIdentityProxyModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QIdentityProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQIdentityProxyModelCustomEvent
+func callbackQIdentityProxyModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIdentityProxyModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qiodevice.go

@@ -486,3 +486,93 @@ func (ptr *QIODevice) DestroyQIODevice() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QIODevice) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QIODevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QIODevice) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QIODevice::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQIODeviceTimerEvent
+func callbackQIODeviceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIODevice::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIODevice) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QIODevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QIODevice) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QIODevice::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQIODeviceChildEvent
+func callbackQIODeviceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIODevice::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIODevice) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QIODevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QIODevice) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QIODevice::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQIODeviceCustomEvent
+func callbackQIODeviceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIODevice::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qitemselectionmodel.go

@@ -432,3 +432,93 @@ func (ptr *QItemSelectionModel) DestroyQItemSelectionModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QItemSelectionModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QItemSelectionModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QItemSelectionModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QItemSelectionModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQItemSelectionModelTimerEvent
+func callbackQItemSelectionModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QItemSelectionModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QItemSelectionModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QItemSelectionModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QItemSelectionModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QItemSelectionModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQItemSelectionModelChildEvent
+func callbackQItemSelectionModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QItemSelectionModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QItemSelectionModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QItemSelectionModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QItemSelectionModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QItemSelectionModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQItemSelectionModelCustomEvent
+func callbackQItemSelectionModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QItemSelectionModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qlibrary.go

@@ -171,3 +171,93 @@ func (ptr *QLibrary) DestroyQLibrary() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QLibrary) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QLibrary::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QLibrary) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QLibrary::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQLibraryTimerEvent
+func callbackQLibraryTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLibrary::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLibrary) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QLibrary::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QLibrary) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QLibrary::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQLibraryChildEvent
+func callbackQLibraryChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLibrary::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QLibrary) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QLibrary::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QLibrary) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QLibrary::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQLibraryCustomEvent
+func callbackQLibraryCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QLibrary::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qmimedata.go

@@ -215,3 +215,93 @@ func (ptr *QMimeData) DestroyQMimeData() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QMimeData) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QMimeData::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QMimeData) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QMimeData::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQMimeDataTimerEvent
+func callbackQMimeDataTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMimeData::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QMimeData) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QMimeData::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QMimeData) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QMimeData::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQMimeDataChildEvent
+func callbackQMimeDataChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMimeData::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QMimeData) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QMimeData::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QMimeData) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QMimeData::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQMimeDataCustomEvent
+func callbackQMimeDataCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMimeData::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qobjectcleanuphandler.go

@@ -76,3 +76,93 @@ func (ptr *QObjectCleanupHandler) DestroyQObjectCleanupHandler() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QObjectCleanupHandler) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QObjectCleanupHandler::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QObjectCleanupHandler) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QObjectCleanupHandler::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQObjectCleanupHandlerTimerEvent
+func callbackQObjectCleanupHandlerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QObjectCleanupHandler::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QObjectCleanupHandler) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QObjectCleanupHandler::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QObjectCleanupHandler) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QObjectCleanupHandler::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQObjectCleanupHandlerChildEvent
+func callbackQObjectCleanupHandlerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QObjectCleanupHandler::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QObjectCleanupHandler) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QObjectCleanupHandler::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QObjectCleanupHandler) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QObjectCleanupHandler::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQObjectCleanupHandlerCustomEvent
+func callbackQObjectCleanupHandlerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QObjectCleanupHandler::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qparallelanimationgroup.go

@@ -143,3 +143,93 @@ func (ptr *QParallelAnimationGroup) DestroyQParallelAnimationGroup() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QParallelAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QParallelAnimationGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QParallelAnimationGroup) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QParallelAnimationGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQParallelAnimationGroupTimerEvent
+func callbackQParallelAnimationGroupTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QParallelAnimationGroup::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QParallelAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QParallelAnimationGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QParallelAnimationGroup) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QParallelAnimationGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQParallelAnimationGroupChildEvent
+func callbackQParallelAnimationGroupChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QParallelAnimationGroup::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QParallelAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QParallelAnimationGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QParallelAnimationGroup) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QParallelAnimationGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQParallelAnimationGroupCustomEvent
+func callbackQParallelAnimationGroupCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QParallelAnimationGroup::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qpauseanimation.go

@@ -103,3 +103,153 @@ func (ptr *QPauseAnimation) DestroyQPauseAnimation() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QPauseAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
+	defer qt.Recovering("connect QPauseAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
+	}
+}
+
+func (ptr *QPauseAnimation) DisconnectUpdateDirection() {
+	defer qt.Recovering("disconnect QPauseAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
+	}
+}
+
+//export callbackQPauseAnimationUpdateDirection
+func callbackQPauseAnimationUpdateDirection(ptrName *C.char, direction C.int) bool {
+	defer qt.Recovering("callback QPauseAnimation::updateDirection")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
+		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPauseAnimation) ConnectUpdateState(f func(newState QAbstractAnimation__State, oldState QAbstractAnimation__State)) {
+	defer qt.Recovering("connect QPauseAnimation::updateState")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "updateState", f)
+	}
+}
+
+func (ptr *QPauseAnimation) DisconnectUpdateState() {
+	defer qt.Recovering("disconnect QPauseAnimation::updateState")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "updateState")
+	}
+}
+
+//export callbackQPauseAnimationUpdateState
+func callbackQPauseAnimationUpdateState(ptrName *C.char, newState C.int, oldState C.int) bool {
+	defer qt.Recovering("callback QPauseAnimation::updateState")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "updateState"); signal != nil {
+		signal.(func(QAbstractAnimation__State, QAbstractAnimation__State))(QAbstractAnimation__State(newState), QAbstractAnimation__State(oldState))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPauseAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QPauseAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QPauseAnimation) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QPauseAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQPauseAnimationTimerEvent
+func callbackQPauseAnimationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPauseAnimation::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPauseAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QPauseAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QPauseAnimation) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QPauseAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQPauseAnimationChildEvent
+func callbackQPauseAnimationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPauseAnimation::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPauseAnimation) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QPauseAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QPauseAnimation) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QPauseAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQPauseAnimationCustomEvent
+func callbackQPauseAnimationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPauseAnimation::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qpluginloader.go

@@ -144,3 +144,93 @@ func (ptr *QPluginLoader) DestroyQPluginLoader() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QPluginLoader) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QPluginLoader::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QPluginLoader) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QPluginLoader::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQPluginLoaderTimerEvent
+func callbackQPluginLoaderTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPluginLoader::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPluginLoader) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QPluginLoader::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QPluginLoader) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QPluginLoader::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQPluginLoaderChildEvent
+func callbackQPluginLoaderChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPluginLoader::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPluginLoader) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QPluginLoader::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QPluginLoader) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QPluginLoader::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQPluginLoaderCustomEvent
+func callbackQPluginLoaderCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPluginLoader::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qprocess.go

@@ -716,3 +716,93 @@ func (ptr *QProcess) DestroyQProcess() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QProcess) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QProcess::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QProcess) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QProcess::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQProcessTimerEvent
+func callbackQProcessTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QProcess::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QProcess) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QProcess::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QProcess) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QProcess::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQProcessChildEvent
+func callbackQProcessChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QProcess::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QProcess) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QProcess::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QProcess) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QProcess::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQProcessCustomEvent
+func callbackQProcessCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QProcess::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qpropertyanimation.go

@@ -150,3 +150,153 @@ func (ptr *QPropertyAnimation) DestroyQPropertyAnimation() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QPropertyAnimation) ConnectUpdateCurrentTime(f func(v int)) {
+	defer qt.Recovering("connect QPropertyAnimation::updateCurrentTime")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "updateCurrentTime", f)
+	}
+}
+
+func (ptr *QPropertyAnimation) DisconnectUpdateCurrentTime() {
+	defer qt.Recovering("disconnect QPropertyAnimation::updateCurrentTime")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "updateCurrentTime")
+	}
+}
+
+//export callbackQPropertyAnimationUpdateCurrentTime
+func callbackQPropertyAnimationUpdateCurrentTime(ptrName *C.char, v C.int) bool {
+	defer qt.Recovering("callback QPropertyAnimation::updateCurrentTime")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "updateCurrentTime"); signal != nil {
+		signal.(func(int))(int(v))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPropertyAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
+	defer qt.Recovering("connect QPropertyAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
+	}
+}
+
+func (ptr *QPropertyAnimation) DisconnectUpdateDirection() {
+	defer qt.Recovering("disconnect QPropertyAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
+	}
+}
+
+//export callbackQPropertyAnimationUpdateDirection
+func callbackQPropertyAnimationUpdateDirection(ptrName *C.char, direction C.int) bool {
+	defer qt.Recovering("callback QPropertyAnimation::updateDirection")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
+		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPropertyAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QPropertyAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QPropertyAnimation) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QPropertyAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQPropertyAnimationTimerEvent
+func callbackQPropertyAnimationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPropertyAnimation::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPropertyAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QPropertyAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QPropertyAnimation) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QPropertyAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQPropertyAnimationChildEvent
+func callbackQPropertyAnimationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPropertyAnimation::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPropertyAnimation) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QPropertyAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QPropertyAnimation) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QPropertyAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQPropertyAnimationCustomEvent
+func callbackQPropertyAnimationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPropertyAnimation::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsavefile.go

@@ -122,3 +122,93 @@ func (ptr *QSaveFile) DestroyQSaveFile() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSaveFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSaveFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSaveFile) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSaveFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSaveFileTimerEvent
+func callbackQSaveFileTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSaveFile::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSaveFile) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSaveFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSaveFile) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSaveFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSaveFileChildEvent
+func callbackQSaveFileChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSaveFile::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSaveFile) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSaveFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSaveFile) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSaveFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSaveFileCustomEvent
+func callbackQSaveFileCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSaveFile::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsequentialanimationgroup.go

@@ -198,3 +198,93 @@ func (ptr *QSequentialAnimationGroup) DestroyQSequentialAnimationGroup() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSequentialAnimationGroup) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSequentialAnimationGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSequentialAnimationGroup) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSequentialAnimationGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSequentialAnimationGroupTimerEvent
+func callbackQSequentialAnimationGroupTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSequentialAnimationGroup::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSequentialAnimationGroup) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSequentialAnimationGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSequentialAnimationGroup) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSequentialAnimationGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSequentialAnimationGroupChildEvent
+func callbackQSequentialAnimationGroupChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSequentialAnimationGroup::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSequentialAnimationGroup) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSequentialAnimationGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSequentialAnimationGroup) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSequentialAnimationGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSequentialAnimationGroupCustomEvent
+func callbackQSequentialAnimationGroupCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSequentialAnimationGroup::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsettings.go

@@ -367,3 +367,93 @@ func (ptr *QSettings) DestroyQSettings() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSettings) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSettings::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSettings) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSettings::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSettingsTimerEvent
+func callbackQSettingsTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSettings::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSettings) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSettings::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSettings) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSettings::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSettingsChildEvent
+func callbackQSettingsChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSettings::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSettings) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSettings::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSettings) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSettings::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSettingsCustomEvent
+func callbackQSettingsCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSettings::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsharedmemory.go

@@ -221,3 +221,93 @@ func (ptr *QSharedMemory) DestroyQSharedMemory() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSharedMemory) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSharedMemory::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSharedMemory) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSharedMemory::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSharedMemoryTimerEvent
+func callbackQSharedMemoryTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSharedMemory::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSharedMemory) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSharedMemory::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSharedMemory) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSharedMemory::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSharedMemoryChildEvent
+func callbackQSharedMemoryChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSharedMemory::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSharedMemory) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSharedMemory::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSharedMemory) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSharedMemory::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSharedMemoryCustomEvent
+func callbackQSharedMemoryCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSharedMemory::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsignalmapper.go

@@ -254,3 +254,93 @@ func (ptr *QSignalMapper) DestroyQSignalMapper() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSignalMapper) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSignalMapper::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSignalMapper) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSignalMapper::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSignalMapperTimerEvent
+func callbackQSignalMapperTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalMapper::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSignalMapper) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSignalMapper::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSignalMapper) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSignalMapper::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSignalMapperChildEvent
+func callbackQSignalMapperChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalMapper::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSignalMapper) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSignalMapper::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSignalMapper) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSignalMapper::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSignalMapperCustomEvent
+func callbackQSignalMapperCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalMapper::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsignaltransition.go

@@ -176,3 +176,93 @@ func (ptr *QSignalTransition) DestroyQSignalTransition() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSignalTransition) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSignalTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSignalTransition) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSignalTransition::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSignalTransitionTimerEvent
+func callbackQSignalTransitionTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalTransition::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSignalTransition) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSignalTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSignalTransition) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSignalTransition::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSignalTransitionChildEvent
+func callbackQSignalTransitionChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalTransition::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSignalTransition) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSignalTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSignalTransition) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSignalTransition::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSignalTransitionCustomEvent
+func callbackQSignalTransitionCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSignalTransition::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsocketnotifier.go

@@ -107,3 +107,93 @@ func (ptr *QSocketNotifier) DestroyQSocketNotifier() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSocketNotifier) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSocketNotifier::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSocketNotifier) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSocketNotifier::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSocketNotifierTimerEvent
+func callbackQSocketNotifierTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSocketNotifier::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSocketNotifier) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSocketNotifier::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSocketNotifier) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSocketNotifier::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSocketNotifierChildEvent
+func callbackQSocketNotifierChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSocketNotifier::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSocketNotifier) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSocketNotifier::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSocketNotifier) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSocketNotifier::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSocketNotifierCustomEvent
+func callbackQSocketNotifierCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSocketNotifier::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qsortfilterproxymodel.go

@@ -534,3 +534,123 @@ func (ptr *QSortFilterProxyModel) DestroyQSortFilterProxyModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSortFilterProxyModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QSortFilterProxyModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QSortFilterProxyModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QSortFilterProxyModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQSortFilterProxyModelRevert
+func callbackQSortFilterProxyModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QSortFilterProxyModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSortFilterProxyModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QSortFilterProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSortFilterProxyModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSortFilterProxyModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSortFilterProxyModelTimerEvent
+func callbackQSortFilterProxyModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSortFilterProxyModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSortFilterProxyModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QSortFilterProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSortFilterProxyModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSortFilterProxyModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSortFilterProxyModelChildEvent
+func callbackQSortFilterProxyModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSortFilterProxyModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSortFilterProxyModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QSortFilterProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSortFilterProxyModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSortFilterProxyModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSortFilterProxyModelCustomEvent
+func callbackQSortFilterProxyModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSortFilterProxyModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qstate.go

@@ -365,3 +365,93 @@ func (ptr *QState) DestroyQState() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QState) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QState) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QState::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQStateTimerEvent
+func callbackQStateTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QState::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QState) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QState) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QState::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQStateChildEvent
+func callbackQStateChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QState::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QState) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QState) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QState::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQStateCustomEvent
+func callbackQStateCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QState::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qstatemachine.go

@@ -378,3 +378,93 @@ func (ptr *QStateMachine) DestroyQStateMachine() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QStateMachine) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QStateMachine::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QStateMachine) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QStateMachine::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQStateMachineTimerEvent
+func callbackQStateMachineTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStateMachine::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStateMachine) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QStateMachine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QStateMachine) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QStateMachine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQStateMachineChildEvent
+func callbackQStateMachineChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStateMachine::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStateMachine) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QStateMachine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QStateMachine) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QStateMachine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQStateMachineCustomEvent
+func callbackQStateMachineCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStateMachine::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qstringlistmodel.go

@@ -155,3 +155,153 @@ func (ptr *QStringListModel) SupportedDropActions() Qt__DropAction {
 	}
 	return 0
 }
+
+func (ptr *QStringListModel) ConnectFetchMore(f func(parent *QModelIndex)) {
+	defer qt.Recovering("connect QStringListModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QStringListModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QStringListModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQStringListModelFetchMore
+func callbackQStringListModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStringListModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*QModelIndex))(NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStringListModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QStringListModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QStringListModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QStringListModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQStringListModelRevert
+func callbackQStringListModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QStringListModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStringListModel) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QStringListModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QStringListModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QStringListModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQStringListModelTimerEvent
+func callbackQStringListModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStringListModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStringListModel) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QStringListModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QStringListModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QStringListModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQStringListModelChildEvent
+func callbackQStringListModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStringListModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStringListModel) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QStringListModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QStringListModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QStringListModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQStringListModelCustomEvent
+func callbackQStringListModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStringListModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qtemporaryfile.go

@@ -132,3 +132,93 @@ func (ptr *QTemporaryFile) DestroyQTemporaryFile() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTemporaryFile) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QTemporaryFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTemporaryFile) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTemporaryFile::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTemporaryFileTimerEvent
+func callbackQTemporaryFileTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTemporaryFile::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTemporaryFile) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QTemporaryFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTemporaryFile) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTemporaryFile::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTemporaryFileChildEvent
+func callbackQTemporaryFileChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTemporaryFile::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTemporaryFile) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QTemporaryFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTemporaryFile) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTemporaryFile::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTemporaryFileCustomEvent
+func callbackQTemporaryFileCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTemporaryFile::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qthread.go

@@ -287,3 +287,93 @@ func QThread_YieldCurrentThread() {
 
 	C.QThread_QThread_YieldCurrentThread()
 }
+
+func (ptr *QThread) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QThread::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QThread) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QThread::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQThreadTimerEvent
+func callbackQThreadTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThread::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QThread) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QThread::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QThread) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QThread::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQThreadChildEvent
+func callbackQThreadChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThread::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QThread) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QThread::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QThread) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QThread::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQThreadCustomEvent
+func callbackQThreadCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThread::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qthreadpool.go

@@ -157,3 +157,93 @@ func (ptr *QThreadPool) DestroyQThreadPool() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QThreadPool) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QThreadPool::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QThreadPool) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QThreadPool::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQThreadPoolTimerEvent
+func callbackQThreadPoolTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThreadPool::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QThreadPool) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QThreadPool::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QThreadPool) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QThreadPool::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQThreadPoolChildEvent
+func callbackQThreadPoolChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThreadPool::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QThreadPool) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QThreadPool::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QThreadPool) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QThreadPool::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQThreadPoolCustomEvent
+func callbackQThreadPoolCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QThreadPool::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qtimeline.go

@@ -467,3 +467,63 @@ func (ptr *QTimeLine) DestroyQTimeLine() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTimeLine) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QTimeLine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTimeLine) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTimeLine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTimeLineChildEvent
+func callbackQTimeLineChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTimeLine::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTimeLine) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QTimeLine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTimeLine) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTimeLine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTimeLineCustomEvent
+func callbackQTimeLineCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTimeLine::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qtimer.go

@@ -222,3 +222,63 @@ func (ptr *QTimer) DestroyQTimer() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTimer) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QTimer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTimer) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTimer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTimerChildEvent
+func callbackQTimerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTimer::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTimer) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QTimer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTimer) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTimer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTimerCustomEvent
+func callbackQTimerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTimer::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qtranslator.go

@@ -86,3 +86,93 @@ func (ptr *QTranslator) DestroyQTranslator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTranslator) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QTranslator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTranslator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTranslator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTranslatorTimerEvent
+func callbackQTranslatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTranslator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTranslator) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QTranslator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTranslator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTranslator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTranslatorChildEvent
+func callbackQTranslatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTranslator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTranslator) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QTranslator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTranslator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTranslator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTranslatorCustomEvent
+func callbackQTranslatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTranslator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

core/qvariantanimation.go

@@ -262,3 +262,123 @@ func (ptr *QVariantAnimation) DestroyQVariantAnimation() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QVariantAnimation) ConnectUpdateDirection(f func(direction QAbstractAnimation__Direction)) {
+	defer qt.Recovering("connect QVariantAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "updateDirection", f)
+	}
+}
+
+func (ptr *QVariantAnimation) DisconnectUpdateDirection() {
+	defer qt.Recovering("disconnect QVariantAnimation::updateDirection")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "updateDirection")
+	}
+}
+
+//export callbackQVariantAnimationUpdateDirection
+func callbackQVariantAnimationUpdateDirection(ptrName *C.char, direction C.int) bool {
+	defer qt.Recovering("callback QVariantAnimation::updateDirection")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "updateDirection"); signal != nil {
+		signal.(func(QAbstractAnimation__Direction))(QAbstractAnimation__Direction(direction))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QVariantAnimation) ConnectTimerEvent(f func(event *QTimerEvent)) {
+	defer qt.Recovering("connect QVariantAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QVariantAnimation) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QVariantAnimation::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQVariantAnimationTimerEvent
+func callbackQVariantAnimationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QVariantAnimation::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*QTimerEvent))(NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QVariantAnimation) ConnectChildEvent(f func(event *QChildEvent)) {
+	defer qt.Recovering("connect QVariantAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QVariantAnimation) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QVariantAnimation::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQVariantAnimationChildEvent
+func callbackQVariantAnimationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QVariantAnimation::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*QChildEvent))(NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QVariantAnimation) ConnectCustomEvent(f func(event *QEvent)) {
+	defer qt.Recovering("connect QVariantAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QVariantAnimation) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QVariantAnimation::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQVariantAnimationCustomEvent
+func callbackQVariantAnimationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QVariantAnimation::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*QEvent))(NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/dbus.cpp

@@ -2,6 +2,7 @@
 #include "_cgo_export.h"
 
 #include <QByteArray>
+#include <QChildEvent>
 #include <QDBusAbstractAdaptor>
 #include <QDBusAbstractInterface>
 #include <QDBusArgument>
@@ -20,9 +21,13 @@
 #include <QDBusUnixFileDescriptor>
 #include <QDBusVariant>
 #include <QDBusVirtualObject>
+#include <QEvent>
 #include <QLatin1String>
 #include <QObject>
 #include <QString>
+#include <QTime>
+#include <QTimer>
+#include <QTimerEvent>
 #include <QVariant>
 
 void QDBusAbstractAdaptor_DestroyQDBusAbstractAdaptor(void* ptr){
@@ -32,6 +37,9 @@ void QDBusAbstractAdaptor_DestroyQDBusAbstractAdaptor(void* ptr){
 class MyQDBusAbstractInterface: public QDBusAbstractInterface {
 public:
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusAbstractInterfaceTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusAbstractInterface::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusAbstractInterfaceChildEvent(this->objectName().toUtf8().data(), event)) { QDBusAbstractInterface::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusAbstractInterfaceCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusAbstractInterface::customEvent(event); }; };
 };
 
 char* QDBusAbstractInterface_Interface(void* ptr){
@@ -243,6 +251,9 @@ public:
 	void Signal_ServiceRegistered(const QString & serviceName) { callbackQDBusConnectionInterfaceServiceRegistered(this->objectName().toUtf8().data(), serviceName.toUtf8().data()); };
 	void Signal_ServiceUnregistered(const QString & serviceName) { callbackQDBusConnectionInterfaceServiceUnregistered(this->objectName().toUtf8().data(), serviceName.toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusConnectionInterfaceTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusConnectionInterface::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusConnectionInterfaceChildEvent(this->objectName().toUtf8().data(), event)) { QDBusConnectionInterface::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusConnectionInterfaceCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusConnectionInterface::customEvent(event); }; };
 };
 
 void QDBusConnectionInterface_ConnectServiceRegistered(void* ptr){
@@ -421,6 +432,9 @@ class MyQDBusPendingCallWatcher: public QDBusPendingCallWatcher {
 public:
 	void Signal_Finished(QDBusPendingCallWatcher * self) { callbackQDBusPendingCallWatcherFinished(this->objectName().toUtf8().data(), self); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusPendingCallWatcherTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusPendingCallWatcher::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusPendingCallWatcherChildEvent(this->objectName().toUtf8().data(), event)) { QDBusPendingCallWatcher::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusPendingCallWatcherCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusPendingCallWatcher::customEvent(event); }; };
 };
 
 void QDBusPendingCallWatcher_WaitForFinished(void* ptr){
@@ -452,6 +466,9 @@ public:
 	MyQDBusServer(QObject *parent) : QDBusServer(parent) {};
 	MyQDBusServer(const QString &address, QObject *parent) : QDBusServer(address, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusServerTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusServer::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusServerChildEvent(this->objectName().toUtf8().data(), event)) { QDBusServer::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusServerCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusServer::customEvent(event); }; };
 };
 
 void* QDBusServer_NewQDBusServer2(void* parent){
@@ -488,6 +505,9 @@ public:
 	void Signal_ServiceRegistered(const QString & serviceName) { callbackQDBusServiceWatcherServiceRegistered(this->objectName().toUtf8().data(), serviceName.toUtf8().data()); };
 	void Signal_ServiceUnregistered(const QString & serviceName) { callbackQDBusServiceWatcherServiceUnregistered(this->objectName().toUtf8().data(), serviceName.toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusServiceWatcherTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusServiceWatcher::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusServiceWatcherChildEvent(this->objectName().toUtf8().data(), event)) { QDBusServiceWatcher::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusServiceWatcherCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusServiceWatcher::customEvent(event); }; };
 };
 
 void QDBusServiceWatcher_SetWatchMode(void* ptr, int mode){
@@ -633,6 +653,9 @@ void* QDBusVariant_Variant(void* ptr){
 class MyQDBusVirtualObject: public QDBusVirtualObject {
 public:
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDBusVirtualObjectTimerEvent(this->objectName().toUtf8().data(), event)) { QDBusVirtualObject::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDBusVirtualObjectChildEvent(this->objectName().toUtf8().data(), event)) { QDBusVirtualObject::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDBusVirtualObjectCustomEvent(this->objectName().toUtf8().data(), event)) { QDBusVirtualObject::customEvent(event); }; };
 };
 
 int QDBusVirtualObject_HandleMessage(void* ptr, void* message, void* connection){

dbus/qdbusabstractadaptor.go

@@ -45,3 +45,93 @@ func (ptr *QDBusAbstractAdaptor) DestroyQDBusAbstractAdaptor() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusAbstractAdaptor) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusAbstractAdaptor::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractAdaptor) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractAdaptor::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusAbstractAdaptorTimerEvent
+func callbackQDBusAbstractAdaptorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractAdaptor::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusAbstractAdaptor) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusAbstractAdaptor::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractAdaptor) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractAdaptor::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusAbstractAdaptorChildEvent
+func callbackQDBusAbstractAdaptorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractAdaptor::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusAbstractAdaptor) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusAbstractAdaptor::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractAdaptor) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractAdaptor::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusAbstractAdaptorCustomEvent
+func callbackQDBusAbstractAdaptorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractAdaptor::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusabstractinterface.go

@@ -98,3 +98,93 @@ func (ptr *QDBusAbstractInterface) DestroyQDBusAbstractInterface() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusAbstractInterface) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusAbstractInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractInterface) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusAbstractInterfaceTimerEvent
+func callbackQDBusAbstractInterfaceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractInterface::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusAbstractInterface) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusAbstractInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractInterface) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusAbstractInterfaceChildEvent
+func callbackQDBusAbstractInterfaceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractInterface::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusAbstractInterface) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusAbstractInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusAbstractInterface) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusAbstractInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusAbstractInterfaceCustomEvent
+func callbackQDBusAbstractInterfaceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusAbstractInterface::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusconnectioninterface.go

@@ -4,6 +4,7 @@ package dbus
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -117,3 +118,93 @@ func callbackQDBusConnectionInterfaceServiceUnregistered(ptrName *C.char, servic
 	}
 
 }
+
+func (ptr *QDBusConnectionInterface) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusConnectionInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusConnectionInterface) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusConnectionInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusConnectionInterfaceTimerEvent
+func callbackQDBusConnectionInterfaceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusConnectionInterface::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusConnectionInterface) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusConnectionInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusConnectionInterface) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusConnectionInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusConnectionInterfaceChildEvent
+func callbackQDBusConnectionInterfaceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusConnectionInterface::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusConnectionInterface) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusConnectionInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusConnectionInterface) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusConnectionInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusConnectionInterfaceCustomEvent
+func callbackQDBusConnectionInterfaceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusConnectionInterface::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusinterface.go

@@ -51,3 +51,93 @@ func (ptr *QDBusInterface) DestroyQDBusInterface() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusInterface) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusInterface) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusInterface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusInterfaceTimerEvent
+func callbackQDBusInterfaceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusInterface::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusInterface) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusInterface) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusInterface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusInterfaceChildEvent
+func callbackQDBusInterfaceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusInterface::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusInterface) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusInterface) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusInterface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusInterfaceCustomEvent
+func callbackQDBusInterfaceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusInterface::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbuspendingcallwatcher.go

@@ -107,3 +107,93 @@ func (ptr *QDBusPendingCallWatcher) DestroyQDBusPendingCallWatcher() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusPendingCallWatcher) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusPendingCallWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusPendingCallWatcher) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusPendingCallWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusPendingCallWatcherTimerEvent
+func callbackQDBusPendingCallWatcherTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusPendingCallWatcher::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusPendingCallWatcher) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusPendingCallWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusPendingCallWatcher) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusPendingCallWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusPendingCallWatcherChildEvent
+func callbackQDBusPendingCallWatcherChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusPendingCallWatcher::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusPendingCallWatcher) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusPendingCallWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusPendingCallWatcher) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusPendingCallWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusPendingCallWatcherCustomEvent
+func callbackQDBusPendingCallWatcherCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusPendingCallWatcher::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusserver.go

@@ -92,3 +92,93 @@ func (ptr *QDBusServer) DestroyQDBusServer() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusServer) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusServer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusServer) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusServer::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusServerTimerEvent
+func callbackQDBusServerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServer::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusServer) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusServer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusServer) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusServer::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusServerChildEvent
+func callbackQDBusServerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServer::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusServer) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusServer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusServer) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusServer::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusServerCustomEvent
+func callbackQDBusServerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServer::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusservicewatcher.go

@@ -210,3 +210,93 @@ func (ptr *QDBusServiceWatcher) DestroyQDBusServiceWatcher() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusServiceWatcher) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusServiceWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusServiceWatcher) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusServiceWatcher::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusServiceWatcherTimerEvent
+func callbackQDBusServiceWatcherTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServiceWatcher::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusServiceWatcher) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusServiceWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusServiceWatcher) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusServiceWatcher::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusServiceWatcherChildEvent
+func callbackQDBusServiceWatcherChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServiceWatcher::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusServiceWatcher) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusServiceWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusServiceWatcher) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusServiceWatcher::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusServiceWatcherCustomEvent
+func callbackQDBusServiceWatcherCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusServiceWatcher::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

dbus/qdbusvirtualobject.go

@@ -63,3 +63,93 @@ func (ptr *QDBusVirtualObject) DestroyQDBusVirtualObject() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDBusVirtualObject) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDBusVirtualObject::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDBusVirtualObject) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDBusVirtualObject::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDBusVirtualObjectTimerEvent
+func callbackQDBusVirtualObjectTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusVirtualObject::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusVirtualObject) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDBusVirtualObject::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDBusVirtualObject) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDBusVirtualObject::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDBusVirtualObjectChildEvent
+func callbackQDBusVirtualObjectChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusVirtualObject::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDBusVirtualObject) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDBusVirtualObject::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDBusVirtualObject) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDBusVirtualObject::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDBusVirtualObjectCustomEvent
+func callbackQDBusVirtualObjectCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDBusVirtualObject::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/gui.cpp

@@ -26,6 +26,7 @@
 #include <QBrush>
 #include <QByteArray>
 #include <QChar>
+#include <QChildEvent>
 #include <QClipboard>
 #include <QCloseEvent>
 #include <QColor>
@@ -175,6 +176,9 @@
 #include <QTextTableCell>
 #include <QTextTableCellFormat>
 #include <QTextTableFormat>
+#include <QTime>
+#include <QTimer>
+#include <QTimerEvent>
 #include <QTouchDevice>
 #include <QTouchEvent>
 #include <QTransform>
@@ -195,6 +199,9 @@ class MyQAbstractTextDocumentLayout: public QAbstractTextDocumentLayout {
 public:
 	void Signal_PageCountChanged(int newPages) { callbackQAbstractTextDocumentLayoutPageCountChanged(this->objectName().toUtf8().data(), newPages); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQAbstractTextDocumentLayoutTimerEvent(this->objectName().toUtf8().data(), event)) { QAbstractTextDocumentLayout::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQAbstractTextDocumentLayoutChildEvent(this->objectName().toUtf8().data(), event)) { QAbstractTextDocumentLayout::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQAbstractTextDocumentLayoutCustomEvent(this->objectName().toUtf8().data(), event)) { QAbstractTextDocumentLayout::customEvent(event); }; };
 };
 
 char* QAbstractTextDocumentLayout_AnchorAt(void* ptr, void* position){
@@ -1143,6 +1150,9 @@ public:
 	void Signal_FindBufferChanged() { callbackQClipboardFindBufferChanged(this->objectName().toUtf8().data()); };
 	void Signal_SelectionChanged() { callbackQClipboardSelectionChanged(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQClipboardTimerEvent(this->objectName().toUtf8().data(), event)) { QClipboard::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQClipboardChildEvent(this->objectName().toUtf8().data(), event)) { QClipboard::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQClipboardCustomEvent(this->objectName().toUtf8().data(), event)) { QClipboard::customEvent(event); }; };
 };
 
 void QClipboard_Clear(void* ptr, int mode){
@@ -1705,6 +1715,9 @@ class MyQDoubleValidator: public QDoubleValidator {
 public:
 	MyQDoubleValidator(QObject *parent) : QDoubleValidator(parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDoubleValidatorTimerEvent(this->objectName().toUtf8().data(), event)) { QDoubleValidator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDoubleValidatorChildEvent(this->objectName().toUtf8().data(), event)) { QDoubleValidator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDoubleValidatorCustomEvent(this->objectName().toUtf8().data(), event)) { QDoubleValidator::customEvent(event); }; };
 };
 
 int QDoubleValidator_Notation(void* ptr){
@@ -1736,6 +1749,9 @@ public:
 	void Signal_ActionChanged(Qt::DropAction action) { callbackQDragActionChanged(this->objectName().toUtf8().data(), action); };
 	void Signal_TargetChanged(QObject * newTarget) { callbackQDragTargetChanged(this->objectName().toUtf8().data(), newTarget); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQDragTimerEvent(this->objectName().toUtf8().data(), event)) { QDrag::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQDragChildEvent(this->objectName().toUtf8().data(), event)) { QDrag::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQDragCustomEvent(this->objectName().toUtf8().data(), event)) { QDrag::customEvent(event); }; };
 };
 
 void* QDrag_NewQDrag(void* dragSource){
@@ -2742,6 +2758,9 @@ public:
 	void Signal_ScreenAdded(QScreen * screen) { callbackQGuiApplicationScreenAdded(this->objectName().toUtf8().data(), screen); };
 	void Signal_ScreenRemoved(QScreen * screen) { callbackQGuiApplicationScreenRemoved(this->objectName().toUtf8().data(), screen); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQGuiApplicationTimerEvent(this->objectName().toUtf8().data(), event)) { QGuiApplication::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQGuiApplicationChildEvent(this->objectName().toUtf8().data(), event)) { QGuiApplication::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQGuiApplicationCustomEvent(this->objectName().toUtf8().data(), event)) { QGuiApplication::customEvent(event); }; };
 };
 
 char* QGuiApplication_QGuiApplication_ApplicationDisplayName(){
@@ -3652,6 +3671,9 @@ public:
 	void Signal_LocaleChanged() { callbackQInputMethodLocaleChanged(this->objectName().toUtf8().data()); };
 	void Signal_VisibleChanged() { callbackQInputMethodVisibleChanged(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQInputMethodTimerEvent(this->objectName().toUtf8().data(), event)) { QInputMethod::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQInputMethodChildEvent(this->objectName().toUtf8().data(), event)) { QInputMethod::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQInputMethodCustomEvent(this->objectName().toUtf8().data(), event)) { QInputMethod::customEvent(event); }; };
 };
 
 int QInputMethod_InputDirection(void* ptr){
@@ -3804,6 +3826,9 @@ public:
 	MyQIntValidator(int minimum, int maximum, QObject *parent) : QIntValidator(minimum, maximum, parent) {};
 	void setRange(int bottom, int top) { if (!callbackQIntValidatorSetRange(this->objectName().toUtf8().data(), bottom, top)) { QIntValidator::setRange(bottom, top); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQIntValidatorTimerEvent(this->objectName().toUtf8().data(), event)) { QIntValidator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQIntValidatorChildEvent(this->objectName().toUtf8().data(), event)) { QIntValidator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQIntValidatorCustomEvent(this->objectName().toUtf8().data(), event)) { QIntValidator::customEvent(event); }; };
 };
 
 void QIntValidator_SetBottom(void* ptr, int v){
@@ -4076,6 +4101,9 @@ public:
 	void Signal_StateChanged(QMovie::MovieState state) { callbackQMovieStateChanged(this->objectName().toUtf8().data(), state); };
 	void Signal_Updated(const QRect & rect) { callbackQMovieUpdated(this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQMovieTimerEvent(this->objectName().toUtf8().data(), event)) { QMovie::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQMovieChildEvent(this->objectName().toUtf8().data(), event)) { QMovie::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQMovieCustomEvent(this->objectName().toUtf8().data(), event)) { QMovie::customEvent(event); }; };
 };
 
 int QMovie_CacheMode(void* ptr){
@@ -4275,6 +4303,9 @@ public:
 	MyQOffscreenSurface(QScreen *targetScreen) : QOffscreenSurface(targetScreen) {};
 	void Signal_ScreenChanged(QScreen * screen) { callbackQOffscreenSurfaceScreenChanged(this->objectName().toUtf8().data(), screen); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQOffscreenSurfaceTimerEvent(this->objectName().toUtf8().data(), event)) { QOffscreenSurface::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQOffscreenSurfaceChildEvent(this->objectName().toUtf8().data(), event)) { QOffscreenSurface::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQOffscreenSurfaceCustomEvent(this->objectName().toUtf8().data(), event)) { QOffscreenSurface::customEvent(event); }; };
 };
 
 void* QOffscreenSurface_NewQOffscreenSurface(void* targetScreen){
@@ -4653,6 +4684,25 @@ class MyQPaintDeviceWindow: public QPaintDeviceWindow {
 public:
 protected:
 	void paintEvent(QPaintEvent * event) { if (!callbackQPaintDeviceWindowPaintEvent(this->objectName().toUtf8().data(), event)) { QPaintDeviceWindow::paintEvent(event); }; };
+	void exposeEvent(QExposeEvent * ev) { if (!callbackQPaintDeviceWindowExposeEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::exposeEvent(ev); }; };
+	void focusInEvent(QFocusEvent * ev) { if (!callbackQPaintDeviceWindowFocusInEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::focusInEvent(ev); }; };
+	void focusOutEvent(QFocusEvent * ev) { if (!callbackQPaintDeviceWindowFocusOutEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::focusOutEvent(ev); }; };
+	void hideEvent(QHideEvent * ev) { if (!callbackQPaintDeviceWindowHideEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::hideEvent(ev); }; };
+	void keyPressEvent(QKeyEvent * ev) { if (!callbackQPaintDeviceWindowKeyPressEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::keyPressEvent(ev); }; };
+	void keyReleaseEvent(QKeyEvent * ev) { if (!callbackQPaintDeviceWindowKeyReleaseEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::keyReleaseEvent(ev); }; };
+	void mouseDoubleClickEvent(QMouseEvent * ev) { if (!callbackQPaintDeviceWindowMouseDoubleClickEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::mouseDoubleClickEvent(ev); }; };
+	void mouseMoveEvent(QMouseEvent * ev) { if (!callbackQPaintDeviceWindowMouseMoveEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::mouseMoveEvent(ev); }; };
+	void mousePressEvent(QMouseEvent * ev) { if (!callbackQPaintDeviceWindowMousePressEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::mousePressEvent(ev); }; };
+	void mouseReleaseEvent(QMouseEvent * ev) { if (!callbackQPaintDeviceWindowMouseReleaseEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::mouseReleaseEvent(ev); }; };
+	void moveEvent(QMoveEvent * ev) { if (!callbackQPaintDeviceWindowMoveEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::moveEvent(ev); }; };
+	void resizeEvent(QResizeEvent * ev) { if (!callbackQPaintDeviceWindowResizeEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::resizeEvent(ev); }; };
+	void showEvent(QShowEvent * ev) { if (!callbackQPaintDeviceWindowShowEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::showEvent(ev); }; };
+	void tabletEvent(QTabletEvent * ev) { if (!callbackQPaintDeviceWindowTabletEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::tabletEvent(ev); }; };
+	void touchEvent(QTouchEvent * ev) { if (!callbackQPaintDeviceWindowTouchEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::touchEvent(ev); }; };
+	void wheelEvent(QWheelEvent * ev) { if (!callbackQPaintDeviceWindowWheelEvent(this->objectName().toUtf8().data(), ev)) { QPaintDeviceWindow::wheelEvent(ev); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQPaintDeviceWindowTimerEvent(this->objectName().toUtf8().data(), event)) { QPaintDeviceWindow::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQPaintDeviceWindowChildEvent(this->objectName().toUtf8().data(), event)) { QPaintDeviceWindow::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQPaintDeviceWindowCustomEvent(this->objectName().toUtf8().data(), event)) { QPaintDeviceWindow::customEvent(event); }; };
 };
 
 void QPaintDeviceWindow_Update3(void* ptr){
@@ -5932,6 +5982,9 @@ public:
 	MyQPdfWriter(QIODevice *device) : QPdfWriter(device) {};
 	MyQPdfWriter(const QString &filename) : QPdfWriter(filename) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQPdfWriterTimerEvent(this->objectName().toUtf8().data(), event)) { QPdfWriter::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQPdfWriterChildEvent(this->objectName().toUtf8().data(), event)) { QPdfWriter::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQPdfWriterCustomEvent(this->objectName().toUtf8().data(), event)) { QPdfWriter::customEvent(event); }; };
 };
 
 void* QPdfWriter_NewQPdfWriter2(void* device){
@@ -6639,6 +6692,9 @@ public:
 	MyQRegExpValidator(QObject *parent) : QRegExpValidator(parent) {};
 	MyQRegExpValidator(const QRegExp &rx, QObject *parent) : QRegExpValidator(rx, parent) {};
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQRegExpValidatorTimerEvent(this->objectName().toUtf8().data(), event)) { QRegExpValidator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQRegExpValidatorChildEvent(this->objectName().toUtf8().data(), event)) { QRegExpValidator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQRegExpValidatorCustomEvent(this->objectName().toUtf8().data(), event)) { QRegExpValidator::customEvent(event); }; };
 };
 
 void QRegExpValidator_SetRegExp(void* ptr, void* rx){
@@ -6771,6 +6827,9 @@ public:
 	MyQRegularExpressionValidator(const QRegularExpression &re, QObject *parent) : QRegularExpressionValidator(re, parent) {};
 	void Signal_RegularExpressionChanged(const QRegularExpression & re) { callbackQRegularExpressionValidatorRegularExpressionChanged(this->objectName().toUtf8().data(), new QRegularExpression(re)); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQRegularExpressionValidatorTimerEvent(this->objectName().toUtf8().data(), event)) { QRegularExpressionValidator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQRegularExpressionValidatorChildEvent(this->objectName().toUtf8().data(), event)) { QRegularExpressionValidator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQRegularExpressionValidatorCustomEvent(this->objectName().toUtf8().data(), event)) { QRegularExpressionValidator::customEvent(event); }; };
 };
 
 void* QRegularExpressionValidator_RegularExpression(void* ptr){
@@ -6824,6 +6883,9 @@ public:
 	void Signal_RefreshRateChanged(qreal refreshRate) { callbackQScreenRefreshRateChanged(this->objectName().toUtf8().data(), static_cast<double>(refreshRate)); };
 	void Signal_VirtualGeometryChanged(const QRect & rect) { callbackQScreenVirtualGeometryChanged(this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height())); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQScreenTimerEvent(this->objectName().toUtf8().data(), event)) { QScreen::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQScreenChildEvent(this->objectName().toUtf8().data(), event)) { QScreen::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQScreenCustomEvent(this->objectName().toUtf8().data(), event)) { QScreen::customEvent(event); }; };
 };
 
 void* QScreen_AvailableGeometry(void* ptr){
@@ -7437,7 +7499,12 @@ public:
 	MyQStandardItemModel(int rows, int columns, QObject *parent) : QStandardItemModel(rows, columns, parent) {};
 	void Signal_ItemChanged(QStandardItem * item) { callbackQStandardItemModelItemChanged(this->objectName().toUtf8().data(), item); };
 	void sort(int column, Qt::SortOrder order) { if (!callbackQStandardItemModelSort(this->objectName().toUtf8().data(), column, order)) { QStandardItemModel::sort(column, order); }; };
+	void fetchMore(const QModelIndex & parent) { if (!callbackQStandardItemModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QStandardItemModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQStandardItemModelRevert(this->objectName().toUtf8().data())) { QStandardItemModel::revert(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQStandardItemModelTimerEvent(this->objectName().toUtf8().data(), event)) { QStandardItemModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQStandardItemModelChildEvent(this->objectName().toUtf8().data(), event)) { QStandardItemModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQStandardItemModelCustomEvent(this->objectName().toUtf8().data(), event)) { QStandardItemModel::customEvent(event); }; };
 };
 
 void QStandardItemModel_SetSortRole(void* ptr, int role){
@@ -7716,6 +7783,9 @@ public:
 	void Signal_StartDragDistanceChanged(int startDragDistance) { callbackQStyleHintsStartDragDistanceChanged(this->objectName().toUtf8().data(), startDragDistance); };
 	void Signal_StartDragTimeChanged(int startDragTime) { callbackQStyleHintsStartDragTimeChanged(this->objectName().toUtf8().data(), startDragTime); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQStyleHintsTimerEvent(this->objectName().toUtf8().data(), event)) { QStyleHints::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQStyleHintsChildEvent(this->objectName().toUtf8().data(), event)) { QStyleHints::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQStyleHintsCustomEvent(this->objectName().toUtf8().data(), event)) { QStyleHints::customEvent(event); }; };
 };
 
 int QStyleHints_CursorFlashTime(void* ptr){
@@ -8013,6 +8083,9 @@ void QSurfaceFormat_DestroyQSurfaceFormat(void* ptr){
 class MyQSyntaxHighlighter: public QSyntaxHighlighter {
 public:
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQSyntaxHighlighterTimerEvent(this->objectName().toUtf8().data(), event)) { QSyntaxHighlighter::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQSyntaxHighlighterChildEvent(this->objectName().toUtf8().data(), event)) { QSyntaxHighlighter::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQSyntaxHighlighterCustomEvent(this->objectName().toUtf8().data(), event)) { QSyntaxHighlighter::customEvent(event); }; };
 };
 
 void* QSyntaxHighlighter_Document(void* ptr){
@@ -8314,6 +8387,9 @@ double QTextBlockFormat_TopMargin(void* ptr){
 class MyQTextBlockGroup: public QTextBlockGroup {
 public:
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQTextBlockGroupTimerEvent(this->objectName().toUtf8().data(), event)) { QTextBlockGroup::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTextBlockGroupChildEvent(this->objectName().toUtf8().data(), event)) { QTextBlockGroup::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTextBlockGroupCustomEvent(this->objectName().toUtf8().data(), event)) { QTextBlockGroup::customEvent(event); }; };
 };
 
 class MyQTextBlockUserData: public QTextBlockUserData {
@@ -8835,6 +8911,9 @@ public:
 	void Signal_UndoAvailable(bool available) { callbackQTextDocumentUndoAvailable(this->objectName().toUtf8().data(), available); };
 	void Signal_UndoCommandAdded() { callbackQTextDocumentUndoCommandAdded(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQTextDocumentTimerEvent(this->objectName().toUtf8().data(), event)) { QTextDocument::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQTextDocumentChildEvent(this->objectName().toUtf8().data(), event)) { QTextDocument::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQTextDocumentCustomEvent(this->objectName().toUtf8().data(), event)) { QTextDocument::customEvent(event); }; };
 };
 
 void* QTextDocument_BaseUrl(void* ptr){
@@ -10429,6 +10508,9 @@ class MyQValidator: public QValidator {
 public:
 	void Signal_Changed() { callbackQValidatorChanged(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQValidatorTimerEvent(this->objectName().toUtf8().data(), event)) { QValidator::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQValidatorChildEvent(this->objectName().toUtf8().data(), event)) { QValidator::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQValidatorCustomEvent(this->objectName().toUtf8().data(), event)) { QValidator::customEvent(event); }; };
 };
 
 void QValidator_ConnectChanged(void* ptr){
@@ -10646,6 +10728,9 @@ protected:
 	void tabletEvent(QTabletEvent * ev) { if (!callbackQWindowTabletEvent(this->objectName().toUtf8().data(), ev)) { QWindow::tabletEvent(ev); }; };
 	void touchEvent(QTouchEvent * ev) { if (!callbackQWindowTouchEvent(this->objectName().toUtf8().data(), ev)) { QWindow::touchEvent(ev); }; };
 	void wheelEvent(QWheelEvent * ev) { if (!callbackQWindowWheelEvent(this->objectName().toUtf8().data(), ev)) { QWindow::wheelEvent(ev); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQWindowTimerEvent(this->objectName().toUtf8().data(), event)) { QWindow::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQWindowChildEvent(this->objectName().toUtf8().data(), event)) { QWindow::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQWindowCustomEvent(this->objectName().toUtf8().data(), event)) { QWindow::customEvent(event); }; };
 };
 
 int QWindow_ContentOrientation(void* ptr){

gui/qabstracttextdocumentlayout.go

@@ -133,3 +133,93 @@ func (ptr *QAbstractTextDocumentLayout) UnregisterHandler(objectType int, compon
 		C.QAbstractTextDocumentLayout_UnregisterHandler(ptr.Pointer(), C.int(objectType), core.PointerFromQObject(component))
 	}
 }
+
+func (ptr *QAbstractTextDocumentLayout) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QAbstractTextDocumentLayout::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QAbstractTextDocumentLayout) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QAbstractTextDocumentLayout::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQAbstractTextDocumentLayoutTimerEvent
+func callbackQAbstractTextDocumentLayoutTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTextDocumentLayout::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTextDocumentLayout) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QAbstractTextDocumentLayout::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QAbstractTextDocumentLayout) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QAbstractTextDocumentLayout::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQAbstractTextDocumentLayoutChildEvent
+func callbackQAbstractTextDocumentLayoutChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTextDocumentLayout::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QAbstractTextDocumentLayout) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QAbstractTextDocumentLayout::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QAbstractTextDocumentLayout) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QAbstractTextDocumentLayout::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQAbstractTextDocumentLayoutCustomEvent
+func callbackQAbstractTextDocumentLayoutCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QAbstractTextDocumentLayout::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qclipboard.go

@@ -261,3 +261,93 @@ func (ptr *QClipboard) Text(mode QClipboard__Mode) string {
 	}
 	return ""
 }
+
+func (ptr *QClipboard) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QClipboard::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QClipboard) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QClipboard::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQClipboardTimerEvent
+func callbackQClipboardTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QClipboard::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QClipboard) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QClipboard::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QClipboard) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QClipboard::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQClipboardChildEvent
+func callbackQClipboardChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QClipboard::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QClipboard) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QClipboard::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QClipboard) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QClipboard::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQClipboardCustomEvent
+func callbackQClipboardCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QClipboard::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qdoublevalidator.go

@@ -93,3 +93,93 @@ func (ptr *QDoubleValidator) DestroyQDoubleValidator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDoubleValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDoubleValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDoubleValidator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDoubleValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDoubleValidatorTimerEvent
+func callbackQDoubleValidatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDoubleValidator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDoubleValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDoubleValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDoubleValidator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDoubleValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDoubleValidatorChildEvent
+func callbackQDoubleValidatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDoubleValidator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDoubleValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDoubleValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDoubleValidator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDoubleValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDoubleValidatorCustomEvent
+func callbackQDoubleValidatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDoubleValidator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qdrag.go

@@ -202,3 +202,93 @@ func (ptr *QDrag) DestroyQDrag() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QDrag) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QDrag::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QDrag) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QDrag::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQDragTimerEvent
+func callbackQDragTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDrag::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDrag) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QDrag::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QDrag) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QDrag::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQDragChildEvent
+func callbackQDragChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDrag::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QDrag) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QDrag::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QDrag) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QDrag::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQDragCustomEvent
+func callbackQDragCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QDrag::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qguiapplication.go

@@ -528,3 +528,93 @@ func (ptr *QGuiApplication) DestroyQGuiApplication() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QGuiApplication) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QGuiApplication::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QGuiApplication) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QGuiApplication::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQGuiApplicationTimerEvent
+func callbackQGuiApplicationTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QGuiApplication::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QGuiApplication) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QGuiApplication::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QGuiApplication) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QGuiApplication::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQGuiApplicationChildEvent
+func callbackQGuiApplicationChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QGuiApplication::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QGuiApplication) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QGuiApplication::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QGuiApplication) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QGuiApplication::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQGuiApplicationCustomEvent
+func callbackQGuiApplicationCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QGuiApplication::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qinputmethod.go

@@ -317,3 +317,93 @@ func callbackQInputMethodVisibleChanged(ptrName *C.char) {
 	}
 
 }
+
+func (ptr *QInputMethod) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QInputMethod::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QInputMethod) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QInputMethod::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQInputMethodTimerEvent
+func callbackQInputMethodTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QInputMethod::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QInputMethod) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QInputMethod::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QInputMethod) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QInputMethod::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQInputMethodChildEvent
+func callbackQInputMethodChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QInputMethod::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QInputMethod) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QInputMethod::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QInputMethod) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QInputMethod::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQInputMethodCustomEvent
+func callbackQInputMethodCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QInputMethod::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qintvalidator.go

@@ -121,3 +121,93 @@ func (ptr *QIntValidator) DestroyQIntValidator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QIntValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QIntValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QIntValidator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QIntValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQIntValidatorTimerEvent
+func callbackQIntValidatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIntValidator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIntValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QIntValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QIntValidator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QIntValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQIntValidatorChildEvent
+func callbackQIntValidatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIntValidator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QIntValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QIntValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QIntValidator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QIntValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQIntValidatorCustomEvent
+func callbackQIntValidatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QIntValidator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qmovie.go

@@ -500,3 +500,93 @@ func (ptr *QMovie) DestroyQMovie() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QMovie) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QMovie::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QMovie) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QMovie::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQMovieTimerEvent
+func callbackQMovieTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMovie::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QMovie) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QMovie::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QMovie) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QMovie::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQMovieChildEvent
+func callbackQMovieChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMovie::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QMovie) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QMovie::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QMovie) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QMovie::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQMovieCustomEvent
+func callbackQMovieCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QMovie::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qoffscreensurface.go

@@ -158,3 +158,93 @@ func (ptr *QOffscreenSurface) DestroyQOffscreenSurface() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QOffscreenSurface) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QOffscreenSurface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QOffscreenSurface) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QOffscreenSurface::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQOffscreenSurfaceTimerEvent
+func callbackQOffscreenSurfaceTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QOffscreenSurface::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QOffscreenSurface) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QOffscreenSurface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QOffscreenSurface) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QOffscreenSurface::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQOffscreenSurfaceChildEvent
+func callbackQOffscreenSurfaceChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QOffscreenSurface::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QOffscreenSurface) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QOffscreenSurface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QOffscreenSurface) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QOffscreenSurface::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQOffscreenSurfaceCustomEvent
+func callbackQOffscreenSurfaceCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QOffscreenSurface::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qpaintdevicewindow.go

@@ -101,3 +101,573 @@ func (ptr *QPaintDeviceWindow) Update2(region QRegion_ITF) {
 		C.QPaintDeviceWindow_Update2(ptr.Pointer(), PointerFromQRegion(region))
 	}
 }
+
+func (ptr *QPaintDeviceWindow) ConnectExposeEvent(f func(ev *QExposeEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::exposeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "exposeEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectExposeEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::exposeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "exposeEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowExposeEvent
+func callbackQPaintDeviceWindowExposeEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::exposeEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "exposeEvent"); signal != nil {
+		signal.(func(*QExposeEvent))(NewQExposeEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectFocusInEvent(f func(ev *QFocusEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::focusInEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "focusInEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectFocusInEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::focusInEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "focusInEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowFocusInEvent
+func callbackQPaintDeviceWindowFocusInEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::focusInEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "focusInEvent"); signal != nil {
+		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectFocusOutEvent(f func(ev *QFocusEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::focusOutEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "focusOutEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectFocusOutEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::focusOutEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "focusOutEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowFocusOutEvent
+func callbackQPaintDeviceWindowFocusOutEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::focusOutEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "focusOutEvent"); signal != nil {
+		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectHideEvent(f func(ev *QHideEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::hideEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "hideEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectHideEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::hideEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "hideEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowHideEvent
+func callbackQPaintDeviceWindowHideEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::hideEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "hideEvent"); signal != nil {
+		signal.(func(*QHideEvent))(NewQHideEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectKeyPressEvent(f func(ev *QKeyEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::keyPressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "keyPressEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectKeyPressEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::keyPressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "keyPressEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowKeyPressEvent
+func callbackQPaintDeviceWindowKeyPressEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::keyPressEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "keyPressEvent"); signal != nil {
+		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectKeyReleaseEvent(f func(ev *QKeyEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::keyReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "keyReleaseEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectKeyReleaseEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::keyReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "keyReleaseEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowKeyReleaseEvent
+func callbackQPaintDeviceWindowKeyReleaseEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::keyReleaseEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "keyReleaseEvent"); signal != nil {
+		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectMouseDoubleClickEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::mouseDoubleClickEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectMouseDoubleClickEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseDoubleClickEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowMouseDoubleClickEvent
+func callbackQPaintDeviceWindowMouseDoubleClickEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::mouseDoubleClickEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectMouseMoveEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::mouseMoveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseMoveEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectMouseMoveEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseMoveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseMoveEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowMouseMoveEvent
+func callbackQPaintDeviceWindowMouseMoveEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::mouseMoveEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseMoveEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectMousePressEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::mousePressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mousePressEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectMousePressEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::mousePressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mousePressEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowMousePressEvent
+func callbackQPaintDeviceWindowMousePressEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::mousePressEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mousePressEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectMouseReleaseEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::mouseReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseReleaseEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectMouseReleaseEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::mouseReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseReleaseEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowMouseReleaseEvent
+func callbackQPaintDeviceWindowMouseReleaseEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::mouseReleaseEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseReleaseEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectMoveEvent(f func(ev *QMoveEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::moveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "moveEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectMoveEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::moveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "moveEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowMoveEvent
+func callbackQPaintDeviceWindowMoveEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::moveEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "moveEvent"); signal != nil {
+		signal.(func(*QMoveEvent))(NewQMoveEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectResizeEvent(f func(ev *QResizeEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::resizeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "resizeEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectResizeEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::resizeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "resizeEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowResizeEvent
+func callbackQPaintDeviceWindowResizeEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::resizeEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "resizeEvent"); signal != nil {
+		signal.(func(*QResizeEvent))(NewQResizeEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectShowEvent(f func(ev *QShowEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::showEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "showEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectShowEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::showEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "showEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowShowEvent
+func callbackQPaintDeviceWindowShowEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::showEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "showEvent"); signal != nil {
+		signal.(func(*QShowEvent))(NewQShowEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectTabletEvent(f func(ev *QTabletEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::tabletEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "tabletEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectTabletEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::tabletEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "tabletEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowTabletEvent
+func callbackQPaintDeviceWindowTabletEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::tabletEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "tabletEvent"); signal != nil {
+		signal.(func(*QTabletEvent))(NewQTabletEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectTouchEvent(f func(ev *QTouchEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::touchEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "touchEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectTouchEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::touchEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "touchEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowTouchEvent
+func callbackQPaintDeviceWindowTouchEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::touchEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "touchEvent"); signal != nil {
+		signal.(func(*QTouchEvent))(NewQTouchEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectWheelEvent(f func(ev *QWheelEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::wheelEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "wheelEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectWheelEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::wheelEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "wheelEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowWheelEvent
+func callbackQPaintDeviceWindowWheelEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::wheelEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "wheelEvent"); signal != nil {
+		signal.(func(*QWheelEvent))(NewQWheelEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowTimerEvent
+func callbackQPaintDeviceWindowTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowChildEvent
+func callbackQPaintDeviceWindowChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPaintDeviceWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QPaintDeviceWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QPaintDeviceWindow) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QPaintDeviceWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQPaintDeviceWindowCustomEvent
+func callbackQPaintDeviceWindowCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPaintDeviceWindow::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qpdfwriter.go

@@ -173,3 +173,93 @@ func (ptr *QPdfWriter) DestroyQPdfWriter() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QPdfWriter) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QPdfWriter::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QPdfWriter) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QPdfWriter::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQPdfWriterTimerEvent
+func callbackQPdfWriterTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPdfWriter::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPdfWriter) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QPdfWriter::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QPdfWriter) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QPdfWriter::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQPdfWriterChildEvent
+func callbackQPdfWriterChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPdfWriter::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QPdfWriter) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QPdfWriter::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QPdfWriter) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QPdfWriter::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQPdfWriterCustomEvent
+func callbackQPdfWriterCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QPdfWriter::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qrasterwindow.go

@@ -4,6 +4,7 @@ package gui
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -41,3 +42,603 @@ func NewQRasterWindow(parent QWindow_ITF) *QRasterWindow {
 
 	return NewQRasterWindowFromPointer(C.QRasterWindow_NewQRasterWindow(PointerFromQWindow(parent)))
 }
+
+func (ptr *QRasterWindow) ConnectPaintEvent(f func(event *QPaintEvent)) {
+	defer qt.Recovering("connect QRasterWindow::paintEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "paintEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectPaintEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::paintEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "paintEvent")
+	}
+}
+
+//export callbackQRasterWindowPaintEvent
+func callbackQRasterWindowPaintEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::paintEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "paintEvent"); signal != nil {
+		signal.(func(*QPaintEvent))(NewQPaintEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectExposeEvent(f func(ev *QExposeEvent)) {
+	defer qt.Recovering("connect QRasterWindow::exposeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "exposeEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectExposeEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::exposeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "exposeEvent")
+	}
+}
+
+//export callbackQRasterWindowExposeEvent
+func callbackQRasterWindowExposeEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::exposeEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "exposeEvent"); signal != nil {
+		signal.(func(*QExposeEvent))(NewQExposeEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectFocusInEvent(f func(ev *QFocusEvent)) {
+	defer qt.Recovering("connect QRasterWindow::focusInEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "focusInEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectFocusInEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::focusInEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "focusInEvent")
+	}
+}
+
+//export callbackQRasterWindowFocusInEvent
+func callbackQRasterWindowFocusInEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::focusInEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "focusInEvent"); signal != nil {
+		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectFocusOutEvent(f func(ev *QFocusEvent)) {
+	defer qt.Recovering("connect QRasterWindow::focusOutEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "focusOutEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectFocusOutEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::focusOutEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "focusOutEvent")
+	}
+}
+
+//export callbackQRasterWindowFocusOutEvent
+func callbackQRasterWindowFocusOutEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::focusOutEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "focusOutEvent"); signal != nil {
+		signal.(func(*QFocusEvent))(NewQFocusEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectHideEvent(f func(ev *QHideEvent)) {
+	defer qt.Recovering("connect QRasterWindow::hideEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "hideEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectHideEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::hideEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "hideEvent")
+	}
+}
+
+//export callbackQRasterWindowHideEvent
+func callbackQRasterWindowHideEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::hideEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "hideEvent"); signal != nil {
+		signal.(func(*QHideEvent))(NewQHideEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectKeyPressEvent(f func(ev *QKeyEvent)) {
+	defer qt.Recovering("connect QRasterWindow::keyPressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "keyPressEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectKeyPressEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::keyPressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "keyPressEvent")
+	}
+}
+
+//export callbackQRasterWindowKeyPressEvent
+func callbackQRasterWindowKeyPressEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::keyPressEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "keyPressEvent"); signal != nil {
+		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectKeyReleaseEvent(f func(ev *QKeyEvent)) {
+	defer qt.Recovering("connect QRasterWindow::keyReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "keyReleaseEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectKeyReleaseEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::keyReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "keyReleaseEvent")
+	}
+}
+
+//export callbackQRasterWindowKeyReleaseEvent
+func callbackQRasterWindowKeyReleaseEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::keyReleaseEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "keyReleaseEvent"); signal != nil {
+		signal.(func(*QKeyEvent))(NewQKeyEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectMouseDoubleClickEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QRasterWindow::mouseDoubleClickEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectMouseDoubleClickEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::mouseDoubleClickEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseDoubleClickEvent")
+	}
+}
+
+//export callbackQRasterWindowMouseDoubleClickEvent
+func callbackQRasterWindowMouseDoubleClickEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::mouseDoubleClickEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseDoubleClickEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectMouseMoveEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QRasterWindow::mouseMoveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseMoveEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectMouseMoveEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::mouseMoveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseMoveEvent")
+	}
+}
+
+//export callbackQRasterWindowMouseMoveEvent
+func callbackQRasterWindowMouseMoveEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::mouseMoveEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseMoveEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectMousePressEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QRasterWindow::mousePressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mousePressEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectMousePressEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::mousePressEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mousePressEvent")
+	}
+}
+
+//export callbackQRasterWindowMousePressEvent
+func callbackQRasterWindowMousePressEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::mousePressEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mousePressEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectMouseReleaseEvent(f func(ev *QMouseEvent)) {
+	defer qt.Recovering("connect QRasterWindow::mouseReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "mouseReleaseEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectMouseReleaseEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::mouseReleaseEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "mouseReleaseEvent")
+	}
+}
+
+//export callbackQRasterWindowMouseReleaseEvent
+func callbackQRasterWindowMouseReleaseEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::mouseReleaseEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "mouseReleaseEvent"); signal != nil {
+		signal.(func(*QMouseEvent))(NewQMouseEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectMoveEvent(f func(ev *QMoveEvent)) {
+	defer qt.Recovering("connect QRasterWindow::moveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "moveEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectMoveEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::moveEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "moveEvent")
+	}
+}
+
+//export callbackQRasterWindowMoveEvent
+func callbackQRasterWindowMoveEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::moveEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "moveEvent"); signal != nil {
+		signal.(func(*QMoveEvent))(NewQMoveEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectResizeEvent(f func(ev *QResizeEvent)) {
+	defer qt.Recovering("connect QRasterWindow::resizeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "resizeEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectResizeEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::resizeEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "resizeEvent")
+	}
+}
+
+//export callbackQRasterWindowResizeEvent
+func callbackQRasterWindowResizeEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::resizeEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "resizeEvent"); signal != nil {
+		signal.(func(*QResizeEvent))(NewQResizeEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectShowEvent(f func(ev *QShowEvent)) {
+	defer qt.Recovering("connect QRasterWindow::showEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "showEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectShowEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::showEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "showEvent")
+	}
+}
+
+//export callbackQRasterWindowShowEvent
+func callbackQRasterWindowShowEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::showEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "showEvent"); signal != nil {
+		signal.(func(*QShowEvent))(NewQShowEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectTabletEvent(f func(ev *QTabletEvent)) {
+	defer qt.Recovering("connect QRasterWindow::tabletEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "tabletEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectTabletEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::tabletEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "tabletEvent")
+	}
+}
+
+//export callbackQRasterWindowTabletEvent
+func callbackQRasterWindowTabletEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::tabletEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "tabletEvent"); signal != nil {
+		signal.(func(*QTabletEvent))(NewQTabletEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectTouchEvent(f func(ev *QTouchEvent)) {
+	defer qt.Recovering("connect QRasterWindow::touchEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "touchEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectTouchEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::touchEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "touchEvent")
+	}
+}
+
+//export callbackQRasterWindowTouchEvent
+func callbackQRasterWindowTouchEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::touchEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "touchEvent"); signal != nil {
+		signal.(func(*QTouchEvent))(NewQTouchEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectWheelEvent(f func(ev *QWheelEvent)) {
+	defer qt.Recovering("connect QRasterWindow::wheelEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "wheelEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectWheelEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::wheelEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "wheelEvent")
+	}
+}
+
+//export callbackQRasterWindowWheelEvent
+func callbackQRasterWindowWheelEvent(ptrName *C.char, ev unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::wheelEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "wheelEvent"); signal != nil {
+		signal.(func(*QWheelEvent))(NewQWheelEventFromPointer(ev))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QRasterWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQRasterWindowTimerEvent
+func callbackQRasterWindowTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QRasterWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQRasterWindowChildEvent
+func callbackQRasterWindowChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRasterWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QRasterWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QRasterWindow) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QRasterWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQRasterWindowCustomEvent
+func callbackQRasterWindowCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRasterWindow::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qregexpvalidator.go

@@ -74,3 +74,93 @@ func (ptr *QRegExpValidator) DestroyQRegExpValidator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QRegExpValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QRegExpValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QRegExpValidator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QRegExpValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQRegExpValidatorTimerEvent
+func callbackQRegExpValidatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegExpValidator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRegExpValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QRegExpValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QRegExpValidator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QRegExpValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQRegExpValidatorChildEvent
+func callbackQRegExpValidatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegExpValidator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRegExpValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QRegExpValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QRegExpValidator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QRegExpValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQRegExpValidatorCustomEvent
+func callbackQRegExpValidatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegExpValidator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qregularexpressionvalidator.go

@@ -102,3 +102,93 @@ func (ptr *QRegularExpressionValidator) DestroyQRegularExpressionValidator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QRegularExpressionValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QRegularExpressionValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QRegularExpressionValidator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QRegularExpressionValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQRegularExpressionValidatorTimerEvent
+func callbackQRegularExpressionValidatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegularExpressionValidator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRegularExpressionValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QRegularExpressionValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QRegularExpressionValidator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QRegularExpressionValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQRegularExpressionValidatorChildEvent
+func callbackQRegularExpressionValidatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegularExpressionValidator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QRegularExpressionValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QRegularExpressionValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QRegularExpressionValidator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QRegularExpressionValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQRegularExpressionValidatorCustomEvent
+func callbackQRegularExpressionValidatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QRegularExpressionValidator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qscreen.go

@@ -511,3 +511,93 @@ func (ptr *QScreen) DestroyQScreen() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QScreen) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QScreen::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QScreen) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QScreen::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQScreenTimerEvent
+func callbackQScreenTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QScreen::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QScreen) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QScreen::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QScreen) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QScreen::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQScreenChildEvent
+func callbackQScreenChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QScreen::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QScreen) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QScreen::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QScreen) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QScreen::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQScreenCustomEvent
+func callbackQScreenCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QScreen::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qsessionmanager.go

@@ -183,3 +183,93 @@ func (ptr *QSessionManager) SetRestartHint(hint QSessionManager__RestartHint) {
 		C.QSessionManager_SetRestartHint(ptr.Pointer(), C.int(hint))
 	}
 }
+
+func (ptr *QSessionManager) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QSessionManager::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSessionManager) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSessionManager::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSessionManagerTimerEvent
+func callbackQSessionManagerTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSessionManager::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSessionManager) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QSessionManager::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSessionManager) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSessionManager::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSessionManagerChildEvent
+func callbackQSessionManagerChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSessionManager::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSessionManager) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QSessionManager::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSessionManager) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSessionManager::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSessionManagerCustomEvent
+func callbackQSessionManagerCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSessionManager::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qstandarditemmodel.go

@@ -499,3 +499,153 @@ func (ptr *QStandardItemModel) DestroyQStandardItemModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QStandardItemModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
+	defer qt.Recovering("connect QStandardItemModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QStandardItemModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QStandardItemModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQStandardItemModelFetchMore
+func callbackQStandardItemModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStandardItemModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStandardItemModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QStandardItemModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QStandardItemModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QStandardItemModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQStandardItemModelRevert
+func callbackQStandardItemModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QStandardItemModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStandardItemModel) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QStandardItemModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QStandardItemModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QStandardItemModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQStandardItemModelTimerEvent
+func callbackQStandardItemModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStandardItemModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStandardItemModel) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QStandardItemModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QStandardItemModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QStandardItemModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQStandardItemModelChildEvent
+func callbackQStandardItemModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStandardItemModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStandardItemModel) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QStandardItemModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QStandardItemModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QStandardItemModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQStandardItemModelCustomEvent
+func callbackQStandardItemModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStandardItemModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qstylehints.go

@@ -311,3 +311,93 @@ func callbackQStyleHintsStartDragTimeChanged(ptrName *C.char, startDragTime C.in
 	}
 
 }
+
+func (ptr *QStyleHints) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QStyleHints::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QStyleHints) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QStyleHints::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQStyleHintsTimerEvent
+func callbackQStyleHintsTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStyleHints::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStyleHints) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QStyleHints::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QStyleHints) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QStyleHints::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQStyleHintsChildEvent
+func callbackQStyleHintsChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStyleHints::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QStyleHints) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QStyleHints::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QStyleHints) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QStyleHints::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQStyleHintsCustomEvent
+func callbackQStyleHintsCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QStyleHints::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qsyntaxhighlighter.go

@@ -78,3 +78,93 @@ func (ptr *QSyntaxHighlighter) DestroyQSyntaxHighlighter() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QSyntaxHighlighter) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QSyntaxHighlighter::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QSyntaxHighlighter) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QSyntaxHighlighter::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQSyntaxHighlighterTimerEvent
+func callbackQSyntaxHighlighterTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSyntaxHighlighter::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSyntaxHighlighter) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QSyntaxHighlighter::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QSyntaxHighlighter) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QSyntaxHighlighter::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQSyntaxHighlighterChildEvent
+func callbackQSyntaxHighlighterChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSyntaxHighlighter::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QSyntaxHighlighter) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QSyntaxHighlighter::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QSyntaxHighlighter) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QSyntaxHighlighter::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQSyntaxHighlighterCustomEvent
+func callbackQSyntaxHighlighterCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QSyntaxHighlighter::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtextblockgroup.go

@@ -4,6 +4,7 @@ package gui
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -35,3 +36,93 @@ func NewQTextBlockGroupFromPointer(ptr unsafe.Pointer) *QTextBlockGroup {
 func (ptr *QTextBlockGroup) QTextBlockGroup_PTR() *QTextBlockGroup {
 	return ptr
 }
+
+func (ptr *QTextBlockGroup) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextBlockGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextBlockGroup) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextBlockGroup::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextBlockGroupTimerEvent
+func callbackQTextBlockGroupTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextBlockGroup::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextBlockGroup) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextBlockGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextBlockGroup) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextBlockGroup::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextBlockGroupChildEvent
+func callbackQTextBlockGroupChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextBlockGroup::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextBlockGroup) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextBlockGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextBlockGroup) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextBlockGroup::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextBlockGroupCustomEvent
+func callbackQTextBlockGroupCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextBlockGroup::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtextdocument.go

@@ -861,3 +861,93 @@ func (ptr *QTextDocument) DestroyQTextDocument() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTextDocument) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextDocument::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextDocument) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextDocument::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextDocumentTimerEvent
+func callbackQTextDocumentTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextDocument::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextDocument) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextDocument::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextDocument) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextDocument::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextDocumentChildEvent
+func callbackQTextDocumentChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextDocument::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextDocument) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextDocument::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextDocument) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextDocument::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextDocumentCustomEvent
+func callbackQTextDocumentCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextDocument::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtextframe.go

@@ -4,6 +4,7 @@ package gui
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -85,3 +86,93 @@ func (ptr *QTextFrame) DestroyQTextFrame() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QTextFrame) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextFrame::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextFrame) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextFrame::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextFrameTimerEvent
+func callbackQTextFrameTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextFrame::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextFrame) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextFrame::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextFrame) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextFrame::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextFrameChildEvent
+func callbackQTextFrameChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextFrame::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextFrame) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextFrame::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextFrame) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextFrame::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextFrameCustomEvent
+func callbackQTextFrameCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextFrame::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtextlist.go

@@ -4,6 +4,7 @@ package gui
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -86,3 +87,93 @@ func (ptr *QTextList) SetFormat(format QTextListFormat_ITF) {
 		C.QTextList_SetFormat(ptr.Pointer(), PointerFromQTextListFormat(format))
 	}
 }
+
+func (ptr *QTextList) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextList::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextList) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextList::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextListTimerEvent
+func callbackQTextListTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextList::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextList) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextList::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextList) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextList::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextListChildEvent
+func callbackQTextListChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextList::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextList) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextList::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextList) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextList::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextListCustomEvent
+func callbackQTextListCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextList::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtextobject.go

@@ -63,3 +63,93 @@ func (ptr *QTextObject) ObjectIndex() int {
 	}
 	return 0
 }
+
+func (ptr *QTextObject) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextObject::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextObject) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextObject::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextObjectTimerEvent
+func callbackQTextObjectTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextObject::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextObject) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextObject::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextObject) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextObject::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextObjectChildEvent
+func callbackQTextObjectChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextObject::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextObject) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextObject::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextObject) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextObject::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextObjectCustomEvent
+func callbackQTextObjectCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextObject::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qtexttable.go

@@ -4,6 +4,7 @@ package gui
 import "C"
 import (
 	"github.com/therecipe/qt"
+	"github.com/therecipe/qt/core"
 	"unsafe"
 )
 
@@ -141,3 +142,93 @@ func (ptr *QTextTable) SplitCell(row int, column int, numRows int, numCols int)
 		C.QTextTable_SplitCell(ptr.Pointer(), C.int(row), C.int(column), C.int(numRows), C.int(numCols))
 	}
 }
+
+func (ptr *QTextTable) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QTextTable::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QTextTable) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QTextTable::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQTextTableTimerEvent
+func callbackQTextTableTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextTable::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextTable) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QTextTable::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QTextTable) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QTextTable::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQTextTableChildEvent
+func callbackQTextTableChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextTable::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QTextTable) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QTextTable::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QTextTable) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QTextTable::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQTextTableCustomEvent
+func callbackQTextTableCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QTextTable::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qvalidator.go

@@ -90,3 +90,93 @@ func (ptr *QValidator) DestroyQValidator() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QValidator) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QValidator) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QValidator::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQValidatorTimerEvent
+func callbackQValidatorTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QValidator::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QValidator) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QValidator) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QValidator::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQValidatorChildEvent
+func callbackQValidatorChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QValidator::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QValidator) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QValidator) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QValidator::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQValidatorCustomEvent
+func callbackQValidatorCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QValidator::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

gui/qwindow.go

@@ -1877,3 +1877,93 @@ func (ptr *QWindow) DestroyQWindow() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QWindow) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QWindow) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QWindow::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQWindowTimerEvent
+func callbackQWindowTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QWindow::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QWindow) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QWindow) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QWindow::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQWindowChildEvent
+func callbackQWindowChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QWindow::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QWindow) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QWindow) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QWindow::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQWindowCustomEvent
+func callbackQWindowCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QWindow::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

help/help.cpp

@@ -1,7 +1,21 @@
 #include "help.h"
 #include "_cgo_export.h"
 
+#include <QAbstractItemDelegate>
+#include <QAbstractItemView>
+#include <QAction>
+#include <QActionEvent>
 #include <QByteArray>
+#include <QChildEvent>
+#include <QCloseEvent>
+#include <QContextMenuEvent>
+#include <QDrag>
+#include <QDragEnterEvent>
+#include <QDragLeaveEvent>
+#include <QDragMoveEvent>
+#include <QDropEvent>
+#include <QEvent>
+#include <QFocusEvent>
 #include <QHelpContentItem>
 #include <QHelpContentModel>
 #include <QHelpContentWidget>
@@ -13,13 +27,31 @@
 #include <QHelpSearchQuery>
 #include <QHelpSearchQueryWidget>
 #include <QHelpSearchResultWidget>
+#include <QHideEvent>
+#include <QInputMethod>
+#include <QInputMethodEvent>
+#include <QItemSelection>
+#include <QItemSelectionModel>
+#include <QKeyEvent>
 #include <QMetaObject>
 #include <QModelIndex>
+#include <QMouseEvent>
+#include <QMoveEvent>
 #include <QObject>
+#include <QPaintEvent>
+#include <QPainter>
 #include <QPoint>
+#include <QRect>
+#include <QResizeEvent>
+#include <QShowEvent>
 #include <QString>
+#include <QTabletEvent>
+#include <QTime>
+#include <QTimer>
+#include <QTimerEvent>
 #include <QUrl>
 #include <QVariant>
+#include <QWheelEvent>
 #include <QWidget>
 
 void* QHelpContentItem_Child(void* ptr, int row){
@@ -58,7 +90,13 @@ class MyQHelpContentModel: public QHelpContentModel {
 public:
 	void Signal_ContentsCreated() { callbackQHelpContentModelContentsCreated(this->objectName().toUtf8().data()); };
 	void Signal_ContentsCreationStarted() { callbackQHelpContentModelContentsCreationStarted(this->objectName().toUtf8().data()); };
+	void fetchMore(const QModelIndex & parent) { if (!callbackQHelpContentModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QHelpContentModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQHelpContentModelRevert(this->objectName().toUtf8().data())) { QHelpContentModel::revert(); }; };
+	void sort(int column, Qt::SortOrder order) { if (!callbackQHelpContentModelSort(this->objectName().toUtf8().data(), column, order)) { QHelpContentModel::sort(column, order); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpContentModelTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpContentModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpContentModelChildEvent(this->objectName().toUtf8().data(), event)) { QHelpContentModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpContentModelCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpContentModel::customEvent(event); }; };
 };
 
 int QHelpContentModel_ColumnCount(void* ptr, void* parent){
@@ -116,7 +154,56 @@ void QHelpContentModel_DestroyQHelpContentModel(void* ptr){
 class MyQHelpContentWidget: public QHelpContentWidget {
 public:
 	void Signal_LinkActivated(const QUrl & link) { callbackQHelpContentWidgetLinkActivated(this->objectName().toUtf8().data(), new QUrl(link)); };
+	void keyboardSearch(const QString & search) { if (!callbackQHelpContentWidgetKeyboardSearch(this->objectName().toUtf8().data(), search.toUtf8().data())) { QHelpContentWidget::keyboardSearch(search); }; };
+	void reset() { if (!callbackQHelpContentWidgetReset(this->objectName().toUtf8().data())) { QHelpContentWidget::reset(); }; };
+	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { if (!callbackQHelpContentWidgetScrollTo(this->objectName().toUtf8().data(), index.internalPointer(), hint)) { QHelpContentWidget::scrollTo(index, hint); }; };
+	void selectAll() { if (!callbackQHelpContentWidgetSelectAll(this->objectName().toUtf8().data())) { QHelpContentWidget::selectAll(); }; };
+	void setRootIndex(const QModelIndex & index) { if (!callbackQHelpContentWidgetSetRootIndex(this->objectName().toUtf8().data(), index.internalPointer())) { QHelpContentWidget::setRootIndex(index); }; };
+	void setSelectionModel(QItemSelectionModel * selectionModel) { if (!callbackQHelpContentWidgetSetSelectionModel(this->objectName().toUtf8().data(), selectionModel)) { QHelpContentWidget::setSelectionModel(selectionModel); }; };
+	void setupViewport(QWidget * viewport) { if (!callbackQHelpContentWidgetSetupViewport(this->objectName().toUtf8().data(), viewport)) { QHelpContentWidget::setupViewport(viewport); }; };
+	void setVisible(bool visible) { if (!callbackQHelpContentWidgetSetVisible(this->objectName().toUtf8().data(), visible)) { QHelpContentWidget::setVisible(visible); }; };
 protected:
+	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { if (!callbackQHelpContentWidgetCurrentChanged(this->objectName().toUtf8().data(), current.internalPointer(), previous.internalPointer())) { QHelpContentWidget::currentChanged(current, previous); }; };
+	void dragMoveEvent(QDragMoveEvent * event) { if (!callbackQHelpContentWidgetDragMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::dragMoveEvent(event); }; };
+	void drawBranches(QPainter * painter, const QRect & rect, const QModelIndex & index) const { if (!callbackQHelpContentWidgetDrawBranches(this->objectName().toUtf8().data(), painter, new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), index.internalPointer())) { QHelpContentWidget::drawBranches(painter, rect, index); }; };
+	void keyPressEvent(QKeyEvent * event) { if (!callbackQHelpContentWidgetKeyPressEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::keyPressEvent(event); }; };
+	void mouseDoubleClickEvent(QMouseEvent * event) { if (!callbackQHelpContentWidgetMouseDoubleClickEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::mouseDoubleClickEvent(event); }; };
+	void mouseMoveEvent(QMouseEvent * event) { if (!callbackQHelpContentWidgetMouseMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::mouseMoveEvent(event); }; };
+	void mousePressEvent(QMouseEvent * event) { if (!callbackQHelpContentWidgetMousePressEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::mousePressEvent(event); }; };
+	void mouseReleaseEvent(QMouseEvent * event) { if (!callbackQHelpContentWidgetMouseReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::mouseReleaseEvent(event); }; };
+	void paintEvent(QPaintEvent * event) { if (!callbackQHelpContentWidgetPaintEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::paintEvent(event); }; };
+	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { if (!callbackQHelpContentWidgetRowsAboutToBeRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), start, end)) { QHelpContentWidget::rowsAboutToBeRemoved(parent, start, end); }; };
+	void rowsInserted(const QModelIndex & parent, int start, int end) { if (!callbackQHelpContentWidgetRowsInserted(this->objectName().toUtf8().data(), parent.internalPointer(), start, end)) { QHelpContentWidget::rowsInserted(parent, start, end); }; };
+	void scrollContentsBy(int dx, int dy) { if (!callbackQHelpContentWidgetScrollContentsBy(this->objectName().toUtf8().data(), dx, dy)) { QHelpContentWidget::scrollContentsBy(dx, dy); }; };
+	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { if (!callbackQHelpContentWidgetSetSelection(this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command)) { QHelpContentWidget::setSelection(rect, command); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpContentWidgetTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::timerEvent(event); }; };
+	void updateGeometries() { if (!callbackQHelpContentWidgetUpdateGeometries(this->objectName().toUtf8().data())) { QHelpContentWidget::updateGeometries(); }; };
+	void dragLeaveEvent(QDragLeaveEvent * event) { if (!callbackQHelpContentWidgetDragLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::dragLeaveEvent(event); }; };
+	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { if (!callbackQHelpContentWidgetCloseEditor(this->objectName().toUtf8().data(), editor, hint)) { QHelpContentWidget::closeEditor(editor, hint); }; };
+	void commitData(QWidget * editor) { if (!callbackQHelpContentWidgetCommitData(this->objectName().toUtf8().data(), editor)) { QHelpContentWidget::commitData(editor); }; };
+	void dragEnterEvent(QDragEnterEvent * event) { if (!callbackQHelpContentWidgetDragEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::dragEnterEvent(event); }; };
+	void dropEvent(QDropEvent * event) { if (!callbackQHelpContentWidgetDropEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::dropEvent(event); }; };
+	void editorDestroyed(QObject * editor) { if (!callbackQHelpContentWidgetEditorDestroyed(this->objectName().toUtf8().data(), editor)) { QHelpContentWidget::editorDestroyed(editor); }; };
+	void focusInEvent(QFocusEvent * event) { if (!callbackQHelpContentWidgetFocusInEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::focusInEvent(event); }; };
+	void focusOutEvent(QFocusEvent * event) { if (!callbackQHelpContentWidgetFocusOutEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::focusOutEvent(event); }; };
+	void inputMethodEvent(QInputMethodEvent * event) { if (!callbackQHelpContentWidgetInputMethodEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::inputMethodEvent(event); }; };
+	void resizeEvent(QResizeEvent * event) { if (!callbackQHelpContentWidgetResizeEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::resizeEvent(event); }; };
+	void startDrag(Qt::DropActions supportedActions) { if (!callbackQHelpContentWidgetStartDrag(this->objectName().toUtf8().data(), supportedActions)) { QHelpContentWidget::startDrag(supportedActions); }; };
+	void contextMenuEvent(QContextMenuEvent * e) { if (!callbackQHelpContentWidgetContextMenuEvent(this->objectName().toUtf8().data(), e)) { QHelpContentWidget::contextMenuEvent(e); }; };
+	void wheelEvent(QWheelEvent * e) { if (!callbackQHelpContentWidgetWheelEvent(this->objectName().toUtf8().data(), e)) { QHelpContentWidget::wheelEvent(e); }; };
+	void changeEvent(QEvent * ev) { if (!callbackQHelpContentWidgetChangeEvent(this->objectName().toUtf8().data(), ev)) { QHelpContentWidget::changeEvent(ev); }; };
+	void actionEvent(QActionEvent * event) { if (!callbackQHelpContentWidgetActionEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::actionEvent(event); }; };
+	void enterEvent(QEvent * event) { if (!callbackQHelpContentWidgetEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::enterEvent(event); }; };
+	void hideEvent(QHideEvent * event) { if (!callbackQHelpContentWidgetHideEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::hideEvent(event); }; };
+	void leaveEvent(QEvent * event) { if (!callbackQHelpContentWidgetLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::leaveEvent(event); }; };
+	void moveEvent(QMoveEvent * event) { if (!callbackQHelpContentWidgetMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::moveEvent(event); }; };
+	void showEvent(QShowEvent * event) { if (!callbackQHelpContentWidgetShowEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::showEvent(event); }; };
+	void closeEvent(QCloseEvent * event) { if (!callbackQHelpContentWidgetCloseEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::closeEvent(event); }; };
+	void initPainter(QPainter * painter) const { if (!callbackQHelpContentWidgetInitPainter(this->objectName().toUtf8().data(), painter)) { QHelpContentWidget::initPainter(painter); }; };
+	void keyReleaseEvent(QKeyEvent * event) { if (!callbackQHelpContentWidgetKeyReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::keyReleaseEvent(event); }; };
+	void tabletEvent(QTabletEvent * event) { if (!callbackQHelpContentWidgetTabletEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::tabletEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpContentWidgetChildEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpContentWidgetCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpContentWidget::customEvent(event); }; };
 };
 
 void* QHelpContentWidget_IndexOf(void* ptr, void* link){
@@ -168,6 +255,9 @@ public:
 	void Signal_SetupStarted() { callbackQHelpEngineCoreSetupStarted(this->objectName().toUtf8().data()); };
 	void Signal_Warning(const QString & msg) { callbackQHelpEngineCoreWarning(this->objectName().toUtf8().data(), msg.toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpEngineCoreTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpEngineCore::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpEngineCoreChildEvent(this->objectName().toUtf8().data(), event)) { QHelpEngineCore::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpEngineCoreCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpEngineCore::customEvent(event); }; };
 };
 
 int QHelpEngineCore_AutoSaveFilter(void* ptr){
@@ -322,7 +412,13 @@ class MyQHelpIndexModel: public QHelpIndexModel {
 public:
 	void Signal_IndexCreated() { callbackQHelpIndexModelIndexCreated(this->objectName().toUtf8().data()); };
 	void Signal_IndexCreationStarted() { callbackQHelpIndexModelIndexCreationStarted(this->objectName().toUtf8().data()); };
+	void sort(int column, Qt::SortOrder order) { if (!callbackQHelpIndexModelSort(this->objectName().toUtf8().data(), column, order)) { QHelpIndexModel::sort(column, order); }; };
+	void fetchMore(const QModelIndex & parent) { if (!callbackQHelpIndexModelFetchMore(this->objectName().toUtf8().data(), parent.internalPointer())) { QHelpIndexModel::fetchMore(parent); }; };
+	void revert() { if (!callbackQHelpIndexModelRevert(this->objectName().toUtf8().data())) { QHelpIndexModel::revert(); }; };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpIndexModelTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexModel::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpIndexModelChildEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexModel::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpIndexModelCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexModel::customEvent(event); }; };
 };
 
 void QHelpIndexModel_CreateIndex(void* ptr, char* customFilterName){
@@ -356,7 +452,55 @@ int QHelpIndexModel_IsCreatingIndex(void* ptr){
 class MyQHelpIndexWidget: public QHelpIndexWidget {
 public:
 	void Signal_LinkActivated(const QUrl & link, const QString & keyword) { callbackQHelpIndexWidgetLinkActivated(this->objectName().toUtf8().data(), new QUrl(link), keyword.toUtf8().data()); };
+	void scrollTo(const QModelIndex & index, QAbstractItemView::ScrollHint hint) { if (!callbackQHelpIndexWidgetScrollTo(this->objectName().toUtf8().data(), index.internalPointer(), hint)) { QHelpIndexWidget::scrollTo(index, hint); }; };
+	void keyboardSearch(const QString & search) { if (!callbackQHelpIndexWidgetKeyboardSearch(this->objectName().toUtf8().data(), search.toUtf8().data())) { QHelpIndexWidget::keyboardSearch(search); }; };
+	void reset() { if (!callbackQHelpIndexWidgetReset(this->objectName().toUtf8().data())) { QHelpIndexWidget::reset(); }; };
+	void selectAll() { if (!callbackQHelpIndexWidgetSelectAll(this->objectName().toUtf8().data())) { QHelpIndexWidget::selectAll(); }; };
+	void setRootIndex(const QModelIndex & index) { if (!callbackQHelpIndexWidgetSetRootIndex(this->objectName().toUtf8().data(), index.internalPointer())) { QHelpIndexWidget::setRootIndex(index); }; };
+	void setSelectionModel(QItemSelectionModel * selectionModel) { if (!callbackQHelpIndexWidgetSetSelectionModel(this->objectName().toUtf8().data(), selectionModel)) { QHelpIndexWidget::setSelectionModel(selectionModel); }; };
+	void setupViewport(QWidget * viewport) { if (!callbackQHelpIndexWidgetSetupViewport(this->objectName().toUtf8().data(), viewport)) { QHelpIndexWidget::setupViewport(viewport); }; };
+	void setVisible(bool visible) { if (!callbackQHelpIndexWidgetSetVisible(this->objectName().toUtf8().data(), visible)) { QHelpIndexWidget::setVisible(visible); }; };
 protected:
+	void currentChanged(const QModelIndex & current, const QModelIndex & previous) { if (!callbackQHelpIndexWidgetCurrentChanged(this->objectName().toUtf8().data(), current.internalPointer(), previous.internalPointer())) { QHelpIndexWidget::currentChanged(current, previous); }; };
+	void dragLeaveEvent(QDragLeaveEvent * e) { if (!callbackQHelpIndexWidgetDragLeaveEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::dragLeaveEvent(e); }; };
+	void dragMoveEvent(QDragMoveEvent * e) { if (!callbackQHelpIndexWidgetDragMoveEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::dragMoveEvent(e); }; };
+	void dropEvent(QDropEvent * e) { if (!callbackQHelpIndexWidgetDropEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::dropEvent(e); }; };
+	void mouseMoveEvent(QMouseEvent * e) { if (!callbackQHelpIndexWidgetMouseMoveEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::mouseMoveEvent(e); }; };
+	void mouseReleaseEvent(QMouseEvent * e) { if (!callbackQHelpIndexWidgetMouseReleaseEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::mouseReleaseEvent(e); }; };
+	void paintEvent(QPaintEvent * e) { if (!callbackQHelpIndexWidgetPaintEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::paintEvent(e); }; };
+	void resizeEvent(QResizeEvent * e) { if (!callbackQHelpIndexWidgetResizeEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::resizeEvent(e); }; };
+	void rowsAboutToBeRemoved(const QModelIndex & parent, int start, int end) { if (!callbackQHelpIndexWidgetRowsAboutToBeRemoved(this->objectName().toUtf8().data(), parent.internalPointer(), start, end)) { QHelpIndexWidget::rowsAboutToBeRemoved(parent, start, end); }; };
+	void rowsInserted(const QModelIndex & parent, int start, int end) { if (!callbackQHelpIndexWidgetRowsInserted(this->objectName().toUtf8().data(), parent.internalPointer(), start, end)) { QHelpIndexWidget::rowsInserted(parent, start, end); }; };
+	void setSelection(const QRect & rect, QItemSelectionModel::SelectionFlags command) { if (!callbackQHelpIndexWidgetSetSelection(this->objectName().toUtf8().data(), new QRect(static_cast<QRect>(rect).x(), static_cast<QRect>(rect).y(), static_cast<QRect>(rect).width(), static_cast<QRect>(rect).height()), command)) { QHelpIndexWidget::setSelection(rect, command); }; };
+	void startDrag(Qt::DropActions supportedActions) { if (!callbackQHelpIndexWidgetStartDrag(this->objectName().toUtf8().data(), supportedActions)) { QHelpIndexWidget::startDrag(supportedActions); }; };
+	void timerEvent(QTimerEvent * e) { if (!callbackQHelpIndexWidgetTimerEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::timerEvent(e); }; };
+	void updateGeometries() { if (!callbackQHelpIndexWidgetUpdateGeometries(this->objectName().toUtf8().data())) { QHelpIndexWidget::updateGeometries(); }; };
+	void closeEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint) { if (!callbackQHelpIndexWidgetCloseEditor(this->objectName().toUtf8().data(), editor, hint)) { QHelpIndexWidget::closeEditor(editor, hint); }; };
+	void commitData(QWidget * editor) { if (!callbackQHelpIndexWidgetCommitData(this->objectName().toUtf8().data(), editor)) { QHelpIndexWidget::commitData(editor); }; };
+	void dragEnterEvent(QDragEnterEvent * event) { if (!callbackQHelpIndexWidgetDragEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::dragEnterEvent(event); }; };
+	void editorDestroyed(QObject * editor) { if (!callbackQHelpIndexWidgetEditorDestroyed(this->objectName().toUtf8().data(), editor)) { QHelpIndexWidget::editorDestroyed(editor); }; };
+	void focusInEvent(QFocusEvent * event) { if (!callbackQHelpIndexWidgetFocusInEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::focusInEvent(event); }; };
+	void focusOutEvent(QFocusEvent * event) { if (!callbackQHelpIndexWidgetFocusOutEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::focusOutEvent(event); }; };
+	void inputMethodEvent(QInputMethodEvent * event) { if (!callbackQHelpIndexWidgetInputMethodEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::inputMethodEvent(event); }; };
+	void keyPressEvent(QKeyEvent * event) { if (!callbackQHelpIndexWidgetKeyPressEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::keyPressEvent(event); }; };
+	void mouseDoubleClickEvent(QMouseEvent * event) { if (!callbackQHelpIndexWidgetMouseDoubleClickEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::mouseDoubleClickEvent(event); }; };
+	void mousePressEvent(QMouseEvent * event) { if (!callbackQHelpIndexWidgetMousePressEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::mousePressEvent(event); }; };
+	void contextMenuEvent(QContextMenuEvent * e) { if (!callbackQHelpIndexWidgetContextMenuEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::contextMenuEvent(e); }; };
+	void scrollContentsBy(int dx, int dy) { if (!callbackQHelpIndexWidgetScrollContentsBy(this->objectName().toUtf8().data(), dx, dy)) { QHelpIndexWidget::scrollContentsBy(dx, dy); }; };
+	void wheelEvent(QWheelEvent * e) { if (!callbackQHelpIndexWidgetWheelEvent(this->objectName().toUtf8().data(), e)) { QHelpIndexWidget::wheelEvent(e); }; };
+	void changeEvent(QEvent * ev) { if (!callbackQHelpIndexWidgetChangeEvent(this->objectName().toUtf8().data(), ev)) { QHelpIndexWidget::changeEvent(ev); }; };
+	void actionEvent(QActionEvent * event) { if (!callbackQHelpIndexWidgetActionEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::actionEvent(event); }; };
+	void enterEvent(QEvent * event) { if (!callbackQHelpIndexWidgetEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::enterEvent(event); }; };
+	void hideEvent(QHideEvent * event) { if (!callbackQHelpIndexWidgetHideEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::hideEvent(event); }; };
+	void leaveEvent(QEvent * event) { if (!callbackQHelpIndexWidgetLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::leaveEvent(event); }; };
+	void moveEvent(QMoveEvent * event) { if (!callbackQHelpIndexWidgetMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::moveEvent(event); }; };
+	void showEvent(QShowEvent * event) { if (!callbackQHelpIndexWidgetShowEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::showEvent(event); }; };
+	void closeEvent(QCloseEvent * event) { if (!callbackQHelpIndexWidgetCloseEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::closeEvent(event); }; };
+	void initPainter(QPainter * painter) const { if (!callbackQHelpIndexWidgetInitPainter(this->objectName().toUtf8().data(), painter)) { QHelpIndexWidget::initPainter(painter); }; };
+	void keyReleaseEvent(QKeyEvent * event) { if (!callbackQHelpIndexWidgetKeyReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::keyReleaseEvent(event); }; };
+	void tabletEvent(QTabletEvent * event) { if (!callbackQHelpIndexWidgetTabletEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::tabletEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpIndexWidgetChildEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpIndexWidgetCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpIndexWidget::customEvent(event); }; };
 };
 
 void QHelpIndexWidget_ActivateCurrentItem(void* ptr){
@@ -382,6 +526,9 @@ public:
 	void Signal_SearchingFinished(int hits) { callbackQHelpSearchEngineSearchingFinished(this->objectName().toUtf8().data(), hits); };
 	void Signal_SearchingStarted() { callbackQHelpSearchEngineSearchingStarted(this->objectName().toUtf8().data()); };
 protected:
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpSearchEngineTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchEngine::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpSearchEngineChildEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchEngine::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpSearchEngineCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchEngine::customEvent(event); }; };
 };
 
 void* QHelpSearchEngine_NewQHelpSearchEngine(void* helpEngine, void* parent){
@@ -459,7 +606,36 @@ void* QHelpSearchQuery_NewQHelpSearchQuery2(int field, char* wordList){
 class MyQHelpSearchQueryWidget: public QHelpSearchQueryWidget {
 public:
 	void Signal_Search() { callbackQHelpSearchQueryWidgetSearch(this->objectName().toUtf8().data()); };
+	void setVisible(bool visible) { if (!callbackQHelpSearchQueryWidgetSetVisible(this->objectName().toUtf8().data(), visible)) { QHelpSearchQueryWidget::setVisible(visible); }; };
 protected:
+	void actionEvent(QActionEvent * event) { if (!callbackQHelpSearchQueryWidgetActionEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::actionEvent(event); }; };
+	void dragEnterEvent(QDragEnterEvent * event) { if (!callbackQHelpSearchQueryWidgetDragEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::dragEnterEvent(event); }; };
+	void dragLeaveEvent(QDragLeaveEvent * event) { if (!callbackQHelpSearchQueryWidgetDragLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::dragLeaveEvent(event); }; };
+	void dragMoveEvent(QDragMoveEvent * event) { if (!callbackQHelpSearchQueryWidgetDragMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::dragMoveEvent(event); }; };
+	void dropEvent(QDropEvent * event) { if (!callbackQHelpSearchQueryWidgetDropEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::dropEvent(event); }; };
+	void enterEvent(QEvent * event) { if (!callbackQHelpSearchQueryWidgetEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::enterEvent(event); }; };
+	void focusOutEvent(QFocusEvent * event) { if (!callbackQHelpSearchQueryWidgetFocusOutEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::focusOutEvent(event); }; };
+	void hideEvent(QHideEvent * event) { if (!callbackQHelpSearchQueryWidgetHideEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::hideEvent(event); }; };
+	void leaveEvent(QEvent * event) { if (!callbackQHelpSearchQueryWidgetLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::leaveEvent(event); }; };
+	void moveEvent(QMoveEvent * event) { if (!callbackQHelpSearchQueryWidgetMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::moveEvent(event); }; };
+	void paintEvent(QPaintEvent * event) { if (!callbackQHelpSearchQueryWidgetPaintEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::paintEvent(event); }; };
+	void showEvent(QShowEvent * event) { if (!callbackQHelpSearchQueryWidgetShowEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::showEvent(event); }; };
+	void closeEvent(QCloseEvent * event) { if (!callbackQHelpSearchQueryWidgetCloseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::closeEvent(event); }; };
+	void contextMenuEvent(QContextMenuEvent * event) { if (!callbackQHelpSearchQueryWidgetContextMenuEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::contextMenuEvent(event); }; };
+	void initPainter(QPainter * painter) const { if (!callbackQHelpSearchQueryWidgetInitPainter(this->objectName().toUtf8().data(), painter)) { QHelpSearchQueryWidget::initPainter(painter); }; };
+	void inputMethodEvent(QInputMethodEvent * event) { if (!callbackQHelpSearchQueryWidgetInputMethodEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::inputMethodEvent(event); }; };
+	void keyPressEvent(QKeyEvent * event) { if (!callbackQHelpSearchQueryWidgetKeyPressEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::keyPressEvent(event); }; };
+	void keyReleaseEvent(QKeyEvent * event) { if (!callbackQHelpSearchQueryWidgetKeyReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::keyReleaseEvent(event); }; };
+	void mouseDoubleClickEvent(QMouseEvent * event) { if (!callbackQHelpSearchQueryWidgetMouseDoubleClickEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::mouseDoubleClickEvent(event); }; };
+	void mouseMoveEvent(QMouseEvent * event) { if (!callbackQHelpSearchQueryWidgetMouseMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::mouseMoveEvent(event); }; };
+	void mousePressEvent(QMouseEvent * event) { if (!callbackQHelpSearchQueryWidgetMousePressEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::mousePressEvent(event); }; };
+	void mouseReleaseEvent(QMouseEvent * event) { if (!callbackQHelpSearchQueryWidgetMouseReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::mouseReleaseEvent(event); }; };
+	void resizeEvent(QResizeEvent * event) { if (!callbackQHelpSearchQueryWidgetResizeEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::resizeEvent(event); }; };
+	void tabletEvent(QTabletEvent * event) { if (!callbackQHelpSearchQueryWidgetTabletEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::tabletEvent(event); }; };
+	void wheelEvent(QWheelEvent * event) { if (!callbackQHelpSearchQueryWidgetWheelEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::wheelEvent(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpSearchQueryWidgetTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpSearchQueryWidgetChildEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpSearchQueryWidgetCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchQueryWidget::customEvent(event); }; };
 };
 
 int QHelpSearchQueryWidget_IsCompactMode(void* ptr){
@@ -493,7 +669,36 @@ void QHelpSearchQueryWidget_DestroyQHelpSearchQueryWidget(void* ptr){
 class MyQHelpSearchResultWidget: public QHelpSearchResultWidget {
 public:
 	void Signal_RequestShowLink(const QUrl & link) { callbackQHelpSearchResultWidgetRequestShowLink(this->objectName().toUtf8().data(), new QUrl(link)); };
+	void setVisible(bool visible) { if (!callbackQHelpSearchResultWidgetSetVisible(this->objectName().toUtf8().data(), visible)) { QHelpSearchResultWidget::setVisible(visible); }; };
 protected:
+	void actionEvent(QActionEvent * event) { if (!callbackQHelpSearchResultWidgetActionEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::actionEvent(event); }; };
+	void dragEnterEvent(QDragEnterEvent * event) { if (!callbackQHelpSearchResultWidgetDragEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::dragEnterEvent(event); }; };
+	void dragLeaveEvent(QDragLeaveEvent * event) { if (!callbackQHelpSearchResultWidgetDragLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::dragLeaveEvent(event); }; };
+	void dragMoveEvent(QDragMoveEvent * event) { if (!callbackQHelpSearchResultWidgetDragMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::dragMoveEvent(event); }; };
+	void dropEvent(QDropEvent * event) { if (!callbackQHelpSearchResultWidgetDropEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::dropEvent(event); }; };
+	void enterEvent(QEvent * event) { if (!callbackQHelpSearchResultWidgetEnterEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::enterEvent(event); }; };
+	void focusOutEvent(QFocusEvent * event) { if (!callbackQHelpSearchResultWidgetFocusOutEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::focusOutEvent(event); }; };
+	void hideEvent(QHideEvent * event) { if (!callbackQHelpSearchResultWidgetHideEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::hideEvent(event); }; };
+	void leaveEvent(QEvent * event) { if (!callbackQHelpSearchResultWidgetLeaveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::leaveEvent(event); }; };
+	void moveEvent(QMoveEvent * event) { if (!callbackQHelpSearchResultWidgetMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::moveEvent(event); }; };
+	void paintEvent(QPaintEvent * event) { if (!callbackQHelpSearchResultWidgetPaintEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::paintEvent(event); }; };
+	void showEvent(QShowEvent * event) { if (!callbackQHelpSearchResultWidgetShowEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::showEvent(event); }; };
+	void closeEvent(QCloseEvent * event) { if (!callbackQHelpSearchResultWidgetCloseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::closeEvent(event); }; };
+	void contextMenuEvent(QContextMenuEvent * event) { if (!callbackQHelpSearchResultWidgetContextMenuEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::contextMenuEvent(event); }; };
+	void initPainter(QPainter * painter) const { if (!callbackQHelpSearchResultWidgetInitPainter(this->objectName().toUtf8().data(), painter)) { QHelpSearchResultWidget::initPainter(painter); }; };
+	void inputMethodEvent(QInputMethodEvent * event) { if (!callbackQHelpSearchResultWidgetInputMethodEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::inputMethodEvent(event); }; };
+	void keyPressEvent(QKeyEvent * event) { if (!callbackQHelpSearchResultWidgetKeyPressEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::keyPressEvent(event); }; };
+	void keyReleaseEvent(QKeyEvent * event) { if (!callbackQHelpSearchResultWidgetKeyReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::keyReleaseEvent(event); }; };
+	void mouseDoubleClickEvent(QMouseEvent * event) { if (!callbackQHelpSearchResultWidgetMouseDoubleClickEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::mouseDoubleClickEvent(event); }; };
+	void mouseMoveEvent(QMouseEvent * event) { if (!callbackQHelpSearchResultWidgetMouseMoveEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::mouseMoveEvent(event); }; };
+	void mousePressEvent(QMouseEvent * event) { if (!callbackQHelpSearchResultWidgetMousePressEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::mousePressEvent(event); }; };
+	void mouseReleaseEvent(QMouseEvent * event) { if (!callbackQHelpSearchResultWidgetMouseReleaseEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::mouseReleaseEvent(event); }; };
+	void resizeEvent(QResizeEvent * event) { if (!callbackQHelpSearchResultWidgetResizeEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::resizeEvent(event); }; };
+	void tabletEvent(QTabletEvent * event) { if (!callbackQHelpSearchResultWidgetTabletEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::tabletEvent(event); }; };
+	void wheelEvent(QWheelEvent * event) { if (!callbackQHelpSearchResultWidgetWheelEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::wheelEvent(event); }; };
+	void timerEvent(QTimerEvent * event) { if (!callbackQHelpSearchResultWidgetTimerEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::timerEvent(event); }; };
+	void childEvent(QChildEvent * event) { if (!callbackQHelpSearchResultWidgetChildEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::childEvent(event); }; };
+	void customEvent(QEvent * event) { if (!callbackQHelpSearchResultWidgetCustomEvent(this->objectName().toUtf8().data(), event)) { QHelpSearchResultWidget::customEvent(event); }; };
 };
 
 void* QHelpSearchResultWidget_LinkAt(void* ptr, void* point){

help/qhelpcontentmodel.go

@@ -172,3 +172,183 @@ func (ptr *QHelpContentModel) DestroyQHelpContentModel() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QHelpContentModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
+	defer qt.Recovering("connect QHelpContentModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "fetchMore", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectFetchMore() {
+	defer qt.Recovering("disconnect QHelpContentModel::fetchMore")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "fetchMore")
+	}
+}
+
+//export callbackQHelpContentModelFetchMore
+func callbackQHelpContentModelFetchMore(ptrName *C.char, parent unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpContentModel::fetchMore")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "fetchMore"); signal != nil {
+		signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpContentModel) ConnectRevert(f func()) {
+	defer qt.Recovering("connect QHelpContentModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "revert", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectRevert() {
+	defer qt.Recovering("disconnect QHelpContentModel::revert")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "revert")
+	}
+}
+
+//export callbackQHelpContentModelRevert
+func callbackQHelpContentModelRevert(ptrName *C.char) bool {
+	defer qt.Recovering("callback QHelpContentModel::revert")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "revert"); signal != nil {
+		signal.(func())()
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpContentModel) ConnectSort(f func(column int, order core.Qt__SortOrder)) {
+	defer qt.Recovering("connect QHelpContentModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "sort", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectSort() {
+	defer qt.Recovering("disconnect QHelpContentModel::sort")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "sort")
+	}
+}
+
+//export callbackQHelpContentModelSort
+func callbackQHelpContentModelSort(ptrName *C.char, column C.int, order C.int) bool {
+	defer qt.Recovering("callback QHelpContentModel::sort")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "sort"); signal != nil {
+		signal.(func(int, core.Qt__SortOrder))(int(column), core.Qt__SortOrder(order))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpContentModel) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QHelpContentModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QHelpContentModel::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQHelpContentModelTimerEvent
+func callbackQHelpContentModelTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpContentModel::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpContentModel) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QHelpContentModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QHelpContentModel::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQHelpContentModelChildEvent
+func callbackQHelpContentModelChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpContentModel::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpContentModel) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QHelpContentModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QHelpContentModel) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QHelpContentModel::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQHelpContentModelCustomEvent
+func callbackQHelpContentModelCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpContentModel::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

help/qhelpengine.go

@@ -96,3 +96,93 @@ func (ptr *QHelpEngine) DestroyQHelpEngine() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QHelpEngine) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QHelpEngine::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QHelpEngine) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QHelpEngine::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQHelpEngineTimerEvent
+func callbackQHelpEngineTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngine::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpEngine) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QHelpEngine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QHelpEngine) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QHelpEngine::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQHelpEngineChildEvent
+func callbackQHelpEngineChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngine::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpEngine) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QHelpEngine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QHelpEngine) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QHelpEngine::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQHelpEngineCustomEvent
+func callbackQHelpEngineCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngine::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}

help/qhelpenginecore.go

@@ -408,3 +408,93 @@ func (ptr *QHelpEngineCore) DestroyQHelpEngineCore() {
 		ptr.SetPointer(nil)
 	}
 }
+
+func (ptr *QHelpEngineCore) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
+	defer qt.Recovering("connect QHelpEngineCore::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "timerEvent", f)
+	}
+}
+
+func (ptr *QHelpEngineCore) DisconnectTimerEvent() {
+	defer qt.Recovering("disconnect QHelpEngineCore::timerEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "timerEvent")
+	}
+}
+
+//export callbackQHelpEngineCoreTimerEvent
+func callbackQHelpEngineCoreTimerEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngineCore::timerEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "timerEvent"); signal != nil {
+		signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpEngineCore) ConnectChildEvent(f func(event *core.QChildEvent)) {
+	defer qt.Recovering("connect QHelpEngineCore::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "childEvent", f)
+	}
+}
+
+func (ptr *QHelpEngineCore) DisconnectChildEvent() {
+	defer qt.Recovering("disconnect QHelpEngineCore::childEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "childEvent")
+	}
+}
+
+//export callbackQHelpEngineCoreChildEvent
+func callbackQHelpEngineCoreChildEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngineCore::childEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "childEvent"); signal != nil {
+		signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
+		return true
+	}
+	return false
+
+}
+
+func (ptr *QHelpEngineCore) ConnectCustomEvent(f func(event *core.QEvent)) {
+	defer qt.Recovering("connect QHelpEngineCore::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.ConnectSignal(ptr.ObjectName(), "customEvent", f)
+	}
+}
+
+func (ptr *QHelpEngineCore) DisconnectCustomEvent() {
+	defer qt.Recovering("disconnect QHelpEngineCore::customEvent")
+
+	if ptr.Pointer() != nil {
+
+		qt.DisconnectSignal(ptr.ObjectName(), "customEvent")
+	}
+}
+
+//export callbackQHelpEngineCoreCustomEvent
+func callbackQHelpEngineCoreCustomEvent(ptrName *C.char, event unsafe.Pointer) bool {
+	defer qt.Recovering("callback QHelpEngineCore::customEvent")
+
+	if signal := qt.GetSignal(C.GoString(ptrName), "customEvent"); signal != nil {
+		signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
+		return true
+	}
+	return false
+
+}