/*!
Sets up remote invocation proxies for all signals and public slots
on this object, starting at the class specified by \a meta.
Normally \a meta will be the \c staticMetaObject value for the
immediate subclass of QAbstractIpcInterface. It allows the proxying
to be limited to a subset of the class hierarchy if more derived
classes have signals and slots that should not be proxied.
This method is useful when the subclass has many signals
and slots, and it would be error-prone to proxy them individually
with proxy().
\sa proxy()
*/
void QAbstractIpcInterface::proxyAll( const QMetaObject& meta )
{
// Only needed for the server at present.
if ( d->mode != Server )
return;
// Find the starting point within the metaobject tree.
const QMetaObject *current = metaObject();
while ( current != 0 && current != &meta ) {
current = current->superClass();
}
if ( ! current )
return;
// If we have been called multiple times, then only proxy
// the ones we haven't done yet.
int last = current->methodCount();
if ( last > d->lastProxy ) {
int index = d->lastProxy;
d->lastProxy = last;
for ( ; index < last; ++index ) {
QMetaMethod method = current->method( index );
if ( method.methodType() == QMetaMethod::Slot &&
method.access() == QMetaMethod::Public ) {
QByteArray name = method.signature();
QtopiaIpcAdaptor::connect( d->receive, "3" + name, this, "1" + name );
} else if ( method.methodType() == QMetaMethod::Signal ) {
QByteArray name = method.signature();
QtopiaIpcAdaptor::connect( this, "2" + name, d->send, "3" + name );
}
}
}
}
void ChainLink::setupConnections(const KoFilter *sender, const KoFilter *receiver) const
{
const QMetaObject * const parent = sender->metaObject();
const QMetaObject * const child = receiver->metaObject();
if (!parent || !child)
return;
int senderMethodCount = parent->methodCount();
for (int i = 0; i < senderMethodCount; ++i) {
QMetaMethod signal = parent->method(i);
if (signal.methodType() != QMetaMethod::Signal)
continue;
// ### untested (QMetaMethod::signature())
if (strncmp(signal.signature(), SIGNAL_PREFIX, SIGNAL_PREFIX_LEN) == 0) {
int receiverMethodCount = child->methodCount();
for (int j = 0; j < receiverMethodCount; ++j) {
QMetaMethod slot = child->method(j);
if (slot.methodType() != QMetaMethod::Slot)
continue;
if (strncmp(slot.signature(), SLOT_PREFIX, SLOT_PREFIX_LEN) == 0) {
if (strcmp(signal.signature() + SIGNAL_PREFIX_LEN, slot.signature() + SLOT_PREFIX_LEN) == 0) {
QByteArray signalString;
signalString.setNum(QSIGNAL_CODE);
signalString += signal.signature();
QByteArray slotString;
slotString.setNum(QSLOT_CODE);
slotString += slot.signature();
QObject::connect(sender, signalString, receiver, slotString);
}
}
}
}
}
}
int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv)
{
Q_Q(QDBusInterface);
if (c == QMetaObject::InvokeMetaMethod) {
int offset = metaObject->methodOffset();
QMetaMethod mm = metaObject->method(id + offset);
if (mm.methodType() == QMetaMethod::Signal) {
// signal relay from D-Bus world to Qt world
QMetaObject::activate(q, metaObject, id, argv);
} else if (mm.methodType() == QMetaMethod::Slot || mm.methodType() == QMetaMethod::Method) {
// method call relay from Qt world to D-Bus world
// get D-Bus equivalent signature
QString methodName = QString::fromLatin1(mm.name());
const int *inputTypes = metaObject->inputTypesForMethod(id);
int inputTypesCount = *inputTypes;
// we will assume that the input arguments were passed correctly
QVariantList args;
args.reserve(inputTypesCount);
int i = 1;
for ( ; i <= inputTypesCount; ++i)
args << QVariant(inputTypes[i], argv[i]);
// make the call
QDBusMessage reply = q->callWithArgumentList(QDBus::Block, methodName, args);
if (reply.type() == QDBusMessage::ReplyMessage) {
// attempt to demarshall the return values
args = reply.arguments();
QVariantList::ConstIterator it = args.constBegin();
const int *outputTypes = metaObject->outputTypesForMethod(id);
int outputTypesCount = *outputTypes++;
if (mm.returnType() != QMetaType::UnknownType && mm.returnType() != QMetaType::Void) {
// this method has a return type
if (argv[0] && it != args.constEnd())
copyArgument(argv[0], *outputTypes++, *it);
// skip this argument even if we didn't copy it
--outputTypesCount;
++it;
}
for (int j = 0; j < outputTypesCount && it != args.constEnd(); ++i, ++j, ++it) {
copyArgument(argv[i], outputTypes[j], *it);
}
}
// done
lastError = QDBusError(reply);
return -1;
}
}
return id;
}
int QQmlProxyMetaObject::metaCall(QObject *o, QMetaObject::Call c, int id, void **a)
{
Q_ASSERT(object == o);
if ((c == QMetaObject::ReadProperty ||
c == QMetaObject::WriteProperty) &&
id >= metaObjects->constLast().propertyOffset) {
for (int ii = 0; ii < metaObjects->count(); ++ii) {
const ProxyData &data = metaObjects->at(ii);
if (id >= data.propertyOffset) {
if (!proxies) {
proxies = new QObject*[metaObjects->count()];
::memset(proxies, 0,
sizeof(QObject *) * metaObjects->count());
}
if (!proxies[ii]) {
QObject *proxy = data.createFunc(object);
const QMetaObject *metaObject = proxy->metaObject();
proxies[ii] = proxy;
int localOffset = data.metaObject->methodOffset();
int methodOffset = metaObject->methodOffset();
int methods = metaObject->methodCount() - methodOffset;
// ### - Can this be done more optimally?
for (int jj = 0; jj < methods; ++jj) {
QMetaMethod method =
metaObject->method(jj + methodOffset);
if (method.methodType() == QMetaMethod::Signal)
QQmlPropertyPrivate::connect(proxy, methodOffset + jj, object, localOffset + jj);
}
}
int proxyOffset = proxies[ii]->metaObject()->propertyOffset();
int proxyId = id - data.propertyOffset + proxyOffset;
return proxies[ii]->qt_metacall(c, proxyId, a);
}
}
} else if (c == QMetaObject::InvokeMetaMethod &&
id >= metaObjects->constLast().methodOffset) {
QMetaMethod m = object->metaObject()->method(id);
if (m.methodType() == QMetaMethod::Signal) {
QMetaObject::activate(object, id, a);
return -1;
}
}
if (parent)
return parent->metaCall(o, c, id, a);
else
return object->qt_metacall(c, id, a);
}
QVariant ObjectMethodModel::metaData(const QModelIndex &index,
const QMetaMethod &method, int role) const
{
if (role == Qt::DisplayRole) {
if (index.column() == 0) {
return Util::prettyMethodSignature(method);
}
if (index.column() == 1) {
switch (method.methodType()) {
case QMetaMethod::Method:
return tr("Method");
case QMetaMethod::Constructor:
return tr("Constructor");
case QMetaMethod::Slot:
return tr("Slot");
case QMetaMethod::Signal:
return tr("Signal");
default:
return tr("Unknown");
}
}
if (index.column() == 2) {
switch (method.access()) {
case QMetaMethod::Public:
return tr("Public");
case QMetaMethod::Protected:
return tr("Protected");
case QMetaMethod::Private:
return tr("Private");
default:
return tr("Unknown");
}
}
if (index.column() == 3) {
return method.tag();
}
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
if (index.column() == 4) {
return QString::number(method.revision());
}
#endif
} else if (role == ObjectMethodModelRole::MetaMethod) {
return QVariant::fromValue(method);
} else if (role == ObjectMethodModelRole::MetaMethodType) {
return QVariant::fromValue(method.methodType());
} else if (role == ObjectMethodModelRole::MethodSignature) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return method.signature();
#else
return method.methodSignature();
#endif
}
return QVariant();
}
factory_method::factory_method(type result_type, QMetaMethod meta_method) :
_object_type{meta_method.enclosingMetaObject()},
_result_type{std::move(result_type)},
_meta_method{std::move(meta_method)}
{
assert(meta_method.methodType() == QMetaMethod::Method || meta_method.methodType() == QMetaMethod::Slot);
assert(meta_method.parameterCount() == 0);
assert(meta_method.enclosingMetaObject() != nullptr);
assert(!_result_type.is_empty());
assert(_result_type.name() + "*" == std::string{meta_method.typeName()});
}
QVariant ObjectMethodModel::metaData(const QModelIndex &index,
const QMetaMethod &method, int role) const
{
if (role == Qt::DisplayRole) {
if (index.column() == 0) {
return Util::prettyMethodSignature(method);
}
if (index.column() == 1) {
switch (method.methodType()) {
case QMetaMethod::Method:
return tr("Method");
case QMetaMethod::Constructor:
return tr("Constructor");
case QMetaMethod::Slot:
return tr("Slot");
case QMetaMethod::Signal:
return tr("Signal");
default:
return tr("Unknown");
}
}
if (index.column() == 2) {
switch (method.access()) {
case QMetaMethod::Public:
return tr("Public");
case QMetaMethod::Protected:
return tr("Protected");
case QMetaMethod::Private:
return tr("Private");
default:
return tr("Unknown");
}
}
} else if (role == Qt::ToolTipRole) {
QString tt = Util::prettyMethodSignature(method);
tt += tr("\nTag: %1\n").arg(qstrlen(method.tag()) > 0 ? method.tag() : tr("<none>"));
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
tt += tr("Revision: %1").arg(method.revision());
#endif
return tt;
} else if (role == ObjectMethodModelRole::MetaMethod) {
return QVariant::fromValue(method);
} else if (role == ObjectMethodModelRole::MetaMethodType) {
return QVariant::fromValue(method.methodType());
} else if (role == ObjectMethodModelRole::MethodSignature) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return method.signature();
#else
return method.methodSignature();
#endif
}
return QVariant();
}
static int
qt_connect(lua_State *L)
{
// LUA: "qt.connect(object signal closure)"
// Connects signal to closure.
// LUA: "qt.connect(object signal object signal_or_slot)"
// Connects signal to signal or slot.
QObject *obj = luaQ_checkqobject<QObject>(L, 1);
const char *sig = luaL_checkstring(L, 2);
QObject *robj = luaQ_toqobject(L, 3);
if (robj)
{
// search signal or slot
QByteArray rsig = luaL_checkstring(L, 4);
const QMetaObject *mo = robj->metaObject();
int idx = mo->indexOfMethod(rsig.constData());
if (idx < 0)
{
rsig = QMetaObject::normalizedSignature(rsig.constData());
idx = mo->indexOfMethod(rsig.constData());
if (idx < 0)
luaL_error(L, "cannot find target slot or signal %s",
rsig.constData());
}
// prepend signal or slot indicator
QMetaMethod method = mo->method(idx);
if (method.methodType() == QMetaMethod::Signal)
rsig.prepend('0' + QSIGNAL_CODE);
else if (method.methodType() == QMetaMethod::Slot)
rsig.prepend('0' + QSLOT_CODE);
else
luaL_error(L, "target %s is not a slot or a signal",
rsig.constData());
// connect
QByteArray ssig = sig;
ssig.prepend('0' + QSIGNAL_CODE);
if (! QObject::connect(obj, ssig.constData(), robj, rsig.constData()))
luaL_error(L, "cannot find source signal %s", sig);
}
else
{
luaL_checktype(L, 3, LUA_TFUNCTION);
bool direct = lua_toboolean(L, 4);
if (direct)
luaL_checktype(L, 4, LUA_TBOOLEAN);
if (! luaQ_connect(L, obj, sig, 3, direct))
luaL_error(L, "cannot find source signal %s", sig);
}
return 0;
}
void PropertyController::activateMethod()
{
QItemSelectionModel* selectionModel = ObjectBroker::selectionModel(m_methodModel);
if (selectionModel->selectedRows().size() != 1)
return;
const QModelIndex index = selectionModel->selectedRows().first();
const QMetaMethod method = index.data(ObjectMethodModelRole::MetaMethod).value<QMetaMethod>();
if (method.methodType() == QMetaMethod::Slot) {
m_methodArgumentModel->setMethod(method);
} else if (method.methodType() == QMetaMethod::Signal) {
m_signalMapper->connectToSignal(m_object, method);
}
}
bool action_method::validate_action_method(const QMetaMethod &meta_method)
{
auto meta_object = meta_method.enclosingMetaObject();
if (!meta_object)
throw exception::invalid_action{std::string{"action does not have enclosing meta object: "} + "?::" + meta_method.methodSignature().data()};
if (meta_method.methodType() == QMetaMethod::Signal)
throw exception::invalid_action{std::string{"action is signal: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (meta_method.methodType() == QMetaMethod::Constructor)
throw exception::invalid_action{std::string{"action is constructor: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (!is_action_init_tag(meta_method.tag()) && !is_action_done_tag(meta_method.tag()))
throw exception::invalid_action{std::string{"action does not have valid tag: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
if (meta_method.parameterCount() != 0)
throw exception::invalid_action{std::string{"invalid parameter count: "} + meta_object->className() + "::" + meta_method.methodSignature().data()};
return true;
}
void QMediaAbstractControlServer::proxyAll()
{
QMetaObject const* mo = metaObject();
int mc = mo->methodCount();
int offset = QMediaAbstractControlServer::staticMetaObject.methodOffset();
QString className = mo->className();
for (int i = offset; i < mc; ++i)
{
QMetaMethod method = mo->method(i);
switch (method.methodType())
{
case QMetaMethod::Signal:
QtopiaIpcAdaptor::connect(this, QByteArray::number(QSIGNAL_CODE) + method.signature(),
d->send, QByteArray::number(QMESSAGE_CODE) + method.signature());
break;
case QMetaMethod::Slot:
if (method.access() == QMetaMethod::Public)
{
QtopiaIpcAdaptor::connect(d->recieve, QByteArray::number(QMESSAGE_CODE) + method.signature(),
this, QByteArray::number(QSLOT_CODE) + method.signature());
}
break;
case QMetaMethod::Method:
break;
}
}
}
void InvokeMethod::setControl(QAxBase *ax)
{
activex = ax;
bool hasControl = activex && !activex->isNull();
labelMethods->setEnabled(hasControl);
comboMethods->setEnabled(hasControl);
buttonInvoke->setEnabled(hasControl);
boxParameters->setEnabled(hasControl);
comboMethods->clear();
listParameters->clear();
if (!hasControl) {
editValue->clear();
return;
}
const QMetaObject *mo = activex->metaObject();
if (mo->methodCount()) {
for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
const QMetaMethod method = mo->method(i);
if (method.methodType() == QMetaMethod::Slot)
comboMethods->addItem(QString::fromLatin1(method.signature()));
}
comboMethods->model()->sort(0);
on_comboMethods_activated(comboMethods->currentText());
}
}
static int lqtL_methods(lua_State *L) {
QObject* self = static_cast<QObject*>(lqtL_toudata(L, 1, "QObject*"));
if (self == NULL)
return luaL_argerror(L, 1, "expecting QObject*");
const QMetaObject *mo = self->metaObject();
lua_createtable(L, mo->methodCount(), 0);
for (int i=0; i < mo->methodCount(); i++) {
QMetaMethod m = mo->method(i);
lua_pushstring(L, m.signature());
switch (m.access()) {
CASE(Private);
CASE(Protected);
CASE(Public);
}
switch (m.methodType()) {
CASE(Method);
CASE(Signal);
CASE(Slot);
CASE(Constructor);
}
lua_concat(L, 3);
lua_rawseti(L, -2, i+1);
}
return 1;
}
QSObject QSAEditor::queryQSObject( const QMetaObject *meta, const QString &property, bool /*includeSuperClass*/ ) const
{
int propertyIndex = -1;
const QMetaObject *m = meta;
propertyIndex = m->indexOfProperty(property.toLatin1().constData());
if (propertyIndex >= 0) {
QMetaProperty mp = m->property(propertyIndex);
QSObject o = vTypeToQSType( QString::fromLatin1(mp.typeName()) );
if ( !o.isNull() && !o.isUndefined() )
return o;
}
m = meta;
for (int i=0; i<m->methodCount(); ++i) {
QMetaMethod mm = m->method(i);
if (mm.methodType() == QMetaMethod::Slot) {
QString n = QLatin1String(mm.methodSignature());
n = n.left(n.indexOf('('));
if ( property != n )
continue;
return vTypeToQSType(mm.typeName());
}
}
return env()->createUndefined();
}
extern "C" SEXP qt_qmocMethods(SEXP x) {
const QMetaObject *meta = unwrapSmoke(x, QMetaObject);
int n = meta->methodCount();
SEXP ans, ans_type, ans_signature, ans_return, ans_nargs;
PROTECT(ans = allocVector(VECSXP, 4));
ans_type = allocVector(INTSXP, n);
SET_VECTOR_ELT(ans, 0, ans_type);
ans_signature = allocVector(STRSXP, n);
SET_VECTOR_ELT(ans, 1, ans_signature);
ans_return = allocVector(STRSXP, n);
SET_VECTOR_ELT(ans, 2, ans_return);
ans_nargs = allocVector(INTSXP, n);
SET_VECTOR_ELT(ans, 3, ans_nargs);
for (int i = 0; i < n; i++) {
QMetaMethod metaMethod = meta->method(i);
INTEGER(ans_type)[i] = metaMethod.methodType();
SET_STRING_ELT(ans_signature, i, mkChar(metaMethod.signature()));
SET_STRING_ELT(ans_return, i, mkChar(metaMethod.typeName()));
INTEGER(ans_nargs)[i] = metaMethod.parameterNames().size();
}
UNPROTECT(1);
return ans;
}
QVariant ObjectMethodModel::metaData(const QModelIndex &index, const QMetaMethod &method,
int role) const
{
if (role == Qt::DisplayRole && index.column() == 0) {
return Util::prettyMethodSignature(method);
} else if (role == ObjectMethodModelRole::MetaMethod) {
return QVariant::fromValue(method);
} else if (role == ObjectMethodModelRole::MetaMethodType && index.column() == 1) {
return QVariant::fromValue(method.methodType());
} else if (role == ObjectMethodModelRole::MethodAccess && index.column() == 2) {
return QVariant::fromValue(method.access());
} else if (role == ObjectMethodModelRole::MethodSignature && index.column() == 0) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return method.signature();
#else
return method.methodSignature();
#endif
} else if (role == ObjectMethodModelRole::MethodTag && index.column() == 0 && qstrlen(method.tag())) {
return method.tag();
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
} else if (role == ObjectMethodModelRole::MethodRevision && index.column() == 0) {
return method.revision();
#endif
} else if (role == ObjectMethodModelRole::MethodIssues && index.column() == 0) {
const QMetaObject *mo = m_metaObject;
while (mo->methodOffset() > index.row())
mo = mo->superClass();
const auto r = QMetaObjectValidator::checkMethod(mo, method);
return r == QMetaObjectValidatorResult::NoIssue ? QVariant() : QVariant::fromValue(r);
}
return QVariant();
}
void QDeclarativePropertyCache::Data::lazyLoad(const QMetaMethod &m)
{
coreIndex = m.methodIndex();
relatedIndex = -1;
flags |= Data::IsFunction;
if (m.methodType() == QMetaMethod::Signal)
flags |= Data::IsSignal;
propType = QVariant::Invalid;
const char *returnType = m.typeName();
if (returnType && *returnType) {
propTypeName = returnType;
flags |= Data::NotFullyResolved;
}
const char *signature = m.signature();
while (*signature != '(') { Q_ASSERT(*signature != 0); ++signature; }
++signature;
if (*signature != ')') {
flags |= Data::HasArguments;
if (0 == ::strcmp(signature, "QDeclarativeV8Function*)")) {
flags |= Data::IsV8Function;
}
}
revision = m.revision();
}
/*!
\internal
Catch signal disconnections.
*/
void QDBusAbstractInterface::disconnectNotify(const QMetaMethod &signal)
{
// someone disconnecting from one of our signals
Q_D(QDBusAbstractInterface);
if (!d->isValid)
return;
QDBusConnectionPrivate *conn = d->connectionPrivate();
if (conn && signal.isValid() && !isSignalConnected(signal))
return conn->disconnectRelay(d->service, d->path, d->interface,
this, signal);
if (!conn)
return;
// wildcard disconnecting, we need to figure out which of our signals are
// no longer connected to anything
const QMetaObject *mo = metaObject();
int midx = QObject::staticMetaObject.methodCount();
const int end = mo->methodCount();
for ( ; midx < end; ++midx) {
QMetaMethod mm = mo->method(midx);
if (mm.methodType() == QMetaMethod::Signal && !isSignalConnected(mm))
conn->disconnectRelay(d->service, d->path, d->interface, this, mm);
}
}
error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, void *func, int argsLen)
{
QObject *qobject = reinterpret_cast<QObject *>(object);
QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
QByteArray qsignal(signal, signalLen);
const QMetaObject *meta = qobject->metaObject();
// Walk backwards so descendants have priority.
for (int i = meta->methodCount()-1; i >= 0; i--) {
QMetaMethod method = meta->method(i);
if (method.methodType() == QMetaMethod::Signal) {
QByteArray name = method.name();
if (name.length() == signalLen && qstrncmp(name.constData(), signal, signalLen) == 0) {
if (method.parameterCount() < argsLen) {
// TODO Might continue looking to see if a different signal has the same name and enough arguments.
return errorf("signal \"%s\" has too few parameters for provided function", name.constData());
}
Connector *connector = Connector::New(qobject, method, qengine, func, argsLen);
const QMetaObject *connmeta = connector->metaObject();
QObject::connect(qobject, method, connector, connmeta->method(connmeta->methodOffset()));
return 0;
}
}
}
// Cannot use constData here as the byte array is not null-terminated.
return errorf("object does not expose a \"%s\" signal", qsignal.data());
}
// Creates a string, describing an object, using meta-object introspection
QString objToString(const QObject *obj) {
QStringList result;
const QMetaObject *meta = obj->metaObject();
result += QString("class %1 : public %2 {").arg(meta->className())
.arg(meta->superClass()->className());
for (auto i=0; i < meta->propertyCount(); ++i) {
const QMetaProperty property = meta->property(i);
QVariant value = obj->property(property.name());
if (value.canConvert(QVariant::String))
result += QString(" %1 %2 = %3;")
.arg(property.typeName())
.arg(property.name())
.arg(value.toString());
}
QString signalPrefix("");
for (auto i=0; i < meta->methodCount(); ++i) {
const QMetaMethod method = meta->method(i);
const QMetaMethod::MethodType methodType = method.methodType();
if (methodType == QMetaMethod::Signal)
signalPrefix = QStringLiteral("Q_SIGNAL");
else if (methodType == QMetaMethod::Slot)
signalPrefix = QStringLiteral("Q_SLOT");
result += QString(" %1 %2 %3;")
.arg(signalPrefix)
.arg(QVariant::typeToName(method.returnType()))
.arg(QString(method.methodSignature()));
}
result += "};";
return result.join("\n");
}
const QMetaObject *QSAEditor::queryQMetaObject( const QMetaObject *meta,
const QString &property,
bool /*includeSuperClass*/ ) const
{
const QMetaObject *m = meta;
for (int i=0; i<m->methodCount(); ++i) {
QMetaMethod mm = m->method(i);
if (mm.methodType() == QMetaMethod::Slot) {
QString n = QLatin1String(mm.methodSignature());
n = n.left(n.indexOf('('));
if (property != n)
continue ;
QByteArray retType(mm.typeName());
if (retType.count('*') == 1) {
extern const QMetaObject *qsa_query_meta_object(const QByteArray &name);
return qsa_query_meta_object(qsa_strip_stars(retType));
}
}
}
return 0;
}
void PropertyController::invokeMethod(Qt::ConnectionType connectionType)
{
if (!m_object) {
m_methodLogModel->appendRow(new QStandardItem(tr("%1: Invocation failed: Invalid object, probably got deleted in the meantime.")
.arg(QTime::currentTime().toString("HH:mm:ss.zzz"))));
return;
}
QMetaMethod method;
QItemSelectionModel* selectionModel = ObjectBroker::selectionModel(m_methodModel);
if (selectionModel->selectedRows().size() == 1) {
const QModelIndex index = selectionModel->selectedRows().first();
method = index.data(ObjectMethodModelRole::MetaMethod).value<QMetaMethod>();
}
if (method.methodType() != QMetaMethod::Slot) {
m_methodLogModel->appendRow(new QStandardItem(tr("%1: Invocation failed: Invalid method (not a slot?).")
.arg(QTime::currentTime().toString("HH:mm:ss.zzz"))));
return;
}
const QVector<MethodArgument> args = m_methodArgumentModel->arguments();
// TODO retrieve return value and add it to the log in case of success
// TODO measure executation time and that to the log
const bool result = method.invoke(m_object.data(), connectionType,
args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
if (!result) {
m_methodLogModel->appendRow(new QStandardItem(tr("%1: Invocation failed..").arg(QTime::currentTime().toString("HH:mm:ss.zzz"))));
return;
}
m_methodArgumentModel->setMethod(QMetaMethod());
}
JSValue QtInstance::stringValue(ExecState* exec) const
{
QObject* obj = getObject();
if (!obj)
return jsNull();
// Hmm.. see if there is a toString defined
QByteArray buf;
bool useDefault = true;
getClass();
if (m_class) {
// Cheat and don't use the full name resolution
int index = obj->metaObject()->indexOfMethod("toString()");
if (index >= 0) {
QMetaMethod m = obj->metaObject()->method(index);
// Check to see how much we can call it
if (m.access() != QMetaMethod::Private
&& m.methodType() != QMetaMethod::Signal
#if HAVE(QT5)
&& m.parameterCount() == 0
&& m.returnType() != QMetaType::Void) {
QVariant ret(m.returnType(), (void*)0);
void * qargs[1];
qargs[0] = ret.data();
if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) {
if (ret.isValid() && ret.canConvert(QVariant::String)) {
buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii?
useDefault = false;
#else
&& m.parameterTypes().isEmpty()) {
const char* retsig = m.typeName();
if (retsig && *retsig) {
QVariant ret(QMetaType::type(retsig), (void*)0);
void * qargs[1];
qargs[0] = ret.data();
if (QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, qargs) < 0) {
if (ret.isValid() && ret.canConvert(QVariant::String)) {
buf = ret.toString().toLatin1().constData(); // ### Latin 1? Ascii?
useDefault = false;
}
#endif
}
}
}
}
}
if (useDefault) {
const QMetaObject* meta = obj ? obj->metaObject() : &QObject::staticMetaObject;
QString name = obj ? obj->objectName() : QString::fromUtf8("unnamed");
QString str = QString::fromUtf8("%0(name = \"%1\")")
.arg(QLatin1String(meta->className())).arg(name);
buf = str.toLatin1();
}
return jsString(exec, buf.constData());
}
void QRemoteObjectReplicaPrivate::configurePrivate(QRemoteObjectReplica *rep)
{
qCDebug(QT_REMOTEOBJECT) << "configurePrivate starting for" << this->m_objectName;
//We need to connect the Replicant only signals too
const QMetaObject *m = qobject_cast<QRemoteObjectDynamicReplica *>(rep) ?
&QRemoteObjectReplica::staticMetaObject : &QRemoteObjectDynamicReplica::staticMetaObject;
for (int i = m->methodOffset(); i < m->methodCount(); ++i)
{
const QMetaMethod mm = m->method(i);
if (mm.methodType() == QMetaMethod::Signal) {
const bool res = QMetaObject::connect(this, i, rep, i, Qt::DirectConnection, 0);
qCDebug(QT_REMOTEOBJECT) << " Rep connect"<<i<<res<<mm.name();
Q_UNUSED(res);
}
}
if (m_methodOffset == 0) //We haven't initialized the offsets yet
{
for (int i = m_signalOffset; i < m_metaObject->methodCount(); ++i) {
const QMetaMethod mm = m_metaObject->method(i);
if (mm.methodType() == QMetaMethod::Signal) {
++m_numSignals;
const bool res = QMetaObject::connect(this, i, rep, i, Qt::DirectConnection, 0);
qCDebug(QT_REMOTEOBJECT) << " Connect"<<i<<res<<mm.name();
Q_UNUSED(res);
}
}
m_methodOffset = m_signalOffset + m_numSignals;
qCDebug(QT_REMOTEOBJECT) << QStringLiteral("configurePrivate finished, signalOffset = %1, methodOffset = %2, #Signals = %3").arg(m_signalOffset).arg(m_methodOffset).arg(m_numSignals);
} else { //We have initialized offsets, this is an additional Replica attaching
for (int i = m_signalOffset; i < m_methodOffset; ++i) {
const bool res = QMetaObject::connect(this, i, rep, i, Qt::DirectConnection, 0);
qCDebug(QT_REMOTEOBJECT) << " Connect"<<i<<res<<m_metaObject->method(i).name();
Q_UNUSED(res);
}
if (isInitialized()) {
qCDebug(QT_REMOTEOBJECT) << QStringLiteral("ReplicaPrivate initialized, emitting signal on Replica");
emit rep->initialized(); //Emit from new replica only
}
if (!isReplicaValid()) {
qCDebug(QT_REMOTEOBJECT) << QStringLiteral("ReplicaPrivate not currently valid, emitting signal on Replica");
emit rep->isReplicaValidChanged(); //Emit from new replica only
}
qCDebug(QT_REMOTEOBJECT) << QStringLiteral("configurePrivate finished, added Replica to existing ReplicaPrivate");
}
}
MethodViewer::Item::Item(QObject *object, const QMetaMethod &method) {
QMetaMethod::MethodType methodType = method.methodType();
setText(0, getMethodTypeName(methodType));
setText(1, method.signature());
m_method = method;
m_object = object;
}
void QMetaUtilities::connectSlotsByName(QObject * source, QObject * target)
{
if (!source || !target) return;
const QMetaObject * source_mo = source->metaObject();
const QMetaObject * target_mo = target->metaObject();
Q_ASSERT(source_mo);
Q_ASSERT(target_mo);
// find source's children
// and add source itself to the list, so we can autoconnect its signals too
const QObjectList list = source->findChildren<QObject *>(QString()) << source;
for (int i = 0; i < target_mo->methodCount(); ++i) {
const char *slot = target_mo->method(i).signature();
Q_ASSERT(slot);
if (slot[0] != 'o' || slot[1] != 'n' || slot[2] != '_')
continue;
bool foundIt = false;
for(int j = 0; j < list.count(); ++j) {
const QObject *co = list.at(j);
const QMetaObject *smo = co->metaObject();
QByteArray objName = co->objectName().toAscii();
int len = objName.length();
if (!len || qstrncmp(slot + 3, objName.data(), len) || slot[len+3] != '_')
continue;
int sigIndex = smo->indexOfSignal(slot + len + 4);
if (sigIndex < 0) { // search for compatible signals
int slotlen = qstrlen(slot + len + 4) - 1;
for (int k = 0; k < co->metaObject()->methodCount(); ++k) {
QMetaMethod method = smo->method(k);
if (method.methodType() != QMetaMethod::Signal)
continue;
if (!qstrncmp(method.signature(), slot + len + 4, slotlen)) {
sigIndex = k;
break;
}
}
}
if (sigIndex < 0)
continue;
if (QMetaObject::connect(co, sigIndex, target, i)) {
foundIt = true;
break;
}
}
if (foundIt) {
// we found our slot, now skip all overloads
while (target_mo->method(i + 1).attributes() & QMetaMethod::Cloned)
++i;
} else if (!(target_mo->method(i).attributes() & QMetaMethod::Cloned)) {
qWarning("QMetaObject::connectSlotsByName: No matching signal for %s", slot);
}
}
}
// Connect up a particular slot name, with optional arguments.
static void connect(QObject *qobj, PyObject *slot_obj,
const QByteArray &slot_nm, const QByteArray &args)
{
// Ignore if it's not an autoconnect slot.
if (!slot_nm.startsWith("on_"))
return;
// Extract the names of the emitting object and the signal.
int i;
i = slot_nm.lastIndexOf('_');
if (i - 3 < 1 || i + 1 >= slot_nm.size())
return;
QByteArray ename = slot_nm.mid(3, i - 3);
QByteArray sname = slot_nm.mid(i + 1);
// Find the emitting object and get its meta-object.
QObject *eobj = qobj->findChild<QObject *>(ename);
if (!eobj)
return;
const QMetaObject *mo = eobj->metaObject();
// Got through the methods looking for a matching signal.
for (int m = 0; m < mo->methodCount(); ++m)
{
QMetaMethod mm = mo->method(m);
if (mm.methodType() != QMetaMethod::Signal)
continue;
QByteArray sig(mm.methodSignature());
if (Chimera::Signature::name(sig) != sname)
continue;
// If we have slot arguments then they must match as well.
if (!args.isEmpty() && Chimera::Signature::arguments(sig) != args)
continue;
QObject *receiver;
QByteArray slot_sig;
if (pyqt5_get_connection_parts(slot_obj, eobj, sig.constData(), false, &receiver, slot_sig) != sipErrorNone)
continue;
// Add the type character.
sig.prepend('2');
// Connect the signal.
QObject::connect(eobj, sig.constData(), receiver, slot_sig.constData());
}
}
MetaMethodList MetaObjectInspector::slotMethods() const
{
MetaMethodList result;
for (int index=0; index<m_metaObject.methodCount(); index++) {
QMetaMethod metaMethod = m_metaObject.method(index);
if (metaMethod.methodType() == QMetaMethod::Slot)
result << m_metaObject.method(index);
}
return result;
}
void mafObjectBase::connectObjectSlotsByName(QObject *signal_object) {
const QMetaObject *mo = this->metaObject();
Q_ASSERT(mo);
const QObjectList list = qFindChildren<QObject *>(signal_object, QString());
for (int i = 0; i < mo->methodCount(); ++i) {
QMetaMethod method_slot = mo->method(i);
if (method_slot.methodType() != QMetaMethod::Slot)
continue;
const char *slot = mo->method(i).signature();
if (slot[0] != 'o' || slot[1] != 'n' || slot[2] != '_')
continue;
bool foundIt = false;
for(int j = 0; j < list.count(); ++j) {
const QObject *co = list.at(j);
QByteArray objName = co->objectName().toAscii();
int len = objName.length();
if (!len || qstrncmp(slot + 3, objName.data(), len) || slot[len+3] != '_')
continue;
int sigIndex = -1; //co->metaObject()->signalIndex(slot + len + 4);
const QMetaObject *smo = co->metaObject();
if (sigIndex < 0) { // search for compatible signals
int slotlen = qstrlen(slot + len + 4) - 1;
for (int k = 0; k < co->metaObject()->methodCount(); ++k) {
QMetaMethod method = smo->method(k);
if (method.methodType() != QMetaMethod::Signal)
continue;
if (!qstrncmp(method.signature(), slot + len + 4, slotlen)) {
const char *signal = method.signature();
QString event_sig = SIGNAL_SIGNATURE;
event_sig.append(signal);
QString observer_sig = CALLBACK_SIGNATURE;
observer_sig.append(slot);
if(connect(co, event_sig.toAscii(), this, observer_sig.toAscii())) {
qDebug() << mafTr("CONNECTED slot %1 with signal %2").arg(slot, signal);
foundIt = true;
break;
} else {
qWarning() << mafTr("Cannot connect slot %1 with signal %2").arg(slot, signal);
}
}
}
}
}
if (foundIt) {
// we found our slot, now skip all overloads
while (mo->method(i + 1).attributes() & QMetaMethod::Cloned)
++i;
} else if (!(mo->method(i).attributes() & QMetaMethod::Cloned)) {
qWarning("QMetaObject::connectSlotsByName: No matching signal for %s", slot);
}
}
}
QVariantMap JsonHandler::introspect(QMetaMethod::MethodType type)
{
QVariantMap data;
for (int i = 0; i < metaObject()->methodCount(); ++i) {
QMetaMethod method = metaObject()->method(i);
if (method.methodType() != type) {
continue;
}
switch (method.methodType()) {
case QMetaMethod::Method: {
if (!m_descriptions.contains(method.name()) || !m_params.contains(method.name()) || !m_returns.contains(method.name())) {
continue;
}
qCDebug(dcJsonRpc) << "got method" << method.name();
QVariantMap methodData;
methodData.insert("description", m_descriptions.value(method.name()));
methodData.insert("params", m_params.value(method.name()));
methodData.insert("returns", m_returns.value(method.name()));
data.insert(name() + "." + method.name(), methodData);
break;
}
case QMetaMethod::Signal: {
if (!m_descriptions.contains(method.name()) || !m_params.contains(method.name())) {
continue;
}
if (QString(method.name()).contains(QRegExp("^[A-Z]"))) {
qCDebug(dcJsonRpc) << "got signal" << method.name();
QVariantMap methodData;
methodData.insert("description", m_descriptions.value(method.name()));
methodData.insert("params", m_params.value(method.name()));
data.insert(name() + "." + method.name(), methodData);
}
break;
default:
;;// Nothing to do for slots
}
}
}
return data;
}
