-const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) {
- QByteArray className(obj->metaObject()->className());
- Q_ASSERT(_classInfo.contains(className));
- if(!_classInfo[className]->methodNames.contains(methodId))
- setMethodName(obj, methodId);
- return _classInfo[className]->methodNames[methodId];
+bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, QVariant& returnValue, Peer* peer)
+{
+ ExtendedMetaObject* eMeta = extendedMetaObject(receiver);
+ const QList<int> args = eMeta->argTypes(methodId);
+ const int numArgs = params.count() < args.count() ? params.count() : args.count();
+
+ if (eMeta->minArgCount(methodId) > params.count()) {
+ qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId);
+ return false;
+ }
+
+ void* _a[] = {nullptr, // return type...
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr, // and 10 args - that's the max size qt can handle with signals and slots
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr,
+ nullptr};
+
+ // check for argument compatibility and build params array
+ for (int i = 0; i < numArgs; i++) {
+ if (!params[i].isValid()) {
+ qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method"
+ << QString("%1::%2()")
+ .arg(receiver->metaObject()->className())
+ .arg(receiver->metaObject()->method(methodId).methodSignature().constData());
+ qWarning() << " - make sure all your data types are known by the Qt MetaSystem";
+ return false;
+ }
+ if (args[i] != QMetaType::type(params[i].typeName())) {
+ qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
+ return false;
+ }
+
+ _a[i + 1] = const_cast<void*>(params[i].constData());
+ }
+
+ if (returnValue.type() != QVariant::Invalid)
+ _a[0] = const_cast<void*>(returnValue.constData());
+
+ Qt::ConnectionType type = QThread::currentThread() == receiver->thread() ? Qt::DirectConnection : Qt::QueuedConnection;
+
+ if (type == Qt::DirectConnection) {
+ _sourcePeer = peer;
+ auto result = receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
+ _sourcePeer = nullptr;
+ return result;
+ }
+ else {
+ qWarning() << "Queued Connections are not implemented yet";
+ // note to self: qmetaobject.cpp:990 ff
+ return false;
+ }
+}
+
+bool SignalProxy::invokeSlot(QObject* receiver, int methodId, const QVariantList& params, Peer* peer)
+{
+ QVariant ret;
+ return invokeSlot(receiver, methodId, params, ret, peer);