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 metaMethodSignal = parent->method(i);
if (metaMethodSignal.methodType() != QMetaMethod::Signal)
continue;
// ### untested (QMetaMethod::signature())
if (strncmp(metaMethodSignal.methodSignature(), SIGNAL_PREFIX, SIGNAL_PREFIX_LEN) == 0) {
int receiverMethodCount = child->methodCount();
for (int j = 0; j < receiverMethodCount; ++j) {
QMetaMethod metaMethodSlot = child->method(j);
if (metaMethodSlot.methodType() != QMetaMethod::Slot)
continue;
if (strncmp(metaMethodSlot.methodSignature().constData(), SLOT_PREFIX, SLOT_PREFIX_LEN) == 0) {
if (strcmp(metaMethodSignal.methodSignature().constData() + SIGNAL_PREFIX_LEN, metaMethodSlot.methodSignature().constData() + SLOT_PREFIX_LEN) == 0) {
QByteArray signalString;
signalString.setNum(QSIGNAL_CODE);
signalString += metaMethodSignal.methodSignature();
QByteArray slotString;
slotString.setNum(QSLOT_CODE);
slotString += metaMethodSlot.methodSignature();
QObject::connect(sender, signalString, receiver, slotString);
}
}
}
}
}
}
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantMap& args,
QVariantList& converted_args)
{
QList<QByteArray> param_types = meta_method.parameterTypes();
if (args.size() != param_types.size()) {
logError(QString("wrong number of arguments to method %1 -- "
"expected %2 arguments, but got %3")
.arg(QString(meta_method.methodSignature()))
.arg(meta_method.parameterCount())
.arg(args.size()));
return false;
}
for (int i = 0; i < param_types.size(); i++) {
QByteArray param_name = meta_method.parameterNames().at(i);
if (args.find(param_name) == args.end()) {
// no arg with param name found
return false;
}
const QVariant& arg = args.value(param_name);
if (!arg.isValid()) {
logError(QString("argument %1 of %2 to method %3 is invalid")
.arg(i + 1)
.arg(param_types.size())
.arg(QString(meta_method.methodSignature())));
return false;
}
QByteArray arg_type_name = arg.typeName();
QByteArray param_type_name = param_types.at(i);
QVariant::Type param_type = QVariant::nameToType(param_type_name);
QVariant copy = QVariant(arg);
if (copy.type() != param_type) {
if (copy.canConvert(param_type)) {
if (!copy.convert(param_type)) {
// qDebug() << "cannot convert" << arg_type_name
// << "to" << param_type_name;
return false;
}
}
}
converted_args << copy;
}
return true;
}
void InvokeMethod::on_comboMethods_activated(const QString &method)
{
if (!activex)
return;
listParameters->clear();
const QMetaObject *mo = activex->metaObject();
const QMetaMethod slot = mo->method(mo->indexOfSlot(method.toLatin1()));
QString signature = QString::fromLatin1(slot.methodSignature());
signature = signature.mid(signature.indexOf(QLatin1Char('(')) + 1);
signature.truncate(signature.length()-1);
QList<QByteArray> pnames = slot.parameterNames();
QList<QByteArray> ptypes = slot.parameterTypes();
for (int p = 0; p < ptypes.count(); ++p) {
QString ptype(QString::fromLatin1(ptypes.at(p)));
if (ptype.isEmpty())
continue;
QString pname(QString::fromLatin1(pnames.at(p).constData()));
if (pname.isEmpty())
pname = QString::fromLatin1("<unnamed %1>").arg(p);
QTreeWidgetItem *item = new QTreeWidgetItem(listParameters);
item->setText(0, pname);
item->setText(1, ptype);
}
if (listParameters->topLevelItemCount())
listParameters->setCurrentItem(listParameters->topLevelItem(0));
editReturn->setText(QString::fromLatin1(slot.typeName()));
}
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.methodSignature()));
}
comboMethods->model()->sort(0);
on_comboMethods_activated(comboMethods->currentText());
}
}
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();
}
void QtInstance::getPropertyNames(ExecState* exec, PropertyNameArray& array)
{
// This is the enumerable properties, so put:
// properties
// dynamic properties
// slots
QObject* obj = getObject();
if (obj) {
const QMetaObject* meta = obj->metaObject();
int i;
for (i = 0; i < meta->propertyCount(); i++) {
QMetaProperty prop = meta->property(i);
if (prop.isScriptable())
array.add(Identifier(exec, prop.name()));
}
#ifndef QT_NO_PROPERTIES
QList<QByteArray> dynProps = obj->dynamicPropertyNames();
foreach (const QByteArray& ba, dynProps)
array.add(Identifier(exec, ba.constData()));
#endif
const int methodCount = meta->methodCount();
for (i = 0; i < methodCount; i++) {
QMetaMethod method = meta->method(i);
if (method.access() != QMetaMethod::Private) {
QByteArray sig = method.methodSignature();
array.add(Identifier(exec, String(sig.constData(), sig.length())));
}
}
}
}
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;
}
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();
}
// 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");
}
void Nuria::ObjectWrapperResourcePrivate::connectToSignal (QMetaMethod method) {
// Connect objects' signal to our homegrown qt_metacall().
int index = method.methodIndex ();
if (!QMetaObject::connect (this->object, index, this, index, Qt::DirectConnection)) {
nError() << "connect() failed on" << this->object << "for signal" << method.methodSignature ();
}
}
static QByteArray QMetaMethod_name(const QMetaMethod &m)
{
QByteArray sig = m.methodSignature();
int paren = sig.indexOf('(');
if (paren == -1)
return sig;
else
return sig.left(paren);
}
// 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());
}
}
void tst_qmetaobject::indexOfMethod_data()
{
QTest::addColumn<QByteArray>("method");
const QMetaObject *mo = &QTreeView::staticMetaObject;
for (int i = 0; i < mo->methodCount(); ++i) {
QMetaMethod method = mo->method(i);
QByteArray sig = method.methodSignature();
QTest::newRow(sig) << sig;
}
}
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();
}
/*!
\internal
Returns the signal that corresponds to \a proxySignal in the
meta-object of the \a sourceObject.
*/
static QMetaMethod proxyToSourceSignal(const QMetaMethod &proxySignal, QObject *sourceObject)
{
if (!proxySignal.isValid())
return proxySignal;
Q_ASSERT(proxySignal.methodType() == QMetaMethod::Signal);
Q_ASSERT(sourceObject != 0);
const QMetaObject *sourceMeta = sourceObject->metaObject();
int sourceIndex = sourceMeta->indexOfSignal(proxySignal.methodSignature());
Q_ASSERT(sourceIndex != -1);
return sourceMeta->method(sourceIndex);
}
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();
}
void QDBusAdaptorConnector::relay(QObject *senderObj, int lastSignalIdx, void **argv)
{
if (lastSignalIdx < QObject::staticMetaObject.methodCount())
// QObject signal (destroyed(QObject *)) -- ignore
return;
const QMetaObject *senderMetaObject = senderObj->metaObject();
QMetaMethod mm = senderMetaObject->method(lastSignalIdx);
QObject *realObject = senderObj;
if (qobject_cast<QDBusAbstractAdaptor *>(senderObj))
// it's an adaptor, so the real object is in fact its parent
realObject = realObject->parent();
// break down the parameter list
QVector<int> types;
QString errorMsg;
int inputCount = qDBusParametersForMethod(mm, types, errorMsg);
if (inputCount == -1) {
// invalid signal signature
qWarning("QDBusAbstractAdaptor: Cannot relay signal %s::%s: %s",
senderMetaObject->className(), mm.methodSignature().constData(),
qPrintable(errorMsg));
return;
}
if (inputCount + 1 != types.count() ||
types.at(inputCount) == QDBusMetaTypeId::message()) {
// invalid signal signature
qWarning("QDBusAbstractAdaptor: Cannot relay signal %s::%s",
senderMetaObject->className(), mm.methodSignature().constData());
return;
}
QVariantList args;
for (int i = 1; i < types.count(); ++i)
args << QVariant(types.at(i), argv[i]);
// now emit the signal with all the information
emit relaySignal(realObject, senderMetaObject, lastSignalIdx, args);
}
/**
* @brief JsRoboKey::getMethods
* Get a string showing all of the methods available to connect
* @return
*/
QString JsRoboKey::getMethods()
{
QString s = "";
for (int i = 0; i < this->metaObject()->methodCount(); i++)
{
QMetaMethod method = this->metaObject()->method(i);
if (method.methodType() == QMetaMethod::Slot && method.access() == QMetaMethod::Public){
if (s != ""){ s += "\n"; }
s += method.methodSignature();
}
}
return s;
}
QServiceProxy::QServiceProxy(const QByteArray& metadata, ObjectEndPoint* endPoint, QObject* parent)
: QServiceProxyBase(endPoint, parent)
{
Q_ASSERT(endPoint);
d = new QServiceProxyPrivate();
d->metadata = metadata;
d->meta = 0;
d->endPoint = endPoint;
d->localToRemote = 0;
d->remoteToLocal = 0;
QDataStream stream(d->metadata);
QMetaObjectBuilder builder;
QMap<QByteArray, const QMetaObject*> refs;
builder.deserialize(stream, refs);
if (stream.status() != QDataStream::Ok) {
qWarning() << "Invalid metaObject for service received";
} else {
QMetaObject *remote = builder.toMetaObject();
builder.setSuperClass(QServiceProxyBase::metaObject());
QMetaObject *local = builder.toMetaObject();
d->remoteToLocal = new int[local->methodCount()];
d->localToRemote = new int[local->methodCount()];
for (int i = 0; i < local->methodCount(); i++){
const QMetaMethod m = local->method(i);
int r = remote->indexOfMethod(m.methodSignature().constData());
d->localToRemote[i] = r;
if (r > 0)
d->remoteToLocal[r] = i;
}
#if defined(QT_SFW_IPC_DEBUG) && defined(QT_SFW_IPC_DEBUG_VERBOSE)
QString mapping = QString::fromLatin1("%%% QWE Doing lookup table for ") + endPoint->objectName();
for (int i = 0; i < local->methodCount(); i++){
const QMetaMethod m = local->method(i);
int r = d->localToRemote[i];
mapping.append(QString::fromLatin1("\n%%%Mapping %1 from %2 to %3").arg(QString::fromLatin1(m.signature())).arg(i).arg(r));
}
QServiceDebugLog::instance()->appendToLog(mapping);
#endif
d->meta = local;
endPoint->setLookupTable(d->localToRemote, d->remoteToLocal);
}
}
static bool hasMetaMethodStartingWith(QObject *object, const QString &checkedSignature)
{
const QMetaObject *mo = object->metaObject();
bool found = false;
for (int methodIndex = 0; methodIndex < mo->methodCount(); ++methodIndex) {
QMetaMethod mm = mo->method(methodIndex);
QString signature = QString::fromLatin1(mm.methodSignature());
if (signature.startsWith(checkedSignature)) {
found = true;
break;
}
}
return found;
}
static void getSlots( const QMetaObject *meta, QList<Property> &result,
bool super, bool withArgs, bool sigs )
{
while (meta) {
int nmethods = meta->methodCount();
for (int i=0; i<nmethods; ++i) {
const QMetaMethod m = meta->method(i);
if (m.access() == QMetaMethod::Private)
continue ;
if ((m.methodType() == QMetaMethod::Slot && !sigs) ||
(m.methodType() == QMetaMethod::Signal && sigs)) {
Property prop;
QString s = QLatin1String( m.methodSignature() );
s = s.left(s.indexOf('('));
QList<QByteArray> parameterTypes = m.parameterTypes();
QList<QByteArray> parameterNames = m.parameterNames();
prop.type = m.typeName();
QuickInterpreter::cleanType(prop.type);
if ( withArgs ) {
s += QLatin1String("(");
for ( int j = 0; j < parameterTypes.count(); ++j ) {
s += parameterTypes.at(j);
s += QLatin1String(" ");
s += QString::fromLatin1(parameterNames.at(j));
if ( j < parameterTypes.count() - 1 )
s += QString::fromLatin1(",");
}
s += QString::fromLatin1(")");
}
prop.name = s;
if (result.indexOf(prop) == -1)
result << prop;
}
}
if (super)
meta = meta->superClass();
else
meta = 0;
}
}
QDeclarativePropertyCache::Data QDeclarativePropertyCache::create(const QMetaObject *metaObject,
const QString &property)
{
Q_ASSERT(metaObject);
QDeclarativePropertyCache::Data rv;
{
const QMetaObject *cmo = metaObject;
while (cmo) {
int idx = metaObject->indexOfProperty(property.toUtf8());
if (idx != -1) {
QMetaProperty p = metaObject->property(idx);
if (p.isScriptable()) {
rv.load(metaObject->property(idx));
return rv;
} else {
while (cmo && cmo->propertyOffset() >= idx)
cmo = cmo->superClass();
}
} else {
cmo = 0;
}
}
}
int methodCount = metaObject->methodCount();
// >=QObject::staticMetaObject.methodCount() to block the destroyed signal and deleteLater() slot
// and other QObject methods.
for (int ii = methodCount - 1; ii >= QObject::staticMetaObject.methodCount(); --ii) {
QMetaMethod m = metaObject->method(ii);
if (m.access() == QMetaMethod::Private)
continue;
QString methodName = QString::fromUtf8(m.methodSignature());
int parenIdx = methodName.indexOf(QLatin1Char('('));
Q_ASSERT(parenIdx != -1);
QStringRef methodNameRef = methodName.leftRef(parenIdx);
if (methodNameRef == property) {
rv.load(m);
return rv;
}
}
return rv;
}
QString QDeclarativePropertyCache::Data::name(const QMetaObject *metaObject)
{
if (!metaObject || coreIndex == -1)
return QString();
if (flags & IsFunction) {
QMetaMethod m = metaObject->method(coreIndex);
QString name = QString::fromUtf8(m.methodSignature());
int parenIdx = name.indexOf(QLatin1Char('('));
if (parenIdx != -1)
name = name.left(parenIdx);
return name;
} else {
QMetaProperty p = metaObject->property(coreIndex);
return QString::fromUtf8(p.name());
}
}
void tst_QQmlMetaObject::method()
{
QFETCH(QString, testFile);
QFETCH(QString, signature);
QFETCH(QMetaMethod::MethodType, methodType);
QFETCH(int, returnType);
QFETCH(QString, returnTypeName);
QFETCH(QList<int>, parameterTypes);
QFETCH(QList<QByteArray>, parameterTypeNames);
QFETCH(QList<QByteArray>, parameterNames);
QCOMPARE(parameterTypes.size(), parameterTypeNames.size());
QCOMPARE(parameterTypeNames.size(), parameterNames.size());
QQmlEngine engine;
QQmlComponent component(&engine, testFileUrl(testFile));
QObject *object = component.create();
QVERIFY(object != 0);
const QMetaObject *mo = object->metaObject();
QVERIFY(mo->superClass() != 0);
QVERIFY(QByteArray(mo->className()).contains("_QML_"));
QCOMPARE(mo->methodOffset(), mo->superClass()->methodCount());
QCOMPARE(mo->methodCount(), mo->superClass()->methodCount() + 1);
QMetaMethod method = mo->method(mo->methodOffset());
QCOMPARE(method.methodType(), methodType);
QCOMPARE(QString::fromUtf8(method.methodSignature().constData()), signature);
QCOMPARE(method.access(), QMetaMethod::Public);
QString computedName = signature.left(signature.indexOf('('));
QCOMPARE(QString::fromUtf8(method.name()), computedName);
QCOMPARE(method.parameterCount(), parameterTypes.size());
for (int i = 0; i < parameterTypes.size(); ++i)
QCOMPARE(method.parameterType(i), parameterTypes.at(i));
QCOMPARE(method.parameterTypes(), parameterTypeNames);
QCOMPARE(method.tag(), "");
QCOMPARE(QString::fromUtf8(method.typeName()), returnTypeName);
QCOMPARE(method.returnType(), returnType);
delete object;
}
void QxtWebJsonRPCService::Private::initTables(QObject *in)
{
invokable = in;
const QMetaObject *po = invokable->metaObject();
for (int i = po->methodOffset(); i < po->methodCount(); i++) {
QxtWebJsonRPCService::Private::Method method;
QMetaMethod mo = po->method (i);
#if QT_VERSION >= 0x50000
method.name = QByteArray(mo.methodSignature()).split('(').at(0);
#else
method.name = QByteArray(mo.signature()).split('(').at(0);
#endif
method.meta = mo;
method.argCount = mo.parameterTypes ().count();
method.returns = QByteArray(mo.typeName()).count();
methods.insert(method.name + QByteArray::number(method.argCount), method);
}
}
void connectFunctions(ChildrenInterface* children) {
Q_ASSERT( m_engine );
Q_ASSERT( ! m_engine->hasUncaughtException() );
QString eval;
QScriptValue global = m_engine->globalObject();
QHashIterator< QString, ChildrenInterface::Options > it( children->objectOptions() );
while(it.hasNext()) {
it.next();
if( it.value() & ChildrenInterface::AutoConnectSignals ) {
QObject* sender = children->object(it.key());
if( ! sender )
continue;
QScriptValue obj = m_engine->globalObject().property(it.key());
if( ! obj.isQObject() )
continue;
const QMetaObject* mo = sender->metaObject();
const int count = mo->methodCount();
for(int i = 0; i < count; ++i) {
QMetaMethod mm = mo->method(i);
#if QT_VERSION < 0x050000
const QString signature = mm.signature();
#else
const QString signature = mm.methodSignature();
#endif
const QString name = signature.left(signature.indexOf('('));
if( mm.methodType() == QMetaMethod::Signal ) {
QScriptValue func = global.property(name);
if( ! func.isFunction() ) {
//qrossdebug( QString("EcmaScript::connectFunctions No function to connect with %1.%2").arg(it.key()).arg(name) );
continue;
}
qrossdebug( QString("EcmaScript::connectFunctions Connecting with %1.%2").arg(it.key()).arg(name) );
eval += QString("try { %1.%2.connect(%3); } catch(e) { print(e); }\n").arg(it.key()).arg(name).arg(name);
}
}
}
}
Q_ASSERT( ! m_engine->hasUncaughtException() );
if( ! eval.isNull() ) {
m_engine->evaluate(eval);
Q_ASSERT( ! m_engine->hasUncaughtException() );
}
}
static inline QList<QMetaMethod> methodsByName(const QObject *object,
const QString &methodName)
{
QList<QMetaMethod> methods;
QStringList methodSignatures;
for (int i = 0; i < object->metaObject()->methodCount(); i++) {
QMetaMethod method = object->metaObject()->method(i);
QString signature(method.methodSignature());
if (QRegExp(QString("\\s*%1\\s*\\(.*").arg(methodName))
.exactMatch(signature))
if (!methodSignatures.contains(signature)) {
methods << method;
methodSignatures << signature;
}
}
return methods;
}
PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo)
{
#ifdef PYTHONQT_DEBUG
#if( QT_VERSION >= QT_VERSION_CHECK(5,0,0) )
QByteArray sig(meta.methodSignature());
#else
QByteArray sig(meta.signature());
#endif
sig = sig.mid(sig.indexOf('('));
QByteArray fullSig = QByteArray(meta.typeName()) + " " + sig;
std::cout << "caching " << fullSig.data() << std::endl;
#endif
ParameterInfo type;
fillParameterInfo(type, QByteArray(meta.typeName()), classInfo);
_parameters.append(type);
QList<QByteArray> names = meta.parameterTypes();
Q_FOREACH (const QByteArray& name, names) {
fillParameterInfo(type, name, classInfo);
_parameters.append(type);
}
/**
\ingroup q4pugss
\internal
\brief
*/
bool q4pugss_GetMethodString(QObject* caller, int method_index, void **argv, QString &string)
{
const QMetaObject * mo = caller->metaObject();
if( !mo )
return false;
QMetaMethod m = mo->method(method_index);
if( method_index >= mo->methodCount() )
return false;
static QString methodType[] = {"Method", "Signal", "Slot"};
string.fill(' ', TabSize);
string = QString("%1 (%2) ")
.arg(caller->objectName().isNull()?"noname":caller->objectName())
.arg(mo->className());
#if QT_VERSION < 0x050000
string += QString("%1: %2(")
.arg(methodType[(int)m.methodType()])
.arg(QString(m.signature()).section('(',0,0));
#else
string += QString("%1: %2(")
.arg(methodType[(int)m.methodType()])
.arg(QString(m.methodSignature()).section('(',0,0));
#endif
QList<QByteArray> pNames = m.parameterNames();
QList<QByteArray> pTypes = m.parameterTypes();
for(int i=0; i<pNames.count(); i++) {
string += QString("%1=%2")
.arg(QString(pNames.at(i)))
.arg(q4pugss_value(pTypes.at(i), argv[i+1]));
if(i != pNames.count()-1)
string += ", ";
}
string += QString(")");
return true;
}
/*!
Toggles automatic signal relaying from the real object (see object()).
Automatic signal relaying consists of signal-to-signal connection of the signals on the parent
that have the exact same method signatue in both classes.
If \a enable is set to true, connect the signals; if set to false, disconnect all signals.
*/
void QDBusAbstractAdaptor::setAutoRelaySignals(bool enable)
{
const QMetaObject *us = metaObject();
const QMetaObject *them = parent()->metaObject();
bool connected = false;
for (int idx = staticMetaObject.methodCount(); idx < us->methodCount(); ++idx) {
QMetaMethod mm = us->method(idx);
if (mm.methodType() != QMetaMethod::Signal)
continue;
// try to connect/disconnect to a signal on the parent that has the same method signature
QByteArray sig = QMetaObject::normalizedSignature(mm.methodSignature().constData());
if (them->indexOfSignal(sig) == -1)
continue;
sig.prepend(QSIGNAL_CODE + '0');
parent()->disconnect(sig, this, sig);
if (enable)
connected = connect(parent(), sig, sig) || connected;
}
d_func()->autoRelaySignals = connected;
}
