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;
}
void MethodViewer::_invokeMethodEvery() {
QAction *sender = static_cast<QAction*>(this->sender());
Item *item = sender->property("treeItem").value<MethodViewer::Item*>();
QMetaMethod method = item->getMethod();
bool bOk;
int interval = QInputDialog::getInt(this, tr("Invoke method %1 every...").arg(method.signature()),
tr("Interval in seconds"), 5, 1, 30, 1, &bOk);
if (!bOk) return;
m_invokedMethod = method;
m_invokedObject = item->getObject();
m_invokeTimer.start(interval*1000);
}
void Timed::invoke_signal(const nanotime_t &back)
{
log_debug("systime_back=%s, back=%s", systime_back.str().c_str(), back.str().c_str()) ;
systime_back += back ;
log_debug("new value: systime_back=%s", systime_back.str().c_str()) ;
if(signal_invoked)
return ;
signal_invoked = true ;
int methodIndex = this->metaObject()->indexOfMethod("send_time_settings()") ;
QMetaMethod method = this->metaObject()->method(methodIndex);
method.invoke(this, Qt::QueuedConnection);
log_assert(q_pause==NULL) ;
q_pause = new machine_t::pause_t(am) ;
log_debug("new q_pause=%p", q_pause) ;
}
static int publicMethodIndex(NPObject *npobj, NPIdentifier name)
{
NPClass_Prolog;
QByteArray qname = NPN_UTF8FromIdentifier(name);
const QMetaObject *metaObject = qobject->metaObject();
for (int slotIndex = metaOffset(metaObject, MetaMethod); slotIndex < metaObject->methodCount(); ++slotIndex) {
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
if (slot.access() != QMetaMethod::Public || slot.methodType() == QMetaMethod::Signal)
continue;
QByteArray signature = slot.signature();
if (signature.left(signature.indexOf('(')) == qname)
return slotIndex;
}
return -1;
}
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));
if (!isDynamicMetaObject(cmo))
rv.flags |= Data::IsDirect;
return rv;
} else {
while (cmo && cmo->propertyOffset() >= idx)
cmo = cmo->superClass();
}
} else {
cmo = 0;
}
}
}
int methodCount = metaObject->methodCount();
for (int ii = methodCount - 1; ii >= 3; --ii) { // >=3 to block the destroyed signal and deleteLater() slot
QMetaMethod m = metaObject->method(ii);
if (m.access() == QMetaMethod::Private)
continue;
QString methodName = QString::fromUtf8(m.signature());
int parenIdx = methodName.indexOf(QLatin1Char('('));
Q_ASSERT(parenIdx != -1);
QStringRef methodNameRef = methodName.leftRef(parenIdx);
if (methodNameRef == property) {
rv.load(m);
if (!isDynamicMetaObject(m.enclosingMetaObject()))
rv.flags |= Data::IsDirect;
return rv;
}
}
return rv;
}
void listInterface(const QString &service, const QString &path, const QString &interface)
{
QDBusInterfacePtr iface(*connection, service, path, interface);
if (!iface->isValid()) {
QDBusError err(iface->lastError());
fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n",
qPrintable(interface), qPrintable(path), qPrintable(service),
qPrintable(err.name()), qPrintable(err.message()));
exit(1);
}
const QMetaObject *mo = iface->metaObject();
// properties
for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i) {
QMetaProperty mp = mo->property(i);
printf("property ");
if (mp.isReadable() && mp.isWritable())
printf("readwrite");
else if (mp.isReadable())
printf("read");
else
printf("write");
printf(" %s %s.%s\n", mp.typeName(), qPrintable(interface), mp.name());
}
// methods (signals and slots)
for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
QMetaMethod mm = mo->method(i);
QByteArray signature = mm.signature();
signature.truncate(signature.indexOf('('));
printf("%s %s%s%s %s.%s(",
mm.methodType() == QMetaMethod::Signal ? "signal" : "method",
mm.tag(), *mm.tag() ? " " : "",
*mm.typeName() ? mm.typeName() : "void",
qPrintable(interface), signature.constData());
QList<QByteArray> types = mm.parameterTypes();
QList<QByteArray> names = mm.parameterNames();
bool first = true;
for (int i = 0; i < types.count(); ++i) {
printf("%s%s",
first ? "" : ", ",
types.at(i).constData());
if (!names.at(i).isEmpty())
printf(" %s", names.at(i).constData());
first = false;
}
printf(")\n");
}
}
int DynamicQObject::findSignalId(const char *signal)
{
#if 0
const QMetaObject *meta = obj->metaObject();
// Finding signal id
for (int i = meta->methodOffset(); i < meta->methodCount(); ++i) {
QMetaMethod method = meta->method(i);
const char *methodName = method.name().data();
if (strcmp(signal, methodName) == 0)
return i;
}
#endif
return -1;
}
static int publicMethodIndex(NPObject *npobj, const QByteArray &slotName, int argCount = -1)
{
NPClass_Prolog;
const QMetaObject *metaObject = qobject->metaObject();
for (int slotIndex = metaOffset(metaObject, MetaMethod); slotIndex < metaObject->methodCount(); ++slotIndex) {
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
if (slot.access() != QMetaMethod::Public || slot.methodType() == QMetaMethod::Signal)
continue;
QByteArray signature = slot.signature();
if (signature.left(signature.indexOf('(')) == slotName) {
if (argCount == -1 || slot.parameterTypes().count() == argCount)
return slotIndex;
}
}
return -1;
}
bool QObject::isSignalConnected(const QMetaMethod &signalMetaMethod) const
{
bool retval = false;
const BentoAbstract *signalMethod_Bento = signalMetaMethod.getBentoBox();
std::unique_lock<std::mutex> senderLock{this->m_mutex_ToReceiver};
for(auto index = this->m_connectList_ToReceiver.begin(); index != this->m_connectList_ToReceiver.end(); ++index) {
const ConnectStruct &temp = *index;
if (*(temp.signalMethod) != *(signalMethod_Bento)) {
continue;
}
if (temp.sender == 0) {
// connection is marked for deletion
continue;
}
retval = true;
break;
}
return retval;
}
static inline QByteArray getMethodName(const QMetaMethod& method) {
QByteArray name(method.signature());
int bracket = name.indexOf("(");
if (bracket >= 0)
name.remove(bracket, name.size() - bracket);
return name;
}
bool PacketReceiver::registerListener(PacketType type, QObject* listener, const char* slot,
bool deliverPending) {
Q_ASSERT_X(listener, "PacketReceiver::registerListener", "No object to register");
Q_ASSERT_X(slot, "PacketReceiver::registerListener", "No slot to register");
QMetaMethod matchingMethod = matchingMethodForListener(type, listener, slot);
if (matchingMethod.isValid()) {
qCDebug(networking) << "Registering a packet listener for packet list type" << type;
registerVerifiedListener(type, listener, matchingMethod, deliverPending);
return true;
} else {
qCWarning(networking) << "FAILED to Register a packet listener for packet list type" << type;
return false;
}
}
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result)
{
NPClass_Prolog;
int slotIndex = publicMethodIndex(npobj, name);
if (slotIndex == -1) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("No such method " + qname).constData());
return false;
}
const QMetaMethod slot = qobject->metaObject()->method(slotIndex);
QList<QByteArray> parameterTypes = slot.parameterTypes();
if (parameterTypes.count() != static_cast<int>(argCount)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + qname).constData());
return false;
}
QVariant returnVariant(QVariant::nameToType(slot.typeName()), (void *)0);
QVector<QVariant> variants(parameterTypes.count()); // keep data alive
QVector<const void *> metacallArgs(parameterTypes.count() + 1); // arguments for qt_metacall
metacallArgs[0] = returnVariant.data(); // args[0] == return value
for (int p = 0; p < parameterTypes.count(); ++p) {
QVariant::Type type = QVariant::nameToType(parameterTypes.at(p));
if (type == QVariant::Invalid) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter in method " + qname).constData());
return false;
}
QVariant qvar = args[p];
if (!qvar.convert(type)) {
QByteArray qname = NPN_UTF8FromIdentifier(name);
NPN_SetException(npobj, QByteArray("Unsupported parameter value in method " + qname).constData());
return false;
}
variants[p] = qvar;
metacallArgs[p + 1] = variants.at(p).constData(); // must not detach!
}
qobject->qt_metacall(QMetaObject::InvokeMetaMethod, slotIndex, const_cast<void * *>(metacallArgs.data()));
if (returnVariant.isValid() && result)
*result = NPVariant::fromQVariant(This, returnVariant);
return true;
}
/* We catch all qt_metacall invocations */
extern "C" SEXP qt_qmetacall(SEXP x, SEXP s_call, SEXP s_id, SEXP s_args)
{
SmokeObject *so = SmokeObject::fromSexp(x);
QMetaObject::Call call =
enum_from_sexp<QMetaObject::Call>(s_call, SmokeType());
int id = from_sexp<int>(s_id);
void **args = reinterpret_cast<void **>(from_sexp<void *>(s_args));
// Assume the target slot is a C++ one
Smoke::StackItem i[4];
i[1].s_enum = call;
i[2].s_int = id;
i[3].s_voidp = args;
so->invokeMethod("qt_metacall$$?", i);
int ret = i[0].s_int;
if (ret < 0) {
return ScalarInteger(ret);
}
if (call != QMetaObject::InvokeMetaMethod)
return ScalarInteger(id);
QObject * qobj = reinterpret_cast<QObject *>(so->castPtr("QObject"));
// get obj metaobject with a virtual call
const QMetaObject *metaobject = qobj->metaObject();
// get method count
int count = metaobject->methodCount();
QMetaMethod method = metaobject->method(id);
if (method.methodType() == QMetaMethod::Signal) {
// FIXME: this override of 'activate' is obsolete
metaobject->activate(qobj, id, (void**) args);
return ScalarInteger(id - count);
}
DynamicBinding binding(MocMethod(so->smoke(), metaobject, id));
QVector<SmokeType> stackTypes = binding.types();
MocStack mocStack = MocStack(args, stackTypes.size());
SmokeStack smokeStack = mocStack.toSmoke(stackTypes);
binding.invoke(so, smokeStack.items());
mocStack.returnFromSmoke(smokeStack, stackTypes[0]);
if (binding.lastError() == Method::NoError)
warning("Slot invocation failed for %s::%s", so->klass()->name(),
binding.name());
return ScalarInteger(id - count);
}
/*!
Places a call to the remote method specified by \a method on this interface, using \a args as
arguments. This function returns the message that was received as a reply, which can be a normal
QDBusMessage::ReplyMessage (indicating success) or QDBusMessage::ErrorMessage (if the call
failed). The \a mode parameter specifies how this call should be placed.
If the call succeeds, lastError() will be cleared; otherwise, it will contain the error this
call produced.
Normally, you should place calls using call().
\warning If you use \c UseEventLoop, your code must be prepared to deal with any reentrancy:
other method calls and signals may be delivered before this function returns, as well
as other Qt queued signals and events.
\threadsafe
*/
QDBusMessage QDBusAbstractInterface::callWithArgumentList(QDBus::CallMode mode,
const QString& method,
const QList<QVariant>& args)
{
Q_D(QDBusAbstractInterface);
QString m = method;
// split out the signature from the method
int pos = method.indexOf(QLatin1Char('.'));
if (pos != -1)
m.truncate(pos);
if (mode == QDBus::AutoDetect) {
// determine if this a sync or async call
mode = QDBus::Block;
const QMetaObject *mo = metaObject();
QByteArray match = m.toLatin1() + '(';
for (int i = staticMetaObject.methodCount(); i < mo->methodCount(); ++i) {
QMetaMethod mm = mo->method(i);
if (QByteArray(mm.signature()).startsWith(match)) {
// found a method with the same name as what we're looking for
// hopefully, nobody is overloading asynchronous and synchronous methods with
// the same name
QList<QByteArray> tags = QByteArray(mm.tag()).split(' ');
if (tags.contains("Q_NOREPLY"))
mode = QDBus::NoBlock;
break;
}
}
}
// qDebug() << "QDBusAbstractInterface" << "Service" << service() << "Path:" << path();
QDBusMessage msg = QDBusMessage::createMethodCall(service(), path(), interface(), m);
msg.setArguments(args);
QDBusMessage reply = d->connection.call(msg, mode);
d->lastError = reply; // will clear if reply isn't an error
// ensure that there is at least one element
if (reply.arguments().isEmpty())
reply << QVariant();
return reply;
}
static int lqtL_connect(lua_State *L) {
static int methodId = 0;
QObject* sender = static_cast<QObject*>(lqtL_toudata(L, 1, "QObject*"));
if (sender == NULL)
return luaL_argerror(L, 1, "sender not QObject*");
const char *signal = luaL_checkstring(L, 2);
const QMetaObject *senderMeta = sender->metaObject();
int idxS = senderMeta->indexOfSignal(signal + 1);
if (idxS == -1)
return luaL_argerror(L, 2, qPrintable(QString("no such sender signal: '%1'").arg(signal + 1)));
QObject* receiver;
QString methodName;
if (lua_type(L, 3) == LUA_TFUNCTION) {
receiver = sender;
// simulate sender:__addmethod('LQT_SLOT_X(signature)', function()...end)
QMetaMethod m = senderMeta->method(idxS);
methodName = QString(m.signature()).replace(QRegExp("^[^\\(]+"), QString("LQT_SLOT_%1").arg(methodId++));
lua_getfield(L, 1, "__addmethod");
lua_pushvalue(L, 1);
lua_pushstring(L, qPrintable(methodName));
lua_pushvalue(L, 3);
lua_call(L, 3, 0);
methodName.prepend("1");
} else {
receiver = static_cast<QObject*>(lqtL_toudata(L, 3, "QObject*"));
if (receiver == NULL)
return luaL_argerror(L, 3, "receiver not QObject*");
const char *method = luaL_checkstring(L, 4);
methodName = method;
const QMetaObject *receiverMeta = receiver->metaObject();
int idxR = receiverMeta->indexOfMethod(method + 1);
if (idxR == -1)
return luaL_argerror(L, 4, qPrintable(QString("no such receiver method: '%1'").arg(method + 1)));
}
bool ok = QObject::connect(sender, signal, receiver, qPrintable(methodName));
lua_pushboolean(L, ok);
return 1;
}
QString QbPersistable::getObjectString() {
QString prefix = QbProperties::getInstance()->getProperty("qubic.configuration.getters.prefix");
QString objectString;
for(int i = 0; i < this->metaObject()->methodCount(); i++)
{
QMetaMethod method = this->metaObject()->method(i);
if(method.name().startsWith(prefix.toStdString().c_str()))
{
QString memberName = method.name().right(method.name().length() - prefix.length());
memberName = memberName.toUpper();
QString memberValue = QbMappingHelper::getStringValue(*this, method);
objectString.append(memberName + " = " + memberValue + "; ");
}
}
objectString = objectString.left(objectString.length() - 2);
return objectString;
}
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
&& 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;
}
}
}
}
}
}
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());
}
PythonQtMethodInfo::PythonQtMethodInfo(const QMetaMethod& meta, PythonQtClassInfo* classInfo)
{
#ifdef PYTHONQT_DEBUG
QByteArray sig(meta.signature());
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();
foreach (const QByteArray& name, names) {
fillParameterInfo(type, name, classInfo);
_parameters.append(type);
}
inline int indexOfMethod( const QMetaObject * metaObject,
const QByteArray methodName, int methodType = -1 )
{
while (metaObject->superClass() != 0)
{
for (int idx = metaObject->methodOffset(); idx < metaObject->methodCount(); ++idx)
{
QMetaMethod method = metaObject->method(idx);
if (methodType != -1 && method.methodType() != methodType)
continue;
if (method.name() == methodName)
return idx;
}
metaObject = metaObject->superClass();
}
return -1;
}
QByteArray MaiaXmlRpcServerConnection::getReturnType( const QMetaObject *obj,
const QByteArray &method,
const QList<QByteArray> &argTypes )
{
for( int n = 0; n < obj->methodCount(); ++n ) {
QMetaMethod m = obj->method(n);
#if QT_VERSION >= 0x050000
if( m.name() == method && m.parameterTypes() == argTypes ) {
return m.typeName();
}
#else
QByteArray sig = m.signature();
int offset = sig.indexOf('(');
if( offset == -1 ) {
continue;
}
QByteArray name = sig.mid(0, offset);
if( name == method && m.parameterTypes() == argTypes ) {
return m.typeName();
}
#endif
}
return QByteArray();
} // QByteArray getReturnType( const QMetaObject *obj, const QByteArray &method, const QList<QByteArray> &argTypes )
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantList& 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++) {
const QVariant& arg = args.at(i);
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;
}
QString ExtendedBase::fromMethodToCallbackFlag(const QMetaMethod &method)
{
QString buf;
buf += method.name();
buf += "(";
for(auto index = 0; index < method.parameterCount(); index++)
{
if(index)
{
buf += ",";
}
buf += method.parameterTypes()[index];
}
buf += ")";
return buf;
}
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.signature());
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 QDeclarativePropertyCache::Data::load(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)
propType = QMetaType::type(returnType);
QList<QByteArray> params = m.parameterTypes();
if (!params.isEmpty())
flags |= Data::HasArguments;
revision = m.revision();
}
void Nuria::ObjectWrapperResourcePrivate::addMethodToPropertyList (QMetaMethod method, Method &descriptor) {
Nuria::Resource::Property::Type type = (method.methodType () == QMetaMethod::Signal)
? Nuria::Resource::Property::Signal
: Nuria::Resource::Property::Slot;
QString name = QString::fromLatin1 (method.name ());
int resultType = method.returnType ();
Nuria::Resource::ArgumentTypeMap args;
// Convert descriptor to argument type map
for (int i = 0; i < descriptor.names.length (); i++) {
args.insert (descriptor.names.at (i), descriptor.types.at (i));
}
// Add to list
descriptor.propertyIndex = this->propertyList.length ();
this->propertyList.append (Nuria::Resource::Property (type, name, args, resultType));
}
QStringList Component::getEffectList()
{
QMetaObject metaObject = *this->metaObject();
QMetaMethod method;
QStringList effectList;
for (int i = 0; i<metaObject.methodCount(); i++)
{
method = metaObject.method(i);
QString signature = metaObject.normalizedSignature(method.signature());
if (method.methodType() == QMetaMethod::Slot && signature.startsWith("effect"))
{
effectList << signature;
}
}
return effectList;
}
/**
* \brief Extract the arguments types of a meta method
*
* \param metaMethod Qt meta method
*
* \return Arguments types of the meta method
*/
static std::vector<ponder::Type> argTypes(const QMetaMethod& metaMethod)
{
std::vector<ponder::Type> types;
QList<QByteArray> args = metaMethod.parameterTypes();
Q_FOREACH(QByteArray arg, args)
{
types.push_back(QtHelper::type(arg));
}
static QByteArray QMetaMethod_name(const QMetaMethod &m)
{
QByteArray sig = m.signature();
int paren = sig.indexOf('(');
if (paren == -1)
return sig;
else
return sig.left(paren);
}
QByteArray MaiaXmlRpcServerConnection::getReturnType(const QMetaObject *obj,
const QByteArray &method, const QList<QByteArray> argTypes) {
for(int n = 0; n < obj->methodCount(); ++n) {
QMetaMethod m = obj->method(n);
QByteArray sig = m.signature();
int offset = sig.indexOf('(');
if(offset == -1)
continue;
QByteArray name = sig.mid(0, offset);
if(name != method)
continue;
if(m.parameterTypes() != argTypes)
continue;
return m.typeName();
}
return QByteArray();
}
void DataWidgetMapper::addMapping(QWidget *widget, int section, const QByteArray &propertyName) {
QMetaProperty property;
for (int i=0; i<widget->metaObject()->propertyCount(); ++i) {
if (QString(widget->metaObject()->property(i).name()) == propertyName) {
property = widget->metaObject()->property(i);
break;
}
}
Q_ASSERT(property.isValid());
QMetaMethod notifySignal = property.notifySignal();
Q_ASSERT(notifySignal.isValid());
connect(widget, notifySignal, this, QMetaMethod::fromSignal(&DataWidgetMapper::dataChanged));
QDataWidgetMapper::addMapping(widget, section, propertyName);
}
