fix connect functions, dynamic mxe lookup, futher qmake related changes

.travis.yml

@@ -10,30 +10,30 @@ env: DESKTOP=true ANDROID=false QT_QMAKE_CGO=true
 matrix:
   include:
     - os: linux
-      env: DESKTOP=true ANDROID=false QT_PKG_CONFIG=true PKG_CONFIG_PATH=/opt/qt58/lib/pkgconfig QT_DOC_DIR=/opt/qt58/doc QT_MISC_DIR=/opt/qt58
+      env: DESKTOP=true ANDROID=false QT_PKG_CONFIG=true PKG_CONFIG_PATH=/opt/qt58/lib/pkgconfig QT_DOC_DIR=/opt/qt58/doc QT_MISC_DIR=/opt/qt58 QT_QMAKE_CGO=true
 
     - os: linux
-      env: DESKTOP=false ANDROID=true
+      env: DESKTOP=false ANDROID=true QT_QMAKE_CGO=true
 
     - os: osx
       osx_image: xcode8.2
-      env: DESKTOP=true ANDROID=false
+      env: DESKTOP=true ANDROID=false QT_QMAKE_CGO=true
 
     - os: osx
       osx_image: xcode8.2
-      env: DESKTOP=true ANDROID=false QT_HOMEBREW=true
+      env: DESKTOP=true ANDROID=false QT_HOMEBREW=true QT_QMAKE_CGO=true
 
     - os: osx
       osx_image: xcode8.2
-      env: DESKTOP=false ANDROID=true
+      env: DESKTOP=false ANDROID=true QT_QMAKE_CGO=true
 
     - os: osx
       osx_image: xcode8.2
-      env: DESKTOP=false ANDROID=false IOS=true
+      env: DESKTOP=false ANDROID=false IOS=true QT_QMAKE_CGO=true
 
     - os: osx
       osx_image: xcode8.2
-      env: DESKTOP=false ANDROID=false IOS_SIMULATOR=true
+      env: DESKTOP=false ANDROID=false IOS_SIMULATOR=true QT_QMAKE_CGO=true
 
 install:
   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then travis_wait 30 $GOPATH/src/github.com/therecipe/qt/internal/ci/linux.sh; fi

androidextras/androidextras_android.go

@@ -94,7 +94,14 @@ func callbackQAndroidActivityResultReceiver_HandleActivityResult(ptr unsafe.Poin
 func (ptr *QAndroidActivityResultReceiver) ConnectHandleActivityResult(f func(receiverRequestCode int, resultCode int, data *QAndroidJniObject)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleActivityResult", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "handleActivityResult"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleActivityResult", func(receiverRequestCode int, resultCode int, data *QAndroidJniObject) {
+				signal.(func(int, int, *QAndroidJniObject))(receiverRequestCode, resultCode, data)
+				f(receiverRequestCode, resultCode, data)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleActivityResult", f)
+		}
 	}
 }
 

core/core.cpp

@@ -3554,14 +3554,14 @@ void* QByteArray_Replace2(void* ptr, int pos, int len, char* after, int alen)
 	return new QByteArray(static_cast<QByteArray*>(ptr)->replace(pos, len, const_cast<const char*>(after), alen));
 }
 
-void* QByteArray_SetNum8(void* ptr, double n, char* f, int prec)
+void* QByteArray_SetNum8(void* ptr, double n, char* fo, int prec)
 {
-	return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *f, prec));
+	return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *fo, prec));
 }
 
-void* QByteArray_SetNum7(void* ptr, float n, char* f, int prec)
+void* QByteArray_SetNum7(void* ptr, float n, char* fo, int prec)
 {
-	return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *f, prec));
+	return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *fo, prec));
 }
 
 void* QByteArray_SetNum(void* ptr, int n, int base)
@@ -3624,9 +3624,9 @@ void* QByteArray_QByteArray_FromRawData(char* data, int size)
 	return new QByteArray(QByteArray::fromRawData(const_cast<const char*>(data), size));
 }
 
-void* QByteArray_QByteArray_Number5(double n, char* f, int prec)
+void* QByteArray_QByteArray_Number5(double n, char* fo, int prec)
 {
-	return new QByteArray(QByteArray::number(n, *f, prec));
+	return new QByteArray(QByteArray::number(n, *fo, prec));
 }
 
 void* QByteArray_QByteArray_Number(int n, int base)
@@ -10367,14 +10367,14 @@ struct QtCore_PackedString QLocale_ToString11(void* ptr, void* time, char* forma
 	return ({ QByteArray t7e9dfa = static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(time), QString(format)).toUtf8(); QtCore_PackedString { const_cast<char*>(t7e9dfa.prepend("WHITESPACE").constData()+10), t7e9dfa.size()-10 }; });
 }
 
-struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* f, int prec)
+struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* fo, int prec)
 {
-	return ({ QByteArray t0ef931 = static_cast<QLocale*>(ptr)->toString(i, *f, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(t0ef931.prepend("WHITESPACE").constData()+10), t0ef931.size()-10 }; });
+	return ({ QByteArray tb2c8bc = static_cast<QLocale*>(ptr)->toString(i, *fo, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(tb2c8bc.prepend("WHITESPACE").constData()+10), tb2c8bc.size()-10 }; });
 }
 
-struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* f, int prec)
+struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* fo, int prec)
 {
-	return ({ QByteArray t0ef931 = static_cast<QLocale*>(ptr)->toString(i, *f, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(t0ef931.prepend("WHITESPACE").constData()+10), t0ef931.size()-10 }; });
+	return ({ QByteArray tb2c8bc = static_cast<QLocale*>(ptr)->toString(i, *fo, prec).toUtf8(); QtCore_PackedString { const_cast<char*>(tb2c8bc.prepend("WHITESPACE").constData()+10), tb2c8bc.size()-10 }; });
 }
 
 struct QtCore_PackedString QLocale_ToString5(void* ptr, int i)

core/core.h

@@ -466,8 +466,8 @@ void* QByteArray_Replace7(void* ptr, char* before, int bsize, char* after, int a
 void* QByteArray_Replace(void* ptr, int pos, int len, void* after);
 void* QByteArray_Replace3(void* ptr, int pos, int len, char* after);
 void* QByteArray_Replace2(void* ptr, int pos, int len, char* after, int alen);
-void* QByteArray_SetNum8(void* ptr, double n, char* f, int prec);
-void* QByteArray_SetNum7(void* ptr, float n, char* f, int prec);
+void* QByteArray_SetNum8(void* ptr, double n, char* fo, int prec);
+void* QByteArray_SetNum7(void* ptr, float n, char* fo, int prec);
 void* QByteArray_SetNum(void* ptr, int n, int base);
 void* QByteArray_SetNum5(void* ptr, long long n, int base);
 void* QByteArray_SetNum6(void* ptr, unsigned long long n, int base);
@@ -480,7 +480,7 @@ void* QByteArray_QByteArray_FromBase642(void* base64, long long options);
 void* QByteArray_QByteArray_FromHex(void* hexEncoded);
 void* QByteArray_QByteArray_FromPercentEncoding(void* input, char* percent);
 void* QByteArray_QByteArray_FromRawData(char* data, int size);
-void* QByteArray_QByteArray_Number5(double n, char* f, int prec);
+void* QByteArray_QByteArray_Number5(double n, char* fo, int prec);
 void* QByteArray_QByteArray_Number(int n, int base);
 void* QByteArray_QByteArray_Number3(long long n, int base);
 void* QByteArray_QByteArray_Number4(unsigned long long n, int base);
@@ -1700,8 +1700,8 @@ struct QtCore_PackedString QLocale_ToString13(void* ptr, void* dateTime, long lo
 struct QtCore_PackedString QLocale_ToString14(void* ptr, void* dateTime, char* format);
 struct QtCore_PackedString QLocale_ToString12(void* ptr, void* time, long long format);
 struct QtCore_PackedString QLocale_ToString11(void* ptr, void* time, char* format);
-struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* f, int prec);
-struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* f, int prec);
+struct QtCore_PackedString QLocale_ToString7(void* ptr, double i, char* fo, int prec);
+struct QtCore_PackedString QLocale_ToString8(void* ptr, float i, char* fo, int prec);
 struct QtCore_PackedString QLocale_ToString5(void* ptr, int i);
 struct QtCore_PackedString QLocale_ToString(void* ptr, long long i);
 struct QtCore_PackedString QLocale_ToString2(void* ptr, unsigned long long i);

dbus/dbus.go

@@ -594,7 +594,14 @@ func callbackQDBusAbstractInterface_DestroyQDBusAbstractInterface(ptr unsafe.Poi
 func (ptr *QDBusAbstractInterface) ConnectDestroyQDBusAbstractInterface(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusAbstractInterface", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QDBusAbstractInterface"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusAbstractInterface", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusAbstractInterface", f)
+		}
 	}
 }
 
@@ -1985,8 +1992,19 @@ func callbackQDBusConnectionInterface_ServiceRegistered(ptr unsafe.Pointer, serv
 
 func (ptr *QDBusConnectionInterface) ConnectServiceRegistered(f func(serviceName string)) {
 	if ptr.Pointer() != nil {
-		C.QDBusConnectionInterface_ConnectServiceRegistered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered") {
+			C.QDBusConnectionInterface_ConnectServiceRegistered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", func(serviceName string) {
+				signal.(func(string))(serviceName)
+				f(serviceName)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", f)
+		}
 	}
 }
 
@@ -2018,8 +2036,19 @@ func callbackQDBusConnectionInterface_CallWithCallbackFailed(ptr unsafe.Pointer,
 
 func (ptr *QDBusConnectionInterface) ConnectCallWithCallbackFailed(f func(error *QDBusError, call *QDBusMessage)) {
 	if ptr.Pointer() != nil {
-		C.QDBusConnectionInterface_ConnectCallWithCallbackFailed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "callWithCallbackFailed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "callWithCallbackFailed") {
+			C.QDBusConnectionInterface_ConnectCallWithCallbackFailed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "callWithCallbackFailed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "callWithCallbackFailed", func(error *QDBusError, call *QDBusMessage) {
+				signal.(func(*QDBusError, *QDBusMessage))(error, call)
+				f(error, call)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "callWithCallbackFailed", f)
+		}
 	}
 }
 
@@ -2046,8 +2075,19 @@ func callbackQDBusConnectionInterface_ServiceUnregistered(ptr unsafe.Pointer, se
 
 func (ptr *QDBusConnectionInterface) ConnectServiceUnregistered(f func(serviceName string)) {
 	if ptr.Pointer() != nil {
-		C.QDBusConnectionInterface_ConnectServiceUnregistered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered") {
+			C.QDBusConnectionInterface_ConnectServiceUnregistered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", func(serviceName string) {
+				signal.(func(string))(serviceName)
+				f(serviceName)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", f)
+		}
 	}
 }
 
@@ -3156,8 +3196,19 @@ func callbackQDBusPendingCallWatcher_Finished(ptr unsafe.Pointer, self unsafe.Po
 
 func (ptr *QDBusPendingCallWatcher) ConnectFinished(f func(self *QDBusPendingCallWatcher)) {
 	if ptr.Pointer() != nil {
-		C.QDBusPendingCallWatcher_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QDBusPendingCallWatcher_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func(self *QDBusPendingCallWatcher) {
+				signal.(func(*QDBusPendingCallWatcher))(self)
+				f(self)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -3726,8 +3777,19 @@ func callbackQDBusServer_NewConnection(ptr unsafe.Pointer, connection unsafe.Poi
 
 func (ptr *QDBusServer) ConnectNewConnection(f func(connection *QDBusConnection)) {
 	if ptr.Pointer() != nil {
-		C.QDBusServer_ConnectNewConnection(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "newConnection") {
+			C.QDBusServer_ConnectNewConnection(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newConnection"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", func(connection *QDBusConnection) {
+				signal.(func(*QDBusConnection))(connection)
+				f(connection)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", f)
+		}
 	}
 }
 
@@ -3762,7 +3824,14 @@ func callbackQDBusServer_DestroyQDBusServer(ptr unsafe.Pointer) {
 func (ptr *QDBusServer) ConnectDestroyQDBusServer(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusServer", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QDBusServer"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusServer", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusServer", f)
+		}
 	}
 }
 
@@ -4137,8 +4206,19 @@ func callbackQDBusServiceWatcher_ServiceRegistered(ptr unsafe.Pointer, serviceNa
 
 func (ptr *QDBusServiceWatcher) ConnectServiceRegistered(f func(serviceName string)) {
 	if ptr.Pointer() != nil {
-		C.QDBusServiceWatcher_ConnectServiceRegistered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered") {
+			C.QDBusServiceWatcher_ConnectServiceRegistered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", func(serviceName string) {
+				signal.(func(string))(serviceName)
+				f(serviceName)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceRegistered", f)
+		}
 	}
 }
 
@@ -4233,8 +4313,19 @@ func callbackQDBusServiceWatcher_ServiceOwnerChanged(ptr unsafe.Pointer, service
 
 func (ptr *QDBusServiceWatcher) ConnectServiceOwnerChanged(f func(serviceName string, oldOwner string, newOwner string)) {
 	if ptr.Pointer() != nil {
-		C.QDBusServiceWatcher_ConnectServiceOwnerChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceOwnerChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serviceOwnerChanged") {
+			C.QDBusServiceWatcher_ConnectServiceOwnerChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceOwnerChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceOwnerChanged", func(serviceName string, oldOwner string, newOwner string) {
+				signal.(func(string, string, string))(serviceName, oldOwner, newOwner)
+				f(serviceName, oldOwner, newOwner)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceOwnerChanged", f)
+		}
 	}
 }
 
@@ -4276,8 +4367,19 @@ func callbackQDBusServiceWatcher_ServiceUnregistered(ptr unsafe.Pointer, service
 
 func (ptr *QDBusServiceWatcher) ConnectServiceUnregistered(f func(serviceName string)) {
 	if ptr.Pointer() != nil {
-		C.QDBusServiceWatcher_ConnectServiceUnregistered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered") {
+			C.QDBusServiceWatcher_ConnectServiceUnregistered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", func(serviceName string) {
+				signal.(func(string))(serviceName)
+				f(serviceName)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceUnregistered", f)
+		}
 	}
 }
 
@@ -4942,7 +5044,14 @@ func callbackQDBusVirtualObject_HandleMessage(ptr unsafe.Pointer, message unsafe
 func (ptr *QDBusVirtualObject) ConnectHandleMessage(f func(message *QDBusMessage, connection *QDBusConnection) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleMessage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "handleMessage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleMessage", func(message *QDBusMessage, connection *QDBusConnection) bool {
+				signal.(func(*QDBusMessage, *QDBusConnection))(message, connection)
+				return f(message, connection)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handleMessage", f)
+		}
 	}
 }
 
@@ -4972,7 +5081,14 @@ func callbackQDBusVirtualObject_DestroyQDBusVirtualObject(ptr unsafe.Pointer) {
 func (ptr *QDBusVirtualObject) ConnectDestroyQDBusVirtualObject(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusVirtualObject", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QDBusVirtualObject"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusVirtualObject", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QDBusVirtualObject", f)
+		}
 	}
 }
 
@@ -5011,7 +5127,14 @@ func callbackQDBusVirtualObject_Introspect(ptr unsafe.Pointer, path C.struct_QtD
 func (ptr *QDBusVirtualObject) ConnectIntrospect(f func(path string) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "introspect", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "introspect"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "introspect", func(path string) string {
+				signal.(func(string))(path)
+				return f(path)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "introspect", f)
+		}
 	}
 }
 

gamepad/gamepad.go

@@ -78,8 +78,19 @@ func callbackQGamepad_AxisLeftXChanged(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectAxisLeftXChanged(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectAxisLeftXChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftXChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "axisLeftXChanged") {
+			C.QGamepad_ConnectAxisLeftXChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "axisLeftXChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftXChanged", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftXChanged", f)
+		}
 	}
 }
 
@@ -106,8 +117,19 @@ func callbackQGamepad_AxisLeftYChanged(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectAxisLeftYChanged(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectAxisLeftYChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftYChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "axisLeftYChanged") {
+			C.QGamepad_ConnectAxisLeftYChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "axisLeftYChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftYChanged", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisLeftYChanged", f)
+		}
 	}
 }
 
@@ -134,8 +156,19 @@ func callbackQGamepad_AxisRightXChanged(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectAxisRightXChanged(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectAxisRightXChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightXChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "axisRightXChanged") {
+			C.QGamepad_ConnectAxisRightXChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "axisRightXChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightXChanged", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightXChanged", f)
+		}
 	}
 }
 
@@ -162,8 +195,19 @@ func callbackQGamepad_AxisRightYChanged(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectAxisRightYChanged(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectAxisRightYChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightYChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "axisRightYChanged") {
+			C.QGamepad_ConnectAxisRightYChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "axisRightYChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightYChanged", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "axisRightYChanged", f)
+		}
 	}
 }
 
@@ -190,8 +234,19 @@ func callbackQGamepad_ButtonAChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonAChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonAChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonAChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonAChanged") {
+			C.QGamepad_ConnectButtonAChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonAChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonAChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonAChanged", f)
+		}
 	}
 }
 
@@ -218,8 +273,19 @@ func callbackQGamepad_ButtonBChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonBChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonBChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonBChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonBChanged") {
+			C.QGamepad_ConnectButtonBChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonBChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonBChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonBChanged", f)
+		}
 	}
 }
 
@@ -246,8 +312,19 @@ func callbackQGamepad_ButtonCenterChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonCenterChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonCenterChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonCenterChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonCenterChanged") {
+			C.QGamepad_ConnectButtonCenterChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonCenterChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonCenterChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonCenterChanged", f)
+		}
 	}
 }
 
@@ -274,8 +351,19 @@ func callbackQGamepad_ButtonDownChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonDownChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonDownChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonDownChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonDownChanged") {
+			C.QGamepad_ConnectButtonDownChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonDownChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonDownChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonDownChanged", f)
+		}
 	}
 }
 
@@ -302,8 +390,19 @@ func callbackQGamepad_ButtonGuideChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonGuideChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonGuideChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonGuideChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonGuideChanged") {
+			C.QGamepad_ConnectButtonGuideChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonGuideChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonGuideChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonGuideChanged", f)
+		}
 	}
 }
 
@@ -330,8 +429,19 @@ func callbackQGamepad_ButtonL1Changed(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonL1Changed(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonL1Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL1Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonL1Changed") {
+			C.QGamepad_ConnectButtonL1Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonL1Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL1Changed", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL1Changed", f)
+		}
 	}
 }
 
@@ -358,8 +468,19 @@ func callbackQGamepad_ButtonL2Changed(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectButtonL2Changed(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonL2Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL2Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonL2Changed") {
+			C.QGamepad_ConnectButtonL2Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonL2Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL2Changed", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL2Changed", f)
+		}
 	}
 }
 
@@ -386,8 +507,19 @@ func callbackQGamepad_ButtonL3Changed(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonL3Changed(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonL3Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL3Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonL3Changed") {
+			C.QGamepad_ConnectButtonL3Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonL3Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL3Changed", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonL3Changed", f)
+		}
 	}
 }
 
@@ -414,8 +546,19 @@ func callbackQGamepad_ButtonLeftChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonLeftChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonLeftChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonLeftChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonLeftChanged") {
+			C.QGamepad_ConnectButtonLeftChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonLeftChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonLeftChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonLeftChanged", f)
+		}
 	}
 }
 
@@ -442,8 +585,19 @@ func callbackQGamepad_ButtonR1Changed(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonR1Changed(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonR1Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR1Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonR1Changed") {
+			C.QGamepad_ConnectButtonR1Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonR1Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR1Changed", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR1Changed", f)
+		}
 	}
 }
 
@@ -470,8 +624,19 @@ func callbackQGamepad_ButtonR2Changed(ptr unsafe.Pointer, value C.double) {
 
 func (ptr *QGamepad) ConnectButtonR2Changed(f func(value float64)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonR2Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR2Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonR2Changed") {
+			C.QGamepad_ConnectButtonR2Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonR2Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR2Changed", func(value float64) {
+				signal.(func(float64))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR2Changed", f)
+		}
 	}
 }
 
@@ -498,8 +663,19 @@ func callbackQGamepad_ButtonR3Changed(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonR3Changed(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonR3Changed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR3Changed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonR3Changed") {
+			C.QGamepad_ConnectButtonR3Changed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonR3Changed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR3Changed", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonR3Changed", f)
+		}
 	}
 }
 
@@ -526,8 +702,19 @@ func callbackQGamepad_ButtonRightChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonRightChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonRightChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonRightChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonRightChanged") {
+			C.QGamepad_ConnectButtonRightChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonRightChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonRightChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonRightChanged", f)
+		}
 	}
 }
 
@@ -554,8 +741,19 @@ func callbackQGamepad_ButtonSelectChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonSelectChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonSelectChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonSelectChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonSelectChanged") {
+			C.QGamepad_ConnectButtonSelectChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonSelectChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonSelectChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonSelectChanged", f)
+		}
 	}
 }
 
@@ -582,8 +780,19 @@ func callbackQGamepad_ButtonStartChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonStartChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonStartChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonStartChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonStartChanged") {
+			C.QGamepad_ConnectButtonStartChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonStartChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonStartChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonStartChanged", f)
+		}
 	}
 }
 
@@ -610,8 +819,19 @@ func callbackQGamepad_ButtonUpChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonUpChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonUpChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonUpChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonUpChanged") {
+			C.QGamepad_ConnectButtonUpChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonUpChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonUpChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonUpChanged", f)
+		}
 	}
 }
 
@@ -638,8 +858,19 @@ func callbackQGamepad_ButtonXChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonXChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonXChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonXChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonXChanged") {
+			C.QGamepad_ConnectButtonXChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonXChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonXChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonXChanged", f)
+		}
 	}
 }
 
@@ -666,8 +897,19 @@ func callbackQGamepad_ButtonYChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectButtonYChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectButtonYChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonYChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "buttonYChanged") {
+			C.QGamepad_ConnectButtonYChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "buttonYChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonYChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "buttonYChanged", f)
+		}
 	}
 }
 
@@ -694,8 +936,19 @@ func callbackQGamepad_ConnectedChanged(ptr unsafe.Pointer, value C.char) {
 
 func (ptr *QGamepad) ConnectConnectedChanged(f func(value bool)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectConnectedChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectedChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "connectedChanged") {
+			C.QGamepad_ConnectConnectedChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "connectedChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectedChanged", func(value bool) {
+				signal.(func(bool))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectedChanged", f)
+		}
 	}
 }
 
@@ -722,8 +975,19 @@ func callbackQGamepad_DeviceIdChanged(ptr unsafe.Pointer, value C.int) {
 
 func (ptr *QGamepad) ConnectDeviceIdChanged(f func(value int)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectDeviceIdChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceIdChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "deviceIdChanged") {
+			C.QGamepad_ConnectDeviceIdChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deviceIdChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceIdChanged", func(value int) {
+				signal.(func(int))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceIdChanged", f)
+		}
 	}
 }
 
@@ -750,8 +1014,19 @@ func callbackQGamepad_NameChanged(ptr unsafe.Pointer, value C.struct_QtGamepad_P
 
 func (ptr *QGamepad) ConnectNameChanged(f func(value string)) {
 	if ptr.Pointer() != nil {
-		C.QGamepad_ConnectNameChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nameChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "nameChanged") {
+			C.QGamepad_ConnectNameChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nameChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nameChanged", func(value string) {
+				signal.(func(string))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nameChanged", f)
+		}
 	}
 }
 
@@ -785,7 +1060,14 @@ func callbackQGamepad_SetDeviceId(ptr unsafe.Pointer, number C.int) {
 func (ptr *QGamepad) ConnectSetDeviceId(f func(number int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDeviceId", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setDeviceId"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDeviceId", func(number int) {
+				signal.(func(int))(number)
+				f(number)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDeviceId", f)
+		}
 	}
 }
 

gui/gui.cpp

@@ -4699,9 +4699,9 @@ char QFont_FixedPitch(void* ptr)
 	return static_cast<QFont*>(ptr)->fixedPitch();
 }
 
-char QFont_IsCopyOf(void* ptr, void* f)
+char QFont_IsCopyOf(void* ptr, void* fo)
 {
-	return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(f));
+	return static_cast<QFont*>(ptr)->isCopyOf(*static_cast<QFont*>(fo));
 }
 
 char QFont_Italic(void* ptr)
@@ -21995,9 +21995,9 @@ void* QTextDocument_Object(void* ptr, int objectIndex)
 	return static_cast<QTextDocument*>(ptr)->object(objectIndex);
 }
 
-void* QTextDocument_ObjectForFormat(void* ptr, void* f)
+void* QTextDocument_ObjectForFormat(void* ptr, void* fo)
 {
-	return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(f));
+	return static_cast<QTextDocument*>(ptr)->objectForFormat(*static_cast<QTextFormat*>(fo));
 }
 
 void* QTextDocument_DefaultTextOption(void* ptr)

gui/gui.h

@@ -767,7 +767,7 @@ long long QFont_StyleStrategy(void* ptr);
 char QFont_Bold(void* ptr);
 char QFont_ExactMatch(void* ptr);
 char QFont_FixedPitch(void* ptr);
-char QFont_IsCopyOf(void* ptr, void* f);
+char QFont_IsCopyOf(void* ptr, void* fo);
 char QFont_Italic(void* ptr);
 char QFont_Kerning(void* ptr);
 char QFont_Overline(void* ptr);
@@ -3806,7 +3806,7 @@ void* QTextDocument_Find2(void* ptr, char* subString, int position, long long op
 void* QTextDocument_Clone(void* ptr, void* parent);
 void* QTextDocument_RootFrame(void* ptr);
 void* QTextDocument_Object(void* ptr, int objectIndex);
-void* QTextDocument_ObjectForFormat(void* ptr, void* f);
+void* QTextDocument_ObjectForFormat(void* ptr, void* fo);
 void* QTextDocument_DefaultTextOption(void* ptr);
 void* QTextDocument_BaseUrl(void* ptr);
 void* QTextDocument_Resource(void* ptr, int ty, void* name);

help/help.go

@@ -169,8 +169,19 @@ func callbackQHelpContentModel_ContentsCreated(ptr unsafe.Pointer) {
 
 func (ptr *QHelpContentModel) ConnectContentsCreated(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpContentModel_ConnectContentsCreated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contentsCreated") {
+			C.QHelpContentModel_ConnectContentsCreated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contentsCreated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreated", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreated", f)
+		}
 	}
 }
 
@@ -197,8 +208,19 @@ func callbackQHelpContentModel_ContentsCreationStarted(ptr unsafe.Pointer) {
 
 func (ptr *QHelpContentModel) ConnectContentsCreationStarted(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpContentModel_ConnectContentsCreationStarted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreationStarted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contentsCreationStarted") {
+			C.QHelpContentModel_ConnectContentsCreationStarted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contentsCreationStarted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreationStarted", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contentsCreationStarted", f)
+		}
 	}
 }
 
@@ -253,7 +275,14 @@ func callbackQHelpContentModel_Index(ptr unsafe.Pointer, row C.int, column C.int
 func (ptr *QHelpContentModel) ConnectIndex(f func(row int, column int, parent *core.QModelIndex) *core.QModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "index", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "index"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "index", func(row int, column int, parent *core.QModelIndex) *core.QModelIndex {
+				signal.(func(int, int, *core.QModelIndex))(row, column, parent)
+				return f(row, column, parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "index", f)
+		}
 	}
 }
 
@@ -294,7 +323,14 @@ func callbackQHelpContentModel_Parent(ptr unsafe.Pointer, index unsafe.Pointer)
 func (ptr *QHelpContentModel) ConnectParent(f func(index *core.QModelIndex) *core.QModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "parent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parent", func(index *core.QModelIndex) *core.QModelIndex {
+				signal.(func(*core.QModelIndex))(index)
+				return f(index)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parent", f)
+		}
 	}
 }
 
@@ -335,7 +371,14 @@ func callbackQHelpContentModel_Data(ptr unsafe.Pointer, index unsafe.Pointer, ro
 func (ptr *QHelpContentModel) ConnectData(f func(index *core.QModelIndex, role int) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "data", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "data"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "data", func(index *core.QModelIndex, role int) *core.QVariant {
+				signal.(func(*core.QModelIndex, int))(index, role)
+				return f(index, role)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "data", f)
+		}
 	}
 }
 
@@ -383,7 +426,14 @@ func callbackQHelpContentModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Poi
 func (ptr *QHelpContentModel) ConnectColumnCount(f func(parent *core.QModelIndex) int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "columnCount", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "columnCount"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "columnCount", func(parent *core.QModelIndex) int {
+				signal.(func(*core.QModelIndex))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "columnCount", f)
+		}
 	}
 }
 
@@ -420,7 +470,14 @@ func callbackQHelpContentModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointe
 func (ptr *QHelpContentModel) ConnectRowCount(f func(parent *core.QModelIndex) int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rowCount", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "rowCount"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rowCount", func(parent *core.QModelIndex) int {
+				signal.(func(*core.QModelIndex))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rowCount", f)
+		}
 	}
 }
 
@@ -1841,8 +1898,19 @@ func callbackQHelpContentWidget_LinkActivated(ptr unsafe.Pointer, link unsafe.Po
 
 func (ptr *QHelpContentWidget) ConnectLinkActivated(f func(link *core.QUrl)) {
 	if ptr.Pointer() != nil {
-		C.QHelpContentWidget_ConnectLinkActivated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "linkActivated") {
+			C.QHelpContentWidget_ConnectLinkActivated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "linkActivated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", func(link *core.QUrl) {
+				signal.(func(*core.QUrl))(link)
+				f(link)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", f)
+		}
 	}
 }
 
@@ -4384,8 +4452,19 @@ func callbackQHelpEngineCore_CurrentFilterChanged(ptr unsafe.Pointer, newFilter
 
 func (ptr *QHelpEngineCore) ConnectCurrentFilterChanged(f func(newFilter string)) {
 	if ptr.Pointer() != nil {
-		C.QHelpEngineCore_ConnectCurrentFilterChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentFilterChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentFilterChanged") {
+			C.QHelpEngineCore_ConnectCurrentFilterChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentFilterChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentFilterChanged", func(newFilter string) {
+				signal.(func(string))(newFilter)
+				f(newFilter)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentFilterChanged", f)
+		}
 	}
 }
 
@@ -4417,8 +4496,19 @@ func callbackQHelpEngineCore_ReadersAboutToBeInvalidated(ptr unsafe.Pointer) {
 
 func (ptr *QHelpEngineCore) ConnectReadersAboutToBeInvalidated(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpEngineCore_ConnectReadersAboutToBeInvalidated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readersAboutToBeInvalidated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "readersAboutToBeInvalidated") {
+			C.QHelpEngineCore_ConnectReadersAboutToBeInvalidated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readersAboutToBeInvalidated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readersAboutToBeInvalidated", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readersAboutToBeInvalidated", f)
+		}
 	}
 }
 
@@ -4473,8 +4563,19 @@ func callbackQHelpEngineCore_SetupFinished(ptr unsafe.Pointer) {
 
 func (ptr *QHelpEngineCore) ConnectSetupFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpEngineCore_ConnectSetupFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupFinished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "setupFinished") {
+			C.QHelpEngineCore_ConnectSetupFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setupFinished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupFinished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupFinished", f)
+		}
 	}
 }
 
@@ -4501,8 +4602,19 @@ func callbackQHelpEngineCore_SetupStarted(ptr unsafe.Pointer) {
 
 func (ptr *QHelpEngineCore) ConnectSetupStarted(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpEngineCore_ConnectSetupStarted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupStarted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "setupStarted") {
+			C.QHelpEngineCore_ConnectSetupStarted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setupStarted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupStarted", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setupStarted", f)
+		}
 	}
 }
 
@@ -4529,8 +4641,19 @@ func callbackQHelpEngineCore_Warning(ptr unsafe.Pointer, msg C.struct_QtHelp_Pac
 
 func (ptr *QHelpEngineCore) ConnectWarning(f func(msg string)) {
 	if ptr.Pointer() != nil {
-		C.QHelpEngineCore_ConnectWarning(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warning", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "warning") {
+			C.QHelpEngineCore_ConnectWarning(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "warning"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warning", func(msg string) {
+				signal.(func(string))(msg)
+				f(msg)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warning", f)
+		}
 	}
 }
 
@@ -4564,7 +4687,14 @@ func callbackQHelpEngineCore_DestroyQHelpEngineCore(ptr unsafe.Pointer) {
 func (ptr *QHelpEngineCore) ConnectDestroyQHelpEngineCore(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QHelpEngineCore", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QHelpEngineCore"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QHelpEngineCore", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QHelpEngineCore", f)
+		}
 	}
 }
 
@@ -5150,8 +5280,19 @@ func callbackQHelpIndexModel_IndexCreated(ptr unsafe.Pointer) {
 
 func (ptr *QHelpIndexModel) ConnectIndexCreated(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpIndexModel_ConnectIndexCreated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "indexCreated") {
+			C.QHelpIndexModel_ConnectIndexCreated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "indexCreated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreated", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreated", f)
+		}
 	}
 }
 
@@ -5178,8 +5319,19 @@ func callbackQHelpIndexModel_IndexCreationStarted(ptr unsafe.Pointer) {
 
 func (ptr *QHelpIndexModel) ConnectIndexCreationStarted(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpIndexModel_ConnectIndexCreationStarted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreationStarted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "indexCreationStarted") {
+			C.QHelpIndexModel_ConnectIndexCreationStarted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "indexCreationStarted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreationStarted", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexCreationStarted", f)
+		}
 	}
 }
 
@@ -6760,7 +6912,14 @@ func callbackQHelpIndexWidget_ActivateCurrentItem(ptr unsafe.Pointer) {
 func (ptr *QHelpIndexWidget) ConnectActivateCurrentItem(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activateCurrentItem", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activateCurrentItem"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activateCurrentItem", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activateCurrentItem", f)
+		}
 	}
 }
 
@@ -6795,7 +6954,14 @@ func callbackQHelpIndexWidget_FilterIndices(ptr unsafe.Pointer, filter C.struct_
 func (ptr *QHelpIndexWidget) ConnectFilterIndices(f func(filter string, wildcard string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filterIndices", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "filterIndices"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filterIndices", func(filter string, wildcard string) {
+				signal.(func(string, string))(filter, wildcard)
+				f(filter, wildcard)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "filterIndices", f)
+		}
 	}
 }
 
@@ -6848,8 +7014,19 @@ func callbackQHelpIndexWidget_LinkActivated(ptr unsafe.Pointer, link unsafe.Poin
 
 func (ptr *QHelpIndexWidget) ConnectLinkActivated(f func(link *core.QUrl, keyword string)) {
 	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_ConnectLinkActivated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "linkActivated") {
+			C.QHelpIndexWidget_ConnectLinkActivated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "linkActivated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", func(link *core.QUrl, keyword string) {
+				signal.(func(*core.QUrl, string))(link, keyword)
+				f(link, keyword)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linkActivated", f)
+		}
 	}
 }
 
@@ -6887,8 +7064,19 @@ func callbackQHelpIndexWidget_LinksActivated(ptr unsafe.Pointer, links C.struct_
 
 func (ptr *QHelpIndexWidget) ConnectLinksActivated(f func(links map[string]*core.QUrl, keyword string)) {
 	if ptr.Pointer() != nil {
-		C.QHelpIndexWidget_ConnectLinksActivated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linksActivated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "linksActivated") {
+			C.QHelpIndexWidget_ConnectLinksActivated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "linksActivated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linksActivated", func(links map[string]*core.QUrl, keyword string) {
+				signal.(func(map[string]*core.QUrl, string))(links, keyword)
+				f(links, keyword)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "linksActivated", f)
+		}
 	}
 }
 
@@ -9057,7 +9245,14 @@ func callbackQHelpSearchEngine_CancelIndexing(ptr unsafe.Pointer) {
 func (ptr *QHelpSearchEngine) ConnectCancelIndexing(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelIndexing", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelIndexing"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelIndexing", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelIndexing", f)
+		}
 	}
 }
 
@@ -9092,7 +9287,14 @@ func callbackQHelpSearchEngine_CancelSearching(ptr unsafe.Pointer) {
 func (ptr *QHelpSearchEngine) ConnectCancelSearching(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearching", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelSearching"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearching", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearching", f)
+		}
 	}
 }
 
@@ -9125,8 +9327,19 @@ func callbackQHelpSearchEngine_IndexingFinished(ptr unsafe.Pointer) {
 
 func (ptr *QHelpSearchEngine) ConnectIndexingFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchEngine_ConnectIndexingFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingFinished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "indexingFinished") {
+			C.QHelpSearchEngine_ConnectIndexingFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "indexingFinished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingFinished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingFinished", f)
+		}
 	}
 }
 
@@ -9153,8 +9366,19 @@ func callbackQHelpSearchEngine_IndexingStarted(ptr unsafe.Pointer) {
 
 func (ptr *QHelpSearchEngine) ConnectIndexingStarted(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchEngine_ConnectIndexingStarted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingStarted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "indexingStarted") {
+			C.QHelpSearchEngine_ConnectIndexingStarted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "indexingStarted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingStarted", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "indexingStarted", f)
+		}
 	}
 }
 
@@ -9183,7 +9407,14 @@ func callbackQHelpSearchEngine_ReindexDocumentation(ptr unsafe.Pointer) {
 func (ptr *QHelpSearchEngine) ConnectReindexDocumentation(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reindexDocumentation", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "reindexDocumentation"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reindexDocumentation", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reindexDocumentation", f)
+		}
 	}
 }
 
@@ -9230,7 +9461,14 @@ func callbackQHelpSearchEngine_Search(ptr unsafe.Pointer, queryList C.struct_QtH
 func (ptr *QHelpSearchEngine) ConnectSearch(f func(queryList []*QHelpSearchQuery)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "search"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", func(queryList []*QHelpSearchQuery) {
+				signal.(func([]*QHelpSearchQuery))(queryList)
+				f(queryList)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", f)
+		}
 	}
 }
 
@@ -9275,8 +9513,19 @@ func callbackQHelpSearchEngine_SearchingFinished(ptr unsafe.Pointer, hits C.int)
 
 func (ptr *QHelpSearchEngine) ConnectSearchingFinished(f func(hits int)) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchEngine_ConnectSearchingFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingFinished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "searchingFinished") {
+			C.QHelpSearchEngine_ConnectSearchingFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchingFinished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingFinished", func(hits int) {
+				signal.(func(int))(hits)
+				f(hits)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingFinished", f)
+		}
 	}
 }
 
@@ -9303,8 +9552,19 @@ func callbackQHelpSearchEngine_SearchingStarted(ptr unsafe.Pointer) {
 
 func (ptr *QHelpSearchEngine) ConnectSearchingStarted(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchEngine_ConnectSearchingStarted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingStarted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "searchingStarted") {
+			C.QHelpSearchEngine_ConnectSearchingStarted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchingStarted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingStarted", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingStarted", f)
+		}
 	}
 }
 
@@ -9801,8 +10061,19 @@ func callbackQHelpSearchQueryWidget_Search(ptr unsafe.Pointer) {
 
 func (ptr *QHelpSearchQueryWidget) ConnectSearch(f func()) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchQueryWidget_ConnectSearch(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "search") {
+			C.QHelpSearchQueryWidget_ConnectSearch(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "search"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "search", f)
+		}
 	}
 }
 
@@ -11138,8 +11409,19 @@ func callbackQHelpSearchResultWidget_RequestShowLink(ptr unsafe.Pointer, link un
 
 func (ptr *QHelpSearchResultWidget) ConnectRequestShowLink(f func(link *core.QUrl)) {
 	if ptr.Pointer() != nil {
-		C.QHelpSearchResultWidget_ConnectRequestShowLink(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestShowLink", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestShowLink") {
+			C.QHelpSearchResultWidget_ConnectRequestShowLink(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestShowLink"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestShowLink", func(link *core.QUrl) {
+				signal.(func(*core.QUrl))(link)
+				f(link)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestShowLink", f)
+		}
 	}
 }
 

internal/binding/converter/header.go

@@ -234,6 +234,14 @@ func GoHeaderInputSignalFunction(f *parser.Function) string {
 	return bb.String()
 }
 
+func GoGoInput(f *parser.Function) string {
+	var tmp = make([]string, 0)
+	for _, p := range f.Parameters {
+		tmp = append(tmp, parser.CleanName(p.Name, p.Value))
+	}
+	return strings.Join(tmp, ", ")
+}
+
 func CppHeaderInput(f *parser.Function) string {
 	var tmp = make([]string, 0)
 

internal/binding/parser/helper.go

@@ -121,6 +121,11 @@ func CleanName(name, value string) string {
 				return fmt.Sprintf("v%v", strings.ToLower(v))
 			}
 		}
+
+	case "f":
+		{
+			return "fo"
+		}
 	}
 
 	return name

internal/binding/templater/function_go.go

@@ -96,6 +96,13 @@ func goFunctionBody(function *parser.Function) string {
 	if function.SignalMode == "" || (function.Meta == parser.SIGNAL && function.SignalMode != parser.CALLBACK) {
 
 		//TODO: -->
+		if function.SignalMode == parser.CONNECT {
+			fmt.Fprintf(bb, "\nif !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), \"%v%v\") {\n",
+				function.Name,
+				function.OverloadNumber,
+			)
+		}
+
 		var body = converter.GoOutputParametersFromC(function, fmt.Sprintf("C.%v(%v)", converter.CppHeaderName(function), converter.GoInputParametersForC(function)))
 		fmt.Fprint(bb, func() string {
 			if converter.GoHeaderOutput(function) == "" {
@@ -194,6 +201,10 @@ func goFunctionBody(function *parser.Function) string {
 			}
 
 		}())
+
+		if function.SignalMode == parser.CONNECT {
+			fmt.Fprint(bb, "\n}\n")
+		}
 	}
 	//<--
 
@@ -301,7 +312,60 @@ func goFunctionBody(function *parser.Function) string {
 
 		}
 
-	case parser.CONNECT, parser.DISCONNECT:
+	case parser.CONNECT:
+		{
+			fmt.Fprintf(bb, "\nif signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), \"%v%v\"); signal != nil {\n",
+				function.Name,
+				function.OverloadNumber,
+			)
+
+			fmt.Fprintf(bb, "\tqt.%vSignal(fmt.Sprint(ptr.Pointer()), \"%v%v\", %v)",
+				function.SignalMode,
+				function.Name,
+				function.OverloadNumber,
+				func() string {
+					var bb = new(bytes.Buffer)
+					defer bb.Reset()
+
+					fmt.Fprintf(bb, "%v {\n", strings.TrimPrefix(converter.GoHeaderInput(function), "f "))
+
+					fmt.Fprintf(bb, "signal.(%v)(%v)\n",
+						converter.GoHeaderInputSignalFunction(function),
+						converter.GoGoInput(function),
+					)
+
+					var f = *function
+					f.SignalMode = ""
+					if converter.GoHeaderOutput(&f) != "" {
+						fmt.Fprint(bb, "return ")
+					}
+
+					fmt.Fprintf(bb, "f(%v)\n",
+						converter.GoGoInput(function),
+					)
+
+					fmt.Fprint(bb, "}")
+
+					return bb.String()
+				}())
+
+			fmt.Fprintf(bb, "} else {\n")
+			fmt.Fprintf(bb, "\tqt.%vSignal(fmt.Sprint(ptr.Pointer()), \"%v%v\"%v)",
+				function.SignalMode,
+				function.Name,
+				function.OverloadNumber,
+				func() string {
+					if function.SignalMode == parser.CONNECT {
+						return ", f"
+					}
+					return ""
+				}(),
+			)
+
+			fmt.Fprintf(bb, "}")
+		}
+
+	case parser.DISCONNECT:
 		{
 			fmt.Fprintf(bb, "\nqt.%vSignal(fmt.Sprint(ptr.Pointer()), \"%v%v\"%v)",
 				function.SignalMode,

internal/binding/templater/template_cgo.go

@@ -19,8 +19,6 @@ func CgoTemplate(module, mocPath, buildTarget string) {
 		switch {
 		case parser.State.Moc:
 			QmakeCgoTemplate(module, mocPath, buildTarget, MOC)
-		case parser.State.Rcc:
-			QmakeCgoTemplate(module, mocPath, buildTarget, RCC)
 		case parser.State.Minimal:
 			QmakeCgoTemplate(module, mocPath, buildTarget, MINIMAL)
 		default:
@@ -226,7 +224,7 @@ func cgoWindowsForLinux(module, mocPath string) {
 	var (
 		bb     = new(bytes.Buffer)
 		libs   = cleanLibs(module)
-		QT_DIR = func() string { return "/usr/lib/mxe/usr/i686-w64-mingw32.shared/qt5" }
+		QT_DIR = func() string { return filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "qt5") }
 	)
 	defer bb.Reset()
 

internal/binding/templater/template_cgo_qmake.go

@@ -68,6 +68,9 @@ func QmakeCgoTemplate(module, path, target string, mode int) (o string) {
 		target = runtime.GOOS
 	}
 
+	if isAlreadyCached(module, path, target, mode) {
+		return
+	}
 	createProject(module, path, mode)
 	createMakefile(module, path, target, mode)
 	createCgo(module, path, target, mode)
@@ -78,6 +81,26 @@ func QmakeCgoTemplate(module, path, target string, mode int) (o string) {
 	return
 }
 
+func isAlreadyCached(module, path, target string, mode int) bool {
+	for _, file := range cgoFileNames(module, path, target, mode) {
+		file = filepath.Join(path, file)
+		if utils.ExistsFile(file) {
+			switch target {
+			case "darwin", "linux", "windows":
+				//TODO msys pkg-config mxe brew
+				return strings.Contains(utils.Load(file), utils.QT_DIR()) || strings.Contains(utils.Load(file), utils.QT_DARWIN_DIR())
+			case "android":
+				return strings.Contains(utils.Load(file), utils.QT_DIR()) && strings.Contains(utils.Load(file), utils.ANDROID_NDK_DIR())
+			case "ios", "ios-simulator":
+				return strings.Contains(utils.Load(file), utils.QT_DIR()) || strings.Contains(utils.Load(file), utils.QT_DARWIN_DIR())
+			case "sailfish", "sailfish-emulator", "asteroid":
+			case "rpi1", "rpi2", "rpi3":
+			}
+		}
+	}
+	return false
+}
+
 func createProject(module, path string, mode int) {
 	var out []string
 
@@ -101,55 +124,7 @@ func createProject(module, path string, mode int) {
 }
 
 func createMakefile(module, path, target string, mode int) {
-	var qmakePath string
-	switch target {
-	case "darwin":
-		qmakePath = filepath.Join(utils.QT_DARWIN_DIR(), "bin", "qmake")
-	case "windows":
-		if runtime.GOOS == target {
-			if utils.UseMsys2() {
-				qmakePath = filepath.Join(utils.QT_MSYS2_DIR(), "bin", "qmake")
-			} else {
-				qmakePath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "mingw53_32", "bin", "qmake")
-			}
-			break
-		}
-		var prefix = "i686"
-		if utils.QT_MXE_ARCH() == "amd64" {
-			prefix = "x86_64"
-		}
-		var suffix = "shared"
-		if utils.QT_MXE_STATIC() {
-			suffix = "static"
-		}
-		qmakePath = filepath.Join("/usr", "lib", "mxe", "usr", fmt.Sprintf("%v-w64-mingw32.%v", prefix, suffix), "qt5", "bin", "qmake")
-	case "linux":
-		if utils.UsePkgConfig() {
-			if utils.QT_QMAKE_CGO() {
-				qmakePath = filepath.Join(strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=host_bins", "Qt5Core"), "cgo.LinuxPkgConfig_hostBins")), "qmake")
-			} else {
-				qmakePath = filepath.Join(utils.QT_MISC_DIR(), "bin", "qmake")
-			}
-		} else {
-			qmakePath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "gcc_64", "bin", "qmake")
-		}
-	case "ios", "ios-simulator":
-		qmakePath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "ios", "bin", "qmake")
-	case "android":
-		qmakePath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "android_armv7", "bin", "qmake")
-	case "sailfish":
-		qmakePath = filepath.Join(os.Getenv("HOME"), ".config", "SailfishOS-SDK", "mer-sdk-tools", "MerSDK", "SailfishOS-armv7hl", "qmake")
-	case "sailfish-emulator":
-		qmakePath = filepath.Join(os.Getenv("HOME"), ".config", "SailfishOS-SDK", "mer-sdk-tools", "MerSDK", "SailfishOS-i486", "qmake")
-	case "asteroid":
-	case "rp1", "rpi2", "rpi3":
-		qmakePath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), target, "bin", "qmake")
-	}
-	if dir := utils.QT_QMAKE_DIR(); dir != "" {
-		qmakePath = filepath.Join(dir, "qmake")
-	}
-
-	var cmd = exec.Command(qmakePath, filepath.Join(path, "..", fmt.Sprintf("%v.pro", strings.ToLower(module))))
+	var cmd = exec.Command(utils.ToolPath("qmake", target), filepath.Join(path, "..", fmt.Sprintf("%v.pro", strings.ToLower(module))))
 	cmd.Dir = path
 	switch target {
 	case "darwin":
@@ -164,7 +139,6 @@ func createMakefile(module, path, target string, mode int) {
 		cmd.Args = append(cmd.Args, []string{"-spec", "macx-ios-clang", "CONFIG+=release", "CONFIG+=iphonesimulator", "CONFIG+=simulator"}...)
 	case "android":
 		cmd.Args = append(cmd.Args, []string{"-spec", "android-g++"}...)
-		cmd.Env = []string{fmt.Sprintf("ANDROID_NDK_ROOT=%v", utils.ANDROID_NDK_DIR())}
 	case "sailfish", "sailfish-emulator":
 		cmd.Args = append(cmd.Args, []string{"-spec", "linux-g++"}...)
 		cmd.Env = []string{
@@ -182,7 +156,17 @@ func createMakefile(module, path, target string, mode int) {
 	case "rpi1", "rpi2", "rpi3":
 	}
 
-	utils.RunCmdOptional(cmd, fmt.Sprintf("run qmake for %v on %v", target, runtime.GOOS))
+	if target == "android" && runtime.GOOS == "windows" {
+		//TODO: -->
+		utils.Save(filepath.Join(cmd.Dir, "qmake.bat"), fmt.Sprintf("set ANDROID_NDK_ROOT=%v\r\n%v", utils.ANDROID_NDK_DIR(), strings.Join(cmd.Args, " ")))
+		cmd = exec.Command(".\\qmake.bat")
+		cmd.Dir = path
+		utils.RunCmdOptional(cmd, fmt.Sprintf("run qmake for %v on %v", target, runtime.GOOS))
+		utils.RemoveAll(filepath.Join(cmd.Dir, "qmake.bat"))
+		//<--
+	} else {
+		utils.RunCmdOptional(cmd, fmt.Sprintf("run qmake for %v on %v", target, runtime.GOOS))
+	}
 
 	utils.RemoveAll(filepath.Join(path, "..", fmt.Sprintf("%v.pro", strings.ToLower(module))))
 	utils.RemoveAll(filepath.Join(path, ".qmake.stash"))
@@ -285,8 +269,7 @@ func createCgo(module, path, target string, mode int) string {
 			if target == "windows" && !utils.QT_MXE_STATIC() {
 				var pFix = []string{
 					filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "mingw53_32"),
-					filepath.Join("/usr", "lib", "mxe", "usr", "i686-w64-mingw32.shared", "qt5"),
-					filepath.Join("/usr", "lib", "mxe", "usr", "x86_64-w64-mingw32.shared", "qt5"),
+					filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "qt5"),
 					utils.QT_MSYS2_DIR(),
 				}
 				for _, pFix := range pFix {
@@ -329,6 +312,9 @@ func createCgo(module, path, target string, mode int) string {
 		tmp = strings.Replace(tmp, "$(EXPORT_ARCH_ARGS)", "-arch x86_64", -1)
 		tmp = strings.Replace(tmp, "$(EXPORT_QMAKE_XARCH_CFLAGS)", "", -1)
 		tmp = strings.Replace(tmp, "$(EXPORT_QMAKE_XARCH_LFLAGS)", "", -1)
+	case "android":
+		tmp = strings.Replace(tmp, fmt.Sprintf("-Wl,-soname,lib%v.so", strings.ToLower(module)), "", -1)
+		tmp = strings.Replace(tmp, "-shared", "", -1)
 	}
 
 	for _, variable := range []string{"DEFINES", "SUBLIBS", "EXPORT_QMAKE_XARCH_CFLAGS", "EXPORT_QMAKE_XARCH_LFLAGS", "EXPORT_ARCH_ARGS", "-fvisibility=hidden", "-fembed-bitcode"} {
@@ -349,6 +335,31 @@ func createCgo(module, path, target string, mode int) string {
 		return tmp
 	}
 
+	for _, file := range cgoFileNames(module, path, target, mode) {
+		switch target {
+		case "windows":
+			if utils.UseMsys2() && utils.QT_MSYS2_ARCH() == "amd64" {
+				tmp = strings.Replace(tmp, " -Wa,-mbig-obj ", " ", -1)
+			}
+			if (utils.UseMsys2() && utils.QT_MSYS2_ARCH() == "amd64") || utils.QT_MXE_ARCH() == "amd64" {
+				tmp = strings.Replace(tmp, " -Wl,-s ", " ", -1)
+			}
+		case "ios":
+			if strings.HasSuffix(file, "darwin_arm.go") {
+				tmp = strings.Replace(tmp, "arm64", "armv7", -1)
+			}
+		case "ios-simulator":
+			if strings.HasSuffix(file, "darwin_386.go") {
+				tmp = strings.Replace(tmp, "x86_64", "i386", -1)
+			}
+		}
+		utils.Save(filepath.Join(path, file), tmp)
+	}
+
+	return ""
+}
+
+func cgoFileNames(module, path, target string, mode int) []string {
 	var pFix string
 	switch mode {
 	case RCC:
@@ -387,26 +398,9 @@ func createCgo(module, path, target string, mode int) string {
 		sFixes = []string{"linux_arm"}
 	}
 
+	var o []string
 	for _, sFix := range sFixes {
-		switch target {
-		case "windows":
-			if utils.UseMsys2() && utils.QT_MSYS2_ARCH() == "amd64" {
-				tmp = strings.Replace(tmp, " -Wa,-mbig-obj ", " ", -1)
-			}
-			if (utils.UseMsys2() && utils.QT_MSYS2_ARCH() == "amd64") || utils.QT_MXE_ARCH() == "amd64" {
-				tmp = strings.Replace(tmp, " -Wl,-s ", " ", -1)
-			}
-		case "ios":
-			if sFix == "darwin_arm" {
-				tmp = strings.Replace(tmp, "arm64", "armv7", -1)
-			}
-		case "ios-simulator":
-			if sFix == "darwin_386" {
-				tmp = strings.Replace(tmp, "x86_64", "i386", -1)
-			}
-		}
-		utils.Save(filepath.Join(path, fmt.Sprintf("%vcgo_%v_%v.go", pFix, strings.Replace(target, "-", "_", -1), sFix)), tmp)
+		o = append(o, fmt.Sprintf("%vcgo_%v_%v.go", pFix, strings.Replace(target, "-", "_", -1), sFix))
 	}
-
-	return ""
+	return o
 }

internal/cmd/deploy/deploy.go

@@ -384,22 +384,9 @@ func build() {
 				"GOARCH": utils.QT_MXE_ARCH(),
 
 				"CGO_ENABLED": "1",
+				"CC":          utils.QT_MXE_BIN("gcc"),
+				"CXX":         utils.QT_MXE_BIN("g++"),
 			}
-
-			var path = func() string {
-				var prefix = "i686"
-				if utils.QT_MXE_ARCH() == "amd64" {
-					prefix = "x86_64"
-				}
-				var suffix = "shared"
-				if utils.QT_MXE_STATIC() {
-					suffix = "static"
-				}
-				return filepath.Join("/usr", "lib", "mxe", "usr", "bin", fmt.Sprintf("%v-w64-mingw32.%v", prefix, suffix))
-			}()
-
-			env["CC"] = path + "-gcc"
-			env["CXX"] = path + "-g++"
 		}
 	}
 
@@ -701,10 +688,7 @@ func deployInternal() {
 						return
 					}
 
-					var libraryPath = "/usr/lib/mxe/usr/i686-w64-mingw32.shared/bin/"
-					if utils.QT_MXE_ARCH() == "amd64" {
-						libraryPath = "/usr/lib/mxe/usr/x86_64-w64-mingw32.shared/bin/"
-					}
+					var libraryPath = filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "bin")
 					for _, d := range []string{"libbz2", "libfreetype-6", "libglib-2.0-0", "libharfbuzz-0", "libiconv-2", "libintl-8", "libpcre-1", "libpcre16-0", "libpng16-16", "libstdc++-6", "libwinpthread-1", "zlib1", "libeay32", "ssleay32"} {
 						utils.RunCmdOptional(exec.Command("cp", filepath.Join(libraryPath, fmt.Sprintf("%v.dll", d)), depPath), fmt.Sprintf("copy %v for %v on %v", d, buildTarget, runtime.GOOS))
 					}
@@ -718,23 +702,12 @@ func deployInternal() {
 					}
 					utils.RunCmdOptional(exec.Command("cp", filepath.Join(libraryPath, fmt.Sprintf("%v.dll", gccDep)), depPath), fmt.Sprintf("copy %v for %v on %v", gccDep, buildTarget, runtime.GOOS))
 
-					libraryPath = "/usr/lib/mxe/usr/i686-w64-mingw32.shared/qt5/"
-					if utils.QT_MXE_ARCH() == "amd64" {
-						libraryPath = "/usr/lib/mxe/usr/x86_64-w64-mingw32.shared/qt5/"
-					}
+					libraryPath = filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "qt5")
 					utils.RunCmd(exec.Command("cp", "-R", filepath.Join(libraryPath, "qml/")+"/.", depPath), fmt.Sprintf("copy qml dir for %v on %v", buildTarget, runtime.GOOS))
 					utils.RunCmd(exec.Command("cp", "-R", filepath.Join(libraryPath, "plugins/")+"/.", depPath), fmt.Sprintf("copy plugins dir for %v on %v", buildTarget, runtime.GOOS))
 
-					libraryPath = "/usr/lib/mxe/usr/i686-w64-mingw32.shared/qt5/bin/"
-					if utils.QT_MXE_ARCH() == "amd64" {
-						libraryPath = "/usr/lib/mxe/usr/x86_64-w64-mingw32.shared/qt5/bin/"
-					}
-
-					var output = utils.RunCmd(exec.Command("/usr/lib/mxe/usr/bin/i686-w64-mingw32.shared-objdump", "-x", filepath.Join(depPath, appName+ending)), fmt.Sprintf("objdump binary for %v on %v", buildTarget, runtime.GOOS))
-					if utils.QT_MXE_ARCH() == "amd64" {
-						output = utils.RunCmd(exec.Command("/usr/lib/mxe/usr/bin/x86_64-w64-mingw32.shared-objdump", "-x", filepath.Join(depPath, appName+ending)), fmt.Sprintf("objdump binary for %v on %v", buildTarget, runtime.GOOS))
-					}
-
+					libraryPath = filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "qt5", "bin")
+					var output = utils.RunCmd(exec.Command(utils.QT_MXE_BIN("objdump"), "-x", filepath.Join(depPath, appName+ending)), fmt.Sprintf("objdump binary for %v on %v", buildTarget, runtime.GOOS))
 					for lib, deps := range parser.LibDeps {
 						if strings.Contains(output, lib) && lib != parser.MOC {
 							for _, lib := range append(deps, lib) {

internal/cmd/moc/moc.go

@@ -247,36 +247,10 @@ func CleanPath(path string) (err error) {
 
 func (m *appMoc) runQtMoc() (err error) {
 	var (
-		mocPath string
+		mocPath = utils.ToolPath("moc", m.buildTarget)
 		output  []byte
 		info    os.FileInfo
 	)
-	switch runtime.GOOS {
-	case "darwin":
-		mocPath = filepath.Join(utils.QT_DARWIN_DIR(), "bin", "moc")
-	case "linux":
-		if m.buildTarget == "windows" || (utils.QT_DOCKER() && os.Getenv("QT_MXE_ARCH") != "") {
-			var prefix = "i686"
-			if utils.QT_MXE_ARCH() == "amd64" {
-				prefix = "x86_64"
-			}
-			var suffix = "shared"
-			if utils.QT_MXE_STATIC() {
-				suffix = "static"
-			}
-			mocPath = filepath.Join("/usr", "lib", "mxe", "usr", fmt.Sprintf("%v-w64-mingw32.%v", prefix, suffix), "qt5", "bin", "moc")
-		} else if utils.UsePkgConfig() {
-			mocPath = filepath.Join(strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=host_bins", "Qt5Core"), "moc.LinuxPkgConfig_hostBins")), "moc")
-		} else {
-			mocPath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "gcc_64", "bin", "moc")
-		}
-	case "windows":
-		if utils.UseMsys2() {
-			mocPath = filepath.Join(utils.QT_MSYS2_DIR(), "bin", "moc")
-		} else {
-			mocPath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "mingw53_32", "bin", "moc")
-		}
-	}
 
 	if runtime.GOOS != "windows" { //TODO: os.Stat fails on windows
 		if info, err = os.Stat(mocPath); err != nil {

internal/cmd/rcc/rcc.go

@@ -18,6 +18,11 @@ import (
 )
 
 func Rcc(appPath, buildTarget string, output_dir *string) {
+	if utils.QT_QMAKE_CGO() {
+		QmakeRcc(appPath, buildTarget, output_dir)
+		return
+	}
+
 	if output_dir == nil {
 		var toutput_dir string
 		output_dir = &toutput_dir
@@ -28,7 +33,7 @@ func Rcc(appPath, buildTarget string, output_dir *string) {
 	utils.MkdirAll(filepath.Join(appPath, "qml"))
 
 	var (
-		rccPath string
+		rccPath = utils.ToolPath("rcc", buildTarget)
 		qmlGo   = filepath.Join(func() string {
 			if *output_dir != "" {
 				return *output_dir
@@ -46,38 +51,6 @@ func Rcc(appPath, buildTarget string, output_dir *string) {
 		}(), "rcc.cpp")
 	)
 
-	switch runtime.GOOS {
-	case "darwin":
-		{
-			rccPath = filepath.Join(utils.QT_DARWIN_DIR(), "bin", "rcc")
-		}
-
-	case "linux":
-		{
-			if buildTarget == "windows" || os.Getenv("QT_MXE_ARCH") != "" {
-				rccPath = filepath.Join("/usr/lib/mxe/usr/", func() string {
-					if utils.QT_MXE_ARCH() == "386" {
-						return "i686"
-					}
-					return "x86_64"
-				}()+"-w64-mingw32.shared/qt5/bin/rcc")
-			} else if utils.UsePkgConfig() {
-				rccPath = filepath.Join(strings.TrimSpace(utils.RunCmd(exec.Command("pkg-config", "--variable=host_bins", "Qt5Core"), fmt.Sprintf("find rccPath with pkg-config on %v", runtime.GOOS))), "rcc")
-			} else {
-				rccPath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "gcc_64", "bin", "rcc")
-			}
-		}
-
-	case "windows":
-		{
-			if utils.UseMsys2() {
-				rccPath = filepath.Join(utils.QT_MSYS2_DIR(), "bin", "rcc")
-			} else {
-				rccPath = filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "mingw53_32", "bin", "rcc")
-			}
-		}
-	}
-
 	utils.Save(qmlGo, qmlHeader(appName, appPath, buildTarget))
 
 	var rcc = exec.Command(rccPath, "-project", "-o", qmlQrc)
@@ -156,16 +129,13 @@ func qmlHeader(appName, appPath, buildTarget string) string {
 */
 import "C"`,
 		"${QT_WINDOWS_DIR}", func() string {
-			if runtime.GOOS == "linux" {
-				if utils.QT_MXE_ARCH() == "amd64" {
-					return "/usr/lib/mxe/usr/x86_64-w64-mingw32.shared/qt5/lib"
+			if runtime.GOOS == "windows" {
+				if utils.UseMsys2() {
+					return filepath.Join(utils.QT_MSYS2_DIR(), "lib")
 				}
-				return "/usr/lib/mxe/usr/i686-w64-mingw32.shared/qt5/lib"
+				return "${QT_DIR}/${QT_VERSION_MAJOR}/mingw53_32/lib"
 			}
-			if utils.UseMsys2() {
-				return filepath.Join(utils.QT_MSYS2_DIR(), "lib")
-			}
-			return "${QT_DIR}/${QT_VERSION_MAJOR}/mingw53_32/lib"
+			return filepath.Join(utils.QT_MXE_DIR(), "usr", utils.QT_MXE_TRIPLET(), "qt5", "lib")
 		}(), -1),
 		"${QT_DARWIN_DIR}", utils.QT_DARWIN_DIR(), -1),
 		"${QT_LINUX_DIR}", func() string {

internal/cmd/rcc/rcc_qmake.go

@@ -0,0 +1,71 @@
+package rcc
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/therecipe/qt/internal/binding/templater"
+	"github.com/therecipe/qt/internal/utils"
+)
+
+func QmakeRcc(path, target string, output_dir *string) {
+	if dir := filepath.Join(path, "qml"); !utils.ExistsDir(dir) {
+		utils.MkdirAll(dir)
+	}
+
+	var (
+		rccQrc = filepath.Join(path, "rcc.qrc")
+
+		rccCpp = filepath.Join(path, "rcc.cpp")
+	)
+	if output_dir != nil {
+		rccCpp = filepath.Join(*output_dir, "rcc.cpp")
+		templater.QmakeCgoTemplate("main", *output_dir, target, templater.RCC)
+	} else {
+		templater.QmakeCgoTemplate("main", path, target, templater.RCC)
+	}
+
+	var rcc = exec.Command(utils.ToolPath("rcc", target), "-project", "-o", rccQrc)
+	rcc.Dir = filepath.Join(path, "qml")
+	utils.RunCmd(rcc, fmt.Sprintf("execute rcc *.qrc on %v for %v", runtime.GOOS, target))
+
+	var content = utils.Load(rccQrc)
+	content = strings.Replace(content, "<file>./", "<file>qml/", -1)
+	if utils.ExistsFile(filepath.Join(path, "qtquickcontrols2.conf")) {
+		content = strings.Replace(content, "<qresource>", "<qresource>\n<file>qtquickcontrols2.conf</file>", -1)
+	}
+	utils.Save(rccQrc, content)
+
+	var (
+		files, err = ioutil.ReadDir(path)
+		fileList   []string
+	)
+	if err != nil {
+		utils.Log.WithError(err).Fatal("failed to read dir")
+	}
+	for _, f := range files {
+		if !f.IsDir() && strings.HasSuffix(f.Name(), ".qrc") {
+			fileList = append(fileList, filepath.Join(path, f.Name()))
+		}
+	}
+
+	rcc = exec.Command(utils.ToolPath("rcc", target), "-o", rccCpp)
+	rcc.Args = append(rcc.Args, fileList...)
+	utils.RunCmd(rcc, fmt.Sprintf("execute rcc *.cpp on %v for %v", runtime.GOOS, target))
+}
+
+func QmakeCleanPath(path string) {
+	var files, err = ioutil.ReadDir(path)
+	if err != nil {
+		utils.Log.WithError(err).Fatal("failed to read dir")
+	}
+	for _, f := range files {
+		if !f.IsDir() && strings.HasPrefix(f.Name(), "rcc") {
+			utils.RemoveAll(filepath.Join(path, f.Name()))
+		}
+	}
+}

internal/cmd/setup/install.go

@@ -263,22 +263,9 @@ func getEnvAndTagflags(buildTarget string) (env map[string]string, tagFlags stri
 				"GOARCH": utils.QT_MXE_ARCH(),
 
 				"CGO_ENABLED": "1",
+				"CC":          utils.QT_MXE_BIN("gcc"),
+				"CXX":         utils.QT_MXE_BIN("g++"),
 			}
-
-			var path = func() string {
-				var prefix = "i686"
-				if utils.QT_MXE_ARCH() == "amd64" {
-					prefix = "x86_64"
-				}
-				var suffix = "shared"
-				if utils.QT_MXE_STATIC() {
-					suffix = "static"
-				}
-				return filepath.Join("/usr", "lib", "mxe", "usr", "bin", fmt.Sprintf("%v-w64-mingw32.%v", prefix, suffix))
-			}()
-
-			env["CC"] = path + "-gcc"
-			env["CXX"] = path + "-g++"
 		}
 
 	default:

internal/utils/env.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"os"
+	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -117,3 +118,51 @@ func QT_QMAKE_CGO() bool {
 func QT_DOCKER() bool {
 	return strings.ToLower(os.Getenv("QT_DOCKER")) == "true"
 }
+
+func ToolPath(tool, target string) string {
+	//TODO: only temporary
+	if target == "desktop" {
+		target = runtime.GOOS
+	}
+	//
+
+	switch tool {
+	case "qmake":
+		if dir := QT_QMAKE_DIR(); dir != "" {
+			return filepath.Join(dir, tool)
+		}
+	}
+
+	switch target {
+	case "darwin":
+		return filepath.Join(QT_DARWIN_DIR(), "bin", tool)
+	case "windows":
+		if runtime.GOOS == target {
+			if UseMsys2() {
+				return filepath.Join(QT_MSYS2_DIR(), "bin", tool)
+			}
+			return filepath.Join(QT_DIR(), QT_VERSION_MAJOR(), "mingw53_32", "bin", tool)
+		}
+		return filepath.Join(QT_MXE_DIR(), "usr", QT_MXE_TRIPLET(), "qt5", "bin", tool)
+	case "linux":
+		if UsePkgConfig() {
+			if QT_QMAKE_CGO() {
+				return filepath.Join(strings.TrimSpace(RunCmd(exec.Command("pkg-config", "--variable=host_bins", "Qt5Core"), "cgo.LinuxPkgConfig_hostBins")), tool)
+			}
+			return filepath.Join(QT_MISC_DIR(), "bin", tool)
+		}
+		return filepath.Join(QT_DIR(), QT_VERSION_MAJOR(), "gcc_64", "bin", tool)
+	case "ios", "ios-simulator":
+		return filepath.Join(QT_DIR(), QT_VERSION_MAJOR(), "ios", "bin", tool)
+	case "android":
+		return filepath.Join(QT_DIR(), QT_VERSION_MAJOR(), "android_armv7", "bin", tool)
+	case "sailfish":
+		return filepath.Join(os.Getenv("HOME"), ".config", "SailfishOS-SDK", "mer-sdk-tools", "MerSDK", "SailfishOS-armv7hl", tool)
+	case "sailfish-emulator":
+		return filepath.Join(os.Getenv("HOME"), ".config", "SailfishOS-SDK", "mer-sdk-tools", "MerSDK", "SailfishOS-i486", tool)
+	case "asteroid":
+	case "rp1", "rpi2", "rpi3":
+		return filepath.Join(QT_DIR(), QT_VERSION_MAJOR(), target, "bin", tool)
+	}
+	return ""
+}

internal/utils/linux.go

@@ -1,6 +1,7 @@
 package utils
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -92,3 +93,26 @@ func QT_MXE_ARCH() string {
 func QT_MXE_STATIC() bool {
 	return strings.ToLower(os.Getenv("QT_MXE_STATIC")) == "true"
 }
+
+func QT_MXE_TRIPLET() string {
+	var prefix = "i686"
+	if QT_MXE_ARCH() == "amd64" {
+		prefix = "x86_64"
+	}
+	var suffix = "shared"
+	if QT_MXE_STATIC() {
+		suffix = "static"
+	}
+	return fmt.Sprintf("%v-w64-mingw32.%v", prefix, suffix)
+}
+
+func QT_MXE_DIR() string {
+	if dir := os.Getenv("QT_MXE_DIR"); dir != "" {
+		return filepath.Clean(dir)
+	}
+	return filepath.Join("/usr", "lib", "mxe")
+}
+
+func QT_MXE_BIN(tool string) string {
+	return filepath.Join(QT_MXE_DIR(), "usr", "bin", fmt.Sprintf("%v-%v", QT_MXE_TRIPLET(), tool))
+}

location/location.go

@@ -631,7 +631,14 @@ func callbackQGeoRouteReply_Abort(ptr unsafe.Pointer) {
 func (ptr *QGeoRouteReply) ConnectAbort(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "abort"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", f)
+		}
 	}
 }
 
@@ -676,8 +683,19 @@ func callbackQGeoRouteReply_Error2(ptr unsafe.Pointer, error C.longlong, errorSt
 
 func (ptr *QGeoRouteReply) ConnectError2(f func(error QGeoRouteReply__Error, errorString string)) {
 	if ptr.Pointer() != nil {
-		C.QGeoRouteReply_ConnectError2(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
+			C.QGeoRouteReply_ConnectError2(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QGeoRouteReply__Error, errorString string) {
+				signal.(func(QGeoRouteReply__Error, string))(error, errorString)
+				f(error, errorString)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+		}
 	}
 }
 
@@ -709,8 +727,19 @@ func callbackQGeoRouteReply_Finished(ptr unsafe.Pointer) {
 
 func (ptr *QGeoRouteReply) ConnectFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QGeoRouteReply_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QGeoRouteReply_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -768,7 +797,14 @@ func callbackQGeoRouteReply_DestroyQGeoRouteReply(ptr unsafe.Pointer) {
 func (ptr *QGeoRouteReply) ConnectDestroyQGeoRouteReply(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRouteReply", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRouteReply"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRouteReply", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRouteReply", f)
+		}
 	}
 }
 
@@ -1767,8 +1803,19 @@ func callbackQGeoRoutingManager_Error(ptr unsafe.Pointer, reply unsafe.Pointer,
 
 func (ptr *QGeoRoutingManager) ConnectError(f func(reply *QGeoRouteReply, error QGeoRouteReply__Error, errorString string)) {
 	if ptr.Pointer() != nil {
-		C.QGeoRoutingManager_ConnectError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
+			C.QGeoRoutingManager_ConnectError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(reply *QGeoRouteReply, error QGeoRouteReply__Error, errorString string) {
+				signal.(func(*QGeoRouteReply, QGeoRouteReply__Error, string))(reply, error, errorString)
+				f(reply, error, errorString)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -1800,8 +1847,19 @@ func callbackQGeoRoutingManager_Finished(ptr unsafe.Pointer, reply unsafe.Pointe
 
 func (ptr *QGeoRoutingManager) ConnectFinished(f func(reply *QGeoRouteReply)) {
 	if ptr.Pointer() != nil {
-		C.QGeoRoutingManager_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QGeoRoutingManager_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func(reply *QGeoRouteReply) {
+				signal.(func(*QGeoRouteReply))(reply)
+				f(reply)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -2220,7 +2278,14 @@ func callbackQGeoRoutingManagerEngine_CalculateRoute(ptr unsafe.Pointer, request
 func (ptr *QGeoRoutingManagerEngine) ConnectCalculateRoute(f func(request *QGeoRouteRequest) *QGeoRouteReply) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "calculateRoute", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "calculateRoute"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "calculateRoute", func(request *QGeoRouteRequest) *QGeoRouteReply {
+				signal.(func(*QGeoRouteRequest))(request)
+				return f(request)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "calculateRoute", f)
+		}
 	}
 }
 
@@ -2254,7 +2319,14 @@ func callbackQGeoRoutingManagerEngine_UpdateRoute(ptr unsafe.Pointer, route unsa
 func (ptr *QGeoRoutingManagerEngine) ConnectUpdateRoute(f func(route *QGeoRoute, position *positioning.QGeoCoordinate) *QGeoRouteReply) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateRoute", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updateRoute"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateRoute", func(route *QGeoRoute, position *positioning.QGeoCoordinate) *QGeoRouteReply {
+				signal.(func(*QGeoRoute, *positioning.QGeoCoordinate))(route, position)
+				return f(route, position)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateRoute", f)
+		}
 	}
 }
 
@@ -2311,8 +2383,19 @@ func callbackQGeoRoutingManagerEngine_Error(ptr unsafe.Pointer, reply unsafe.Poi
 
 func (ptr *QGeoRoutingManagerEngine) ConnectError(f func(reply *QGeoRouteReply, error QGeoRouteReply__Error, errorString string)) {
 	if ptr.Pointer() != nil {
-		C.QGeoRoutingManagerEngine_ConnectError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
+			C.QGeoRoutingManagerEngine_ConnectError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(reply *QGeoRouteReply, error QGeoRouteReply__Error, errorString string) {
+				signal.(func(*QGeoRouteReply, QGeoRouteReply__Error, string))(reply, error, errorString)
+				f(reply, error, errorString)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -2344,8 +2427,19 @@ func callbackQGeoRoutingManagerEngine_Finished(ptr unsafe.Pointer, reply unsafe.
 
 func (ptr *QGeoRoutingManagerEngine) ConnectFinished(f func(reply *QGeoRouteReply)) {
 	if ptr.Pointer() != nil {
-		C.QGeoRoutingManagerEngine_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QGeoRoutingManagerEngine_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func(reply *QGeoRouteReply) {
+				signal.(func(*QGeoRouteReply))(reply)
+				f(reply)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -2422,7 +2516,14 @@ func callbackQGeoRoutingManagerEngine_DestroyQGeoRoutingManagerEngine(ptr unsafe
 func (ptr *QGeoRoutingManagerEngine) ConnectDestroyQGeoRoutingManagerEngine(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRoutingManagerEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRoutingManagerEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRoutingManagerEngine", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoRoutingManagerEngine", f)
+		}
 	}
 }
 
@@ -3526,7 +3627,14 @@ func callbackQGeoServiceProviderFactory_DestroyQGeoServiceProviderFactory(ptr un
 func (ptr *QGeoServiceProviderFactory) ConnectDestroyQGeoServiceProviderFactory(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoServiceProviderFactory", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoServiceProviderFactory"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoServiceProviderFactory", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoServiceProviderFactory", f)
+		}
 	}
 }
 

macextras/macextras.go

@@ -85,7 +85,14 @@ func callbackQMacPasteboardMime_ConvertFromMime(ptr unsafe.Pointer, mime C.struc
 func (ptr *QMacPasteboardMime) ConnectConvertFromMime(f func(mime string, data *core.QVariant, flav string) []*core.QByteArray) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertFromMime", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "convertFromMime"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertFromMime", func(mime string, data *core.QVariant, flav string) []*core.QByteArray {
+				signal.(func(string, *core.QVariant, string))(mime, data, flav)
+				return f(mime, data, flav)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertFromMime", f)
+		}
 	}
 }
 
@@ -140,7 +147,14 @@ func callbackQMacPasteboardMime_ConvertorName(ptr unsafe.Pointer) *C.char {
 func (ptr *QMacPasteboardMime) ConnectConvertorName(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertorName", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "convertorName"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertorName", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertorName", f)
+		}
 	}
 }
 
@@ -170,7 +184,14 @@ func callbackQMacPasteboardMime_FlavorFor(ptr unsafe.Pointer, mime C.struct_QtMa
 func (ptr *QMacPasteboardMime) ConnectFlavorFor(f func(mime string) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flavorFor", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flavorFor"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flavorFor", func(mime string) string {
+				signal.(func(string))(mime)
+				return f(mime)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flavorFor", f)
+		}
 	}
 }
 
@@ -205,7 +226,14 @@ func callbackQMacPasteboardMime_MimeFor(ptr unsafe.Pointer, flav C.struct_QtMacE
 func (ptr *QMacPasteboardMime) ConnectMimeFor(f func(flav string) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mimeFor", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mimeFor"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mimeFor", func(flav string) string {
+				signal.(func(string))(flav)
+				return f(flav)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mimeFor", f)
+		}
 	}
 }
 
@@ -246,7 +274,14 @@ func callbackQMacPasteboardMime_ConvertToMime(ptr unsafe.Pointer, mime C.struct_
 func (ptr *QMacPasteboardMime) ConnectConvertToMime(f func(mime string, data []*core.QByteArray, flav string) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertToMime", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "convertToMime"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertToMime", func(mime string, data []*core.QByteArray, flav string) *core.QVariant {
+				signal.(func(string, []*core.QByteArray, string))(mime, data, flav)
+				return f(mime, data, flav)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "convertToMime", f)
+		}
 	}
 }
 
@@ -294,7 +329,14 @@ func callbackQMacPasteboardMime_CanConvert(ptr unsafe.Pointer, mime C.struct_QtM
 func (ptr *QMacPasteboardMime) ConnectCanConvert(f func(mime string, flav string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "canConvert", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "canConvert"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "canConvert", func(mime string, flav string) bool {
+				signal.(func(string, string))(mime, flav)
+				return f(mime, flav)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "canConvert", f)
+		}
 	}
 }
 
@@ -334,7 +376,14 @@ func callbackQMacPasteboardMime_Count(ptr unsafe.Pointer, mimeData unsafe.Pointe
 func (ptr *QMacPasteboardMime) ConnectCount(f func(mimeData *core.QMimeData) int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "count", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "count"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "count", func(mimeData *core.QMimeData) int {
+				signal.(func(*core.QMimeData))(mimeData)
+				return f(mimeData)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "count", f)
+		}
 	}
 }
 
@@ -371,7 +420,14 @@ func callbackQMacPasteboardMime_DestroyQMacPasteboardMime(ptr unsafe.Pointer) {
 func (ptr *QMacPasteboardMime) ConnectDestroyQMacPasteboardMime(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacPasteboardMime", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMacPasteboardMime"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacPasteboardMime", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacPasteboardMime", f)
+		}
 	}
 }
 
@@ -1013,8 +1069,19 @@ func callbackQMacToolBarItem_Activated(ptr unsafe.Pointer) {
 
 func (ptr *QMacToolBarItem) ConnectActivated(f func()) {
 	if ptr.Pointer() != nil {
-		C.QMacToolBarItem_ConnectActivated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activated") {
+			C.QMacToolBarItem_ConnectActivated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activated", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activated", f)
+		}
 	}
 }
 
@@ -1043,7 +1110,14 @@ func callbackQMacToolBarItem_DestroyQMacToolBarItem(ptr unsafe.Pointer) {
 func (ptr *QMacToolBarItem) ConnectDestroyQMacToolBarItem(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacToolBarItem", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMacToolBarItem"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacToolBarItem", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMacToolBarItem", f)
+		}
 	}
 }
 

nfc/nfc.go

@@ -1234,8 +1234,19 @@ func callbackQNearFieldManager_TargetDetected(ptr unsafe.Pointer, target unsafe.
 
 func (ptr *QNearFieldManager) ConnectTargetDetected(f func(target *QNearFieldTarget)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldManager_ConnectTargetDetected(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "targetDetected") {
+			C.QNearFieldManager_ConnectTargetDetected(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "targetDetected"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", func(target *QNearFieldTarget) {
+				signal.(func(*QNearFieldTarget))(target)
+				f(target)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", f)
+		}
 	}
 }
 
@@ -1262,8 +1273,19 @@ func callbackQNearFieldManager_TargetLost(ptr unsafe.Pointer, target unsafe.Poin
 
 func (ptr *QNearFieldManager) ConnectTargetLost(f func(target *QNearFieldTarget)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldManager_ConnectTargetLost(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetLost", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "targetLost") {
+			C.QNearFieldManager_ConnectTargetLost(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "targetLost"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetLost", func(target *QNearFieldTarget) {
+				signal.(func(*QNearFieldTarget))(target)
+				f(target)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetLost", f)
+		}
 	}
 }
 
@@ -1652,8 +1674,19 @@ func callbackQNearFieldShareManager_Error(ptr unsafe.Pointer, error C.longlong)
 
 func (ptr *QNearFieldShareManager) ConnectError(f func(error QNearFieldShareManager__ShareError)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldShareManager_ConnectError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
+			C.QNearFieldShareManager_ConnectError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error QNearFieldShareManager__ShareError) {
+				signal.(func(QNearFieldShareManager__ShareError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -1686,8 +1719,19 @@ func callbackQNearFieldShareManager_ShareModesChanged(ptr unsafe.Pointer, modes
 
 func (ptr *QNearFieldShareManager) ConnectShareModesChanged(f func(modes QNearFieldShareManager__ShareMode)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldShareManager_ConnectShareModesChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareModesChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "shareModesChanged") {
+			C.QNearFieldShareManager_ConnectShareModesChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shareModesChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareModesChanged", func(modes QNearFieldShareManager__ShareMode) {
+				signal.(func(QNearFieldShareManager__ShareMode))(modes)
+				f(modes)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareModesChanged", f)
+		}
 	}
 }
 
@@ -1714,8 +1758,19 @@ func callbackQNearFieldShareManager_TargetDetected(ptr unsafe.Pointer, shareTarg
 
 func (ptr *QNearFieldShareManager) ConnectTargetDetected(f func(shareTarget *QNearFieldShareTarget)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldShareManager_ConnectTargetDetected(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "targetDetected") {
+			C.QNearFieldShareManager_ConnectTargetDetected(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "targetDetected"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", func(shareTarget *QNearFieldShareTarget) {
+				signal.(func(*QNearFieldShareTarget))(shareTarget)
+				f(shareTarget)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "targetDetected", f)
+		}
 	}
 }
 
@@ -2087,8 +2142,19 @@ func callbackQNearFieldShareTarget_Error(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QNearFieldShareTarget) ConnectError(f func(error QNearFieldShareManager__ShareError)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldShareTarget_ConnectError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
+			C.QNearFieldShareTarget_ConnectError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error QNearFieldShareManager__ShareError) {
+				signal.(func(QNearFieldShareManager__ShareError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -2115,8 +2181,19 @@ func callbackQNearFieldShareTarget_ShareFinished(ptr unsafe.Pointer) {
 
 func (ptr *QNearFieldShareTarget) ConnectShareFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldShareTarget_ConnectShareFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareFinished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "shareFinished") {
+			C.QNearFieldShareTarget_ConnectShareFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shareFinished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareFinished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shareFinished", f)
+		}
 	}
 }
 
@@ -2539,7 +2616,14 @@ func callbackQNearFieldTarget_HasNdefMessage(ptr unsafe.Pointer) C.char {
 func (ptr *QNearFieldTarget) ConnectHasNdefMessage(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasNdefMessage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasNdefMessage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasNdefMessage", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasNdefMessage", f)
+		}
 	}
 }
 
@@ -2574,8 +2658,19 @@ func callbackQNearFieldTarget_Disconnected(ptr unsafe.Pointer) {
 
 func (ptr *QNearFieldTarget) ConnectDisconnected(f func()) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldTarget_ConnectDisconnected(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "disconnected") {
+			C.QNearFieldTarget_ConnectDisconnected(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "disconnected"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", f)
+		}
 	}
 }
 
@@ -2602,8 +2697,19 @@ func callbackQNearFieldTarget_NdefMessageRead(ptr unsafe.Pointer, message unsafe
 
 func (ptr *QNearFieldTarget) ConnectNdefMessageRead(f func(message *QNdefMessage)) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldTarget_ConnectNdefMessageRead(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessageRead", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "ndefMessageRead") {
+			C.QNearFieldTarget_ConnectNdefMessageRead(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ndefMessageRead"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessageRead", func(message *QNdefMessage) {
+				signal.(func(*QNdefMessage))(message)
+				f(message)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessageRead", f)
+		}
 	}
 }
 
@@ -2630,8 +2736,19 @@ func callbackQNearFieldTarget_NdefMessagesWritten(ptr unsafe.Pointer) {
 
 func (ptr *QNearFieldTarget) ConnectNdefMessagesWritten(f func()) {
 	if ptr.Pointer() != nil {
-		C.QNearFieldTarget_ConnectNdefMessagesWritten(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessagesWritten", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "ndefMessagesWritten") {
+			C.QNearFieldTarget_ConnectNdefMessagesWritten(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ndefMessagesWritten"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessagesWritten", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ndefMessagesWritten", f)
+		}
 	}
 }
 
@@ -2660,7 +2777,14 @@ func callbackQNearFieldTarget_DestroyQNearFieldTarget(ptr unsafe.Pointer) {
 func (ptr *QNearFieldTarget) ConnectDestroyQNearFieldTarget(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QNearFieldTarget", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QNearFieldTarget"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QNearFieldTarget", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QNearFieldTarget", f)
+		}
 	}
 }
 
@@ -2699,7 +2823,14 @@ func callbackQNearFieldTarget_AccessMethods(ptr unsafe.Pointer) C.longlong {
 func (ptr *QNearFieldTarget) ConnectAccessMethods(f func() QNearFieldTarget__AccessMethod) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accessMethods", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "accessMethods"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accessMethods", func() QNearFieldTarget__AccessMethod {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accessMethods", f)
+		}
 	}
 }
 
@@ -2729,7 +2860,14 @@ func callbackQNearFieldTarget_Uid(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QNearFieldTarget) ConnectUid(f func() *core.QByteArray) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "uid", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "uid"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "uid", func() *core.QByteArray {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "uid", f)
+		}
 	}
 }
 
@@ -2761,7 +2899,14 @@ func callbackQNearFieldTarget_Url(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QNearFieldTarget) ConnectUrl(f func() *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "url", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "url"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "url", func() *core.QUrl {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "url", f)
+		}
 	}
 }
 
@@ -2802,7 +2947,14 @@ func callbackQNearFieldTarget_Type(ptr unsafe.Pointer) C.longlong {
 func (ptr *QNearFieldTarget) ConnectType(f func() QNearFieldTarget__Type) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "type", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "type"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "type", func() QNearFieldTarget__Type {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "type", f)
+		}
 	}
 }
 
@@ -3186,8 +3338,19 @@ func callbackQQmlNdefRecord_RecordChanged(ptr unsafe.Pointer) {
 
 func (ptr *QQmlNdefRecord) ConnectRecordChanged(f func()) {
 	if ptr.Pointer() != nil {
-		C.QQmlNdefRecord_ConnectRecordChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "recordChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "recordChanged") {
+			C.QQmlNdefRecord_ConnectRecordChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "recordChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "recordChanged", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "recordChanged", f)
+		}
 	}
 }
 
@@ -3269,8 +3432,19 @@ func callbackQQmlNdefRecord_TypeChanged(ptr unsafe.Pointer) {
 
 func (ptr *QQmlNdefRecord) ConnectTypeChanged(f func()) {
 	if ptr.Pointer() != nil {
-		C.QQmlNdefRecord_ConnectTypeChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "typeChanged") {
+			C.QQmlNdefRecord_ConnectTypeChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "typeChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeChanged", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeChanged", f)
+		}
 	}
 }
 
@@ -3297,8 +3471,19 @@ func callbackQQmlNdefRecord_TypeNameFormatChanged(ptr unsafe.Pointer) {
 
 func (ptr *QQmlNdefRecord) ConnectTypeNameFormatChanged(f func()) {
 	if ptr.Pointer() != nil {
-		C.QQmlNdefRecord_ConnectTypeNameFormatChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeNameFormatChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "typeNameFormatChanged") {
+			C.QQmlNdefRecord_ConnectTypeNameFormatChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "typeNameFormatChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeNameFormatChanged", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typeNameFormatChanged", f)
+		}
 	}
 }
 

positioning/positioning.go

@@ -679,7 +679,14 @@ func callbackQGeoAreaMonitorSource_RequestUpdate(ptr unsafe.Pointer, monitor uns
 func (ptr *QGeoAreaMonitorSource) ConnectRequestUpdate(f func(monitor *QGeoAreaMonitorInfo, sign string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", func(monitor *QGeoAreaMonitorInfo, sign string) bool {
+				signal.(func(*QGeoAreaMonitorInfo, string))(monitor, sign)
+				return f(monitor, sign)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		}
 	}
 }
 
@@ -714,7 +721,14 @@ func callbackQGeoAreaMonitorSource_StartMonitoring(ptr unsafe.Pointer, monitor u
 func (ptr *QGeoAreaMonitorSource) ConnectStartMonitoring(f func(monitor *QGeoAreaMonitorInfo) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startMonitoring", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startMonitoring"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startMonitoring", func(monitor *QGeoAreaMonitorInfo) bool {
+				signal.(func(*QGeoAreaMonitorInfo))(monitor)
+				return f(monitor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startMonitoring", f)
+		}
 	}
 }
 
@@ -744,7 +758,14 @@ func callbackQGeoAreaMonitorSource_StopMonitoring(ptr unsafe.Pointer, monitor un
 func (ptr *QGeoAreaMonitorSource) ConnectStopMonitoring(f func(monitor *QGeoAreaMonitorInfo) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopMonitoring", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stopMonitoring"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopMonitoring", func(monitor *QGeoAreaMonitorInfo) bool {
+				signal.(func(*QGeoAreaMonitorInfo))(monitor)
+				return f(monitor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopMonitoring", f)
+		}
 	}
 }
 
@@ -772,8 +793,19 @@ func callbackQGeoAreaMonitorSource_AreaEntered(ptr unsafe.Pointer, monitor unsaf
 
 func (ptr *QGeoAreaMonitorSource) ConnectAreaEntered(f func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoAreaMonitorSource_ConnectAreaEntered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaEntered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "areaEntered") {
+			C.QGeoAreaMonitorSource_ConnectAreaEntered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "areaEntered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaEntered", func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo) {
+				signal.(func(*QGeoAreaMonitorInfo, *QGeoPositionInfo))(monitor, update)
+				f(monitor, update)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaEntered", f)
+		}
 	}
 }
 
@@ -800,8 +832,19 @@ func callbackQGeoAreaMonitorSource_AreaExited(ptr unsafe.Pointer, monitor unsafe
 
 func (ptr *QGeoAreaMonitorSource) ConnectAreaExited(f func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoAreaMonitorSource_ConnectAreaExited(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaExited", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "areaExited") {
+			C.QGeoAreaMonitorSource_ConnectAreaExited(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "areaExited"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaExited", func(monitor *QGeoAreaMonitorInfo, update *QGeoPositionInfo) {
+				signal.(func(*QGeoAreaMonitorInfo, *QGeoPositionInfo))(monitor, update)
+				f(monitor, update)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaExited", f)
+		}
 	}
 }
 
@@ -828,8 +871,19 @@ func callbackQGeoAreaMonitorSource_Error2(ptr unsafe.Pointer, areaMonitoringErro
 
 func (ptr *QGeoAreaMonitorSource) ConnectError2(f func(areaMonitoringError QGeoAreaMonitorSource__Error)) {
 	if ptr.Pointer() != nil {
-		C.QGeoAreaMonitorSource_ConnectError2(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
+			C.QGeoAreaMonitorSource_ConnectError2(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(areaMonitoringError QGeoAreaMonitorSource__Error) {
+				signal.(func(QGeoAreaMonitorSource__Error))(areaMonitoringError)
+				f(areaMonitoringError)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+		}
 	}
 }
 
@@ -856,8 +910,19 @@ func callbackQGeoAreaMonitorSource_MonitorExpired(ptr unsafe.Pointer, monitor un
 
 func (ptr *QGeoAreaMonitorSource) ConnectMonitorExpired(f func(monitor *QGeoAreaMonitorInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoAreaMonitorSource_ConnectMonitorExpired(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "monitorExpired", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "monitorExpired") {
+			C.QGeoAreaMonitorSource_ConnectMonitorExpired(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "monitorExpired"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "monitorExpired", func(monitor *QGeoAreaMonitorInfo) {
+				signal.(func(*QGeoAreaMonitorInfo))(monitor)
+				f(monitor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "monitorExpired", f)
+		}
 	}
 }
 
@@ -886,7 +951,14 @@ func callbackQGeoAreaMonitorSource_SetPositionInfoSource(ptr unsafe.Pointer, new
 func (ptr *QGeoAreaMonitorSource) ConnectSetPositionInfoSource(f func(newSource *QGeoPositionInfoSource)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPositionInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPositionInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPositionInfoSource", func(newSource *QGeoPositionInfoSource) {
+				signal.(func(*QGeoPositionInfoSource))(newSource)
+				f(newSource)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPositionInfoSource", f)
+		}
 	}
 }
 
@@ -921,7 +993,14 @@ func callbackQGeoAreaMonitorSource_DestroyQGeoAreaMonitorSource(ptr unsafe.Point
 func (ptr *QGeoAreaMonitorSource) ConnectDestroyQGeoAreaMonitorSource(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoAreaMonitorSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoAreaMonitorSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoAreaMonitorSource", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoAreaMonitorSource", f)
+		}
 	}
 }
 
@@ -960,7 +1039,14 @@ func callbackQGeoAreaMonitorSource_SupportedAreaMonitorFeatures(ptr unsafe.Point
 func (ptr *QGeoAreaMonitorSource) ConnectSupportedAreaMonitorFeatures(f func() QGeoAreaMonitorSource__AreaMonitorFeature) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAreaMonitorFeatures", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedAreaMonitorFeatures"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAreaMonitorFeatures", func() QGeoAreaMonitorSource__AreaMonitorFeature {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAreaMonitorFeatures", f)
+		}
 	}
 }
 
@@ -990,7 +1076,14 @@ func callbackQGeoAreaMonitorSource_Error(ptr unsafe.Pointer) C.longlong {
 func (ptr *QGeoAreaMonitorSource) ConnectError(f func() QGeoAreaMonitorSource__Error) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QGeoAreaMonitorSource__Error {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -1020,7 +1113,14 @@ func callbackQGeoAreaMonitorSource_PositionInfoSource(ptr unsafe.Pointer) unsafe
 func (ptr *QGeoAreaMonitorSource) ConnectPositionInfoSource(f func() *QGeoPositionInfoSource) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", func() *QGeoPositionInfoSource {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", f)
+		}
 	}
 }
 
@@ -1077,7 +1177,14 @@ func callbackQGeoAreaMonitorSource_ActiveMonitors(ptr unsafe.Pointer) unsafe.Poi
 func (ptr *QGeoAreaMonitorSource) ConnectActiveMonitors(f func() []*QGeoAreaMonitorInfo) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors", func() []*QGeoAreaMonitorInfo {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors", f)
+		}
 	}
 }
 
@@ -1125,7 +1232,14 @@ func callbackQGeoAreaMonitorSource_ActiveMonitors2(ptr unsafe.Pointer, lookupAre
 func (ptr *QGeoAreaMonitorSource) ConnectActiveMonitors2(f func(lookupArea *QGeoShape) []*QGeoAreaMonitorInfo) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors2", func(lookupArea *QGeoShape) []*QGeoAreaMonitorInfo {
+				signal.(func(*QGeoShape))(lookupArea)
+				return f(lookupArea)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeMonitors2", f)
+		}
 	}
 }
 
@@ -1979,8 +2093,19 @@ func callbackQGeoPositionInfoSource_PositionUpdated(ptr unsafe.Pointer, update u
 
 func (ptr *QGeoPositionInfoSource) ConnectPositionUpdated(f func(update *QGeoPositionInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoPositionInfoSource_ConnectPositionUpdated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionUpdated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "positionUpdated") {
+			C.QGeoPositionInfoSource_ConnectPositionUpdated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionUpdated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionUpdated", func(update *QGeoPositionInfo) {
+				signal.(func(*QGeoPositionInfo))(update)
+				f(update)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionUpdated", f)
+		}
 	}
 }
 
@@ -2009,7 +2134,14 @@ func callbackQGeoPositionInfoSource_SetUpdateInterval(ptr unsafe.Pointer, msec C
 func (ptr *QGeoPositionInfoSource) ConnectSetUpdateInterval(f func(msec int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", func(msec int) {
+				signal.(func(int))(msec)
+				f(msec)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", f)
+		}
 	}
 }
 
@@ -2100,8 +2232,19 @@ func callbackQGeoPositionInfoSource_Error2(ptr unsafe.Pointer, positioningError
 
 func (ptr *QGeoPositionInfoSource) ConnectError2(f func(positioningError QGeoPositionInfoSource__Error)) {
 	if ptr.Pointer() != nil {
-		C.QGeoPositionInfoSource_ConnectError2(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
+			C.QGeoPositionInfoSource_ConnectError2(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(positioningError QGeoPositionInfoSource__Error) {
+				signal.(func(QGeoPositionInfoSource__Error))(positioningError)
+				f(positioningError)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+		}
 	}
 }
 
@@ -2129,7 +2272,14 @@ func callbackQGeoPositionInfoSource_RequestUpdate(ptr unsafe.Pointer, timeout C.
 func (ptr *QGeoPositionInfoSource) ConnectRequestUpdate(f func(timeout int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", func(timeout int) {
+				signal.(func(int))(timeout)
+				f(timeout)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		}
 	}
 }
 
@@ -2158,7 +2308,14 @@ func callbackQGeoPositionInfoSource_SetPreferredPositioningMethods(ptr unsafe.Po
 func (ptr *QGeoPositionInfoSource) ConnectSetPreferredPositioningMethods(f func(methods QGeoPositionInfoSource__PositioningMethod)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPreferredPositioningMethods", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPreferredPositioningMethods"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPreferredPositioningMethods", func(methods QGeoPositionInfoSource__PositioningMethod) {
+				signal.(func(QGeoPositionInfoSource__PositioningMethod))(methods)
+				f(methods)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPreferredPositioningMethods", f)
+		}
 	}
 }
 
@@ -2192,7 +2349,14 @@ func callbackQGeoPositionInfoSource_StartUpdates(ptr unsafe.Pointer) {
 func (ptr *QGeoPositionInfoSource) ConnectStartUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		}
 	}
 }
 
@@ -2220,7 +2384,14 @@ func callbackQGeoPositionInfoSource_StopUpdates(ptr unsafe.Pointer) {
 func (ptr *QGeoPositionInfoSource) ConnectStopUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		}
 	}
 }
 
@@ -2247,8 +2418,19 @@ func callbackQGeoPositionInfoSource_UpdateTimeout(ptr unsafe.Pointer) {
 
 func (ptr *QGeoPositionInfoSource) ConnectUpdateTimeout(f func()) {
 	if ptr.Pointer() != nil {
-		C.QGeoPositionInfoSource_ConnectUpdateTimeout(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateTimeout", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "updateTimeout") {
+			C.QGeoPositionInfoSource_ConnectUpdateTimeout(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updateTimeout"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateTimeout", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateTimeout", f)
+		}
 	}
 }
 
@@ -2277,7 +2459,14 @@ func callbackQGeoPositionInfoSource_DestroyQGeoPositionInfoSource(ptr unsafe.Poi
 func (ptr *QGeoPositionInfoSource) ConnectDestroyQGeoPositionInfoSource(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSource", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSource", f)
+		}
 	}
 }
 
@@ -2316,7 +2505,14 @@ func callbackQGeoPositionInfoSource_Error(ptr unsafe.Pointer) C.longlong {
 func (ptr *QGeoPositionInfoSource) ConnectError(f func() QGeoPositionInfoSource__Error) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QGeoPositionInfoSource__Error {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -2353,7 +2549,14 @@ func callbackQGeoPositionInfoSource_SupportedPositioningMethods(ptr unsafe.Point
 func (ptr *QGeoPositionInfoSource) ConnectSupportedPositioningMethods(f func() QGeoPositionInfoSource__PositioningMethod) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", func() QGeoPositionInfoSource__PositioningMethod {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", f)
+		}
 	}
 }
 
@@ -2383,7 +2586,14 @@ func callbackQGeoPositionInfoSource_LastKnownPosition(ptr unsafe.Pointer, fromSa
 func (ptr *QGeoPositionInfoSource) ConnectLastKnownPosition(f func(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", func(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo {
+				signal.(func(bool))(fromSatellitePositioningMethodsOnly)
+				return f(fromSatellitePositioningMethodsOnly)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", f)
+		}
 	}
 }
 
@@ -2422,7 +2632,14 @@ func callbackQGeoPositionInfoSource_MinimumUpdateInterval(ptr unsafe.Pointer) C.
 func (ptr *QGeoPositionInfoSource) ConnectMinimumUpdateInterval(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		}
 	}
 }
 
@@ -2756,7 +2973,14 @@ func callbackQGeoPositionInfoSourceFactory_AreaMonitor(ptr unsafe.Pointer, paren
 func (ptr *QGeoPositionInfoSourceFactory) ConnectAreaMonitor(f func(parent *core.QObject) *QGeoAreaMonitorSource) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaMonitor", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "areaMonitor"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaMonitor", func(parent *core.QObject) *QGeoAreaMonitorSource {
+				signal.(func(*core.QObject))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "areaMonitor", f)
+		}
 	}
 }
 
@@ -2790,7 +3014,14 @@ func callbackQGeoPositionInfoSourceFactory_PositionInfoSource(ptr unsafe.Pointer
 func (ptr *QGeoPositionInfoSourceFactory) ConnectPositionInfoSource(f func(parent *core.QObject) *QGeoPositionInfoSource) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", func(parent *core.QObject) *QGeoPositionInfoSource {
+				signal.(func(*core.QObject))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionInfoSource", f)
+		}
 	}
 }
 
@@ -2824,7 +3055,14 @@ func callbackQGeoPositionInfoSourceFactory_SatelliteInfoSource(ptr unsafe.Pointe
 func (ptr *QGeoPositionInfoSourceFactory) ConnectSatelliteInfoSource(f func(parent *core.QObject) *QGeoSatelliteInfoSource) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satelliteInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "satelliteInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satelliteInfoSource", func(parent *core.QObject) *QGeoSatelliteInfoSource {
+				signal.(func(*core.QObject))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satelliteInfoSource", f)
+		}
 	}
 }
 
@@ -2858,7 +3096,14 @@ func callbackQGeoPositionInfoSourceFactory_DestroyQGeoPositionInfoSourceFactory(
 func (ptr *QGeoPositionInfoSourceFactory) ConnectDestroyQGeoPositionInfoSourceFactory(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSourceFactory", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSourceFactory"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSourceFactory", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoPositionInfoSourceFactory", f)
+		}
 	}
 }
 
@@ -3380,8 +3625,19 @@ func callbackQGeoSatelliteInfoSource_Error2(ptr unsafe.Pointer, satelliteError C
 
 func (ptr *QGeoSatelliteInfoSource) ConnectError2(f func(satelliteError QGeoSatelliteInfoSource__Error)) {
 	if ptr.Pointer() != nil {
-		C.QGeoSatelliteInfoSource_ConnectError2(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
+			C.QGeoSatelliteInfoSource_ConnectError2(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(satelliteError QGeoSatelliteInfoSource__Error) {
+				signal.(func(QGeoSatelliteInfoSource__Error))(satelliteError)
+				f(satelliteError)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+		}
 	}
 }
 
@@ -3408,8 +3664,19 @@ func callbackQGeoSatelliteInfoSource_RequestTimeout(ptr unsafe.Pointer) {
 
 func (ptr *QGeoSatelliteInfoSource) ConnectRequestTimeout(f func()) {
 	if ptr.Pointer() != nil {
-		C.QGeoSatelliteInfoSource_ConnectRequestTimeout(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestTimeout", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestTimeout") {
+			C.QGeoSatelliteInfoSource_ConnectRequestTimeout(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestTimeout"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestTimeout", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestTimeout", f)
+		}
 	}
 }
 
@@ -3437,7 +3704,14 @@ func callbackQGeoSatelliteInfoSource_RequestUpdate(ptr unsafe.Pointer, timeout C
 func (ptr *QGeoSatelliteInfoSource) ConnectRequestUpdate(f func(timeout int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", func(timeout int) {
+				signal.(func(int))(timeout)
+				f(timeout)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		}
 	}
 }
 
@@ -3470,8 +3744,19 @@ func callbackQGeoSatelliteInfoSource_SatellitesInUseUpdated(ptr unsafe.Pointer,
 
 func (ptr *QGeoSatelliteInfoSource) ConnectSatellitesInUseUpdated(f func(satellites []*QGeoSatelliteInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoSatelliteInfoSource_ConnectSatellitesInUseUpdated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInUseUpdated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "satellitesInUseUpdated") {
+			C.QGeoSatelliteInfoSource_ConnectSatellitesInUseUpdated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "satellitesInUseUpdated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInUseUpdated", func(satellites []*QGeoSatelliteInfo) {
+				signal.(func([]*QGeoSatelliteInfo))(satellites)
+				f(satellites)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInUseUpdated", f)
+		}
 	}
 }
 
@@ -3510,8 +3795,19 @@ func callbackQGeoSatelliteInfoSource_SatellitesInViewUpdated(ptr unsafe.Pointer,
 
 func (ptr *QGeoSatelliteInfoSource) ConnectSatellitesInViewUpdated(f func(satellites []*QGeoSatelliteInfo)) {
 	if ptr.Pointer() != nil {
-		C.QGeoSatelliteInfoSource_ConnectSatellitesInViewUpdated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInViewUpdated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "satellitesInViewUpdated") {
+			C.QGeoSatelliteInfoSource_ConnectSatellitesInViewUpdated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "satellitesInViewUpdated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInViewUpdated", func(satellites []*QGeoSatelliteInfo) {
+				signal.(func([]*QGeoSatelliteInfo))(satellites)
+				f(satellites)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "satellitesInViewUpdated", f)
+		}
 	}
 }
 
@@ -3546,7 +3842,14 @@ func callbackQGeoSatelliteInfoSource_SetUpdateInterval(ptr unsafe.Pointer, msec
 func (ptr *QGeoSatelliteInfoSource) ConnectSetUpdateInterval(f func(msec int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", func(msec int) {
+				signal.(func(int))(msec)
+				f(msec)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setUpdateInterval", f)
+		}
 	}
 }
 
@@ -3580,7 +3883,14 @@ func callbackQGeoSatelliteInfoSource_StartUpdates(ptr unsafe.Pointer) {
 func (ptr *QGeoSatelliteInfoSource) ConnectStartUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		}
 	}
 }
 
@@ -3608,7 +3918,14 @@ func callbackQGeoSatelliteInfoSource_StopUpdates(ptr unsafe.Pointer) {
 func (ptr *QGeoSatelliteInfoSource) ConnectStopUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		}
 	}
 }
 
@@ -3637,7 +3954,14 @@ func callbackQGeoSatelliteInfoSource_DestroyQGeoSatelliteInfoSource(ptr unsafe.P
 func (ptr *QGeoSatelliteInfoSource) ConnectDestroyQGeoSatelliteInfoSource(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoSatelliteInfoSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QGeoSatelliteInfoSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoSatelliteInfoSource", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QGeoSatelliteInfoSource", f)
+		}
 	}
 }
 
@@ -3676,7 +4000,14 @@ func callbackQGeoSatelliteInfoSource_Error(ptr unsafe.Pointer) C.longlong {
 func (ptr *QGeoSatelliteInfoSource) ConnectError(f func() QGeoSatelliteInfoSource__Error) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QGeoSatelliteInfoSource__Error {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -3713,7 +4044,14 @@ func callbackQGeoSatelliteInfoSource_MinimumUpdateInterval(ptr unsafe.Pointer) C
 func (ptr *QGeoSatelliteInfoSource) ConnectMinimumUpdateInterval(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		}
 	}
 }
 
@@ -4220,7 +4558,14 @@ func callbackQNmeaPositionInfoSource_ParsePosInfoFromNmeaData(ptr unsafe.Pointer
 func (ptr *QNmeaPositionInfoSource) ConnectParsePosInfoFromNmeaData(f func(data string, size int, posInfo *QGeoPositionInfo, hasFix bool) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parsePosInfoFromNmeaData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "parsePosInfoFromNmeaData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parsePosInfoFromNmeaData", func(data string, size int, posInfo *QGeoPositionInfo, hasFix bool) bool {
+				signal.(func(string, int, *QGeoPositionInfo, bool))(data, size, posInfo, hasFix)
+				return f(data, size, posInfo, hasFix)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parsePosInfoFromNmeaData", f)
+		}
 	}
 }
 
@@ -4267,7 +4612,14 @@ func callbackQNmeaPositionInfoSource_RequestUpdate(ptr unsafe.Pointer, msec C.in
 func (ptr *QNmeaPositionInfoSource) ConnectRequestUpdate(f func(msec int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", func(msec int) {
+				signal.(func(int))(msec)
+				f(msec)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestUpdate", f)
+		}
 	}
 }
 
@@ -4314,7 +4666,14 @@ func callbackQNmeaPositionInfoSource_StartUpdates(ptr unsafe.Pointer) {
 func (ptr *QNmeaPositionInfoSource) ConnectStartUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startUpdates", f)
+		}
 	}
 }
 
@@ -4349,7 +4708,14 @@ func callbackQNmeaPositionInfoSource_StopUpdates(ptr unsafe.Pointer) {
 func (ptr *QNmeaPositionInfoSource) ConnectStopUpdates(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopUpdates", f)
+		}
 	}
 }
 
@@ -4392,7 +4758,14 @@ func callbackQNmeaPositionInfoSource_Error(ptr unsafe.Pointer) C.longlong {
 func (ptr *QNmeaPositionInfoSource) ConnectError(f func() QGeoPositionInfoSource__Error) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QGeoPositionInfoSource__Error {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
+		}
 	}
 }
 
@@ -4429,7 +4802,14 @@ func callbackQNmeaPositionInfoSource_SupportedPositioningMethods(ptr unsafe.Poin
 func (ptr *QNmeaPositionInfoSource) ConnectSupportedPositioningMethods(f func() QGeoPositionInfoSource__PositioningMethod) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", func() QGeoPositionInfoSource__PositioningMethod {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPositioningMethods", f)
+		}
 	}
 }
 
@@ -4466,7 +4846,14 @@ func callbackQNmeaPositionInfoSource_LastKnownPosition(ptr unsafe.Pointer, fromS
 func (ptr *QNmeaPositionInfoSource) ConnectLastKnownPosition(f func(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", func(fromSatellitePositioningMethodsOnly bool) *QGeoPositionInfo {
+				signal.(func(bool))(fromSatellitePositioningMethodsOnly)
+				return f(fromSatellitePositioningMethodsOnly)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lastKnownPosition", f)
+		}
 	}
 }
 
@@ -4532,7 +4919,14 @@ func callbackQNmeaPositionInfoSource_MinimumUpdateInterval(ptr unsafe.Pointer) C
 func (ptr *QNmeaPositionInfoSource) ConnectMinimumUpdateInterval(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "minimumUpdateInterval", f)
+		}
 	}
 }
 

printsupport/printsupport.go

@@ -118,7 +118,14 @@ func callbackQAbstractPrintDialog_Exec(ptr unsafe.Pointer) C.int {
 func (ptr *QAbstractPrintDialog) ConnectExec(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exec"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		}
 	}
 }
 
@@ -1583,7 +1590,14 @@ func callbackQPageSetupDialog_Exec(ptr unsafe.Pointer) C.int {
 func (ptr *QPageSetupDialog) ConnectExec(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exec"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		}
 	}
 }
 
@@ -1620,7 +1634,14 @@ func callbackQPageSetupDialog_Done(ptr unsafe.Pointer, result C.int) {
 func (ptr *QPageSetupDialog) ConnectDone(f func(result int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "done"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", func(result int) {
+				signal.(func(int))(result)
+				f(result)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		}
 	}
 }
 
@@ -3066,7 +3087,14 @@ func callbackQPrintDialog_Done(ptr unsafe.Pointer, result C.int) {
 func (ptr *QPrintDialog) ConnectDone(f func(result int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "done"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", func(result int) {
+				signal.(func(int))(result)
+				f(result)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		}
 	}
 }
 
@@ -3117,7 +3145,14 @@ func callbackQPrintDialog_Exec(ptr unsafe.Pointer) C.int {
 func (ptr *QPrintDialog) ConnectExec(f func() int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exec"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", func() int {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exec", f)
+		}
 	}
 }
 
@@ -3152,8 +3187,19 @@ func callbackQPrintDialog_Accepted(ptr unsafe.Pointer, printer unsafe.Pointer) {
 
 func (ptr *QPrintDialog) ConnectAccepted(f func(printer *QPrinter)) {
 	if ptr.Pointer() != nil {
-		C.QPrintDialog_ConnectAccepted(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accepted", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "accepted") {
+			C.QPrintDialog_ConnectAccepted(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "accepted"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accepted", func(printer *QPrinter) {
+				signal.(func(*QPrinter))(printer)
+				f(printer)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "accepted", f)
+		}
 	}
 }
 
@@ -3304,7 +3350,14 @@ func callbackQPrintEngine_Abort(ptr unsafe.Pointer) C.char {
 func (ptr *QPrintEngine) ConnectAbort(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "abort"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "abort", f)
+		}
 	}
 }
 
@@ -3334,7 +3387,14 @@ func callbackQPrintEngine_NewPage(ptr unsafe.Pointer) C.char {
 func (ptr *QPrintEngine) ConnectNewPage(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newPage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", f)
+		}
 	}
 }
 
@@ -3363,7 +3423,14 @@ func callbackQPrintEngine_SetProperty(ptr unsafe.Pointer, key C.longlong, value
 func (ptr *QPrintEngine) ConnectSetProperty(f func(key QPrintEngine__PrintEnginePropertyKey, value *core.QVariant)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", func(key QPrintEngine__PrintEnginePropertyKey, value *core.QVariant) {
+				signal.(func(QPrintEngine__PrintEnginePropertyKey, *core.QVariant))(key, value)
+				f(key, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", f)
+		}
 	}
 }
 
@@ -3392,7 +3459,14 @@ func callbackQPrintEngine_DestroyQPrintEngine(ptr unsafe.Pointer) {
 func (ptr *QPrintEngine) ConnectDestroyQPrintEngine(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QPrintEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QPrintEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QPrintEngine", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QPrintEngine", f)
+		}
 	}
 }
 
@@ -3431,7 +3505,14 @@ func callbackQPrintEngine_PrinterState(ptr unsafe.Pointer) C.longlong {
 func (ptr *QPrintEngine) ConnectPrinterState(f func() QPrinter__PrinterState) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "printerState", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "printerState"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "printerState", func() QPrinter__PrinterState {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "printerState", f)
+		}
 	}
 }
 
@@ -3461,7 +3542,14 @@ func callbackQPrintEngine_Property(ptr unsafe.Pointer, key C.longlong) unsafe.Po
 func (ptr *QPrintEngine) ConnectProperty(f func(key QPrintEngine__PrintEnginePropertyKey) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "property"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", func(key QPrintEngine__PrintEnginePropertyKey) *core.QVariant {
+				signal.(func(QPrintEngine__PrintEnginePropertyKey))(key)
+				return f(key)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", f)
+		}
 	}
 }
 
@@ -3493,7 +3581,14 @@ func callbackQPrintEngine_Metric(ptr unsafe.Pointer, id C.longlong) C.int {
 func (ptr *QPrintEngine) ConnectMetric(f func(id gui.QPaintDevice__PaintDeviceMetric) int) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metric", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metric"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metric", func(id gui.QPaintDevice__PaintDeviceMetric) int {
+				signal.(func(gui.QPaintDevice__PaintDeviceMetric))(id)
+				return f(id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metric", f)
+		}
 	}
 }
 
@@ -3584,7 +3679,14 @@ func callbackQPrintPreviewDialog_Done(ptr unsafe.Pointer, result C.int) {
 func (ptr *QPrintPreviewDialog) ConnectDone(f func(result int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "done"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", func(result int) {
+				signal.(func(int))(result)
+				f(result)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "done", f)
+		}
 	}
 }
 
@@ -3617,8 +3719,19 @@ func callbackQPrintPreviewDialog_PaintRequested(ptr unsafe.Pointer, printer unsa
 
 func (ptr *QPrintPreviewDialog) ConnectPaintRequested(f func(printer *QPrinter)) {
 	if ptr.Pointer() != nil {
-		C.QPrintPreviewDialog_ConnectPaintRequested(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "paintRequested") {
+			C.QPrintPreviewDialog_ConnectPaintRequested(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paintRequested"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", func(printer *QPrinter) {
+				signal.(func(*QPrinter))(printer)
+				f(printer)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", f)
+		}
 	}
 }
 
@@ -4997,7 +5110,14 @@ func callbackQPrintPreviewWidget_FitInView(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectFitInView(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitInView", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fitInView"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitInView", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitInView", f)
+		}
 	}
 }
 
@@ -5032,7 +5152,14 @@ func callbackQPrintPreviewWidget_FitToWidth(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectFitToWidth(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitToWidth", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fitToWidth"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitToWidth", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fitToWidth", f)
+		}
 	}
 }
 
@@ -5065,8 +5192,19 @@ func callbackQPrintPreviewWidget_PaintRequested(ptr unsafe.Pointer, printer unsa
 
 func (ptr *QPrintPreviewWidget) ConnectPaintRequested(f func(printer *QPrinter)) {
 	if ptr.Pointer() != nil {
-		C.QPrintPreviewWidget_ConnectPaintRequested(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "paintRequested") {
+			C.QPrintPreviewWidget_ConnectPaintRequested(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paintRequested"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", func(printer *QPrinter) {
+				signal.(func(*QPrinter))(printer)
+				f(printer)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintRequested", f)
+		}
 	}
 }
 
@@ -5093,8 +5231,19 @@ func callbackQPrintPreviewWidget_PreviewChanged(ptr unsafe.Pointer) {
 
 func (ptr *QPrintPreviewWidget) ConnectPreviewChanged(f func()) {
 	if ptr.Pointer() != nil {
-		C.QPrintPreviewWidget_ConnectPreviewChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "previewChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "previewChanged") {
+			C.QPrintPreviewWidget_ConnectPreviewChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "previewChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "previewChanged", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "previewChanged", f)
+		}
 	}
 }
 
@@ -5123,7 +5272,14 @@ func callbackQPrintPreviewWidget_Print(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectPrint(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "print", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "print"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "print", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "print", f)
+		}
 	}
 }
 
@@ -5158,7 +5314,14 @@ func callbackQPrintPreviewWidget_SetAllPagesViewMode(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectSetAllPagesViewMode(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAllPagesViewMode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAllPagesViewMode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAllPagesViewMode", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAllPagesViewMode", f)
+		}
 	}
 }
 
@@ -5193,7 +5356,14 @@ func callbackQPrintPreviewWidget_SetCurrentPage(ptr unsafe.Pointer, page C.int)
 func (ptr *QPrintPreviewWidget) ConnectSetCurrentPage(f func(page int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentPage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCurrentPage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentPage", func(page int) {
+				signal.(func(int))(page)
+				f(page)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentPage", f)
+		}
 	}
 }
 
@@ -5228,7 +5398,14 @@ func callbackQPrintPreviewWidget_SetFacingPagesViewMode(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectSetFacingPagesViewMode(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFacingPagesViewMode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFacingPagesViewMode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFacingPagesViewMode", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFacingPagesViewMode", f)
+		}
 	}
 }
 
@@ -5263,7 +5440,14 @@ func callbackQPrintPreviewWidget_SetLandscapeOrientation(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectSetLandscapeOrientation(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLandscapeOrientation", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setLandscapeOrientation"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLandscapeOrientation", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLandscapeOrientation", f)
+		}
 	}
 }
 
@@ -5298,7 +5482,14 @@ func callbackQPrintPreviewWidget_SetOrientation(ptr unsafe.Pointer, orientation
 func (ptr *QPrintPreviewWidget) ConnectSetOrientation(f func(orientation QPrinter__Orientation)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOrientation", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setOrientation"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOrientation", func(orientation QPrinter__Orientation) {
+				signal.(func(QPrinter__Orientation))(orientation)
+				f(orientation)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOrientation", f)
+		}
 	}
 }
 
@@ -5333,7 +5524,14 @@ func callbackQPrintPreviewWidget_SetPortraitOrientation(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectSetPortraitOrientation(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPortraitOrientation", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPortraitOrientation"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPortraitOrientation", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPortraitOrientation", f)
+		}
 	}
 }
 
@@ -5368,7 +5566,14 @@ func callbackQPrintPreviewWidget_SetSinglePageViewMode(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectSetSinglePageViewMode(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSinglePageViewMode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSinglePageViewMode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSinglePageViewMode", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSinglePageViewMode", f)
+		}
 	}
 }
 
@@ -5403,7 +5608,14 @@ func callbackQPrintPreviewWidget_SetViewMode(ptr unsafe.Pointer, mode C.longlong
 func (ptr *QPrintPreviewWidget) ConnectSetViewMode(f func(mode QPrintPreviewWidget__ViewMode)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewMode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setViewMode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewMode", func(mode QPrintPreviewWidget__ViewMode) {
+				signal.(func(QPrintPreviewWidget__ViewMode))(mode)
+				f(mode)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewMode", f)
+		}
 	}
 }
 
@@ -5438,7 +5650,14 @@ func callbackQPrintPreviewWidget_SetVisible(ptr unsafe.Pointer, visible C.char)
 func (ptr *QPrintPreviewWidget) ConnectSetVisible(f func(visible bool)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVisible", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVisible"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVisible", func(visible bool) {
+				signal.(func(bool))(visible)
+				f(visible)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVisible", f)
+		}
 	}
 }
 
@@ -5473,7 +5692,14 @@ func callbackQPrintPreviewWidget_SetZoomFactor(ptr unsafe.Pointer, factor C.doub
 func (ptr *QPrintPreviewWidget) ConnectSetZoomFactor(f func(factor float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomFactor", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setZoomFactor"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomFactor", func(factor float64) {
+				signal.(func(float64))(factor)
+				f(factor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomFactor", f)
+		}
 	}
 }
 
@@ -5508,7 +5734,14 @@ func callbackQPrintPreviewWidget_SetZoomMode(ptr unsafe.Pointer, zoomMode C.long
 func (ptr *QPrintPreviewWidget) ConnectSetZoomMode(f func(zoomMode QPrintPreviewWidget__ZoomMode)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomMode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setZoomMode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomMode", func(zoomMode QPrintPreviewWidget__ZoomMode) {
+				signal.(func(QPrintPreviewWidget__ZoomMode))(zoomMode)
+				f(zoomMode)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setZoomMode", f)
+		}
 	}
 }
 
@@ -5543,7 +5776,14 @@ func callbackQPrintPreviewWidget_UpdatePreview(ptr unsafe.Pointer) {
 func (ptr *QPrintPreviewWidget) ConnectUpdatePreview(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updatePreview", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updatePreview"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updatePreview", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updatePreview", f)
+		}
 	}
 }
 
@@ -5578,7 +5818,14 @@ func callbackQPrintPreviewWidget_ZoomIn(ptr unsafe.Pointer, factor C.double) {
 func (ptr *QPrintPreviewWidget) ConnectZoomIn(f func(factor float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomIn", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "zoomIn"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomIn", func(factor float64) {
+				signal.(func(float64))(factor)
+				f(factor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomIn", f)
+		}
 	}
 }
 
@@ -5613,7 +5860,14 @@ func callbackQPrintPreviewWidget_ZoomOut(ptr unsafe.Pointer, factor C.double) {
 func (ptr *QPrintPreviewWidget) ConnectZoomOut(f func(factor float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomOut", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "zoomOut"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomOut", func(factor float64) {
+				signal.(func(float64))(factor)
+				f(factor)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomOut", f)
+		}
 	}
 }
 
@@ -7185,7 +7439,14 @@ func callbackQPrinter_NewPage(ptr unsafe.Pointer) C.char {
 func (ptr *QPrinter) ConnectNewPage(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newPage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newPage", f)
+		}
 	}
 }
 
@@ -7436,7 +7697,14 @@ func callbackQPrinter_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QPrinter) ConnectPaintEngine(f func() *gui.QPaintEngine) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paintEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", func() *gui.QPaintEngine {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", f)
+		}
 	}
 }
 

purchasing/purchasing.go

@@ -89,7 +89,14 @@ func callbackQInAppProduct_Purchase(ptr unsafe.Pointer) {
 func (ptr *QInAppProduct) ConnectPurchase(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "purchase", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "purchase"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "purchase", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "purchase", f)
+		}
 	}
 }
 
@@ -456,8 +463,19 @@ func callbackQInAppStore_ProductRegistered(ptr unsafe.Pointer, product unsafe.Po
 
 func (ptr *QInAppStore) ConnectProductRegistered(f func(product *QInAppProduct)) {
 	if ptr.Pointer() != nil {
-		C.QInAppStore_ConnectProductRegistered(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productRegistered", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "productRegistered") {
+			C.QInAppStore_ConnectProductRegistered(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "productRegistered"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productRegistered", func(product *QInAppProduct) {
+				signal.(func(*QInAppProduct))(product)
+				f(product)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productRegistered", f)
+		}
 	}
 }
 
@@ -484,8 +502,19 @@ func callbackQInAppStore_ProductUnknown(ptr unsafe.Pointer, productType C.longlo
 
 func (ptr *QInAppStore) ConnectProductUnknown(f func(productType QInAppProduct__ProductType, identifier string)) {
 	if ptr.Pointer() != nil {
-		C.QInAppStore_ConnectProductUnknown(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productUnknown", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "productUnknown") {
+			C.QInAppStore_ConnectProductUnknown(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "productUnknown"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productUnknown", func(productType QInAppProduct__ProductType, identifier string) {
+				signal.(func(QInAppProduct__ProductType, string))(productType, identifier)
+				f(productType, identifier)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "productUnknown", f)
+		}
 	}
 }
 
@@ -550,8 +579,19 @@ func callbackQInAppStore_TransactionReady(ptr unsafe.Pointer, transaction unsafe
 
 func (ptr *QInAppStore) ConnectTransactionReady(f func(transaction *QInAppTransaction)) {
 	if ptr.Pointer() != nil {
-		C.QInAppStore_ConnectTransactionReady(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "transactionReady", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "transactionReady") {
+			C.QInAppStore_ConnectTransactionReady(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "transactionReady"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "transactionReady", func(transaction *QInAppTransaction) {
+				signal.(func(*QInAppTransaction))(transaction)
+				f(transaction)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "transactionReady", f)
+		}
 	}
 }
 
@@ -931,7 +971,14 @@ func callbackQInAppTransaction_ErrorString(ptr unsafe.Pointer) *C.char {
 func (ptr *QInAppTransaction) ConnectErrorString(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorString"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", f)
+		}
 	}
 }
 
@@ -968,7 +1015,14 @@ func callbackQInAppTransaction_OrderId(ptr unsafe.Pointer) *C.char {
 func (ptr *QInAppTransaction) ConnectOrderId(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "orderId", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "orderId"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "orderId", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "orderId", f)
+		}
 	}
 }
 
@@ -1004,7 +1058,14 @@ func callbackQInAppTransaction_Finalize(ptr unsafe.Pointer) {
 func (ptr *QInAppTransaction) ConnectFinalize(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finalize", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finalize"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finalize", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finalize", f)
+		}
 	}
 }
 
@@ -1033,7 +1094,14 @@ func callbackQInAppTransaction_FailureReason(ptr unsafe.Pointer) C.longlong {
 func (ptr *QInAppTransaction) ConnectFailureReason(f func() QInAppTransaction__FailureReason) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "failureReason", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "failureReason"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "failureReason", func() QInAppTransaction__FailureReason {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "failureReason", f)
+		}
 	}
 }
 
@@ -1070,7 +1138,14 @@ func callbackQInAppTransaction_Timestamp(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QInAppTransaction) ConnectTimestamp(f func() *core.QDateTime) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timestamp", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "timestamp"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timestamp", func() *core.QDateTime {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timestamp", f)
+		}
 	}
 }
 
@@ -1122,7 +1197,14 @@ func callbackQInAppTransaction_PlatformProperty(ptr unsafe.Pointer, propertyName
 func (ptr *QInAppTransaction) ConnectPlatformProperty(f func(propertyName string) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "platformProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "platformProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "platformProperty", func(propertyName string) string {
+				signal.(func(string))(propertyName)
+				return f(propertyName)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "platformProperty", f)
+		}
 	}
 }
 

qml/qml.go

@@ -169,7 +169,14 @@ func callbackQJSEngine_DestroyQJSEngine(ptr unsafe.Pointer) {
 func (ptr *QJSEngine) ConnectDestroyQJSEngine(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QJSEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QJSEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QJSEngine", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QJSEngine", f)
+		}
 	}
 }
 
@@ -1067,7 +1074,14 @@ func callbackQQmlAbstractUrlInterceptor_Intercept(ptr unsafe.Pointer, url unsafe
 func (ptr *QQmlAbstractUrlInterceptor) ConnectIntercept(f func(url *core.QUrl, ty QQmlAbstractUrlInterceptor__DataType) *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "intercept", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "intercept"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "intercept", func(url *core.QUrl, ty QQmlAbstractUrlInterceptor__DataType) *core.QUrl {
+				signal.(func(*core.QUrl, QQmlAbstractUrlInterceptor__DataType))(url, ty)
+				return f(url, ty)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "intercept", f)
+		}
 	}
 }
 
@@ -1099,7 +1113,14 @@ func callbackQQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptor(ptr un
 func (ptr *QQmlAbstractUrlInterceptor) ConnectDestroyQQmlAbstractUrlInterceptor(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlAbstractUrlInterceptor", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlAbstractUrlInterceptor"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlAbstractUrlInterceptor", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlAbstractUrlInterceptor", f)
+		}
 	}
 }
 
@@ -1218,7 +1239,14 @@ func callbackQQmlApplicationEngine_Load2(ptr unsafe.Pointer, filePath C.struct_Q
 func (ptr *QQmlApplicationEngine) ConnectLoad2(f func(filePath string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", func(filePath string) {
+				signal.(func(string))(filePath)
+				f(filePath)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		}
 	}
 }
 
@@ -1263,7 +1291,14 @@ func callbackQQmlApplicationEngine_Load(ptr unsafe.Pointer, url unsafe.Pointer)
 func (ptr *QQmlApplicationEngine) ConnectLoad(f func(url *core.QUrl)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", func(url *core.QUrl) {
+				signal.(func(*core.QUrl))(url)
+				f(url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		}
 	}
 }
 
@@ -1298,7 +1333,14 @@ func callbackQQmlApplicationEngine_LoadData(ptr unsafe.Pointer, data unsafe.Poin
 func (ptr *QQmlApplicationEngine) ConnectLoadData(f func(data *core.QByteArray, url *core.QUrl)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loadData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadData", func(data *core.QByteArray, url *core.QUrl) {
+				signal.(func(*core.QByteArray, *core.QUrl))(data, url)
+				f(data, url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadData", f)
+		}
 	}
 }
 
@@ -1331,8 +1373,19 @@ func callbackQQmlApplicationEngine_ObjectCreated(ptr unsafe.Pointer, object unsa
 
 func (ptr *QQmlApplicationEngine) ConnectObjectCreated(f func(object *core.QObject, url *core.QUrl)) {
 	if ptr.Pointer() != nil {
-		C.QQmlApplicationEngine_ConnectObjectCreated(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "objectCreated", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "objectCreated") {
+			C.QQmlApplicationEngine_ConnectObjectCreated(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "objectCreated"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "objectCreated", func(object *core.QObject, url *core.QUrl) {
+				signal.(func(*core.QObject, *core.QUrl))(object, url)
+				f(object, url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "objectCreated", f)
+		}
 	}
 }
 
@@ -1449,7 +1502,14 @@ func callbackQQmlComponent_BeginCreate(ptr unsafe.Pointer, publicContext unsafe.
 func (ptr *QQmlComponent) ConnectBeginCreate(f func(publicContext *QQmlContext) *core.QObject) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beginCreate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "beginCreate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beginCreate", func(publicContext *QQmlContext) *core.QObject {
+				signal.(func(*QQmlContext))(publicContext)
+				return f(publicContext)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "beginCreate", f)
+		}
 	}
 }
 
@@ -1494,7 +1554,14 @@ func callbackQQmlComponent_Create(ptr unsafe.Pointer, context unsafe.Pointer) un
 func (ptr *QQmlComponent) ConnectCreate(f func(context *QQmlContext) *core.QObject) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "create"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", func(context *QQmlContext) *core.QObject {
+				signal.(func(*QQmlContext))(context)
+				return f(context)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
+		}
 	}
 }
 
@@ -1589,7 +1656,14 @@ func callbackQQmlComponent_CompleteCreate(ptr unsafe.Pointer) {
 func (ptr *QQmlComponent) ConnectCompleteCreate(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "completeCreate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "completeCreate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "completeCreate", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "completeCreate", f)
+		}
 	}
 }
 
@@ -1630,7 +1704,14 @@ func callbackQQmlComponent_LoadUrl(ptr unsafe.Pointer, url unsafe.Pointer) {
 func (ptr *QQmlComponent) ConnectLoadUrl(f func(url *core.QUrl)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loadUrl"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl", func(url *core.QUrl) {
+				signal.(func(*core.QUrl))(url)
+				f(url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl", f)
+		}
 	}
 }
 
@@ -1665,7 +1746,14 @@ func callbackQQmlComponent_LoadUrl2(ptr unsafe.Pointer, url unsafe.Pointer, mode
 func (ptr *QQmlComponent) ConnectLoadUrl2(f func(url *core.QUrl, mode QQmlComponent__CompilationMode)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loadUrl2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl2", func(url *core.QUrl, mode QQmlComponent__CompilationMode) {
+				signal.(func(*core.QUrl, QQmlComponent__CompilationMode))(url, mode)
+				f(url, mode)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadUrl2", f)
+		}
 	}
 }
 
@@ -1698,8 +1786,19 @@ func callbackQQmlComponent_ProgressChanged(ptr unsafe.Pointer, progress C.double
 
 func (ptr *QQmlComponent) ConnectProgressChanged(f func(progress float64)) {
 	if ptr.Pointer() != nil {
-		C.QQmlComponent_ConnectProgressChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "progressChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "progressChanged") {
+			C.QQmlComponent_ConnectProgressChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "progressChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "progressChanged", func(progress float64) {
+				signal.(func(float64))(progress)
+				f(progress)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "progressChanged", f)
+		}
 	}
 }
 
@@ -1728,7 +1827,14 @@ func callbackQQmlComponent_SetData(ptr unsafe.Pointer, data unsafe.Pointer, url
 func (ptr *QQmlComponent) ConnectSetData(f func(data *core.QByteArray, url *core.QUrl)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setData", func(data *core.QByteArray, url *core.QUrl) {
+				signal.(func(*core.QByteArray, *core.QUrl))(data, url)
+				f(data, url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setData", f)
+		}
 	}
 }
 
@@ -1761,8 +1867,19 @@ func callbackQQmlComponent_StatusChanged(ptr unsafe.Pointer, status C.longlong)
 
 func (ptr *QQmlComponent) ConnectStatusChanged(f func(status QQmlComponent__Status)) {
 	if ptr.Pointer() != nil {
-		C.QQmlComponent_ConnectStatusChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
+			C.QQmlComponent_ConnectStatusChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QQmlComponent__Status) {
+				signal.(func(QQmlComponent__Status))(status)
+				f(status)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
+		}
 	}
 }
 
@@ -1791,7 +1908,14 @@ func callbackQQmlComponent_DestroyQQmlComponent(ptr unsafe.Pointer) {
 func (ptr *QQmlComponent) ConnectDestroyQQmlComponent(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlComponent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlComponent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlComponent", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlComponent", f)
+		}
 	}
 }
 
@@ -2280,7 +2404,14 @@ func callbackQQmlContext_DestroyQQmlContext(ptr unsafe.Pointer) {
 func (ptr *QQmlContext) ConnectDestroyQQmlContext(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlContext", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlContext"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlContext", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlContext", f)
+		}
 	}
 }
 
@@ -2788,8 +2919,19 @@ func callbackQQmlEngine_Exit(ptr unsafe.Pointer, retCode C.int) {
 
 func (ptr *QQmlEngine) ConnectExit(f func(retCode int)) {
 	if ptr.Pointer() != nil {
-		C.QQmlEngine_ConnectExit(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exit", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "exit") {
+			C.QQmlEngine_ConnectExit(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exit"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exit", func(retCode int) {
+				signal.(func(int))(retCode)
+				f(retCode)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exit", f)
+		}
 	}
 }
 
@@ -2816,8 +2958,19 @@ func callbackQQmlEngine_Quit(ptr unsafe.Pointer) {
 
 func (ptr *QQmlEngine) ConnectQuit(f func()) {
 	if ptr.Pointer() != nil {
-		C.QQmlEngine_ConnectQuit(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "quit", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "quit") {
+			C.QQmlEngine_ConnectQuit(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "quit"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "quit", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "quit", f)
+		}
 	}
 }
 
@@ -2934,8 +3087,19 @@ func callbackQQmlEngine_Warnings(ptr unsafe.Pointer, warnings C.struct_QtQml_Pac
 
 func (ptr *QQmlEngine) ConnectWarnings(f func(warnings []*QQmlError)) {
 	if ptr.Pointer() != nil {
-		C.QQmlEngine_ConnectWarnings(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warnings", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "warnings") {
+			C.QQmlEngine_ConnectWarnings(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "warnings"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warnings", func(warnings []*QQmlError) {
+				signal.(func([]*QQmlError))(warnings)
+				f(warnings)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "warnings", f)
+		}
 	}
 }
 
@@ -2970,7 +3134,14 @@ func callbackQQmlEngine_DestroyQQmlEngine(ptr unsafe.Pointer) {
 func (ptr *QQmlEngine) ConnectDestroyQQmlEngine(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlEngine", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlEngine", f)
+		}
 	}
 }
 
@@ -3415,8 +3586,19 @@ func callbackQQmlExpression_ValueChanged(ptr unsafe.Pointer) {
 
 func (ptr *QQmlExpression) ConnectValueChanged(f func()) {
 	if ptr.Pointer() != nil {
-		C.QQmlExpression_ConnectValueChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "valueChanged") {
+			C.QQmlExpression_ConnectValueChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "valueChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", f)
+		}
 	}
 }
 
@@ -3445,7 +3627,14 @@ func callbackQQmlExpression_DestroyQQmlExpression(ptr unsafe.Pointer) {
 func (ptr *QQmlExpression) ConnectDestroyQQmlExpression(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlExpression", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlExpression"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlExpression", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlExpression", f)
+		}
 	}
 }
 
@@ -3882,7 +4071,14 @@ func callbackQQmlExtensionPlugin_InitializeEngine(ptr unsafe.Pointer, engine uns
 func (ptr *QQmlExtensionPlugin) ConnectInitializeEngine(f func(engine *QQmlEngine, uri string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializeEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "initializeEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializeEngine", func(engine *QQmlEngine, uri string) {
+				signal.(func(*QQmlEngine, string))(engine, uri)
+				f(engine, uri)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializeEngine", f)
+		}
 	}
 }
 
@@ -3926,7 +4122,14 @@ func callbackQQmlExtensionPlugin_RegisterTypes(ptr unsafe.Pointer, uri C.struct_
 func (ptr *QQmlExtensionPlugin) ConnectRegisterTypes(f func(uri string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "registerTypes", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "registerTypes"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "registerTypes", func(uri string) {
+				signal.(func(string))(uri)
+				f(uri)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "registerTypes", f)
+		}
 	}
 }
 
@@ -4656,7 +4859,14 @@ func callbackQQmlImageProviderBase_Flags(ptr unsafe.Pointer) C.longlong {
 func (ptr *QQmlImageProviderBase) ConnectFlags(f func() QQmlImageProviderBase__Flag) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flags"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", func() QQmlImageProviderBase__Flag {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flags", f)
+		}
 	}
 }
 
@@ -4686,7 +4896,14 @@ func callbackQQmlImageProviderBase_ImageType(ptr unsafe.Pointer) C.longlong {
 func (ptr *QQmlImageProviderBase) ConnectImageType(f func() QQmlImageProviderBase__ImageType) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageType", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageType"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageType", func() QQmlImageProviderBase__ImageType {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageType", f)
+		}
 	}
 }
 
@@ -4772,7 +4989,14 @@ func callbackQQmlIncubationController_IncubatingObjectCountChanged(ptr unsafe.Po
 func (ptr *QQmlIncubationController) ConnectIncubatingObjectCountChanged(f func(incubatingObjectCount int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "incubatingObjectCountChanged", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "incubatingObjectCountChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "incubatingObjectCountChanged", func(incubatingObjectCount int) {
+				signal.(func(int))(incubatingObjectCount)
+				f(incubatingObjectCount)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "incubatingObjectCountChanged", f)
+		}
 	}
 }
 
@@ -4908,7 +5132,14 @@ func callbackQQmlIncubator_SetInitialState(ptr unsafe.Pointer, object unsafe.Poi
 func (ptr *QQmlIncubator) ConnectSetInitialState(f func(object *core.QObject)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setInitialState", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setInitialState"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setInitialState", func(object *core.QObject) {
+				signal.(func(*core.QObject))(object)
+				f(object)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setInitialState", f)
+		}
 	}
 }
 
@@ -4943,7 +5174,14 @@ func callbackQQmlIncubator_StatusChanged(ptr unsafe.Pointer, status C.longlong)
 func (ptr *QQmlIncubator) ConnectStatusChanged(f func(status QQmlIncubator__Status)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QQmlIncubator__Status) {
+				signal.(func(QQmlIncubator__Status))(status)
+				f(status)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
+		}
 	}
 }
 
@@ -5307,7 +5545,14 @@ func callbackQQmlNetworkAccessManagerFactory_Create(ptr unsafe.Pointer, parent u
 func (ptr *QQmlNetworkAccessManagerFactory) ConnectCreate(f func(parent *core.QObject) *network.QNetworkAccessManager) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "create"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", func(parent *core.QObject) *network.QNetworkAccessManager {
+				signal.(func(*core.QObject))(parent)
+				return f(parent)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
+		}
 	}
 }
 
@@ -5341,7 +5586,14 @@ func callbackQQmlNetworkAccessManagerFactory_DestroyQQmlNetworkAccessManagerFact
 func (ptr *QQmlNetworkAccessManagerFactory) ConnectDestroyQQmlNetworkAccessManagerFactory(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlNetworkAccessManagerFactory", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlNetworkAccessManagerFactory"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlNetworkAccessManagerFactory", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlNetworkAccessManagerFactory", f)
+		}
 	}
 }
 
@@ -5429,7 +5681,14 @@ func callbackQQmlParserStatus_ClassBegin(ptr unsafe.Pointer) {
 func (ptr *QQmlParserStatus) ConnectClassBegin(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "classBegin"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "classBegin", f)
+		}
 	}
 }
 
@@ -5457,7 +5716,14 @@ func callbackQQmlParserStatus_ComponentComplete(ptr unsafe.Pointer) {
 func (ptr *QQmlParserStatus) ConnectComponentComplete(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "componentComplete"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "componentComplete", f)
+		}
 	}
 }
 
@@ -5941,7 +6207,14 @@ func callbackQQmlPropertyMap_UpdateValue(ptr unsafe.Pointer, key C.struct_QtQml_
 func (ptr *QQmlPropertyMap) ConnectUpdateValue(f func(key string, input *core.QVariant) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "updateValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateValue", func(key string, input *core.QVariant) *core.QVariant {
+				signal.(func(string, *core.QVariant))(key, input)
+				return f(key, input)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "updateValue", f)
+		}
 	}
 }
 
@@ -6012,8 +6285,19 @@ func callbackQQmlPropertyMap_ValueChanged(ptr unsafe.Pointer, key C.struct_QtQml
 
 func (ptr *QQmlPropertyMap) ConnectValueChanged(f func(key string, value *core.QVariant)) {
 	if ptr.Pointer() != nil {
-		C.QQmlPropertyMap_ConnectValueChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "valueChanged") {
+			C.QQmlPropertyMap_ConnectValueChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "valueChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", func(key string, value *core.QVariant) {
+				signal.(func(string, *core.QVariant))(key, value)
+				f(key, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "valueChanged", f)
+		}
 	}
 }
 
@@ -6047,7 +6331,14 @@ func callbackQQmlPropertyMap_DestroyQQmlPropertyMap(ptr unsafe.Pointer) {
 func (ptr *QQmlPropertyMap) ConnectDestroyQQmlPropertyMap(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyMap", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyMap"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyMap", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyMap", f)
+		}
 	}
 }
 
@@ -6439,7 +6730,14 @@ func callbackQQmlPropertyValueSource_SetTarget(ptr unsafe.Pointer, property unsa
 func (ptr *QQmlPropertyValueSource) ConnectSetTarget(f func(property *QQmlProperty)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTarget", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setTarget"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTarget", func(property *QQmlProperty) {
+				signal.(func(*QQmlProperty))(property)
+				f(property)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setTarget", f)
+		}
 	}
 }
 
@@ -6468,7 +6766,14 @@ func callbackQQmlPropertyValueSource_DestroyQQmlPropertyValueSource(ptr unsafe.P
 func (ptr *QQmlPropertyValueSource) ConnectDestroyQQmlPropertyValueSource(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyValueSource", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyValueSource"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyValueSource", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QQmlPropertyValueSource", f)
+		}
 	}
 }
 

qt.go

@@ -27,6 +27,14 @@ func ExistsSignal(name, signal string) bool {
 	return exists
 }
 
+func LendSignal(name, signal string) interface{} {
+	var s interface{}
+	signalsMutex.Lock()
+	s = signals[fmt.Sprintf("%v:%v", name, signal)]
+	signalsMutex.Unlock()
+	return s
+}
+
 func GetSignal(name, signal string) interface{} {
 	if strings.HasSuffix(signal, ":destroyed") || strings.HasSuffix(signal, ":deleteLater") || strings.Contains(signal, ":~") {
 		defer DisconnectAllSignals(name)

quick/quick.cpp

@@ -6059,14 +6059,14 @@ void QSGNode_RemoveChildNode(void* ptr, void* node)
 	static_cast<QSGNode*>(ptr)->removeChildNode(static_cast<QSGNode*>(node));
 }
 
-void QSGNode_SetFlag(void* ptr, long long f, char enabled)
+void QSGNode_SetFlag(void* ptr, long long fo, char enabled)
 {
-	static_cast<QSGNode*>(ptr)->setFlag(static_cast<QSGNode::Flag>(f), enabled != 0);
+	static_cast<QSGNode*>(ptr)->setFlag(static_cast<QSGNode::Flag>(fo), enabled != 0);
 }
 
-void QSGNode_SetFlags(void* ptr, long long f, char enabled)
+void QSGNode_SetFlags(void* ptr, long long fo, char enabled)
 {
-	static_cast<QSGNode*>(ptr)->setFlags(static_cast<QSGNode::Flag>(f), enabled != 0);
+	static_cast<QSGNode*>(ptr)->setFlags(static_cast<QSGNode::Flag>(fo), enabled != 0);
 }
 
 void QSGNode_DestroyQSGNode(void* ptr)

quick/quick.h

@@ -919,8 +919,8 @@ void QSGNode_Preprocess(void* ptr);
 void QSGNode_PreprocessDefault(void* ptr);
 void QSGNode_RemoveAllChildNodes(void* ptr);
 void QSGNode_RemoveChildNode(void* ptr, void* node);
-void QSGNode_SetFlag(void* ptr, long long f, char enabled);
-void QSGNode_SetFlags(void* ptr, long long f, char enabled);
+void QSGNode_SetFlag(void* ptr, long long fo, char enabled);
+void QSGNode_SetFlags(void* ptr, long long fo, char enabled);
 void QSGNode_DestroyQSGNode(void* ptr);
 void QSGNode_DestroyQSGNodeDefault(void* ptr);
 long long QSGNode_Flags(void* ptr);

script/script.go

@@ -227,7 +227,14 @@ func callbackQScriptClass_NewIterator(ptr unsafe.Pointer, object unsafe.Pointer)
 func (ptr *QScriptClass) ConnectNewIterator(f func(object *QScriptValue) *QScriptClassPropertyIterator) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newIterator", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newIterator"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newIterator", func(object *QScriptValue) *QScriptClassPropertyIterator {
+				signal.(func(*QScriptValue))(object)
+				return f(object)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newIterator", f)
+		}
 	}
 }
 
@@ -264,7 +271,14 @@ func callbackQScriptClass_Property(ptr unsafe.Pointer, object unsafe.Pointer, na
 func (ptr *QScriptClass) ConnectProperty(f func(object *QScriptValue, name *QScriptString, id uint) *QScriptValue) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "property"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", func(object *QScriptValue, name *QScriptString, id uint) *QScriptValue {
+				signal.(func(*QScriptValue, *QScriptString, uint))(object, name, id)
+				return f(object, name, id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "property", f)
+		}
 	}
 }
 
@@ -305,7 +319,14 @@ func callbackQScriptClass_PropertyFlags(ptr unsafe.Pointer, object unsafe.Pointe
 func (ptr *QScriptClass) ConnectPropertyFlags(f func(object *QScriptValue, name *QScriptString, id uint) QScriptValue__PropertyFlag) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "propertyFlags", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "propertyFlags"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "propertyFlags", func(object *QScriptValue, name *QScriptString, id uint) QScriptValue__PropertyFlag {
+				signal.(func(*QScriptValue, *QScriptString, uint))(object, name, id)
+				return f(object, name, id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "propertyFlags", f)
+		}
 	}
 }
 
@@ -342,7 +363,14 @@ func callbackQScriptClass_Extension(ptr unsafe.Pointer, extension C.longlong, ar
 func (ptr *QScriptClass) ConnectExtension(f func(extension QScriptClass__Extension, argument *core.QVariant) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "extension"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", func(extension QScriptClass__Extension, argument *core.QVariant) *core.QVariant {
+				signal.(func(QScriptClass__Extension, *core.QVariant))(extension, argument)
+				return f(extension, argument)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", f)
+		}
 	}
 }
 
@@ -383,7 +411,14 @@ func callbackQScriptClass_QueryProperty(ptr unsafe.Pointer, object unsafe.Pointe
 func (ptr *QScriptClass) ConnectQueryProperty(f func(object *QScriptValue, name *QScriptString, flags QScriptClass__QueryFlag, id uint) QScriptClass__QueryFlag) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "queryProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "queryProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "queryProperty", func(object *QScriptValue, name *QScriptString, flags QScriptClass__QueryFlag, id uint) QScriptClass__QueryFlag {
+				signal.(func(*QScriptValue, *QScriptString, QScriptClass__QueryFlag, uint))(object, name, flags, id)
+				return f(object, name, flags, id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "queryProperty", f)
+		}
 	}
 }
 
@@ -420,7 +455,14 @@ func callbackQScriptClass_SetProperty(ptr unsafe.Pointer, object unsafe.Pointer,
 func (ptr *QScriptClass) ConnectSetProperty(f func(object *QScriptValue, name *QScriptString, id uint, value *QScriptValue)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", func(object *QScriptValue, name *QScriptString, id uint, value *QScriptValue) {
+				signal.(func(*QScriptValue, *QScriptString, uint, *QScriptValue))(object, name, id, value)
+				f(object, name, id, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setProperty", f)
+		}
 	}
 }
 
@@ -455,7 +497,14 @@ func callbackQScriptClass_DestroyQScriptClass(ptr unsafe.Pointer) {
 func (ptr *QScriptClass) ConnectDestroyQScriptClass(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptClass", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QScriptClass"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptClass", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptClass", f)
+		}
 	}
 }
 
@@ -505,7 +554,14 @@ func callbackQScriptClass_Prototype(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QScriptClass) ConnectPrototype(f func() *QScriptValue) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "prototype", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "prototype"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "prototype", func() *QScriptValue {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "prototype", f)
+		}
 	}
 }
 
@@ -546,7 +602,14 @@ func callbackQScriptClass_Name(ptr unsafe.Pointer) *C.char {
 func (ptr *QScriptClass) ConnectName(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "name"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		}
 	}
 }
 
@@ -583,7 +646,14 @@ func callbackQScriptClass_SupportsExtension(ptr unsafe.Pointer, extension C.long
 func (ptr *QScriptClass) ConnectSupportsExtension(f func(extension QScriptClass__Extension) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", func(extension QScriptClass__Extension) bool {
+				signal.(func(QScriptClass__Extension))(extension)
+				return f(extension)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", f)
+		}
 	}
 }
 
@@ -1376,8 +1446,19 @@ func callbackQScriptEngine_SignalHandlerException(ptr unsafe.Pointer, exception
 
 func (ptr *QScriptEngine) ConnectSignalHandlerException(f func(exception *QScriptValue)) {
 	if ptr.Pointer() != nil {
-		C.QScriptEngine_ConnectSignalHandlerException(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalHandlerException", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "signalHandlerException") {
+			C.QScriptEngine_ConnectSignalHandlerException(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "signalHandlerException"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalHandlerException", func(exception *QScriptValue) {
+				signal.(func(*QScriptValue))(exception)
+				f(exception)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalHandlerException", f)
+		}
 	}
 }
 
@@ -1406,7 +1487,14 @@ func callbackQScriptEngine_DestroyQScriptEngine(ptr unsafe.Pointer) {
 func (ptr *QScriptEngine) ConnectDestroyQScriptEngine(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngine", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngine", f)
+		}
 	}
 }
 
@@ -1844,7 +1932,14 @@ func callbackQScriptEngineAgent_Extension(ptr unsafe.Pointer, extension C.longlo
 func (ptr *QScriptEngineAgent) ConnectExtension(f func(extension QScriptEngineAgent__Extension, argument *core.QVariant) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "extension"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", func(extension QScriptEngineAgent__Extension, argument *core.QVariant) *core.QVariant {
+				signal.(func(QScriptEngineAgent__Extension, *core.QVariant))(extension, argument)
+				return f(extension, argument)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "extension", f)
+		}
 	}
 }
 
@@ -1885,7 +1980,14 @@ func callbackQScriptEngineAgent_ContextPop(ptr unsafe.Pointer) {
 func (ptr *QScriptEngineAgent) ConnectContextPop(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPop", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contextPop"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPop", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPop", f)
+		}
 	}
 }
 
@@ -1920,7 +2022,14 @@ func callbackQScriptEngineAgent_ContextPush(ptr unsafe.Pointer) {
 func (ptr *QScriptEngineAgent) ConnectContextPush(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPush", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contextPush"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPush", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contextPush", f)
+		}
 	}
 }
 
@@ -1955,7 +2064,14 @@ func callbackQScriptEngineAgent_ExceptionCatch(ptr unsafe.Pointer, scriptId C.lo
 func (ptr *QScriptEngineAgent) ConnectExceptionCatch(f func(scriptId int64, exception *QScriptValue)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionCatch", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exceptionCatch"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionCatch", func(scriptId int64, exception *QScriptValue) {
+				signal.(func(int64, *QScriptValue))(scriptId, exception)
+				f(scriptId, exception)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionCatch", f)
+		}
 	}
 }
 
@@ -1990,7 +2106,14 @@ func callbackQScriptEngineAgent_ExceptionThrow(ptr unsafe.Pointer, scriptId C.lo
 func (ptr *QScriptEngineAgent) ConnectExceptionThrow(f func(scriptId int64, exception *QScriptValue, hasHandler bool)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionThrow", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exceptionThrow"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionThrow", func(scriptId int64, exception *QScriptValue, hasHandler bool) {
+				signal.(func(int64, *QScriptValue, bool))(scriptId, exception, hasHandler)
+				f(scriptId, exception, hasHandler)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exceptionThrow", f)
+		}
 	}
 }
 
@@ -2025,7 +2148,14 @@ func callbackQScriptEngineAgent_FunctionEntry(ptr unsafe.Pointer, scriptId C.lon
 func (ptr *QScriptEngineAgent) ConnectFunctionEntry(f func(scriptId int64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionEntry", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "functionEntry"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionEntry", func(scriptId int64) {
+				signal.(func(int64))(scriptId)
+				f(scriptId)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionEntry", f)
+		}
 	}
 }
 
@@ -2060,7 +2190,14 @@ func callbackQScriptEngineAgent_FunctionExit(ptr unsafe.Pointer, scriptId C.long
 func (ptr *QScriptEngineAgent) ConnectFunctionExit(f func(scriptId int64, returnValue *QScriptValue)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionExit", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "functionExit"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionExit", func(scriptId int64, returnValue *QScriptValue) {
+				signal.(func(int64, *QScriptValue))(scriptId, returnValue)
+				f(scriptId, returnValue)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "functionExit", f)
+		}
 	}
 }
 
@@ -2095,7 +2232,14 @@ func callbackQScriptEngineAgent_PositionChange(ptr unsafe.Pointer, scriptId C.lo
 func (ptr *QScriptEngineAgent) ConnectPositionChange(f func(scriptId int64, lineNumber int, columnNumber int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChange", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionChange"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChange", func(scriptId int64, lineNumber int, columnNumber int) {
+				signal.(func(int64, int, int))(scriptId, lineNumber, columnNumber)
+				f(scriptId, lineNumber, columnNumber)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChange", f)
+		}
 	}
 }
 
@@ -2130,7 +2274,14 @@ func callbackQScriptEngineAgent_ScriptLoad(ptr unsafe.Pointer, id C.longlong, pr
 func (ptr *QScriptEngineAgent) ConnectScriptLoad(f func(id int64, program string, fileName string, baseLineNumber int)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptLoad", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scriptLoad"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptLoad", func(id int64, program string, fileName string, baseLineNumber int) {
+				signal.(func(int64, string, string, int))(id, program, fileName, baseLineNumber)
+				f(id, program, fileName, baseLineNumber)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptLoad", f)
+		}
 	}
 }
 
@@ -2185,7 +2336,14 @@ func callbackQScriptEngineAgent_ScriptUnload(ptr unsafe.Pointer, id C.longlong)
 func (ptr *QScriptEngineAgent) ConnectScriptUnload(f func(id int64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptUnload", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scriptUnload"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptUnload", func(id int64) {
+				signal.(func(int64))(id)
+				f(id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scriptUnload", f)
+		}
 	}
 }
 
@@ -2220,7 +2378,14 @@ func callbackQScriptEngineAgent_DestroyQScriptEngineAgent(ptr unsafe.Pointer) {
 func (ptr *QScriptEngineAgent) ConnectDestroyQScriptEngineAgent(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngineAgent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngineAgent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngineAgent", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScriptEngineAgent", f)
+		}
 	}
 }
 
@@ -2270,7 +2435,14 @@ func callbackQScriptEngineAgent_SupportsExtension(ptr unsafe.Pointer, extension
 func (ptr *QScriptEngineAgent) ConnectSupportsExtension(f func(extension QScriptEngineAgent__Extension) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", func(extension QScriptEngineAgent__Extension) bool {
+				signal.(func(QScriptEngineAgent__Extension))(extension)
+				return f(extension)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportsExtension", f)
+		}
 	}
 }
 
@@ -2352,7 +2524,14 @@ func callbackQScriptExtensionPlugin_Initialize(ptr unsafe.Pointer, key C.struct_
 func (ptr *QScriptExtensionPlugin) ConnectInitialize(f func(key string, engine *QScriptEngine)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initialize", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "initialize"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initialize", func(key string, engine *QScriptEngine) {
+				signal.(func(string, *QScriptEngine))(key, engine)
+				f(key, engine)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initialize", f)
+		}
 	}
 }
 
@@ -2408,7 +2587,14 @@ func callbackQScriptExtensionPlugin_Keys(ptr unsafe.Pointer) *C.char {
 func (ptr *QScriptExtensionPlugin) ConnectKeys(f func() []string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keys", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "keys"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keys", func() []string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "keys", f)
+		}
 	}
 }
 

scripttools/scripttools.go

@@ -162,8 +162,19 @@ func callbackQScriptEngineDebugger_EvaluationResumed(ptr unsafe.Pointer) {
 
 func (ptr *QScriptEngineDebugger) ConnectEvaluationResumed(f func()) {
 	if ptr.Pointer() != nil {
-		C.QScriptEngineDebugger_ConnectEvaluationResumed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationResumed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "evaluationResumed") {
+			C.QScriptEngineDebugger_ConnectEvaluationResumed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "evaluationResumed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationResumed", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationResumed", f)
+		}
 	}
 }
 
@@ -190,8 +201,19 @@ func callbackQScriptEngineDebugger_EvaluationSuspended(ptr unsafe.Pointer) {
 
 func (ptr *QScriptEngineDebugger) ConnectEvaluationSuspended(f func()) {
 	if ptr.Pointer() != nil {
-		C.QScriptEngineDebugger_ConnectEvaluationSuspended(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationSuspended", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "evaluationSuspended") {
+			C.QScriptEngineDebugger_ConnectEvaluationSuspended(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "evaluationSuspended"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationSuspended", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "evaluationSuspended", f)
+		}
 	}
 }
 

scxml/scxml.go

@@ -193,7 +193,14 @@ func callbackQScxmlCppDataModel_SetScxmlProperty(ptr unsafe.Pointer, name C.stru
 func (ptr *QScxmlCppDataModel) ConnectSetScxmlProperty(f func(name string, value *core.QVariant, context string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", func(name string, value *core.QVariant, context string) bool {
+				signal.(func(string, *core.QVariant, string))(name, value, context)
+				return f(name, value, context)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		}
 	}
 }
 
@@ -262,7 +269,14 @@ func callbackQScxmlCppDataModel_Setup(ptr unsafe.Pointer, initialDataValues C.st
 func (ptr *QScxmlCppDataModel) ConnectSetup(f func(initialDataValues map[string]*core.QVariant) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setup"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", func(initialDataValues map[string]*core.QVariant) bool {
+				signal.(func(map[string]*core.QVariant))(initialDataValues)
+				return f(initialDataValues)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		}
 	}
 }
 
@@ -317,7 +331,14 @@ func callbackQScxmlCppDataModel_ScxmlProperty(ptr unsafe.Pointer, name C.struct_
 func (ptr *QScxmlCppDataModel) ConnectScxmlProperty(f func(name string) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", func(name string) *core.QVariant {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		}
 	}
 }
 
@@ -368,7 +389,14 @@ func callbackQScxmlCppDataModel_HasScxmlProperty(ptr unsafe.Pointer, name C.stru
 func (ptr *QScxmlCppDataModel) ConnectHasScxmlProperty(f func(name string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", func(name string) bool {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		}
 	}
 }
 
@@ -481,7 +509,14 @@ func callbackQScxmlDataModel_SetScxmlProperty(ptr unsafe.Pointer, name C.struct_
 func (ptr *QScxmlDataModel) ConnectSetScxmlProperty(f func(name string, value *core.QVariant, context string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", func(name string, value *core.QVariant, context string) bool {
+				signal.(func(string, *core.QVariant, string))(name, value, context)
+				return f(name, value, context)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		}
 	}
 }
 
@@ -527,7 +562,14 @@ func callbackQScxmlDataModel_Setup(ptr unsafe.Pointer, initialDataValues C.struc
 func (ptr *QScxmlDataModel) ConnectSetup(f func(initialDataValues map[string]*core.QVariant) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setup"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", func(initialDataValues map[string]*core.QVariant) bool {
+				signal.(func(map[string]*core.QVariant))(initialDataValues)
+				return f(initialDataValues)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		}
 	}
 }
 
@@ -567,8 +609,19 @@ func callbackQScxmlDataModel_StateMachineChanged(ptr unsafe.Pointer, stateMachin
 
 func (ptr *QScxmlDataModel) ConnectStateMachineChanged(f func(stateMachine *QScxmlStateMachine)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlDataModel_ConnectStateMachineChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateMachineChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateMachineChanged") {
+			C.QScxmlDataModel_ConnectStateMachineChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateMachineChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateMachineChanged", func(stateMachine *QScxmlStateMachine) {
+				signal.(func(*QScxmlStateMachine))(stateMachine)
+				f(stateMachine)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateMachineChanged", f)
+		}
 	}
 }
 
@@ -608,7 +661,14 @@ func callbackQScxmlDataModel_ScxmlProperty(ptr unsafe.Pointer, name C.struct_QtS
 func (ptr *QScxmlDataModel) ConnectScxmlProperty(f func(name string) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", func(name string) *core.QVariant {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		}
 	}
 }
 
@@ -645,7 +705,14 @@ func callbackQScxmlDataModel_HasScxmlProperty(ptr unsafe.Pointer, name C.struct_
 func (ptr *QScxmlDataModel) ConnectHasScxmlProperty(f func(name string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", func(name string) bool {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		}
 	}
 }
 
@@ -1050,7 +1117,14 @@ func callbackQScxmlDynamicScxmlServiceFactory_Invoke(ptr unsafe.Pointer, parentS
 func (ptr *QScxmlDynamicScxmlServiceFactory) ConnectInvoke(f func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "invoke"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService {
+				signal.(func(*QScxmlStateMachine))(parentStateMachine)
+				return f(parentStateMachine)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		}
 	}
 }
 
@@ -1158,7 +1232,14 @@ func callbackQScxmlEcmaScriptDataModel_SetScxmlProperty(ptr unsafe.Pointer, name
 func (ptr *QScxmlEcmaScriptDataModel) ConnectSetScxmlProperty(f func(name string, value *core.QVariant, context string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", func(name string, value *core.QVariant, context string) bool {
+				signal.(func(string, *core.QVariant, string))(name, value, context)
+				return f(name, value, context)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		}
 	}
 }
 
@@ -1227,7 +1308,14 @@ func callbackQScxmlEcmaScriptDataModel_Setup(ptr unsafe.Pointer, initialDataValu
 func (ptr *QScxmlEcmaScriptDataModel) ConnectSetup(f func(initialDataValues map[string]*core.QVariant) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setup"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", func(initialDataValues map[string]*core.QVariant) bool {
+				signal.(func(map[string]*core.QVariant))(initialDataValues)
+				return f(initialDataValues)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		}
 	}
 }
 
@@ -1276,7 +1364,14 @@ func callbackQScxmlEcmaScriptDataModel_SetScxmlEvent(ptr unsafe.Pointer, event u
 func (ptr *QScxmlEcmaScriptDataModel) ConnectSetScxmlEvent(f func(event *QScxmlEvent)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", func(event *QScxmlEvent) {
+				signal.(func(*QScxmlEvent))(event)
+				f(event)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", f)
+		}
 	}
 }
 
@@ -1311,7 +1406,14 @@ func callbackQScxmlEcmaScriptDataModel_ScxmlProperty(ptr unsafe.Pointer, name C.
 func (ptr *QScxmlEcmaScriptDataModel) ConnectScxmlProperty(f func(name string) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", func(name string) *core.QVariant {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		}
 	}
 }
 
@@ -1362,7 +1464,14 @@ func callbackQScxmlEcmaScriptDataModel_HasScxmlProperty(ptr unsafe.Pointer, name
 func (ptr *QScxmlEcmaScriptDataModel) ConnectHasScxmlProperty(f func(name string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", func(name string) bool {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		}
 	}
 }
 
@@ -1814,7 +1923,14 @@ func callbackQScxmlInvokableService_Start(ptr unsafe.Pointer) C.char {
 func (ptr *QScxmlInvokableService) ConnectStart(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
+		}
 	}
 }
 
@@ -1843,7 +1959,14 @@ func callbackQScxmlInvokableService_PostEvent(ptr unsafe.Pointer, event unsafe.P
 func (ptr *QScxmlInvokableService) ConnectPostEvent(f func(event *QScxmlEvent)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "postEvent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "postEvent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "postEvent", func(event *QScxmlEvent) {
+				signal.(func(*QScxmlEvent))(event)
+				f(event)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "postEvent", f)
+		}
 	}
 }
 
@@ -1883,7 +2006,14 @@ func callbackQScxmlInvokableService_Id(ptr unsafe.Pointer) *C.char {
 func (ptr *QScxmlInvokableService) ConnectId(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "id", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "id"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "id", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "id", f)
+		}
 	}
 }
 
@@ -1913,7 +2043,14 @@ func callbackQScxmlInvokableService_Name(ptr unsafe.Pointer) *C.char {
 func (ptr *QScxmlInvokableService) ConnectName(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "name"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		}
 	}
 }
 
@@ -2249,7 +2386,14 @@ func callbackQScxmlInvokableServiceFactory_Invoke(ptr unsafe.Pointer, parentStat
 func (ptr *QScxmlInvokableServiceFactory) ConnectInvoke(f func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "invoke"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService {
+				signal.(func(*QScxmlStateMachine))(parentStateMachine)
+				return f(parentStateMachine)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		}
 	}
 }
 
@@ -2604,7 +2748,14 @@ func callbackQScxmlNullDataModel_SetScxmlProperty(ptr unsafe.Pointer, name C.str
 func (ptr *QScxmlNullDataModel) ConnectSetScxmlProperty(f func(name string, value *core.QVariant, context string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", func(name string, value *core.QVariant, context string) bool {
+				signal.(func(string, *core.QVariant, string))(name, value, context)
+				return f(name, value, context)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlProperty", f)
+		}
 	}
 }
 
@@ -2673,7 +2824,14 @@ func callbackQScxmlNullDataModel_Setup(ptr unsafe.Pointer, initialDataValues C.s
 func (ptr *QScxmlNullDataModel) ConnectSetup(f func(initialDataValues map[string]*core.QVariant) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setup"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", func(initialDataValues map[string]*core.QVariant) bool {
+				signal.(func(map[string]*core.QVariant))(initialDataValues)
+				return f(initialDataValues)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setup", f)
+		}
 	}
 }
 
@@ -2722,7 +2880,14 @@ func callbackQScxmlNullDataModel_SetScxmlEvent(ptr unsafe.Pointer, event unsafe.
 func (ptr *QScxmlNullDataModel) ConnectSetScxmlEvent(f func(event *QScxmlEvent)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", func(event *QScxmlEvent) {
+				signal.(func(*QScxmlEvent))(event)
+				f(event)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setScxmlEvent", f)
+		}
 	}
 }
 
@@ -2765,7 +2930,14 @@ func callbackQScxmlNullDataModel_ScxmlProperty(ptr unsafe.Pointer, name C.struct
 func (ptr *QScxmlNullDataModel) ConnectScxmlProperty(f func(name string) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", func(name string) *core.QVariant {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "scxmlProperty", f)
+		}
 	}
 }
 
@@ -2816,7 +2988,14 @@ func callbackQScxmlNullDataModel_HasScxmlProperty(ptr unsafe.Pointer, name C.str
 func (ptr *QScxmlNullDataModel) ConnectHasScxmlProperty(f func(name string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", func(name string) bool {
+				signal.(func(string))(name)
+				return f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasScxmlProperty", f)
+		}
 	}
 }
 
@@ -2983,7 +3162,14 @@ func callbackQScxmlStateMachine_Init(ptr unsafe.Pointer) C.char {
 func (ptr *QScxmlStateMachine) ConnectInit(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "init", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "init"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "init", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "init", f)
+		}
 	}
 }
 
@@ -3029,8 +3215,19 @@ func callbackQScxmlStateMachine_DataModelChanged(ptr unsafe.Pointer, model unsaf
 
 func (ptr *QScxmlStateMachine) ConnectDataModelChanged(f func(model *QScxmlDataModel)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectDataModelChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataModelChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "dataModelChanged") {
+			C.QScxmlStateMachine_ConnectDataModelChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dataModelChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataModelChanged", func(model *QScxmlDataModel) {
+				signal.(func(*QScxmlDataModel))(model)
+				f(model)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataModelChanged", f)
+		}
 	}
 }
 
@@ -3057,8 +3254,19 @@ func callbackQScxmlStateMachine_Finished(ptr unsafe.Pointer) {
 
 func (ptr *QScxmlStateMachine) ConnectFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QScxmlStateMachine_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -3085,8 +3293,19 @@ func callbackQScxmlStateMachine_InitializedChanged(ptr unsafe.Pointer, initializ
 
 func (ptr *QScxmlStateMachine) ConnectInitializedChanged(f func(initialized bool)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectInitializedChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializedChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "initializedChanged") {
+			C.QScxmlStateMachine_ConnectInitializedChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "initializedChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializedChanged", func(initialized bool) {
+				signal.(func(bool))(initialized)
+				f(initialized)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "initializedChanged", f)
+		}
 	}
 }
 
@@ -3119,8 +3338,19 @@ func callbackQScxmlStateMachine_InvokedServicesChanged(ptr unsafe.Pointer, invok
 
 func (ptr *QScxmlStateMachine) ConnectInvokedServicesChanged(f func(invokedServices []*QScxmlInvokableService)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectInvokedServicesChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invokedServicesChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "invokedServicesChanged") {
+			C.QScxmlStateMachine_ConnectInvokedServicesChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "invokedServicesChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invokedServicesChanged", func(invokedServices []*QScxmlInvokableService) {
+				signal.(func([]*QScxmlInvokableService))(invokedServices)
+				f(invokedServices)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invokedServicesChanged", f)
+		}
 	}
 }
 
@@ -3153,8 +3383,19 @@ func callbackQScxmlStateMachine_Log(ptr unsafe.Pointer, label C.struct_QtScxml_P
 
 func (ptr *QScxmlStateMachine) ConnectLog(f func(label string, msg string)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectLog(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "log", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "log") {
+			C.QScxmlStateMachine_ConnectLog(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "log"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "log", func(label string, msg string) {
+				signal.(func(string, string))(label, msg)
+				f(label, msg)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "log", f)
+		}
 	}
 }
 
@@ -3191,8 +3432,19 @@ func callbackQScxmlStateMachine_ReachedStableState(ptr unsafe.Pointer) {
 
 func (ptr *QScxmlStateMachine) ConnectReachedStableState(f func()) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectReachedStableState(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reachedStableState", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "reachedStableState") {
+			C.QScxmlStateMachine_ConnectReachedStableState(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "reachedStableState"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reachedStableState", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "reachedStableState", f)
+		}
 	}
 }
 
@@ -3219,8 +3471,19 @@ func callbackQScxmlStateMachine_RunningChanged(ptr unsafe.Pointer, running C.cha
 
 func (ptr *QScxmlStateMachine) ConnectRunningChanged(f func(running bool)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectRunningChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "runningChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "runningChanged") {
+			C.QScxmlStateMachine_ConnectRunningChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "runningChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "runningChanged", func(running bool) {
+				signal.(func(bool))(running)
+				f(running)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "runningChanged", f)
+		}
 	}
 }
 
@@ -3279,7 +3542,14 @@ func callbackQScxmlStateMachine_Start(ptr unsafe.Pointer) {
 func (ptr *QScxmlStateMachine) ConnectStart(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
+		}
 	}
 }
 
@@ -3314,7 +3584,14 @@ func callbackQScxmlStateMachine_Stop(ptr unsafe.Pointer) {
 func (ptr *QScxmlStateMachine) ConnectStop(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
+		}
 	}
 }
 
@@ -3375,8 +3652,19 @@ func callbackQScxmlStateMachine_TableDataChanged(ptr unsafe.Pointer, tableData u
 
 func (ptr *QScxmlStateMachine) ConnectTableDataChanged(f func(tableData *QScxmlTableData)) {
 	if ptr.Pointer() != nil {
-		C.QScxmlStateMachine_ConnectTableDataChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "tableDataChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "tableDataChanged") {
+			C.QScxmlStateMachine_ConnectTableDataChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "tableDataChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "tableDataChanged", func(tableData *QScxmlTableData) {
+				signal.(func(*QScxmlTableData))(tableData)
+				f(tableData)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "tableDataChanged", f)
+		}
 	}
 }
 
@@ -4088,7 +4376,14 @@ func callbackQScxmlStaticScxmlServiceFactory_Invoke(ptr unsafe.Pointer, parentSt
 func (ptr *QScxmlStaticScxmlServiceFactory) ConnectInvoke(f func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "invoke"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", func(parentStateMachine *QScxmlStateMachine) *QScxmlInvokableService {
+				signal.(func(*QScxmlStateMachine))(parentStateMachine)
+				return f(parentStateMachine)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "invoke", f)
+		}
 	}
 }
 
@@ -4179,7 +4474,14 @@ func callbackQScxmlTableData_DestroyQScxmlTableData(ptr unsafe.Pointer) {
 func (ptr *QScxmlTableData) ConnectDestroyQScxmlTableData(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScxmlTableData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QScxmlTableData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScxmlTableData", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QScxmlTableData", f)
+		}
 	}
 }
 
@@ -4218,7 +4520,14 @@ func callbackQScxmlTableData_ServiceFactory(ptr unsafe.Pointer, id C.int) unsafe
 func (ptr *QScxmlTableData) ConnectServiceFactory(f func(id int) *QScxmlInvokableServiceFactory) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceFactory", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serviceFactory"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceFactory", func(id int) *QScxmlInvokableServiceFactory {
+				signal.(func(int))(id)
+				return f(id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serviceFactory", f)
+		}
 	}
 }
 
@@ -4252,7 +4561,14 @@ func callbackQScxmlTableData_Name(ptr unsafe.Pointer) *C.char {
 func (ptr *QScxmlTableData) ConnectName(f func() string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "name"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", func() string {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		}
 	}
 }
 

serialbus/serialbus.go

@@ -604,7 +604,14 @@ func callbackQCanBusDevice_InterpretErrorFrame(ptr unsafe.Pointer, frame unsafe.
 func (ptr *QCanBusDevice) ConnectInterpretErrorFrame(f func(frame *QCanBusFrame) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "interpretErrorFrame", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "interpretErrorFrame"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "interpretErrorFrame", func(frame *QCanBusFrame) string {
+				signal.(func(*QCanBusFrame))(frame)
+				return f(frame)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "interpretErrorFrame", f)
+		}
 	}
 }
 
@@ -641,7 +648,14 @@ func callbackQCanBusDevice_Open(ptr unsafe.Pointer) C.char {
 func (ptr *QCanBusDevice) ConnectOpen(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "open"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		}
 	}
 }
 
@@ -671,7 +685,14 @@ func callbackQCanBusDevice_WaitForFramesReceived(ptr unsafe.Pointer, msecs C.int
 func (ptr *QCanBusDevice) ConnectWaitForFramesReceived(f func(msecs int) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesReceived", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesReceived", func(msecs int) bool {
+				signal.(func(int))(msecs)
+				return f(msecs)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesReceived", f)
+		}
 	}
 }
 
@@ -708,7 +729,14 @@ func callbackQCanBusDevice_WaitForFramesWritten(ptr unsafe.Pointer, msecs C.int)
 func (ptr *QCanBusDevice) ConnectWaitForFramesWritten(f func(msecs int) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesWritten", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesWritten"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesWritten", func(msecs int) bool {
+				signal.(func(int))(msecs)
+				return f(msecs)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "waitForFramesWritten", f)
+		}
 	}
 }
 
@@ -745,7 +773,14 @@ func callbackQCanBusDevice_WriteFrame(ptr unsafe.Pointer, frame unsafe.Pointer)
 func (ptr *QCanBusDevice) ConnectWriteFrame(f func(frame *QCanBusFrame) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeFrame", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "writeFrame"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeFrame", func(frame *QCanBusFrame) bool {
+				signal.(func(*QCanBusFrame))(frame)
+				return f(frame)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeFrame", f)
+		}
 	}
 }
 
@@ -774,7 +809,14 @@ func callbackQCanBusDevice_Close(ptr unsafe.Pointer) {
 func (ptr *QCanBusDevice) ConnectClose(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "close"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		}
 	}
 }
 
@@ -825,8 +867,19 @@ func callbackQCanBusDevice_ErrorOccurred(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QCanBusDevice) ConnectErrorOccurred(f func(error QCanBusDevice__CanBusError)) {
 	if ptr.Pointer() != nil {
-		C.QCanBusDevice_ConnectErrorOccurred(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred") {
+			C.QCanBusDevice_ConnectErrorOccurred(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", func(error QCanBusDevice__CanBusError) {
+				signal.(func(QCanBusDevice__CanBusError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+		}
 	}
 }
 
@@ -853,8 +906,19 @@ func callbackQCanBusDevice_FramesReceived(ptr unsafe.Pointer) {
 
 func (ptr *QCanBusDevice) ConnectFramesReceived(f func()) {
 	if ptr.Pointer() != nil {
-		C.QCanBusDevice_ConnectFramesReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "framesReceived") {
+			C.QCanBusDevice_ConnectFramesReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "framesReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesReceived", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesReceived", f)
+		}
 	}
 }
 
@@ -881,8 +945,19 @@ func callbackQCanBusDevice_FramesWritten(ptr unsafe.Pointer, framesCount C.longl
 
 func (ptr *QCanBusDevice) ConnectFramesWritten(f func(framesCount int64)) {
 	if ptr.Pointer() != nil {
-		C.QCanBusDevice_ConnectFramesWritten(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesWritten", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "framesWritten") {
+			C.QCanBusDevice_ConnectFramesWritten(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "framesWritten"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesWritten", func(framesCount int64) {
+				signal.(func(int64))(framesCount)
+				f(framesCount)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "framesWritten", f)
+		}
 	}
 }
 
@@ -911,7 +986,14 @@ func callbackQCanBusDevice_SetConfigurationParameter(ptr unsafe.Pointer, key C.i
 func (ptr *QCanBusDevice) ConnectSetConfigurationParameter(f func(key int, value *core.QVariant)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurationParameter", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setConfigurationParameter"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurationParameter", func(key int, value *core.QVariant) {
+				signal.(func(int, *core.QVariant))(key, value)
+				f(key, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurationParameter", f)
+		}
 	}
 }
 
@@ -961,8 +1043,19 @@ func callbackQCanBusDevice_StateChanged(ptr unsafe.Pointer, state C.longlong) {
 
 func (ptr *QCanBusDevice) ConnectStateChanged(f func(state QCanBusDevice__CanBusDeviceState)) {
 	if ptr.Pointer() != nil {
-		C.QCanBusDevice_ConnectStateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
+			C.QCanBusDevice_ConnectStateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QCanBusDevice__CanBusDeviceState) {
+				signal.(func(QCanBusDevice__CanBusDeviceState))(state)
+				f(state)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+		}
 	}
 }
 
@@ -1387,7 +1480,14 @@ func callbackQCanBusFactory_CreateDevice(ptr unsafe.Pointer, interfaceName C.str
 func (ptr *QCanBusFactory) ConnectCreateDevice(f func(interfaceName string, errorMessage string) *QCanBusDevice) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createDevice", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createDevice"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createDevice", func(interfaceName string, errorMessage string) *QCanBusDevice {
+				signal.(func(string, string))(interfaceName, errorMessage)
+				return f(interfaceName, errorMessage)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createDevice", f)
+		}
 	}
 }
 
@@ -1712,7 +1812,14 @@ func callbackQModbusClient_ProcessPrivateResponse(ptr unsafe.Pointer, response u
 func (ptr *QModbusClient) ConnectProcessPrivateResponse(f func(response *QModbusResponse, data *QModbusDataUnit) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateResponse", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processPrivateResponse"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateResponse", func(response *QModbusResponse, data *QModbusDataUnit) bool {
+				signal.(func(*QModbusResponse, *QModbusDataUnit))(response, data)
+				return f(response, data)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateResponse", f)
+		}
 	}
 }
 
@@ -1749,7 +1856,14 @@ func callbackQModbusClient_ProcessResponse(ptr unsafe.Pointer, response unsafe.P
 func (ptr *QModbusClient) ConnectProcessResponse(f func(response *QModbusResponse, data *QModbusDataUnit) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processResponse", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processResponse"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processResponse", func(response *QModbusResponse, data *QModbusDataUnit) bool {
+				signal.(func(*QModbusResponse, *QModbusDataUnit))(response, data)
+				return f(response, data)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processResponse", f)
+		}
 	}
 }
 
@@ -1796,8 +1910,19 @@ func callbackQModbusClient_TimeoutChanged(ptr unsafe.Pointer, newTimeout C.int)
 
 func (ptr *QModbusClient) ConnectTimeoutChanged(f func(newTimeout int)) {
 	if ptr.Pointer() != nil {
-		C.QModbusClient_ConnectTimeoutChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timeoutChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "timeoutChanged") {
+			C.QModbusClient_ConnectTimeoutChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "timeoutChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timeoutChanged", func(newTimeout int) {
+				signal.(func(int))(newTimeout)
+				f(newTimeout)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "timeoutChanged", f)
+		}
 	}
 }
 
@@ -2202,7 +2327,14 @@ func callbackQModbusDevice_Open(ptr unsafe.Pointer) C.char {
 func (ptr *QModbusDevice) ConnectOpen(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "open"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		}
 	}
 }
 
@@ -2231,7 +2363,14 @@ func callbackQModbusDevice_Close(ptr unsafe.Pointer) {
 func (ptr *QModbusDevice) ConnectClose(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "close"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		}
 	}
 }
 
@@ -2264,8 +2403,19 @@ func callbackQModbusDevice_ErrorOccurred(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QModbusDevice) ConnectErrorOccurred(f func(error QModbusDevice__Error)) {
 	if ptr.Pointer() != nil {
-		C.QModbusDevice_ConnectErrorOccurred(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred") {
+			C.QModbusDevice_ConnectErrorOccurred(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", func(error QModbusDevice__Error) {
+				signal.(func(QModbusDevice__Error))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+		}
 	}
 }
 
@@ -2315,8 +2465,19 @@ func callbackQModbusDevice_StateChanged(ptr unsafe.Pointer, state C.longlong) {
 
 func (ptr *QModbusDevice) ConnectStateChanged(f func(state QModbusDevice__State)) {
 	if ptr.Pointer() != nil {
-		C.QModbusDevice_ConnectStateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
+			C.QModbusDevice_ConnectStateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QModbusDevice__State) {
+				signal.(func(QModbusDevice__State))(state)
+				f(state)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+		}
 	}
 }
 
@@ -2992,7 +3153,14 @@ func callbackQModbusPdu_SetFunctionCode(ptr unsafe.Pointer, code C.longlong) {
 func (ptr *QModbusPdu) ConnectSetFunctionCode(f func(code QModbusPdu__FunctionCode)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFunctionCode", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFunctionCode"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFunctionCode", func(code QModbusPdu__FunctionCode) {
+				signal.(func(QModbusPdu__FunctionCode))(code)
+				f(code)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFunctionCode", f)
+		}
 	}
 }
 
@@ -3027,7 +3195,14 @@ func callbackQModbusPdu_DestroyQModbusPdu(ptr unsafe.Pointer) {
 func (ptr *QModbusPdu) ConnectDestroyQModbusPdu(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QModbusPdu", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QModbusPdu"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QModbusPdu", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QModbusPdu", f)
+		}
 	}
 }
 
@@ -3200,8 +3375,19 @@ func callbackQModbusReply_ErrorOccurred(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QModbusReply) ConnectErrorOccurred(f func(error QModbusDevice__Error)) {
 	if ptr.Pointer() != nil {
-		C.QModbusReply_ConnectErrorOccurred(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred") {
+			C.QModbusReply_ConnectErrorOccurred(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", func(error QModbusDevice__Error) {
+				signal.(func(QModbusDevice__Error))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+		}
 	}
 }
 
@@ -3228,8 +3414,19 @@ func callbackQModbusReply_Finished(ptr unsafe.Pointer) {
 
 func (ptr *QModbusReply) ConnectFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QModbusReply_ConnectFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
+			C.QModbusReply_ConnectFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
+		}
 	}
 }
 
@@ -3906,7 +4103,14 @@ func callbackQModbusServer_ProcessPrivateRequest(ptr unsafe.Pointer, request uns
 func (ptr *QModbusServer) ConnectProcessPrivateRequest(f func(request *QModbusPdu) *QModbusResponse) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateRequest", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processPrivateRequest"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateRequest", func(request *QModbusPdu) *QModbusResponse {
+				signal.(func(*QModbusPdu))(request)
+				return f(request)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processPrivateRequest", f)
+		}
 	}
 }
 
@@ -3947,7 +4151,14 @@ func callbackQModbusServer_ProcessRequest(ptr unsafe.Pointer, request unsafe.Poi
 func (ptr *QModbusServer) ConnectProcessRequest(f func(request *QModbusPdu) *QModbusResponse) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processRequest", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processRequest"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processRequest", func(request *QModbusPdu) *QModbusResponse {
+				signal.(func(*QModbusPdu))(request)
+				return f(request)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processRequest", f)
+		}
 	}
 }
 
@@ -4010,7 +4221,14 @@ func callbackQModbusServer_SetValue(ptr unsafe.Pointer, option C.int, newValue u
 func (ptr *QModbusServer) ConnectSetValue(f func(option int, newValue *core.QVariant) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setValue", func(option int, newValue *core.QVariant) bool {
+				signal.(func(int, *core.QVariant))(option, newValue)
+				return f(option, newValue)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setValue", f)
+		}
 	}
 }
 
@@ -4047,7 +4265,14 @@ func callbackQModbusServer_WriteData(ptr unsafe.Pointer, newData unsafe.Pointer)
 func (ptr *QModbusServer) ConnectWriteData(f func(newData *QModbusDataUnit) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "writeData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", func(newData *QModbusDataUnit) bool {
+				signal.(func(*QModbusDataUnit))(newData)
+				return f(newData)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", f)
+		}
 	}
 }
 
@@ -4082,8 +4307,19 @@ func callbackQModbusServer_DataWritten(ptr unsafe.Pointer, regist C.longlong, ad
 
 func (ptr *QModbusServer) ConnectDataWritten(f func(regist QModbusDataUnit__RegisterType, address int, size int)) {
 	if ptr.Pointer() != nil {
-		C.QModbusServer_ConnectDataWritten(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataWritten", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "dataWritten") {
+			C.QModbusServer_ConnectDataWritten(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dataWritten"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataWritten", func(regist QModbusDataUnit__RegisterType, address int, size int) {
+				signal.(func(QModbusDataUnit__RegisterType, int, int))(regist, address, size)
+				f(regist, address, size)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataWritten", f)
+		}
 	}
 }
 
@@ -4118,7 +4354,14 @@ func callbackQModbusServer_Value(ptr unsafe.Pointer, option C.int) unsafe.Pointe
 func (ptr *QModbusServer) ConnectValue(f func(option int) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "value", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "value"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "value", func(option int) *core.QVariant {
+				signal.(func(int))(option)
+				return f(option)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "value", f)
+		}
 	}
 }
 
@@ -4173,7 +4416,14 @@ func callbackQModbusServer_ProcessesBroadcast(ptr unsafe.Pointer) C.char {
 func (ptr *QModbusServer) ConnectProcessesBroadcast(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processesBroadcast", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processesBroadcast"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processesBroadcast", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processesBroadcast", f)
+		}
 	}
 }
 
@@ -4210,7 +4460,14 @@ func callbackQModbusServer_ReadData(ptr unsafe.Pointer, newData unsafe.Pointer)
 func (ptr *QModbusServer) ConnectReadData(f func(newData *QModbusDataUnit) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", func(newData *QModbusDataUnit) bool {
+				signal.(func(*QModbusDataUnit))(newData)
+				return f(newData)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", f)
+		}
 	}
 }
 

serialport/serialport.go

@@ -363,7 +363,14 @@ func callbackQSerialPort_ReadData(ptr unsafe.Pointer, data C.struct_QtSerialPort
 func (ptr *QSerialPort) ConnectReadData(f func(data *string, maxSize int64) int64) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", func(data *string, maxSize int64) int64 {
+				signal.(func(*string, int64))(data, maxSize)
+				return f(data, maxSize)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readData", f)
+		}
 	}
 }
 
@@ -433,7 +440,14 @@ func callbackQSerialPort_WriteData(ptr unsafe.Pointer, data C.struct_QtSerialPor
 func (ptr *QSerialPort) ConnectWriteData(f func(data string, maxSize int64) int64) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "writeData"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", func(data string, maxSize int64) int64 {
+				signal.(func(string, int64))(data, maxSize)
+				return f(data, maxSize)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writeData", f)
+		}
 	}
 }
 
@@ -478,8 +492,19 @@ func callbackQSerialPort_BaudRateChanged(ptr unsafe.Pointer, baudRate C.int, dir
 
 func (ptr *QSerialPort) ConnectBaudRateChanged(f func(baudRate int, directions QSerialPort__Direction)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectBaudRateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baudRateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "baudRateChanged") {
+			C.QSerialPort_ConnectBaudRateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "baudRateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baudRateChanged", func(baudRate int, directions QSerialPort__Direction) {
+				signal.(func(int, QSerialPort__Direction))(baudRate, directions)
+				f(baudRate, directions)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baudRateChanged", f)
+		}
 	}
 }
 
@@ -506,8 +531,19 @@ func callbackQSerialPort_BreakEnabledChanged(ptr unsafe.Pointer, set C.char) {
 
 func (ptr *QSerialPort) ConnectBreakEnabledChanged(f func(set bool)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectBreakEnabledChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "breakEnabledChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "breakEnabledChanged") {
+			C.QSerialPort_ConnectBreakEnabledChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "breakEnabledChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "breakEnabledChanged", func(set bool) {
+				signal.(func(bool))(set)
+				f(set)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "breakEnabledChanged", f)
+		}
 	}
 }
 
@@ -555,8 +591,19 @@ func callbackQSerialPort_DataBitsChanged(ptr unsafe.Pointer, dataBits C.longlong
 
 func (ptr *QSerialPort) ConnectDataBitsChanged(f func(dataBits QSerialPort__DataBits)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectDataBitsChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataBitsChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "dataBitsChanged") {
+			C.QSerialPort_ConnectDataBitsChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dataBitsChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataBitsChanged", func(dataBits QSerialPort__DataBits) {
+				signal.(func(QSerialPort__DataBits))(dataBits)
+				f(dataBits)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataBitsChanged", f)
+		}
 	}
 }
 
@@ -583,8 +630,19 @@ func callbackQSerialPort_DataTerminalReadyChanged(ptr unsafe.Pointer, set C.char
 
 func (ptr *QSerialPort) ConnectDataTerminalReadyChanged(f func(set bool)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectDataTerminalReadyChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataTerminalReadyChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "dataTerminalReadyChanged") {
+			C.QSerialPort_ConnectDataTerminalReadyChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "dataTerminalReadyChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataTerminalReadyChanged", func(set bool) {
+				signal.(func(bool))(set)
+				f(set)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "dataTerminalReadyChanged", f)
+		}
 	}
 }
 
@@ -611,8 +669,19 @@ func callbackQSerialPort_ErrorOccurred(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QSerialPort) ConnectErrorOccurred(f func(error QSerialPort__SerialPortError)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectErrorOccurred(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred") {
+			C.QSerialPort_ConnectErrorOccurred(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", func(error QSerialPort__SerialPortError) {
+				signal.(func(QSerialPort__SerialPortError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorOccurred", f)
+		}
 	}
 }
 
@@ -639,8 +708,19 @@ func callbackQSerialPort_FlowControlChanged(ptr unsafe.Pointer, flow C.longlong)
 
 func (ptr *QSerialPort) ConnectFlowControlChanged(f func(flow QSerialPort__FlowControl)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectFlowControlChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flowControlChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flowControlChanged") {
+			C.QSerialPort_ConnectFlowControlChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flowControlChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flowControlChanged", func(flow QSerialPort__FlowControl) {
+				signal.(func(QSerialPort__FlowControl))(flow)
+				f(flow)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flowControlChanged", f)
+		}
 	}
 }
 
@@ -667,8 +747,19 @@ func callbackQSerialPort_ParityChanged(ptr unsafe.Pointer, parity C.longlong) {
 
 func (ptr *QSerialPort) ConnectParityChanged(f func(parity QSerialPort__Parity)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectParityChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parityChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "parityChanged") {
+			C.QSerialPort_ConnectParityChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "parityChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parityChanged", func(parity QSerialPort__Parity) {
+				signal.(func(QSerialPort__Parity))(parity)
+				f(parity)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parityChanged", f)
+		}
 	}
 }
 
@@ -695,8 +786,19 @@ func callbackQSerialPort_RequestToSendChanged(ptr unsafe.Pointer, set C.char) {
 
 func (ptr *QSerialPort) ConnectRequestToSendChanged(f func(set bool)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectRequestToSendChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestToSendChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestToSendChanged") {
+			C.QSerialPort_ConnectRequestToSendChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestToSendChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestToSendChanged", func(set bool) {
+				signal.(func(bool))(set)
+				f(set)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestToSendChanged", f)
+		}
 	}
 }
 
@@ -746,8 +848,19 @@ func callbackQSerialPort_StopBitsChanged(ptr unsafe.Pointer, stopBits C.longlong
 
 func (ptr *QSerialPort) ConnectStopBitsChanged(f func(stopBits QSerialPort__StopBits)) {
 	if ptr.Pointer() != nil {
-		C.QSerialPort_ConnectStopBitsChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopBitsChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stopBitsChanged") {
+			C.QSerialPort_ConnectStopBitsChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stopBitsChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopBitsChanged", func(stopBits QSerialPort__StopBits) {
+				signal.(func(QSerialPort__StopBits))(stopBits)
+				f(stopBits)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stopBitsChanged", f)
+		}
 	}
 }
 
@@ -776,7 +889,14 @@ func callbackQSerialPort_DestroyQSerialPort(ptr unsafe.Pointer) {
 func (ptr *QSerialPort) ConnectDestroyQSerialPort(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSerialPort", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSerialPort"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSerialPort", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSerialPort", f)
+		}
 	}
 }
 

speech/speech.go

@@ -111,8 +111,19 @@ func callbackQTextToSpeech_LocaleChanged(ptr unsafe.Pointer, locale unsafe.Point
 
 func (ptr *QTextToSpeech) ConnectLocaleChanged(f func(locale *core.QLocale)) {
 	if ptr.Pointer() != nil {
-		C.QTextToSpeech_ConnectLocaleChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "localeChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "localeChanged") {
+			C.QTextToSpeech_ConnectLocaleChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "localeChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "localeChanged", func(locale *core.QLocale) {
+				signal.(func(*core.QLocale))(locale)
+				f(locale)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "localeChanged", f)
+		}
 	}
 }
 
@@ -141,7 +152,14 @@ func callbackQTextToSpeech_Pause(ptr unsafe.Pointer) {
 func (ptr *QTextToSpeech) ConnectPause(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pause"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", f)
+		}
 	}
 }
 
@@ -174,8 +192,19 @@ func callbackQTextToSpeech_PitchChanged(ptr unsafe.Pointer, pitch C.double) {
 
 func (ptr *QTextToSpeech) ConnectPitchChanged(f func(pitch float64)) {
 	if ptr.Pointer() != nil {
-		C.QTextToSpeech_ConnectPitchChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pitchChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "pitchChanged") {
+			C.QTextToSpeech_ConnectPitchChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pitchChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pitchChanged", func(pitch float64) {
+				signal.(func(float64))(pitch)
+				f(pitch)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pitchChanged", f)
+		}
 	}
 }
 
@@ -202,8 +231,19 @@ func callbackQTextToSpeech_RateChanged(ptr unsafe.Pointer, rate C.double) {
 
 func (ptr *QTextToSpeech) ConnectRateChanged(f func(rate float64)) {
 	if ptr.Pointer() != nil {
-		C.QTextToSpeech_ConnectRateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "rateChanged") {
+			C.QTextToSpeech_ConnectRateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "rateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rateChanged", func(rate float64) {
+				signal.(func(float64))(rate)
+				f(rate)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "rateChanged", f)
+		}
 	}
 }
 
@@ -232,7 +272,14 @@ func callbackQTextToSpeech_Resume(ptr unsafe.Pointer) {
 func (ptr *QTextToSpeech) ConnectResume(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resume", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "resume"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resume", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resume", f)
+		}
 	}
 }
 
@@ -267,7 +314,14 @@ func callbackQTextToSpeech_Say(ptr unsafe.Pointer, text C.struct_QtSpeech_Packed
 func (ptr *QTextToSpeech) ConnectSay(f func(text string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "say", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "say"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "say", func(text string) {
+				signal.(func(string))(text)
+				f(text)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "say", f)
+		}
 	}
 }
 
@@ -312,7 +366,14 @@ func callbackQTextToSpeech_SetLocale(ptr unsafe.Pointer, locale unsafe.Pointer)
 func (ptr *QTextToSpeech) ConnectSetLocale(f func(locale *core.QLocale)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLocale", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setLocale"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLocale", func(locale *core.QLocale) {
+				signal.(func(*core.QLocale))(locale)
+				f(locale)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setLocale", f)
+		}
 	}
 }
 
@@ -347,7 +408,14 @@ func callbackQTextToSpeech_SetPitch(ptr unsafe.Pointer, pitch C.double) {
 func (ptr *QTextToSpeech) ConnectSetPitch(f func(pitch float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPitch", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPitch"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPitch", func(pitch float64) {
+				signal.(func(float64))(pitch)
+				f(pitch)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPitch", f)
+		}
 	}
 }
 
@@ -382,7 +450,14 @@ func callbackQTextToSpeech_SetRate(ptr unsafe.Pointer, rate C.double) {
 func (ptr *QTextToSpeech) ConnectSetRate(f func(rate float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRate", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setRate"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRate", func(rate float64) {
+				signal.(func(float64))(rate)
+				f(rate)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setRate", f)
+		}
 	}
 }
 
@@ -417,7 +492,14 @@ func callbackQTextToSpeech_SetVolume(ptr unsafe.Pointer, volume C.double) {
 func (ptr *QTextToSpeech) ConnectSetVolume(f func(volume float64)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume float64) {
+				signal.(func(float64))(volume)
+				f(volume)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
+		}
 	}
 }
 
@@ -450,8 +532,19 @@ func callbackQTextToSpeech_StateChanged(ptr unsafe.Pointer, state C.longlong) {
 
 func (ptr *QTextToSpeech) ConnectStateChanged(f func(state QTextToSpeech__State)) {
 	if ptr.Pointer() != nil {
-		C.QTextToSpeech_ConnectStateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
+			C.QTextToSpeech_ConnectStateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QTextToSpeech__State) {
+				signal.(func(QTextToSpeech__State))(state)
+				f(state)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+		}
 	}
 }
 
@@ -480,7 +573,14 @@ func callbackQTextToSpeech_Stop(ptr unsafe.Pointer) {
 func (ptr *QTextToSpeech) ConnectStop(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
+		}
 	}
 }
 
@@ -513,8 +613,19 @@ func callbackQTextToSpeech_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
 
 func (ptr *QTextToSpeech) ConnectVolumeChanged(f func(volume int)) {
 	if ptr.Pointer() != nil {
-		C.QTextToSpeech_ConnectVolumeChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
+			C.QTextToSpeech_ConnectVolumeChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume int) {
+				signal.(func(int))(volume)
+				f(volume)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
+		}
 	}
 }
 
@@ -654,7 +765,14 @@ func callbackQTextToSpeechPlugin_DestroyQTextToSpeechPlugin(ptr unsafe.Pointer)
 func (ptr *QTextToSpeechPlugin) ConnectDestroyQTextToSpeechPlugin(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QTextToSpeechPlugin", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QTextToSpeechPlugin"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QTextToSpeechPlugin", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QTextToSpeechPlugin", f)
+		}
 	}
 }
 

svg/svg.go

@@ -104,7 +104,14 @@ func callbackQGraphicsSvgItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer,
 func (ptr *QGraphicsSvgItem) ConnectPaint(f func(painter *gui.QPainter, option *widgets.QStyleOptionGraphicsItem, widget *widgets.QWidget)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paint"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", func(painter *gui.QPainter, option *widgets.QStyleOptionGraphicsItem, widget *widgets.QWidget) {
+				signal.(func(*gui.QPainter, *widgets.QStyleOptionGraphicsItem, *widgets.QWidget))(painter, option, widget)
+				f(painter, option, widget)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", f)
+		}
 	}
 }
 
@@ -162,7 +169,14 @@ func callbackQGraphicsSvgItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QGraphicsSvgItem) ConnectBoundingRect(f func() *core.QRectF) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "boundingRect"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect", func() *core.QRectF {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect", f)
+		}
 	}
 }
 
@@ -1245,7 +1259,14 @@ func callbackQSvgGenerator_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
 func (ptr *QSvgGenerator) ConnectPaintEngine(f func() *gui.QPaintEngine) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paintEngine"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", func() *gui.QPaintEngine {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEngine", f)
+		}
 	}
 }
 
@@ -1412,7 +1433,14 @@ func callbackQSvgRenderer_Load3(ptr unsafe.Pointer, contents unsafe.Pointer) C.c
 func (ptr *QSvgRenderer) ConnectLoad3(f func(contents *core.QXmlStreamReader) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load3", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load3"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load3", func(contents *core.QXmlStreamReader) bool {
+				signal.(func(*core.QXmlStreamReader))(contents)
+				return f(contents)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load3", f)
+		}
 	}
 }
 
@@ -1449,7 +1477,14 @@ func callbackQSvgRenderer_Load2(ptr unsafe.Pointer, contents unsafe.Pointer) C.c
 func (ptr *QSvgRenderer) ConnectLoad2(f func(contents *core.QByteArray) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", func(contents *core.QByteArray) bool {
+				signal.(func(*core.QByteArray))(contents)
+				return f(contents)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		}
 	}
 }
 
@@ -1486,7 +1521,14 @@ func callbackQSvgRenderer_Load(ptr unsafe.Pointer, filename C.struct_QtSvg_Packe
 func (ptr *QSvgRenderer) ConnectLoad(f func(filename string) bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", func(filename string) bool {
+				signal.(func(string))(filename)
+				return f(filename)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		}
 	}
 }
 
@@ -1533,7 +1575,14 @@ func callbackQSvgRenderer_Render(ptr unsafe.Pointer, painter unsafe.Pointer) {
 func (ptr *QSvgRenderer) ConnectRender(f func(painter *gui.QPainter)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "render"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render", func(painter *gui.QPainter) {
+				signal.(func(*gui.QPainter))(painter)
+				f(painter)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render", f)
+		}
 	}
 }
 
@@ -1568,7 +1617,14 @@ func callbackQSvgRenderer_Render2(ptr unsafe.Pointer, painter unsafe.Pointer, bo
 func (ptr *QSvgRenderer) ConnectRender2(f func(painter *gui.QPainter, bounds *core.QRectF)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "render2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render2", func(painter *gui.QPainter, bounds *core.QRectF) {
+				signal.(func(*gui.QPainter, *core.QRectF))(painter, bounds)
+				f(painter, bounds)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render2", f)
+		}
 	}
 }
 
@@ -1603,7 +1659,14 @@ func callbackQSvgRenderer_Render3(ptr unsafe.Pointer, painter unsafe.Pointer, el
 func (ptr *QSvgRenderer) ConnectRender3(f func(painter *gui.QPainter, elementId string, bounds *core.QRectF)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render3", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "render3"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render3", func(painter *gui.QPainter, elementId string, bounds *core.QRectF) {
+				signal.(func(*gui.QPainter, string, *core.QRectF))(painter, elementId, bounds)
+				f(painter, elementId, bounds)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "render3", f)
+		}
 	}
 }
 
@@ -1646,8 +1709,19 @@ func callbackQSvgRenderer_RepaintNeeded(ptr unsafe.Pointer) {
 
 func (ptr *QSvgRenderer) ConnectRepaintNeeded(f func()) {
 	if ptr.Pointer() != nil {
-		C.QSvgRenderer_ConnectRepaintNeeded(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "repaintNeeded", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "repaintNeeded") {
+			C.QSvgRenderer_ConnectRepaintNeeded(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "repaintNeeded"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "repaintNeeded", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "repaintNeeded", f)
+		}
 	}
 }
 
@@ -2094,7 +2168,14 @@ func callbackQSvgWidget_Load2(ptr unsafe.Pointer, contents unsafe.Pointer) {
 func (ptr *QSvgWidget) ConnectLoad2(f func(contents *core.QByteArray)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", func(contents *core.QByteArray) {
+				signal.(func(*core.QByteArray))(contents)
+				f(contents)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load2", f)
+		}
 	}
 }
 
@@ -2129,7 +2210,14 @@ func callbackQSvgWidget_Load(ptr unsafe.Pointer, file C.struct_QtSvg_PackedStrin
 func (ptr *QSvgWidget) ConnectLoad(f func(file string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", func(file string) {
+				signal.(func(string))(file)
+				f(file)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
+		}
 	}
 }
 

uitools/uitools.go

@@ -75,7 +75,14 @@ func callbackQUiLoader_CreateAction(ptr unsafe.Pointer, parent unsafe.Pointer, n
 func (ptr *QUiLoader) ConnectCreateAction(f func(parent *core.QObject, name string) *widgets.QAction) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createAction", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createAction"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createAction", func(parent *core.QObject, name string) *widgets.QAction {
+				signal.(func(*core.QObject, string))(parent, name)
+				return f(parent, name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createAction", f)
+		}
 	}
 }
 
@@ -130,7 +137,14 @@ func callbackQUiLoader_CreateActionGroup(ptr unsafe.Pointer, parent unsafe.Point
 func (ptr *QUiLoader) ConnectCreateActionGroup(f func(parent *core.QObject, name string) *widgets.QActionGroup) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createActionGroup", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createActionGroup"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createActionGroup", func(parent *core.QObject, name string) *widgets.QActionGroup {
+				signal.(func(*core.QObject, string))(parent, name)
+				return f(parent, name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createActionGroup", f)
+		}
 	}
 }
 
@@ -185,7 +199,14 @@ func callbackQUiLoader_CreateLayout(ptr unsafe.Pointer, className C.struct_QtUiT
 func (ptr *QUiLoader) ConnectCreateLayout(f func(className string, parent *core.QObject, name string) *widgets.QLayout) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createLayout", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createLayout"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createLayout", func(className string, parent *core.QObject, name string) *widgets.QLayout {
+				signal.(func(string, *core.QObject, string))(className, parent, name)
+				return f(className, parent, name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createLayout", f)
+		}
 	}
 }
 
@@ -258,7 +279,14 @@ func callbackQUiLoader_CreateWidget(ptr unsafe.Pointer, className C.struct_QtUiT
 func (ptr *QUiLoader) ConnectCreateWidget(f func(className string, parent *widgets.QWidget, name string) *widgets.QWidget) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createWidget", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createWidget"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createWidget", func(className string, parent *widgets.QWidget, name string) *widgets.QWidget {
+				signal.(func(string, *widgets.QWidget, string))(className, parent, name)
+				return f(className, parent, name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createWidget", f)
+		}
 	}
 }
 
@@ -363,7 +391,14 @@ func callbackQUiLoader_DestroyQUiLoader(ptr unsafe.Pointer) {
 func (ptr *QUiLoader) ConnectDestroyQUiLoader(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QUiLoader", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QUiLoader"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QUiLoader", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QUiLoader", f)
+		}
 	}
 }
 

webchannel/webchannel.go

@@ -78,8 +78,19 @@ func callbackQWebChannel_BlockUpdatesChanged(ptr unsafe.Pointer, block C.char) {
 
 func (ptr *QWebChannel) ConnectBlockUpdatesChanged(f func(block bool)) {
 	if ptr.Pointer() != nil {
-		C.QWebChannel_ConnectBlockUpdatesChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "blockUpdatesChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "blockUpdatesChanged") {
+			C.QWebChannel_ConnectBlockUpdatesChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "blockUpdatesChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "blockUpdatesChanged", func(block bool) {
+				signal.(func(bool))(block)
+				f(block)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "blockUpdatesChanged", f)
+		}
 	}
 }
 
@@ -108,7 +119,14 @@ func callbackQWebChannel_ConnectTo(ptr unsafe.Pointer, transport unsafe.Pointer)
 func (ptr *QWebChannel) ConnectConnectTo(f func(transport *QWebChannelAbstractTransport)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectTo", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "connectTo"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectTo", func(transport *QWebChannelAbstractTransport) {
+				signal.(func(*QWebChannelAbstractTransport))(transport)
+				f(transport)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connectTo", f)
+		}
 	}
 }
 
@@ -149,7 +167,14 @@ func callbackQWebChannel_DisconnectFrom(ptr unsafe.Pointer, transport unsafe.Poi
 func (ptr *QWebChannel) ConnectDisconnectFrom(f func(transport *QWebChannelAbstractTransport)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnectFrom", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "disconnectFrom"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnectFrom", func(transport *QWebChannelAbstractTransport) {
+				signal.(func(*QWebChannelAbstractTransport))(transport)
+				f(transport)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnectFrom", f)
+		}
 	}
 }
 
@@ -676,8 +701,19 @@ func callbackQWebChannelAbstractTransport_MessageReceived(ptr unsafe.Pointer, me
 
 func (ptr *QWebChannelAbstractTransport) ConnectMessageReceived(f func(message *core.QJsonObject, transport *QWebChannelAbstractTransport)) {
 	if ptr.Pointer() != nil {
-		C.QWebChannelAbstractTransport_ConnectMessageReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "messageReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "messageReceived") {
+			C.QWebChannelAbstractTransport_ConnectMessageReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "messageReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "messageReceived", func(message *core.QJsonObject, transport *QWebChannelAbstractTransport) {
+				signal.(func(*core.QJsonObject, *QWebChannelAbstractTransport))(message, transport)
+				f(message, transport)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "messageReceived", f)
+		}
 	}
 }
 
@@ -705,7 +741,14 @@ func callbackQWebChannelAbstractTransport_SendMessage(ptr unsafe.Pointer, messag
 func (ptr *QWebChannelAbstractTransport) ConnectSendMessage(f func(message *core.QJsonObject)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sendMessage", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sendMessage"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sendMessage", func(message *core.QJsonObject) {
+				signal.(func(*core.QJsonObject))(message)
+				f(message)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sendMessage", f)
+		}
 	}
 }
 
@@ -734,7 +777,14 @@ func callbackQWebChannelAbstractTransport_DestroyQWebChannelAbstractTransport(pt
 func (ptr *QWebChannelAbstractTransport) ConnectDestroyQWebChannelAbstractTransport(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebChannelAbstractTransport", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QWebChannelAbstractTransport"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebChannelAbstractTransport", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebChannelAbstractTransport", f)
+		}
 	}
 }
 

websockets/websockets.go

@@ -81,7 +81,14 @@ func callbackQMaskGenerator_Seed(ptr unsafe.Pointer) C.char {
 func (ptr *QMaskGenerator) ConnectSeed(f func() bool) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seed", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "seed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seed", func() bool {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seed", f)
+		}
 	}
 }
 
@@ -111,7 +118,14 @@ func callbackQMaskGenerator_NextMask(ptr unsafe.Pointer) C.uint {
 func (ptr *QMaskGenerator) ConnectNextMask(f func() uint) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMask", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nextMask"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMask", func() uint {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMask", f)
+		}
 	}
 }
 
@@ -141,7 +155,14 @@ func callbackQMaskGenerator_DestroyQMaskGenerator(ptr unsafe.Pointer) {
 func (ptr *QMaskGenerator) ConnectDestroyQMaskGenerator(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMaskGenerator", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMaskGenerator"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMaskGenerator", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMaskGenerator", f)
+		}
 	}
 }
 
@@ -520,8 +541,19 @@ func callbackQWebSocket_AboutToClose(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocket) ConnectAboutToClose(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectAboutToClose(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aboutToClose", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "aboutToClose") {
+			C.QWebSocket_ConnectAboutToClose(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "aboutToClose"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aboutToClose", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aboutToClose", f)
+		}
 	}
 }
 
@@ -548,8 +580,19 @@ func callbackQWebSocket_BinaryFrameReceived(ptr unsafe.Pointer, frame unsafe.Poi
 
 func (ptr *QWebSocket) ConnectBinaryFrameReceived(f func(frame *core.QByteArray, isLastFrame bool)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectBinaryFrameReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryFrameReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "binaryFrameReceived") {
+			C.QWebSocket_ConnectBinaryFrameReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "binaryFrameReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryFrameReceived", func(frame *core.QByteArray, isLastFrame bool) {
+				signal.(func(*core.QByteArray, bool))(frame, isLastFrame)
+				f(frame, isLastFrame)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryFrameReceived", f)
+		}
 	}
 }
 
@@ -576,8 +619,19 @@ func callbackQWebSocket_BinaryMessageReceived(ptr unsafe.Pointer, message unsafe
 
 func (ptr *QWebSocket) ConnectBinaryMessageReceived(f func(message *core.QByteArray)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectBinaryMessageReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryMessageReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "binaryMessageReceived") {
+			C.QWebSocket_ConnectBinaryMessageReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "binaryMessageReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryMessageReceived", func(message *core.QByteArray) {
+				signal.(func(*core.QByteArray))(message)
+				f(message)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "binaryMessageReceived", f)
+		}
 	}
 }
 
@@ -604,8 +658,19 @@ func callbackQWebSocket_BytesWritten(ptr unsafe.Pointer, bytes C.longlong) {
 
 func (ptr *QWebSocket) ConnectBytesWritten(f func(bytes int64)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectBytesWritten(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bytesWritten", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bytesWritten") {
+			C.QWebSocket_ConnectBytesWritten(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bytesWritten"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bytesWritten", func(bytes int64) {
+				signal.(func(int64))(bytes)
+				f(bytes)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bytesWritten", f)
+		}
 	}
 }
 
@@ -634,7 +699,14 @@ func callbackQWebSocket_Close(ptr unsafe.Pointer, closeCode C.longlong, reason C
 func (ptr *QWebSocket) ConnectClose(f func(closeCode QWebSocketProtocol__CloseCode, reason string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "close"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", func(closeCode QWebSocketProtocol__CloseCode, reason string) {
+				signal.(func(QWebSocketProtocol__CloseCode, string))(closeCode, reason)
+				f(closeCode, reason)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "close", f)
+		}
 	}
 }
 
@@ -677,8 +749,19 @@ func callbackQWebSocket_Connected(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocket) ConnectConnected(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectConnected(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connected", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "connected") {
+			C.QWebSocket_ConnectConnected(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "connected"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connected", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "connected", f)
+		}
 	}
 }
 
@@ -705,8 +788,19 @@ func callbackQWebSocket_Disconnected(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocket) ConnectDisconnected(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectDisconnected(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "disconnected") {
+			C.QWebSocket_ConnectDisconnected(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "disconnected"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "disconnected", f)
+		}
 	}
 }
 
@@ -733,8 +827,19 @@ func callbackQWebSocket_Error2(ptr unsafe.Pointer, error C.longlong) {
 
 func (ptr *QWebSocket) ConnectError2(f func(error network.QAbstractSocket__SocketError)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectError2(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
+			C.QWebSocket_ConnectError2(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error network.QAbstractSocket__SocketError) {
+				signal.(func(network.QAbstractSocket__SocketError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
+		}
 	}
 }
 
@@ -763,7 +868,14 @@ func callbackQWebSocket_IgnoreSslErrors(ptr unsafe.Pointer) {
 func (ptr *QWebSocket) ConnectIgnoreSslErrors(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ignoreSslErrors", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ignoreSslErrors"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ignoreSslErrors", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ignoreSslErrors", f)
+		}
 	}
 }
 
@@ -810,7 +922,14 @@ func callbackQWebSocket_Open2(ptr unsafe.Pointer, request unsafe.Pointer) {
 func (ptr *QWebSocket) ConnectOpen2(f func(request *network.QNetworkRequest)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open2", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "open2"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open2", func(request *network.QNetworkRequest) {
+				signal.(func(*network.QNetworkRequest))(request)
+				f(request)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open2", f)
+		}
 	}
 }
 
@@ -845,7 +964,14 @@ func callbackQWebSocket_Open(ptr unsafe.Pointer, url unsafe.Pointer) {
 func (ptr *QWebSocket) ConnectOpen(f func(url *core.QUrl)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "open"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", func(url *core.QUrl) {
+				signal.(func(*core.QUrl))(url)
+				f(url)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "open", f)
+		}
 	}
 }
 
@@ -880,7 +1006,14 @@ func callbackQWebSocket_Ping(ptr unsafe.Pointer, payload unsafe.Pointer) {
 func (ptr *QWebSocket) ConnectPing(f func(payload *core.QByteArray)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ping", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "ping"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ping", func(payload *core.QByteArray) {
+				signal.(func(*core.QByteArray))(payload)
+				f(payload)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "ping", f)
+		}
 	}
 }
 
@@ -913,8 +1046,19 @@ func callbackQWebSocket_Pong(ptr unsafe.Pointer, elapsedTime C.ulonglong, payloa
 
 func (ptr *QWebSocket) ConnectPong(f func(elapsedTime uint64, payload *core.QByteArray)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectPong(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pong", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "pong") {
+			C.QWebSocket_ConnectPong(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pong"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pong", func(elapsedTime uint64, payload *core.QByteArray) {
+				signal.(func(uint64, *core.QByteArray))(elapsedTime, payload)
+				f(elapsedTime, payload)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pong", f)
+		}
 	}
 }
 
@@ -941,8 +1085,19 @@ func callbackQWebSocket_PreSharedKeyAuthenticationRequired(ptr unsafe.Pointer, a
 
 func (ptr *QWebSocket) ConnectPreSharedKeyAuthenticationRequired(f func(authenticator *network.QSslPreSharedKeyAuthenticator)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectPreSharedKeyAuthenticationRequired(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired") {
+			C.QWebSocket_ConnectPreSharedKeyAuthenticationRequired(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", func(authenticator *network.QSslPreSharedKeyAuthenticator) {
+				signal.(func(*network.QSslPreSharedKeyAuthenticator))(authenticator)
+				f(authenticator)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", f)
+		}
 	}
 }
 
@@ -969,8 +1124,19 @@ func callbackQWebSocket_ProxyAuthenticationRequired(ptr unsafe.Pointer, proxy un
 
 func (ptr *QWebSocket) ConnectProxyAuthenticationRequired(f func(proxy *network.QNetworkProxy, authenticator *network.QAuthenticator)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectProxyAuthenticationRequired(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "proxyAuthenticationRequired", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "proxyAuthenticationRequired") {
+			C.QWebSocket_ConnectProxyAuthenticationRequired(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "proxyAuthenticationRequired"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "proxyAuthenticationRequired", func(proxy *network.QNetworkProxy, authenticator *network.QAuthenticator) {
+				signal.(func(*network.QNetworkProxy, *network.QAuthenticator))(proxy, authenticator)
+				f(proxy, authenticator)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "proxyAuthenticationRequired", f)
+		}
 	}
 }
 
@@ -997,8 +1163,19 @@ func callbackQWebSocket_ReadChannelFinished(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocket) ConnectReadChannelFinished(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectReadChannelFinished(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readChannelFinished", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "readChannelFinished") {
+			C.QWebSocket_ConnectReadChannelFinished(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readChannelFinished"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readChannelFinished", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readChannelFinished", f)
+		}
 	}
 }
 
@@ -1067,8 +1244,19 @@ func callbackQWebSocket_SslErrors(ptr unsafe.Pointer, errors C.struct_QtWebSocke
 
 func (ptr *QWebSocket) ConnectSslErrors(f func(errors []*network.QSslError)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectSslErrors(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sslErrors") {
+			C.QWebSocket_ConnectSslErrors(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sslErrors"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", func(errors []*network.QSslError) {
+				signal.(func([]*network.QSslError))(errors)
+				f(errors)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", f)
+		}
 	}
 }
 
@@ -1101,8 +1289,19 @@ func callbackQWebSocket_StateChanged(ptr unsafe.Pointer, state C.longlong) {
 
 func (ptr *QWebSocket) ConnectStateChanged(f func(state network.QAbstractSocket__SocketState)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectStateChanged(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
+			C.QWebSocket_ConnectStateChanged(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state network.QAbstractSocket__SocketState) {
+				signal.(func(network.QAbstractSocket__SocketState))(state)
+				f(state)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
+		}
 	}
 }
 
@@ -1129,8 +1328,19 @@ func callbackQWebSocket_TextFrameReceived(ptr unsafe.Pointer, frame C.struct_QtW
 
 func (ptr *QWebSocket) ConnectTextFrameReceived(f func(frame string, isLastFrame bool)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectTextFrameReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textFrameReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "textFrameReceived") {
+			C.QWebSocket_ConnectTextFrameReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textFrameReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textFrameReceived", func(frame string, isLastFrame bool) {
+				signal.(func(string, bool))(frame, isLastFrame)
+				f(frame, isLastFrame)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textFrameReceived", f)
+		}
 	}
 }
 
@@ -1162,8 +1372,19 @@ func callbackQWebSocket_TextMessageReceived(ptr unsafe.Pointer, message C.struct
 
 func (ptr *QWebSocket) ConnectTextMessageReceived(f func(message string)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocket_ConnectTextMessageReceived(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textMessageReceived", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "textMessageReceived") {
+			C.QWebSocket_ConnectTextMessageReceived(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "textMessageReceived"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textMessageReceived", func(message string) {
+				signal.(func(string))(message)
+				f(message)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "textMessageReceived", f)
+		}
 	}
 }
 
@@ -1197,7 +1418,14 @@ func callbackQWebSocket_DestroyQWebSocket(ptr unsafe.Pointer) {
 func (ptr *QWebSocket) ConnectDestroyQWebSocket(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocket", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocket"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocket", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocket", f)
+		}
 	}
 }
 
@@ -1918,7 +2146,14 @@ func callbackQWebSocketServer_NextPendingConnection(ptr unsafe.Pointer) unsafe.P
 func (ptr *QWebSocketServer) ConnectNextPendingConnection(f func() *QWebSocket) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextPendingConnection", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nextPendingConnection"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextPendingConnection", func() *QWebSocket {
+				signal.(func())()
+				return f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextPendingConnection", f)
+		}
 	}
 }
 
@@ -1988,8 +2223,19 @@ func callbackQWebSocketServer_AcceptError(ptr unsafe.Pointer, socketError C.long
 
 func (ptr *QWebSocketServer) ConnectAcceptError(f func(socketError network.QAbstractSocket__SocketError)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectAcceptError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "acceptError", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "acceptError") {
+			C.QWebSocketServer_ConnectAcceptError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "acceptError"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "acceptError", func(socketError network.QAbstractSocket__SocketError) {
+				signal.(func(network.QAbstractSocket__SocketError))(socketError)
+				f(socketError)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "acceptError", f)
+		}
 	}
 }
 
@@ -2022,8 +2268,19 @@ func callbackQWebSocketServer_Closed(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocketServer) ConnectClosed(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectClosed(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "closed", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "closed") {
+			C.QWebSocketServer_ConnectClosed(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "closed"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "closed", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "closed", f)
+		}
 	}
 }
 
@@ -2050,8 +2307,19 @@ func callbackQWebSocketServer_NewConnection(ptr unsafe.Pointer) {
 
 func (ptr *QWebSocketServer) ConnectNewConnection(f func()) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectNewConnection(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "newConnection") {
+			C.QWebSocketServer_ConnectNewConnection(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "newConnection"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "newConnection", f)
+		}
 	}
 }
 
@@ -2078,8 +2346,19 @@ func callbackQWebSocketServer_OriginAuthenticationRequired(ptr unsafe.Pointer, a
 
 func (ptr *QWebSocketServer) ConnectOriginAuthenticationRequired(f func(authenticator *QWebSocketCorsAuthenticator)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectOriginAuthenticationRequired(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "originAuthenticationRequired", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "originAuthenticationRequired") {
+			C.QWebSocketServer_ConnectOriginAuthenticationRequired(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "originAuthenticationRequired"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "originAuthenticationRequired", func(authenticator *QWebSocketCorsAuthenticator) {
+				signal.(func(*QWebSocketCorsAuthenticator))(authenticator)
+				f(authenticator)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "originAuthenticationRequired", f)
+		}
 	}
 }
 
@@ -2112,8 +2391,19 @@ func callbackQWebSocketServer_PeerVerifyError(ptr unsafe.Pointer, error unsafe.P
 
 func (ptr *QWebSocketServer) ConnectPeerVerifyError(f func(error *network.QSslError)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectPeerVerifyError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "peerVerifyError", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "peerVerifyError") {
+			C.QWebSocketServer_ConnectPeerVerifyError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "peerVerifyError"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "peerVerifyError", func(error *network.QSslError) {
+				signal.(func(*network.QSslError))(error)
+				f(error)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "peerVerifyError", f)
+		}
 	}
 }
 
@@ -2140,8 +2430,19 @@ func callbackQWebSocketServer_PreSharedKeyAuthenticationRequired(ptr unsafe.Poin
 
 func (ptr *QWebSocketServer) ConnectPreSharedKeyAuthenticationRequired(f func(authenticator *network.QSslPreSharedKeyAuthenticator)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectPreSharedKeyAuthenticationRequired(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired") {
+			C.QWebSocketServer_ConnectPreSharedKeyAuthenticationRequired(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", func(authenticator *network.QSslPreSharedKeyAuthenticator) {
+				signal.(func(*network.QSslPreSharedKeyAuthenticator))(authenticator)
+				f(authenticator)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "preSharedKeyAuthenticationRequired", f)
+		}
 	}
 }
 
@@ -2174,8 +2475,19 @@ func callbackQWebSocketServer_ServerError(ptr unsafe.Pointer, closeCode C.longlo
 
 func (ptr *QWebSocketServer) ConnectServerError(f func(closeCode QWebSocketProtocol__CloseCode)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectServerError(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serverError", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "serverError") {
+			C.QWebSocketServer_ConnectServerError(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "serverError"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serverError", func(closeCode QWebSocketProtocol__CloseCode) {
+				signal.(func(QWebSocketProtocol__CloseCode))(closeCode)
+				f(closeCode)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "serverError", f)
+		}
 	}
 }
 
@@ -2237,8 +2549,19 @@ func callbackQWebSocketServer_SslErrors(ptr unsafe.Pointer, errors C.struct_QtWe
 
 func (ptr *QWebSocketServer) ConnectSslErrors(f func(errors []*network.QSslError)) {
 	if ptr.Pointer() != nil {
-		C.QWebSocketServer_ConnectSslErrors(ptr.Pointer())
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", f)
+
+		if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sslErrors") {
+			C.QWebSocketServer_ConnectSslErrors(ptr.Pointer())
+		}
+
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sslErrors"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", func(errors []*network.QSslError) {
+				signal.(func([]*network.QSslError))(errors)
+				f(errors)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sslErrors", f)
+		}
 	}
 }
 
@@ -2273,7 +2596,14 @@ func callbackQWebSocketServer_DestroyQWebSocketServer(ptr unsafe.Pointer) {
 func (ptr *QWebSocketServer) ConnectDestroyQWebSocketServer(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocketServer", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocketServer"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocketServer", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QWebSocketServer", f)
+		}
 	}
 }
 

widgets/widgets.cpp

@@ -10653,9 +10653,9 @@ void QDialog_SetSizeGripEnabled(void* ptr, char vbo)
 	static_cast<QDialog*>(ptr)->setSizeGripEnabled(vbo != 0);
 }
 
-void* QDialog_NewQDialog(void* parent, long long f)
+void* QDialog_NewQDialog(void* parent, long long fo)
 {
-	return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 int QDialog_Exec(void* ptr)
@@ -13496,7 +13496,7 @@ class MyQFontComboBox: public QFontComboBox
 public:
 	MyQFontComboBox(QWidget *parent) : QFontComboBox(parent) {};
 	void Signal_CurrentFontChanged(const QFont & font) { callbackQFontComboBox_CurrentFontChanged(this, const_cast<QFont*>(&font)); };
-	void setCurrentFont(const QFont & f) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&f)); };
+	void setCurrentFont(const QFont & fo) { callbackQFontComboBox_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
 	QSize sizeHint() const { return *static_cast<QSize*>(callbackQWidget_SizeHint(const_cast<void*>(static_cast<const void*>(this)))); };
 	void Signal_Activated2(const QString & text) { QByteArray t372ea0 = text.toUtf8(); QtWidgets_PackedString textPacked = { const_cast<char*>(t372ea0.prepend("WHITESPACE").constData()+10), t372ea0.size()-10 };callbackQComboBox_Activated2(this, textPacked); };
 	void Signal_Activated(int index) { callbackQComboBox_Activated(this, index); };
@@ -13598,14 +13598,14 @@ void QFontComboBox_CurrentFontChanged(void* ptr, void* font)
 	static_cast<QFontComboBox*>(ptr)->currentFontChanged(*static_cast<QFont*>(font));
 }
 
-void QFontComboBox_SetCurrentFont(void* ptr, void* f)
+void QFontComboBox_SetCurrentFont(void* ptr, void* fo)
 {
-	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(f)));
+	QMetaObject::invokeMethod(static_cast<QFontComboBox*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(fo)));
 }
 
-void QFontComboBox_SetCurrentFontDefault(void* ptr, void* f)
+void QFontComboBox_SetCurrentFontDefault(void* ptr, void* fo)
 {
-		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentFont(*static_cast<QFont*>(f));
+		static_cast<QFontComboBox*>(ptr)->QFontComboBox::setCurrentFont(*static_cast<QFont*>(fo));
 }
 
 void QFontComboBox_SetFontFilters(void* ptr, long long filters)
@@ -14177,9 +14177,9 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 };
 
-void* QFrame_NewQFrame(void* parent, long long f)
+void* QFrame_NewQFrame(void* parent, long long fo)
 {
-	return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQFrame(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 void QFrame_SetFrameRect(void* ptr, void* vqr)
@@ -29838,14 +29838,14 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 };
 
-void* QLabel_NewQLabel(void* parent, long long f)
+void* QLabel_NewQLabel(void* parent, long long fo)
 {
-	return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQLabel(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
-void* QLabel_NewQLabel2(char* text, void* parent, long long f)
+void* QLabel_NewQLabel2(char* text, void* parent, long long fo)
 {
-	return new MyQLabel(QString(text), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQLabel(QString(text), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 void QLabel_Clear(void* ptr)
@@ -35083,9 +35083,9 @@ int QMessageBox_ButtonMask_Type()
 	return QMessageBox::ButtonMask;
 }
 
-void* QMessageBox_NewQMessageBox2(long long icon, char* title, char* text, long long buttons, void* parent, long long f)
+void* QMessageBox_NewQMessageBox2(long long icon, char* title, char* text, long long buttons, void* parent, long long fo)
 {
-	return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQMessageBox(static_cast<QMessageBox::Icon>(icon), QString(title), QString(text), static_cast<QMessageBox::StandardButton>(buttons), static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 void* QMessageBox_NewQMessageBox(void* parent)
@@ -37202,14 +37202,14 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 };
 
-void* QProgressDialog_NewQProgressDialog(void* parent, long long f)
+void* QProgressDialog_NewQProgressDialog(void* parent, long long fo)
 {
-	return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQProgressDialog(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
-void* QProgressDialog_NewQProgressDialog2(char* labelText, char* cancelButtonText, int minimum, int maximum, void* parent, long long f)
+void* QProgressDialog_NewQProgressDialog2(char* labelText, char* cancelButtonText, int minimum, int maximum, void* parent, long long fo)
 {
-	return new MyQProgressDialog(QString(labelText), QString(cancelButtonText), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQProgressDialog(QString(labelText), QString(cancelButtonText), minimum, maximum, static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 void QProgressDialog_Cancel(void* ptr)
@@ -39698,14 +39698,14 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 };
 
-void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long f)
+void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long fo)
 {
-	return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(f));
+	return new MyQSplashScreen(static_cast<QWidget*>(parent), *static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(fo));
 }
 
-void* QSplashScreen_NewQSplashScreen(void* pixmap, long long f)
+void* QSplashScreen_NewQSplashScreen(void* pixmap, long long fo)
 {
-	return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(f));
+	return new MyQSplashScreen(*static_cast<QPixmap*>(pixmap), static_cast<Qt::WindowType>(fo));
 }
 
 void QSplashScreen_ClearMessage(void* ptr)
@@ -48662,7 +48662,7 @@ public:
 	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
 	void copy() { callbackQTextEdit_Copy(this); };
 	void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
-	void Signal_CurrentCharFormatChanged(const QTextCharFormat & f) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&f)); };
+	void Signal_CurrentCharFormatChanged(const QTextCharFormat & fo) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&fo)); };
 	void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
 	void cut() { callbackQTextEdit_Cut(this); };
 	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
@@ -48685,7 +48685,7 @@ public:
 	void selectAll() { callbackQTextEdit_SelectAll(this); };
 	void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
 	void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
-	void setCurrentFont(const QFont & f) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&f)); };
+	void setCurrentFont(const QFont & fo) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
 	void setFontFamily(const QString & fontFamily) { QByteArray t5db177 = fontFamily.toUtf8(); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177.prepend("WHITESPACE").constData()+10), t5db177.size()-10 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
 	void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
 	void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
@@ -49021,7 +49021,7 @@ public:
 	void contextMenuEvent(QContextMenuEvent * event) { callbackQWidget_ContextMenuEvent(this, event); };
 	void copy() { callbackQTextEdit_Copy(this); };
 	void Signal_CopyAvailable(bool yes) { callbackQTextEdit_CopyAvailable(this, yes); };
-	void Signal_CurrentCharFormatChanged(const QTextCharFormat & f) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&f)); };
+	void Signal_CurrentCharFormatChanged(const QTextCharFormat & fo) { callbackQTextEdit_CurrentCharFormatChanged(this, const_cast<QTextCharFormat*>(&fo)); };
 	void Signal_CursorPositionChanged() { callbackQTextEdit_CursorPositionChanged(this); };
 	void cut() { callbackQTextEdit_Cut(this); };
 	void dragEnterEvent(QDragEnterEvent * e) { callbackQWidget_DragEnterEvent(this, e); };
@@ -49050,7 +49050,7 @@ public:
 	void selectAll() { callbackQTextEdit_SelectAll(this); };
 	void Signal_SelectionChanged() { callbackQTextEdit_SelectionChanged(this); };
 	void setAlignment(Qt::Alignment a) { callbackQTextEdit_SetAlignment(this, a); };
-	void setCurrentFont(const QFont & f) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&f)); };
+	void setCurrentFont(const QFont & fo) { callbackQTextEdit_SetCurrentFont(this, const_cast<QFont*>(&fo)); };
 	void setFontFamily(const QString & fontFamily) { QByteArray t5db177 = fontFamily.toUtf8(); QtWidgets_PackedString fontFamilyPacked = { const_cast<char*>(t5db177.prepend("WHITESPACE").constData()+10), t5db177.size()-10 };callbackQTextEdit_SetFontFamily(this, fontFamilyPacked); };
 	void setFontItalic(bool italic) { callbackQTextEdit_SetFontItalic(this, italic); };
 	void setFontPointSize(qreal s) { callbackQTextEdit_SetFontPointSize(this, s); };
@@ -49236,9 +49236,9 @@ void QTextEdit_DisconnectCurrentCharFormatChanged(void* ptr)
 	QObject::disconnect(static_cast<QTextEdit*>(ptr), static_cast<void (QTextEdit::*)(const QTextCharFormat &)>(&QTextEdit::currentCharFormatChanged), static_cast<MyQTextEdit*>(ptr), static_cast<void (MyQTextEdit::*)(const QTextCharFormat &)>(&MyQTextEdit::Signal_CurrentCharFormatChanged));
 }
 
-void QTextEdit_CurrentCharFormatChanged(void* ptr, void* f)
+void QTextEdit_CurrentCharFormatChanged(void* ptr, void* fo)
 {
-	static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(f));
+	static_cast<QTextEdit*>(ptr)->currentCharFormatChanged(*static_cast<QTextCharFormat*>(fo));
 }
 
 void QTextEdit_ConnectCursorPositionChanged(void* ptr)
@@ -49442,17 +49442,17 @@ void QTextEdit_SetCurrentCharFormat(void* ptr, void* format)
 	static_cast<QTextEdit*>(ptr)->setCurrentCharFormat(*static_cast<QTextCharFormat*>(format));
 }
 
-void QTextEdit_SetCurrentFont(void* ptr, void* f)
+void QTextEdit_SetCurrentFont(void* ptr, void* fo)
 {
-	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(f)));
+	QMetaObject::invokeMethod(static_cast<QTextEdit*>(ptr), "setCurrentFont", Q_ARG(QFont, *static_cast<QFont*>(fo)));
 }
 
-void QTextEdit_SetCurrentFontDefault(void* ptr, void* f)
+void QTextEdit_SetCurrentFontDefault(void* ptr, void* fo)
 {
 	if (dynamic_cast<QTextBrowser*>(static_cast<QObject*>(ptr))) {
-		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(f));
+		static_cast<QTextBrowser*>(ptr)->QTextBrowser::setCurrentFont(*static_cast<QFont*>(fo));
 	} else {
-		static_cast<QTextEdit*>(ptr)->QTextEdit::setCurrentFont(*static_cast<QFont*>(f));
+		static_cast<QTextEdit*>(ptr)->QTextEdit::setCurrentFont(*static_cast<QFont*>(fo));
 	}
 }
 
@@ -50552,9 +50552,9 @@ public:
 	const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWidget_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
 };
 
-void* QToolBox_NewQToolBox(void* parent, long long f)
+void* QToolBox_NewQToolBox(void* parent, long long fo)
 {
-	return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQToolBox(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 int QToolBox_AddItem2(void* ptr, void* w, char* text)
@@ -54322,9 +54322,9 @@ void* QWidget_QWidget_MouseGrabber()
 		return QWidget::mouseGrabber();
 }
 
-void* QWidget_NewQWidget(void* parent, long long f)
+void* QWidget_NewQWidget(void* parent, long long fo)
 {
-	return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+	return new MyQWidget(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 char QWidget_Close(void* ptr)
@@ -60818,9 +60818,9 @@ void QWidget_SetParent(void* ptr, void* parent)
 		static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent));
 }
 
-void QWidget_SetParent2(void* ptr, void* parent, long long f)
+void QWidget_SetParent2(void* ptr, void* parent, long long fo)
 {
-		static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(f));
+		static_cast<QWidget*>(ptr)->setParent(static_cast<QWidget*>(parent), static_cast<Qt::WindowType>(fo));
 }
 
 void QWidget_SetShortcutAutoRepeat(void* ptr, int id, char enable)

widgets/widgets.h

@@ -1363,7 +1363,7 @@ double QDial_NotchTarget(void* ptr);
 void QDial_InitStyleOption(void* ptr, void* option);
 void QDialog_SetModal(void* ptr, char modal);
 void QDialog_SetSizeGripEnabled(void* ptr, char vbo);
-void* QDialog_NewQDialog(void* parent, long long f);
+void* QDialog_NewQDialog(void* parent, long long fo);
 int QDialog_Exec(void* ptr);
 int QDialog_ExecDefault(void* ptr);
 void QDialog_Accept(void* ptr);
@@ -1782,8 +1782,8 @@ void QFocusFrame_InitStyleOption(void* ptr, void* option);
 void QFontComboBox_ConnectCurrentFontChanged(void* ptr);
 void QFontComboBox_DisconnectCurrentFontChanged(void* ptr);
 void QFontComboBox_CurrentFontChanged(void* ptr, void* font);
-void QFontComboBox_SetCurrentFont(void* ptr, void* f);
-void QFontComboBox_SetCurrentFontDefault(void* ptr, void* f);
+void QFontComboBox_SetCurrentFont(void* ptr, void* fo);
+void QFontComboBox_SetCurrentFontDefault(void* ptr, void* fo);
 void QFontComboBox_SetFontFilters(void* ptr, long long filters);
 void* QFontComboBox_NewQFontComboBox(void* parent);
 void QFontComboBox_SetWritingSystem(void* ptr, long long vqf);
@@ -1855,7 +1855,7 @@ int QFormLayout_RowCount(void* ptr);
 int QFormLayout_VerticalSpacing(void* ptr);
 ;
 ;
-void* QFrame_NewQFrame(void* parent, long long f);
+void* QFrame_NewQFrame(void* parent, long long fo);
 void QFrame_SetFrameRect(void* ptr, void* vqr);
 void QFrame_SetFrameShadow(void* ptr, long long vsh);
 void QFrame_SetFrameShape(void* ptr, long long vsh);
@@ -3673,8 +3673,8 @@ char QLCDNumber_SmallDecimalPoint(void* ptr);
 double QLCDNumber_Value(void* ptr);
 int QLCDNumber_DigitCount(void* ptr);
 int QLCDNumber_IntValue(void* ptr);
-void* QLabel_NewQLabel(void* parent, long long f);
-void* QLabel_NewQLabel2(char* text, void* parent, long long f);
+void* QLabel_NewQLabel(void* parent, long long fo);
+void* QLabel_NewQLabel2(char* text, void* parent, long long fo);
 void QLabel_Clear(void* ptr);
 void QLabel_ClearDefault(void* ptr);
 void QLabel_ConnectLinkActivated(void* ptr);
@@ -4364,7 +4364,7 @@ char QMenuBar_IsDefaultUp(void* ptr);
 char QMenuBar_IsNativeMenuBar(void* ptr);
 void QMenuBar_InitStyleOption(void* ptr, void* option, void* action);
 int QMessageBox_ButtonMask_Type();
-void* QMessageBox_NewQMessageBox2(long long icon, char* title, char* text, long long buttons, void* parent, long long f);
+void* QMessageBox_NewQMessageBox2(long long icon, char* title, char* text, long long buttons, void* parent, long long fo);
 void* QMessageBox_NewQMessageBox(void* parent);
 void* QMessageBox_AddButton3(void* ptr, long long button);
 void* QMessageBox_AddButton2(void* ptr, char* text, long long role);
@@ -4691,8 +4691,8 @@ int QProgressBar_Maximum(void* ptr);
 int QProgressBar_Minimum(void* ptr);
 int QProgressBar_Value(void* ptr);
 void QProgressBar_InitStyleOption(void* ptr, void* option);
-void* QProgressDialog_NewQProgressDialog(void* parent, long long f);
-void* QProgressDialog_NewQProgressDialog2(char* labelText, char* cancelButtonText, int minimum, int maximum, void* parent, long long f);
+void* QProgressDialog_NewQProgressDialog(void* parent, long long fo);
+void* QProgressDialog_NewQProgressDialog2(char* labelText, char* cancelButtonText, int minimum, int maximum, void* parent, long long fo);
 void QProgressDialog_Cancel(void* ptr);
 void QProgressDialog_CancelDefault(void* ptr);
 void QProgressDialog_ConnectCanceled(void* ptr);
@@ -4982,8 +4982,8 @@ int QSpinBox_SingleStep(void* ptr);
 int QSpinBox_Value(void* ptr);
 int QSpinBox_ValueFromText(void* ptr, char* text);
 int QSpinBox_ValueFromTextDefault(void* ptr, char* text);
-void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long f);
-void* QSplashScreen_NewQSplashScreen(void* pixmap, long long f);
+void* QSplashScreen_NewQSplashScreen2(void* parent, void* pixmap, long long fo);
+void* QSplashScreen_NewQSplashScreen(void* pixmap, long long fo);
 void QSplashScreen_ClearMessage(void* ptr);
 void QSplashScreen_ClearMessageDefault(void* ptr);
 void QSplashScreen_DrawContents(void* ptr, void* painter);
@@ -6383,7 +6383,7 @@ void QTextEdit_DisconnectCopyAvailable(void* ptr);
 void QTextEdit_CopyAvailable(void* ptr, char yes);
 void QTextEdit_ConnectCurrentCharFormatChanged(void* ptr);
 void QTextEdit_DisconnectCurrentCharFormatChanged(void* ptr);
-void QTextEdit_CurrentCharFormatChanged(void* ptr, void* f);
+void QTextEdit_CurrentCharFormatChanged(void* ptr, void* fo);
 void QTextEdit_ConnectCursorPositionChanged(void* ptr);
 void QTextEdit_DisconnectCursorPositionChanged(void* ptr);
 void QTextEdit_CursorPositionChanged(void* ptr);
@@ -6417,8 +6417,8 @@ void QTextEdit_SetAlignment(void* ptr, long long a);
 void QTextEdit_SetAlignmentDefault(void* ptr, long long a);
 void QTextEdit_SetAutoFormatting(void* ptr, long long features);
 void QTextEdit_SetCurrentCharFormat(void* ptr, void* format);
-void QTextEdit_SetCurrentFont(void* ptr, void* f);
-void QTextEdit_SetCurrentFontDefault(void* ptr, void* f);
+void QTextEdit_SetCurrentFont(void* ptr, void* fo);
+void QTextEdit_SetCurrentFontDefault(void* ptr, void* fo);
 void QTextEdit_SetCursorWidth(void* ptr, int width);
 void QTextEdit_SetDocument(void* ptr, void* document);
 void QTextEdit_SetDocumentTitle(void* ptr, char* title);
@@ -6570,7 +6570,7 @@ char QToolBar_IsAreaAllowed(void* ptr, long long area);
 char QToolBar_IsFloatable(void* ptr);
 char QToolBar_IsFloating(void* ptr);
 char QToolBar_IsMovable(void* ptr);
-void* QToolBox_NewQToolBox(void* parent, long long f);
+void* QToolBox_NewQToolBox(void* parent, long long fo);
 int QToolBox_AddItem2(void* ptr, void* w, char* text);
 int QToolBox_AddItem(void* ptr, void* widget, void* iconSet, char* text);
 int QToolBox_InsertItem(void* ptr, int index, void* widget, void* icon, char* text);
@@ -7126,7 +7126,7 @@ void* QWidget_QWidget_CreateWindowContainer(void* window, void* parent, long lon
 void* QWidget_QWidget_Find(uintptr_t id);
 void* QWidget_QWidget_KeyboardGrabber();
 void* QWidget_QWidget_MouseGrabber();
-void* QWidget_NewQWidget(void* parent, long long f);
+void* QWidget_NewQWidget(void* parent, long long fo);
 char QWidget_Close(void* ptr);
 char QWidget_CloseDefault(void* ptr);
 char QWidget_Event(void* ptr, void* event);
@@ -7276,7 +7276,7 @@ void QWidget_SetMinimumWidth(void* ptr, int minw);
 void QWidget_SetMouseTracking(void* ptr, char enable);
 void QWidget_SetPalette(void* ptr, void* vqp);
 void QWidget_SetParent(void* ptr, void* parent);
-void QWidget_SetParent2(void* ptr, void* parent, long long f);
+void QWidget_SetParent2(void* ptr, void* parent, long long fo);
 void QWidget_SetShortcutAutoRepeat(void* ptr, int id, char enable);
 void QWidget_SetShortcutEnabled(void* ptr, int id, char enable);
 void QWidget_SetSizeIncrement(void* ptr, void* vqs);

xmlpatterns/xmlpatterns.go

@@ -75,7 +75,14 @@ func callbackQAbstractMessageHandler_DestroyQAbstractMessageHandler(ptr unsafe.P
 func (ptr *QAbstractMessageHandler) ConnectDestroyQAbstractMessageHandler(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractMessageHandler", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractMessageHandler"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractMessageHandler", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractMessageHandler", f)
+		}
 	}
 }
 
@@ -419,7 +426,14 @@ func callbackQAbstractUriResolver_DestroyQAbstractUriResolver(ptr unsafe.Pointer
 func (ptr *QAbstractUriResolver) ConnectDestroyQAbstractUriResolver(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractUriResolver", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractUriResolver"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractUriResolver", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractUriResolver", f)
+		}
 	}
 }
 
@@ -458,7 +472,14 @@ func callbackQAbstractUriResolver_Resolve(ptr unsafe.Pointer, relative unsafe.Po
 func (ptr *QAbstractUriResolver) ConnectResolve(f func(relative *core.QUrl, baseURI *core.QUrl) *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resolve", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "resolve"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resolve", func(relative *core.QUrl, baseURI *core.QUrl) *core.QUrl {
+				signal.(func(*core.QUrl, *core.QUrl))(relative, baseURI)
+				return f(relative, baseURI)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resolve", f)
+		}
 	}
 }
 
@@ -799,7 +820,14 @@ func callbackQAbstractXmlNodeModel_DestroyQAbstractXmlNodeModel(ptr unsafe.Point
 func (ptr *QAbstractXmlNodeModel) ConnectDestroyQAbstractXmlNodeModel(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlNodeModel", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlNodeModel"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlNodeModel", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlNodeModel", f)
+		}
 	}
 }
 
@@ -847,7 +875,14 @@ func callbackQAbstractXmlNodeModel_StringValue(ptr unsafe.Pointer, n unsafe.Poin
 func (ptr *QAbstractXmlNodeModel) ConnectStringValue(f func(n *QXmlNodeModelIndex) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stringValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", func(n *QXmlNodeModelIndex) string {
+				signal.(func(*QXmlNodeModelIndex))(n)
+				return f(n)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", f)
+		}
 	}
 }
 
@@ -877,7 +912,14 @@ func callbackQAbstractXmlNodeModel_BaseUri(ptr unsafe.Pointer, n unsafe.Pointer)
 func (ptr *QAbstractXmlNodeModel) ConnectBaseUri(f func(n *QXmlNodeModelIndex) *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "baseUri"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", func(n *QXmlNodeModelIndex) *core.QUrl {
+				signal.(func(*QXmlNodeModelIndex))(n)
+				return f(n)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", f)
+		}
 	}
 }
 
@@ -909,7 +951,14 @@ func callbackQAbstractXmlNodeModel_DocumentUri(ptr unsafe.Pointer, n unsafe.Poin
 func (ptr *QAbstractXmlNodeModel) ConnectDocumentUri(f func(n *QXmlNodeModelIndex) *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "documentUri", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "documentUri"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "documentUri", func(n *QXmlNodeModelIndex) *core.QUrl {
+				signal.(func(*QXmlNodeModelIndex))(n)
+				return f(n)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "documentUri", f)
+		}
 	}
 }
 
@@ -941,7 +990,14 @@ func callbackQAbstractXmlNodeModel_TypedValue(ptr unsafe.Pointer, node unsafe.Po
 func (ptr *QAbstractXmlNodeModel) ConnectTypedValue(f func(node *QXmlNodeModelIndex) *core.QVariant) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typedValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "typedValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typedValue", func(node *QXmlNodeModelIndex) *core.QVariant {
+				signal.(func(*QXmlNodeModelIndex))(node)
+				return f(node)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "typedValue", f)
+		}
 	}
 }
 
@@ -985,7 +1041,14 @@ func callbackQAbstractXmlNodeModel_NamespaceBindings(ptr unsafe.Pointer, n unsaf
 func (ptr *QAbstractXmlNodeModel) ConnectNamespaceBindings(f func(n *QXmlNodeModelIndex) []*QXmlName) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", func(n *QXmlNodeModelIndex) []*QXmlName {
+				signal.(func(*QXmlNodeModelIndex))(n)
+				return f(n)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", f)
+		}
 	}
 }
 
@@ -1033,7 +1096,14 @@ func callbackQAbstractXmlNodeModel_NodesByIdref(ptr unsafe.Pointer, idref unsafe
 func (ptr *QAbstractXmlNodeModel) ConnectNodesByIdref(f func(idref *QXmlName) []*QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", func(idref *QXmlName) []*QXmlNodeModelIndex {
+				signal.(func(*QXmlName))(idref)
+				return f(idref)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", f)
+		}
 	}
 }
 
@@ -1069,7 +1139,14 @@ func callbackQAbstractXmlNodeModel_Name(ptr unsafe.Pointer, ni unsafe.Pointer) u
 func (ptr *QAbstractXmlNodeModel) ConnectName(f func(ni *QXmlNodeModelIndex) *QXmlName) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "name"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", func(ni *QXmlNodeModelIndex) *QXmlName {
+				signal.(func(*QXmlNodeModelIndex))(ni)
+				return f(ni)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "name", f)
+		}
 	}
 }
 
@@ -1128,7 +1205,14 @@ func callbackQAbstractXmlNodeModel_ElementById(ptr unsafe.Pointer, id unsafe.Poi
 func (ptr *QAbstractXmlNodeModel) ConnectElementById(f func(id *QXmlName) *QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "elementById"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", func(id *QXmlName) *QXmlNodeModelIndex {
+				signal.(func(*QXmlName))(id)
+				return f(id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", f)
+		}
 	}
 }
 
@@ -1160,7 +1244,14 @@ func callbackQAbstractXmlNodeModel_NextFromSimpleAxis(ptr unsafe.Pointer, axis C
 func (ptr *QAbstractXmlNodeModel) ConnectNextFromSimpleAxis(f func(axis QAbstractXmlNodeModel__SimpleAxis, origin *QXmlNodeModelIndex) *QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextFromSimpleAxis", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nextFromSimpleAxis"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextFromSimpleAxis", func(axis QAbstractXmlNodeModel__SimpleAxis, origin *QXmlNodeModelIndex) *QXmlNodeModelIndex {
+				signal.(func(QAbstractXmlNodeModel__SimpleAxis, *QXmlNodeModelIndex))(axis, origin)
+				return f(axis, origin)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextFromSimpleAxis", f)
+		}
 	}
 }
 
@@ -1192,7 +1283,14 @@ func callbackQAbstractXmlNodeModel_Root(ptr unsafe.Pointer, n unsafe.Pointer) un
 func (ptr *QAbstractXmlNodeModel) ConnectRoot(f func(n *QXmlNodeModelIndex) *QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "root", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "root"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "root", func(n *QXmlNodeModelIndex) *QXmlNodeModelIndex {
+				signal.(func(*QXmlNodeModelIndex))(n)
+				return f(n)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "root", f)
+		}
 	}
 }
 
@@ -1224,7 +1322,14 @@ func callbackQAbstractXmlNodeModel_CompareOrder(ptr unsafe.Pointer, ni1 unsafe.P
 func (ptr *QAbstractXmlNodeModel) ConnectCompareOrder(f func(ni1 *QXmlNodeModelIndex, ni2 *QXmlNodeModelIndex) QXmlNodeModelIndex__DocumentOrder) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compareOrder", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "compareOrder"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compareOrder", func(ni1 *QXmlNodeModelIndex, ni2 *QXmlNodeModelIndex) QXmlNodeModelIndex__DocumentOrder {
+				signal.(func(*QXmlNodeModelIndex, *QXmlNodeModelIndex))(ni1, ni2)
+				return f(ni1, ni2)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "compareOrder", f)
+		}
 	}
 }
 
@@ -1254,7 +1359,14 @@ func callbackQAbstractXmlNodeModel_Kind(ptr unsafe.Pointer, ni unsafe.Pointer) C
 func (ptr *QAbstractXmlNodeModel) ConnectKind(f func(ni *QXmlNodeModelIndex) QXmlNodeModelIndex__NodeKind) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "kind", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "kind"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "kind", func(ni *QXmlNodeModelIndex) QXmlNodeModelIndex__NodeKind {
+				signal.(func(*QXmlNodeModelIndex))(ni)
+				return f(ni)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "kind", f)
+		}
 	}
 }
 
@@ -1362,7 +1474,14 @@ func callbackQAbstractXmlReceiver_AtomicValue(ptr unsafe.Pointer, value unsafe.P
 func (ptr *QAbstractXmlReceiver) ConnectAtomicValue(f func(value *core.QVariant)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "atomicValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", func(value *core.QVariant) {
+				signal.(func(*core.QVariant))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", f)
+		}
 	}
 }
 
@@ -1390,7 +1509,14 @@ func callbackQAbstractXmlReceiver_Attribute(ptr unsafe.Pointer, name unsafe.Poin
 func (ptr *QAbstractXmlReceiver) ConnectAttribute(f func(name *QXmlName, value *core.QStringRef)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "attribute"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", func(name *QXmlName, value *core.QStringRef) {
+				signal.(func(*QXmlName, *core.QStringRef))(name, value)
+				f(name, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", f)
+		}
 	}
 }
 
@@ -1418,7 +1544,14 @@ func callbackQAbstractXmlReceiver_Characters(ptr unsafe.Pointer, value unsafe.Po
 func (ptr *QAbstractXmlReceiver) ConnectCharacters(f func(value *core.QStringRef)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "characters"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", func(value *core.QStringRef) {
+				signal.(func(*core.QStringRef))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", f)
+		}
 	}
 }
 
@@ -1446,7 +1579,14 @@ func callbackQAbstractXmlReceiver_Comment(ptr unsafe.Pointer, value C.struct_QtX
 func (ptr *QAbstractXmlReceiver) ConnectComment(f func(value string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "comment"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", func(value string) {
+				signal.(func(string))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", f)
+		}
 	}
 }
 
@@ -1479,7 +1619,14 @@ func callbackQAbstractXmlReceiver_EndDocument(ptr unsafe.Pointer) {
 func (ptr *QAbstractXmlReceiver) ConnectEndDocument(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endDocument"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", f)
+		}
 	}
 }
 
@@ -1507,7 +1654,14 @@ func callbackQAbstractXmlReceiver_EndElement(ptr unsafe.Pointer) {
 func (ptr *QAbstractXmlReceiver) ConnectEndElement(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endElement"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", f)
+		}
 	}
 }
 
@@ -1535,7 +1689,14 @@ func callbackQAbstractXmlReceiver_EndOfSequence(ptr unsafe.Pointer) {
 func (ptr *QAbstractXmlReceiver) ConnectEndOfSequence(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", f)
+		}
 	}
 }
 
@@ -1563,7 +1724,14 @@ func callbackQAbstractXmlReceiver_NamespaceBinding(ptr unsafe.Pointer, name unsa
 func (ptr *QAbstractXmlReceiver) ConnectNamespaceBinding(f func(name *QXmlName)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", func(name *QXmlName) {
+				signal.(func(*QXmlName))(name)
+				f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", f)
+		}
 	}
 }
 
@@ -1591,7 +1759,14 @@ func callbackQAbstractXmlReceiver_ProcessingInstruction(ptr unsafe.Pointer, targ
 func (ptr *QAbstractXmlReceiver) ConnectProcessingInstruction(f func(target *QXmlName, value string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", func(target *QXmlName, value string) {
+				signal.(func(*QXmlName, string))(target, value)
+				f(target, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", f)
+		}
 	}
 }
 
@@ -1624,7 +1799,14 @@ func callbackQAbstractXmlReceiver_StartDocument(ptr unsafe.Pointer) {
 func (ptr *QAbstractXmlReceiver) ConnectStartDocument(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startDocument"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", f)
+		}
 	}
 }
 
@@ -1652,7 +1834,14 @@ func callbackQAbstractXmlReceiver_StartElement(ptr unsafe.Pointer, name unsafe.P
 func (ptr *QAbstractXmlReceiver) ConnectStartElement(f func(name *QXmlName)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startElement"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", func(name *QXmlName) {
+				signal.(func(*QXmlName))(name)
+				f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", f)
+		}
 	}
 }
 
@@ -1680,7 +1869,14 @@ func callbackQAbstractXmlReceiver_StartOfSequence(ptr unsafe.Pointer) {
 func (ptr *QAbstractXmlReceiver) ConnectStartOfSequence(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", f)
+		}
 	}
 }
 
@@ -1709,7 +1905,14 @@ func callbackQAbstractXmlReceiver_DestroyQAbstractXmlReceiver(ptr unsafe.Pointer
 func (ptr *QAbstractXmlReceiver) ConnectDestroyQAbstractXmlReceiver(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlReceiver", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlReceiver"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlReceiver", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractXmlReceiver", f)
+		}
 	}
 }
 
@@ -1879,7 +2082,14 @@ func callbackQSimpleXmlNodeModel_DestroyQSimpleXmlNodeModel(ptr unsafe.Pointer)
 func (ptr *QSimpleXmlNodeModel) ConnectDestroyQSimpleXmlNodeModel(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSimpleXmlNodeModel", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QSimpleXmlNodeModel"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSimpleXmlNodeModel", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QSimpleXmlNodeModel", f)
+		}
 	}
 }
 
@@ -1918,7 +2128,14 @@ func callbackQSimpleXmlNodeModel_StringValue(ptr unsafe.Pointer, node unsafe.Poi
 func (ptr *QSimpleXmlNodeModel) ConnectStringValue(f func(node *QXmlNodeModelIndex) string) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stringValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", func(node *QXmlNodeModelIndex) string {
+				signal.(func(*QXmlNodeModelIndex))(node)
+				return f(node)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stringValue", f)
+		}
 	}
 }
 
@@ -1955,7 +2172,14 @@ func callbackQSimpleXmlNodeModel_BaseUri(ptr unsafe.Pointer, node unsafe.Pointer
 func (ptr *QSimpleXmlNodeModel) ConnectBaseUri(f func(node *QXmlNodeModelIndex) *core.QUrl) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "baseUri"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", func(node *QXmlNodeModelIndex) *core.QUrl {
+				signal.(func(*QXmlNodeModelIndex))(node)
+				return f(node)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "baseUri", f)
+		}
 	}
 }
 
@@ -2008,7 +2232,14 @@ func callbackQSimpleXmlNodeModel_NamespaceBindings(ptr unsafe.Pointer, node unsa
 func (ptr *QSimpleXmlNodeModel) ConnectNamespaceBindings(f func(node *QXmlNodeModelIndex) []*QXmlName) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", func(node *QXmlNodeModelIndex) []*QXmlName {
+				signal.(func(*QXmlNodeModelIndex))(node)
+				return f(node)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBindings", f)
+		}
 	}
 }
 
@@ -2069,7 +2300,14 @@ func callbackQSimpleXmlNodeModel_NodesByIdref(ptr unsafe.Pointer, idref unsafe.P
 func (ptr *QSimpleXmlNodeModel) ConnectNodesByIdref(f func(idref *QXmlName) []*QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", func(idref *QXmlName) []*QXmlNodeModelIndex {
+				signal.(func(*QXmlName))(idref)
+				return f(idref)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nodesByIdref", f)
+		}
 	}
 }
 
@@ -2127,7 +2365,14 @@ func callbackQSimpleXmlNodeModel_ElementById(ptr unsafe.Pointer, id unsafe.Point
 func (ptr *QSimpleXmlNodeModel) ConnectElementById(f func(id *QXmlName) *QXmlNodeModelIndex) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "elementById"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", func(id *QXmlName) *QXmlNodeModelIndex {
+				signal.(func(*QXmlName))(id)
+				return f(id)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "elementById", f)
+		}
 	}
 }
 
@@ -3346,7 +3591,14 @@ func callbackQXmlResultItems_DestroyQXmlResultItems(ptr unsafe.Pointer) {
 func (ptr *QXmlResultItems) ConnectDestroyQXmlResultItems(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QXmlResultItems", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QXmlResultItems"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QXmlResultItems", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QXmlResultItems", f)
+		}
 	}
 }
 
@@ -3757,7 +4009,14 @@ func callbackQXmlSerializer_AtomicValue(ptr unsafe.Pointer, value unsafe.Pointer
 func (ptr *QXmlSerializer) ConnectAtomicValue(f func(value *core.QVariant)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "atomicValue"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", func(value *core.QVariant) {
+				signal.(func(*core.QVariant))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "atomicValue", f)
+		}
 	}
 }
 
@@ -3792,7 +4051,14 @@ func callbackQXmlSerializer_Attribute(ptr unsafe.Pointer, name unsafe.Pointer, v
 func (ptr *QXmlSerializer) ConnectAttribute(f func(name *QXmlName, value *core.QStringRef)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "attribute"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", func(name *QXmlName, value *core.QStringRef) {
+				signal.(func(*QXmlName, *core.QStringRef))(name, value)
+				f(name, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "attribute", f)
+		}
 	}
 }
 
@@ -3827,7 +4093,14 @@ func callbackQXmlSerializer_Characters(ptr unsafe.Pointer, value unsafe.Pointer)
 func (ptr *QXmlSerializer) ConnectCharacters(f func(value *core.QStringRef)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "characters"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", func(value *core.QStringRef) {
+				signal.(func(*core.QStringRef))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "characters", f)
+		}
 	}
 }
 
@@ -3862,7 +4135,14 @@ func callbackQXmlSerializer_Comment(ptr unsafe.Pointer, value C.struct_QtXmlPatt
 func (ptr *QXmlSerializer) ConnectComment(f func(value string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "comment"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", func(value string) {
+				signal.(func(string))(value)
+				f(value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "comment", f)
+		}
 	}
 }
 
@@ -3907,7 +4187,14 @@ func callbackQXmlSerializer_EndDocument(ptr unsafe.Pointer) {
 func (ptr *QXmlSerializer) ConnectEndDocument(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endDocument"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endDocument", f)
+		}
 	}
 }
 
@@ -3942,7 +4229,14 @@ func callbackQXmlSerializer_EndElement(ptr unsafe.Pointer) {
 func (ptr *QXmlSerializer) ConnectEndElement(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endElement"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endElement", f)
+		}
 	}
 }
 
@@ -3977,7 +4271,14 @@ func callbackQXmlSerializer_EndOfSequence(ptr unsafe.Pointer) {
 func (ptr *QXmlSerializer) ConnectEndOfSequence(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "endOfSequence", f)
+		}
 	}
 }
 
@@ -4012,7 +4313,14 @@ func callbackQXmlSerializer_NamespaceBinding(ptr unsafe.Pointer, nb unsafe.Point
 func (ptr *QXmlSerializer) ConnectNamespaceBinding(f func(nb *QXmlName)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", func(nb *QXmlName) {
+				signal.(func(*QXmlName))(nb)
+				f(nb)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "namespaceBinding", f)
+		}
 	}
 }
 
@@ -4047,7 +4355,14 @@ func callbackQXmlSerializer_ProcessingInstruction(ptr unsafe.Pointer, name unsaf
 func (ptr *QXmlSerializer) ConnectProcessingInstruction(f func(name *QXmlName, value string)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", func(name *QXmlName, value string) {
+				signal.(func(*QXmlName, string))(name, value)
+				f(name, value)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "processingInstruction", f)
+		}
 	}
 }
 
@@ -4098,7 +4413,14 @@ func callbackQXmlSerializer_StartDocument(ptr unsafe.Pointer) {
 func (ptr *QXmlSerializer) ConnectStartDocument(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startDocument"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startDocument", f)
+		}
 	}
 }
 
@@ -4133,7 +4455,14 @@ func callbackQXmlSerializer_StartElement(ptr unsafe.Pointer, name unsafe.Pointer
 func (ptr *QXmlSerializer) ConnectStartElement(f func(name *QXmlName)) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startElement"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", func(name *QXmlName) {
+				signal.(func(*QXmlName))(name)
+				f(name)
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startElement", f)
+		}
 	}
 }
 
@@ -4168,7 +4497,14 @@ func callbackQXmlSerializer_StartOfSequence(ptr unsafe.Pointer) {
 func (ptr *QXmlSerializer) ConnectStartOfSequence(f func()) {
 	if ptr.Pointer() != nil {
 
-		qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", f)
+		if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence"); signal != nil {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", func() {
+				signal.(func())()
+				f()
+			})
+		} else {
+			qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "startOfSequence", f)
+		}
 	}
 }