void VectorPropertyWidgetItem::setEditValue( const QVariant& value ) { int userType = value.userType(); if( userType == d->vector2d ) { const Vector2f* vector = static_cast<const Vector2f*>( value.data() ); d->x->setValue( vector->x() ); d->y->setValue( vector->y() ); d->z->setVisible( false ); d->w->setVisible( false ); d->vectorDim = 2; } else if( userType == d->vector3d ) { const Vector3f* vector = static_cast<const Vector3f*>( value.data() ); d->x->setValue( vector->x() ); d->y->setValue( vector->y() ); d->z->setValue( vector->z() ); d->w->setVisible( false ); d->vectorDim = 3; } else if( userType == d->vector4d ) { const Vector4f* vector = static_cast<const Vector4f*>( value.data() ); d->x->setValue( vector->x() ); d->y->setValue( vector->y() ); d->z->setValue( vector->z() ); d->w->setValue( vector->w() ); d->vectorDim = 4; } }
ConfigAtom::ConfigAtom(QVariant &var, bool isMap) : deleteOnDestroy(false), typeMap(isMap), readOnly(false) { if (isMap && var.type() != QVariant::Map) var = QVariantMap(); else if (!isMap && var.type() != QVariant::List) var = QVariantList(); if (isMap) map = reinterpret_cast<QVariantMap*>(var.data()); else list = reinterpret_cast<QVariantList*>(var.data()); }
bool Nuria::Serializer::fieldToVariant (QVariant &value, bool &ignore) { QByteArray typeName = QByteArray (value.typeName (), -1); MetaObject *meta = this->d->finder (typeName); if (meta) { void *dataPtr = value.data (); if (typeName.endsWith ('*')) { dataPtr = *reinterpret_cast< void ** > (dataPtr); } if (this->d->curDepth == 1) { ignore = true; } else { value = serializeImpl (dataPtr, meta); } return true; } // Variant::convert() triggers QVariant conversion internally QVariant conv = Nuria::Variant::convert (value, QMetaType::QString); if (conv.isValid ()) { value = conv; return true; } return false; }
void TabbedMainWindow::addUsersToCluster(QString hostname, QString usernamepassword, QListWidget *list1, QListWidget *list2) { ProgressDialog progbar("CMClusters - Connecting...", "Please wait while a connection to the selected clusters are established!"); progbar.show(); for (int i = list1->count(); i --> 0;) { if (list1->item(i)->isSelected()) { QString userid = getSubstringBetween(list1->item(i)->text(), QString("("), QString(")")); qDebug() << userid; QListWidgetItem* userToRemove = list1->item(i); QListWidgetItem* userToAdd = new QListWidgetItem(list1->item(i)->text()); QByteArray jsonString = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:ns=\"http://www.cisco.com/AXL/API/8.5\">"; jsonString += "<soapenv:Body><ns:executeSQLUpdate><sql>UPDATE enduser SET enduser.islocaluser = '******' WHERE enduser.userid = '" + userid.toLocal8Bit() + "'</sql></ns:executeSQLUpdate></SOAP-ENV:Envelope>"; QByteArray postDataSize = QByteArray::number(jsonString.size()); QUrl req("https://" + hostname.toLocal8Bit() + ":8443/axl/"); QNetworkRequest request(req); request.setRawHeader("SOAPAction", "\"CUCM:DB ver=8.5 executeSQLUpdate\""); request.setRawHeader("Authorization", "Basic " + usernamepassword.toLocal8Bit()); request.setRawHeader("Content-Type", "text/xml"); request.setRawHeader("Content-Length", postDataSize); QNetworkAccessManager test; QEventLoop loop; connect(&test, SIGNAL(finished(QNetworkReply*)), &loop, SLOT(quit())); QNetworkReply * reply = test.post(request, jsonString); reply->ignoreSslErrors(); // Ignore only unsigned later on connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onError(QNetworkReply::NetworkError))); loop.exec(); QByteArray response = reply->readAll(); QVariant statusCode = reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ); if ( !statusCode.isValid() ) { qDebug() << "Failed..."; qDebug() << statusCode.data(); } int status = statusCode.toInt(); if ( status != 200 ) { QString reason = reply->attribute( QNetworkRequest::HttpReasonPhraseAttribute ).toString(); qDebug() << reason; } else { qDebug() << "Good reply"; qDebug() << response; if (response.contains("<rowsUpdated>1</rowsUpdated>")) { qDebug() << "Something went correct!"; delete userToRemove; list2->addItem(userToAdd); userToAdd->setBackground(QColor(0, 170, 255));//Correct the color scheme } else { qDebug() << "We f****d up!"; } } } }
ReturnedValue QQmlValueTypeWrapper::get(const Managed *m, String *name, bool *hasProperty) { Q_ASSERT(m->as<QQmlValueTypeWrapper>()); const QQmlValueTypeWrapper *r = static_cast<const QQmlValueTypeWrapper *>(m); QV4::ExecutionEngine *v4 = r->engine(); // Note: readReferenceValue() can change the reference->type. if (const QQmlValueTypeReference *reference = r->as<QQmlValueTypeReference>()) { if (!reference->readReferenceValue()) return Primitive::undefinedValue().asReturnedValue(); } QQmlPropertyData *result = r->d()->propertyCache->property(name, 0, 0); if (!result) return Object::get(m, name, hasProperty); if (hasProperty) *hasProperty = true; if (result->isFunction()) // calling a Q_INVOKABLE function of a value type return QV4::QObjectMethod::create(v4->rootContext(), r, result->coreIndex); #define VALUE_TYPE_LOAD(metatype, cpptype, constructor) \ if (result->propType == metatype) { \ cpptype v; \ void *args[] = { &v, 0 }; \ metaObject->d.static_metacall(reinterpret_cast<QObject*>(gadget), QMetaObject::ReadProperty, index, args); \ return QV4::Encode(constructor(v)); \ } const QMetaObject *metaObject = r->d()->propertyCache->metaObject(); int index = result->coreIndex; QQmlMetaObject::resolveGadgetMethodOrPropertyIndex(QMetaObject::ReadProperty, &metaObject, &index); void *gadget = r->d()->gadgetPtr; // These four types are the most common used by the value type wrappers VALUE_TYPE_LOAD(QMetaType::QReal, qreal, qreal); VALUE_TYPE_LOAD(QMetaType::Int, int, int); VALUE_TYPE_LOAD(QMetaType::QString, QString, v4->newString); VALUE_TYPE_LOAD(QMetaType::Bool, bool, bool); QVariant v; void *args[] = { Q_NULLPTR, Q_NULLPTR }; if (result->propType == QMetaType::QVariant) { args[0] = &v; } else { v = QVariant(result->propType, static_cast<void *>(Q_NULLPTR)); args[0] = v.data(); } metaObject->d.static_metacall(reinterpret_cast<QObject*>(gadget), QMetaObject::ReadProperty, index, args); return v4->fromVariant(v); #undef VALUE_TYPE_ACCESSOR }
QJsonValue QMetaObjectPublisher::invokeMethod(QObject *const object, const int methodIndex, const QJsonArray &args) { const QMetaMethod &method = object->metaObject()->method(methodIndex); if (method.name() == QByteArrayLiteral("deleteLater")) { // invoke `deleteLater` on wrapped QObject indirectly deleteWrappedObject(object); return QJsonValue(); } else if (!method.isValid()) { qWarning() << "Cannot invoke unknown method of index" << methodIndex << "on object" << object << '.'; return QJsonValue(); } else if (method.access() != QMetaMethod::Public) { qWarning() << "Cannot invoke non-public method" << method.name() << "on object" << object << '.'; return QJsonValue(); } else if (method.methodType() != QMetaMethod::Method && method.methodType() != QMetaMethod::Slot) { qWarning() << "Cannot invoke non-public method" << method.name() << "on object" << object << '.'; return QJsonValue(); } else if (args.size() > 10) { qWarning() << "Cannot invoke method" << method.name() << "on object" << object << "with more than 10 arguments, as that is not supported by QMetaMethod::invoke."; return QJsonValue(); } else if (args.size() > method.parameterCount()) { qWarning() << "Ignoring additional arguments while invoking method" << method.name() << "on object" << object << ':' << args.size() << "arguments given, but method only takes" << method.parameterCount() << '.'; } // construct converter objects of QVariant to QGenericArgument VariantArgument arguments[10]; for (int i = 0; i < qMin(args.size(), method.parameterCount()); ++i) { QVariant arg = args.at(i).toVariant(); if (method.parameterType(i) != QMetaType::QVariant && !arg.convert(method.parameterType(i))) { qWarning() << "Could not convert argument" << args.at(i) << "to target type" << method.parameterTypes().at(i) << '.'; } arguments[i].value = arg; } // construct QGenericReturnArgument QVariant returnValue; if (method.returnType() != qMetaTypeId<QVariant>() && method.returnType() != qMetaTypeId<void>()) { // Only init variant with return type if its not a variant itself, which would // lead to nested variants which is not what we want. // Also, skip void-return types for obvious reasons (and to prevent a runtime warning inside Qt). returnValue = QVariant(method.returnType(), 0); } QGenericReturnArgument returnArgument(method.typeName(), returnValue.data()); // now we can call the method method.invoke(object, returnArgument, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8], arguments[9]); return wrapResult(returnValue); }
int toQPSqlConnectionSub::nativeSessionId() { QVariant v = Connection.driver()->handle(); if (v.isValid() && v.typeName() == QString("PGconn*")) { #ifdef HAVE_POSTGRESQL_LIBPQ_FE_H PGconn *handle = *static_cast<PGconn **>(v.data()); if (handle) return PQbackendPID(handle); #endif } return 0; }
/* taken from http://delta.affinix.com/2006/08/14/invokemethodwithvariants/ thanks to Justin Karneges once again :) */ bool MaiaXmlRpcServerConnection::invokeMethodWithVariants(QObject *obj, const QByteArray &method, const QVariantList &args, QVariant *ret, Qt::ConnectionType type) { // QMetaObject::invokeMethod() has a 10 argument maximum if(args.count() > 10) return false; QList<QByteArray> argTypes; for(int n = 0; n < args.count(); ++n) argTypes += args[n].typeName(); // get return type int metatype = 0; QByteArray retTypeName = getReturnType(obj->metaObject(), method, argTypes); if(!retTypeName.isEmpty() && retTypeName != "QVariant") { metatype = QMetaType::type(retTypeName.data()); if(metatype == 0) // lookup failed return false; } QGenericArgument arg[10]; for(int n = 0; n < args.count(); ++n) arg[n] = QGenericArgument(args[n].typeName(), args[n].constData()); QGenericReturnArgument retarg; QVariant retval; if(metatype != 0) { retval = QVariant(metatype, (const void *)0); retarg = QGenericReturnArgument(retval.typeName(), retval.data()); } else { /* QVariant */ retarg = QGenericReturnArgument("QVariant", &retval); } if(retTypeName.isEmpty()) { /* void */ if(!QMetaObject::invokeMethod(obj, method.data(), type, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9])) return false; } else { if(!QMetaObject::invokeMethod(obj, method.data(), type, retarg, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9])) return false; } if(retval.isValid() && ret) *ret = retval; return true; }
/*! Invokes the slot represented by this object with the argument list \a args. The slot's return value is returned from this method. If the slot's return type is "void", then a QVariant instance of type QVariant::Invalid will be returned. If it is possible that the slot may throw an exception, it is the responsibility of the caller to catch and handle the exception. \since 1.1 */ QVariant QSlotInvoker::invoke( const QList<QVariant>& args ) { int arg; QVariant returnValue; // Create a default instance of the return type for the result buffer. if ( d->returnType != (int)QVariant::Invalid ) { returnValue = QVariant( d->returnType, (const void *)0 ); } // Bail out if the receiver object has already disappeared. if ( d->destroyed ) return returnValue; // Check that the number of arguments is compatible with the slot. int numArgs = args.size(); if ( numArgs < d->numArgs ) { qWarning( "QSlotInvoker::invoke: insufficient arguments for slot" ); return returnValue; } else if ( numArgs > d->numArgs ) { // Drop extraneous arguments. numArgs = d->numArgs; } // Construct the raw argument list. QVarLengthArray<void *, 32> a( numArgs + 1 ); if ( d->returnType == (int)QVariant::Invalid ) a[0] = 0; else a[0] = returnValue.data(); for ( arg = 0; arg < numArgs; ++arg ) { if ( d->types[arg] == QSignalIntercepter::QVariantId ) { a[arg + 1] = (void *)&( args[arg] ); } else if ( args[arg].userType() != d->types[arg] ) { qWarning( "QSlotInvoker::invoke: argument %d has incorrect type", arg ); return QVariant(); } else { a[arg + 1] = (void *)( args[arg].data() ); } } // Invoke the specified slot. d->receiver->qt_metacall( QMetaObject::InvokeMetaMethod, d->memberIndex, a.data() ); return returnValue; }
void QQmlVMEMetaObject::writeProperty(int id, const QVariant &value) { if (id >= firstVarPropertyIndex) { if (!ensureVarPropertiesAllocated()) return; QV4::Scope scope(varProperties.engine()); // Importantly, if the current value is a scarce resource, we need to ensure that it // gets automatically released by the engine if no other references to it exist. QV4::ScopedObject vp(scope, varProperties.value()); QV4::Scoped<QV4::VariantObject> oldv(scope, vp->getIndexed(id - firstVarPropertyIndex)); if (!!oldv) oldv->removeVmePropertyReference(); // And, if the new value is a scarce resource, we need to ensure that it does not get // automatically released by the engine until no other references to it exist. QV4::ScopedValue newv(scope, QQmlEnginePrivate::get(ctxt->engine)->v8engine()->fromVariant(value)); QV4::Scoped<QV4::VariantObject> v(scope, newv); if (!!v) v->addVmePropertyReference(); // Write the value and emit change signal as appropriate. QVariant currentValue = readPropertyAsVariant(id); vp->putIndexed(id - firstVarPropertyIndex, newv); if ((currentValue.userType() != value.userType() || currentValue != value)) activate(object, methodOffset() + id, 0); } else { bool needActivate = false; if (value.userType() == QMetaType::QObjectStar) { QObject *o = *(QObject **)value.data(); needActivate = (data[id].dataType() != QMetaType::QObjectStar || data[id].asQObject() != o); data[id].setValue(o, this, id); } else { needActivate = (data[id].dataType() != qMetaTypeId<QVariant>() || data[id].asQVariant().userType() != value.userType() || data[id].asQVariant() != value); data[id].setValue(value); } if (needActivate) activate(object, methodOffset() + id, 0); } }
void testQVariant2() { QVariant value; QVariant::Type t = QVariant::String; value = QVariant(t, (void*)0); *(QString*)value.data() = QString("XXX"); int i = 1; Q_UNUSED(i); #if 1 QVariant var; var.setValue(1); var.setValue(2); var.setValue(3); var.setValue(QString("Hello")); var.setValue(QString("World")); var.setValue(QString("Hello")); var.setValue(QStringList() << "World"); var.setValue(QStringList() << "World" << "Hello"); var.setValue(QStringList() << "Hello" << "Hello"); var.setValue(QStringList() << "World" << "Hello" << "Hello"); #endif #if 1 QVariant var3; QHostAddress ha("127.0.0.1"); var.setValue(ha); var3 = var; var3 = var; var3 = var; var3 = var; QHostAddress ha1 = var.value<QHostAddress>(); typedef QMap<uint, QStringList> MyType; MyType my; my[1] = (QStringList() << "Hello"); my[3] = (QStringList() << "World"); var.setValue(my); // FIXME: Known to break QString type = var.typeName(); var.setValue(my); var.setValue(my); var.setValue(my); var.setValue(my); #endif }
SqliteTrainerModel::SqliteTrainerModel(QObject *parent, QString fileName) : TrainerModel(parent) { m_cardItemModel = new CardItemModel(this); m_cardItemModel->setObjectName("card_items"); QSqlError err; QSqlDatabase db = QSqlDatabase::database(fileName); if(!db.isValid()) { db = QSqlDatabase::addDatabase("QSQLITE", fileName); db.setDatabaseName(fileName); } if (!db.open()) { err = db.lastError(); db = QSqlDatabase(); QSqlDatabase::removeDatabase(fileName); } if(err.isValid()) { qWarning() << err.text(); } else { qDebug() << fileName << "opened"; m_db = db; QVariant v = db.driver()->handle(); if (v.isValid() && qstrcmp(v.typeName(), "sqlite3*")==0) { // v.data() returns a pointer to the handle sqlite3 *handle = *static_cast<sqlite3 **>(v.data()); if (handle != 0) { // check that it is not NULL sqlite3_trace(handle,trace,NULL); } } initCardItemModel(); initModels(); } }
/*! \internal Fills in the QDBusReply data \a error and \a data from the reply message \a reply. */ void qDBusReplyFill(const QDBusMessage &reply, QDBusError &error, QVariant &data) { error = reply; if (error.isValid()) { data = QVariant(); // clear it return; } if (reply.arguments().count() >= 1 && reply.arguments().at(0).userType() == data.userType()) { data = reply.arguments().at(0); return; } const char *expectedSignature = 0; QByteArray receivedSignature; if (reply.arguments().count() >= 1 && reply.arguments().at(0).userType() == QDBusMetaTypeId::argument) { // compare signatures instead QDBusArgument arg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); expectedSignature = QDBusMetaType::typeToSignature(data.userType()); receivedSignature = arg.currentSignature().toLatin1(); if (receivedSignature == expectedSignature) { // matched. Demarshall it QDBusMetaType::demarshall(arg, data.userType(), data.data()); return; } } // error QString errorMsg = QLatin1String("Unexpected reply signature: got \"%1\", " "expected \"%2\" (%3)"); if (receivedSignature.isEmpty()) receivedSignature = "no signature"; error = QDBusError(QDBusError::InvalidSignature, errorMsg.arg(QLatin1String(receivedSignature), QLatin1String(expectedSignature), QLatin1String(data.typeName()))); data = QVariant(); // clear it }
void toQPSqlConnectionSub::nativeCancel() { QVariant v = Connection.driver()->handle(); if (v.isValid() && v.typeName() == QString("PGconn*")) { #ifdef LIBPQ_DECL_CANCEL PGconn *handle = *static_cast<PGconn **>(v.data()); if (!handle) return; PGcancel *cancel = PQgetCancel(handle); if (!cancel) return; char *errbuf = new char[1024]; PQcancel(cancel, errbuf, 1024); PQfreeCancel(cancel); delete[] errbuf; #endif } }
// Author & Date: Ehsan Azar 19 April 2012 // Purpose: Add list iteratively // Inputs: // list - list to add to current node // nodeName - last node name // Outputs: // Returns true if this is an array added bool XmlFile::AddList(QVariantList & list, QString nodeName) { if (list.isEmpty()) return false; QMap<QString, int> mapItemCount; int count = 0, subcount = 1; // itemize the list for (int j = 0; j < list.size(); ++j) { QVariant subval = list[j]; if (!subval.isValid()) continue; count++; // count all valid items QString strSubKey; QMap<QString, QVariant> attribs; if (subval.type() == QVariant::UserType) { const XmlItem * item = static_cast<const XmlItem *>(subval.data()); strSubKey = item->XmlName(); attribs = item->XmlAttribs(); } if (strSubKey.isEmpty()) strSubKey = nodeName + "_item"; subcount = mapItemCount[strSubKey]; mapItemCount[strSubKey] = subcount + 1; if (subcount) strSubKey = strSubKey + QString("<%1>").arg(subcount); // Recursively add this item beginGroup(strSubKey, attribs, subval); endGroup(); } // end for (int j // If all items had same tag name, it is an array if (count > 1 && count == subcount + 1) return true; return false; }
//writeEnumProperty MIRRORS the relelvant bit of QMetaProperty::write AND MUST BE KEPT IN SYNC! bool QDeclarativePropertyPrivate::writeEnumProperty(const QMetaProperty &prop, int idx, QObject *object, const QVariant &value, int flags) { if (!object || !prop.isWritable()) return false; QVariant v = value; if (prop.isEnumType()) { QMetaEnum menum = prop.enumerator(); if (v.userType() == QVariant::String #ifdef QT3_SUPPORT || v.userType() == QVariant::CString #endif ) { if (prop.isFlagType()) v = QVariant(menum.keysToValue(value.toByteArray())); else v = QVariant(menum.keyToValue(value.toByteArray())); } else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) { int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope()) + "::" + menum.name()); if ((enumMetaTypeId == 0) || (v.userType() != enumMetaTypeId) || !v.constData()) return false; v = QVariant(*reinterpret_cast<const int *>(v.constData())); } v.convert(QVariant::Int); } // the status variable is changed by qt_metacall to indicate what it did // this feature is currently only used by QtDBus and should not be depended // upon. Don't change it without looking into QDBusAbstractInterface first // -1 (unchanged): normal qt_metacall, result stored in argv[0] // changed: result stored directly in value, return the value of status int status = -1; void *argv[] = { v.data(), &v, &status, &flags }; QMetaObject::metacall(object, QMetaObject::WriteProperty, idx, argv); return status; }
void QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, QVariant &where) const { if (!isValid || !canMakeCalls()) { // can't make calls where.clear(); return; } // is this metatype registered? const char *expectedSignature = ""; if (mp.type() != 0xff) { expectedSignature = QDBusMetaType::typeToSignature(where.userType()); if (expectedSignature == 0) { qWarning("QDBusAbstractInterface: type %s must be registered with QtDBus before it can be " "used to read property %s.%s", mp.typeName(), qPrintable(interface), mp.name()); lastError = QDBusError(QDBusError::Failed, QString::fromLatin1("Unregistered type %1 cannot be handled") .arg(QLatin1String(mp.typeName()))); where.clear(); return; } } // try to read this property QDBusMessage msg = QDBusMessage::createMethodCall(service, path, QLatin1String(DBUS_INTERFACE_PROPERTIES), QLatin1String("Get")); QDBusMessagePrivate::setParametersValidated(msg, true); msg << interface << QString::fromUtf8(mp.name()); QDBusMessage reply = connection.call(msg, QDBus::Block); if (reply.type() != QDBusMessage::ReplyMessage) { lastError = reply; where.clear(); return; } if (reply.signature() != QLatin1String("v")) { QString errmsg = QLatin1String("Invalid signature `%1' in return from call to " DBUS_INTERFACE_PROPERTIES); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(reply.signature())); where.clear(); return; } QByteArray foundSignature; const char *foundType = 0; QVariant value = qvariant_cast<QDBusVariant>(reply.arguments().at(0)).variant(); if (value.userType() == where.userType() || mp.type() == 0xff || (expectedSignature[0] == 'v' && expectedSignature[1] == '\0')) { // simple match where = value; return; } if (value.userType() == qMetaTypeId<QDBusArgument>()) { QDBusArgument arg = qvariant_cast<QDBusArgument>(value); foundType = "user type"; foundSignature = arg.currentSignature().toLatin1(); if (foundSignature == expectedSignature) { // signatures match, we can demarshall QDBusMetaType::demarshall(arg, where.userType(), where.data()); return; } } else { foundType = value.typeName(); foundSignature = QDBusMetaType::typeToSignature(value.userType()); } // there was an error... QString errmsg = QLatin1String("Unexpected `%1' (%2) when retrieving property `%3.%4' " "(expected type `%5' (%6))"); lastError = QDBusError(QDBusError::InvalidSignature, errmsg.arg(QString::fromLatin1(foundType), QString::fromLatin1(foundSignature), interface, QString::fromUtf8(mp.name()), QString::fromLatin1(mp.typeName()), QString::fromLatin1(expectedSignature))); where.clear(); return; }
QObject *QDeclarativeVME::run(QDeclarativeVMEObjectStack &stack, QDeclarativeContextData *ctxt, QDeclarativeCompiledData *comp, int start, int count, const QBitField &bindingSkipList) { Q_ASSERT(comp); Q_ASSERT(ctxt); const QList<QDeclarativeCompiledData::TypeReference> &types = comp->types; const QList<QString> &primitives = comp->primitives; const QList<QByteArray> &datas = comp->datas; const QList<QDeclarativeCompiledData::CustomTypeData> &customTypeData = comp->customTypeData; const QList<int> &intData = comp->intData; const QList<float> &floatData = comp->floatData; const QList<QDeclarativePropertyCache *> &propertyCaches = comp->propertyCaches; const QList<QDeclarativeParser::Object::ScriptBlock> &scripts = comp->scripts; const QList<QUrl> &urls = comp->urls; QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding> bindValues; QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus> parserStatus; QDeclarativeVMEStack<ListInstance> qliststack; vmeErrors.clear(); QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(ctxt->engine); int status = -1; //for dbus QDeclarativePropertyPrivate::WriteFlags flags = QDeclarativePropertyPrivate::BypassInterceptor | QDeclarativePropertyPrivate::RemoveBindingOnAliasWrite; for (int ii = start; !isError() && ii < (start + count); ++ii) { const QDeclarativeInstruction &instr = comp->bytecode.at(ii); switch(instr.type) { case QDeclarativeInstruction::Init: { if (instr.init.bindingsSize) bindValues = QDeclarativeEnginePrivate::SimpleList<QDeclarativeAbstractBinding>(instr.init.bindingsSize); if (instr.init.parserStatusSize) parserStatus = QDeclarativeEnginePrivate::SimpleList<QDeclarativeParserStatus>(instr.init.parserStatusSize); if (instr.init.contextCache != -1) ctxt->setIdPropertyData(comp->contextCaches.at(instr.init.contextCache)); if (instr.init.compiledBinding != -1) ctxt->optimizedBindings = new QDeclarativeCompiledBindings(datas.at(instr.init.compiledBinding).constData(), ctxt, comp); } break; case QDeclarativeInstruction::CreateObject: { QBitField bindings; if (instr.create.bindingBits != -1) { const QByteArray &bits = datas.at(instr.create.bindingBits); bindings = QBitField((const quint32*)bits.constData(), bits.size() * 8); } if (stack.isEmpty()) bindings = bindings.united(bindingSkipList); QObject *o = types.at(instr.create.type).createInstance(ctxt, bindings, &vmeErrors); if (!o) { VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create object of type %1").arg(QString::fromLatin1(types.at(instr.create.type).className))); } QDeclarativeData *ddata = QDeclarativeData::get(o); Q_ASSERT(ddata); if (stack.isEmpty()) { if (ddata->context) { Q_ASSERT(ddata->context != ctxt); Q_ASSERT(ddata->outerContext); Q_ASSERT(ddata->outerContext != ctxt); QDeclarativeContextData *c = ddata->context; while (c->linkedContext) c = c->linkedContext; c->linkedContext = ctxt; } else { ctxt->addObject(o); } ddata->ownContext = true; } else if (!ddata->context) { ctxt->addObject(o); } ddata->setImplicitDestructible(); ddata->outerContext = ctxt; ddata->lineNumber = instr.line; ddata->columnNumber = instr.create.column; if (instr.create.data != -1) { QDeclarativeCustomParser *customParser = types.at(instr.create.type).type->customParser(); customParser->setCustomData(o, datas.at(instr.create.data)); } if (!stack.isEmpty()) { QObject *parent = stack.top(); if (o->isWidgetType()) { QWidget *widget = static_cast<QWidget*>(o); if (parent->isWidgetType()) { QWidget *parentWidget = static_cast<QWidget*>(parent); widget->setParent(parentWidget); } else { // TODO: parent might be a layout } } else { QDeclarative_setParent_noEvent(o, parent); } } stack.push(o); } break; case QDeclarativeInstruction::CreateSimpleObject: { QObject *o = (QObject *)operator new(instr.createSimple.typeSize + sizeof(QDeclarativeData)); ::memset(static_cast<void *>(o), 0, instr.createSimple.typeSize + sizeof(QDeclarativeData)); instr.createSimple.create(o); QDeclarativeData *ddata = (QDeclarativeData *)(((const char *)o) + instr.createSimple.typeSize); const QDeclarativeCompiledData::TypeReference &ref = types.at(instr.createSimple.type); if (!ddata->propertyCache && ref.typePropertyCache) { ddata->propertyCache = ref.typePropertyCache; ddata->propertyCache->addref(); } ddata->lineNumber = instr.line; ddata->columnNumber = instr.createSimple.column; QObjectPrivate::get(o)->declarativeData = ddata; ddata->context = ddata->outerContext = ctxt; ddata->nextContextObject = ctxt->contextObjects; if (ddata->nextContextObject) ddata->nextContextObject->prevContextObject = &ddata->nextContextObject; ddata->prevContextObject = &ctxt->contextObjects; ctxt->contextObjects = ddata; QObject *parent = stack.top(); QDeclarative_setParent_noEvent(o, parent); stack.push(o); } break; case QDeclarativeInstruction::SetId: { QObject *target = stack.top(); ctxt->setIdProperty(instr.setId.index, target); } break; case QDeclarativeInstruction::SetDefault: { ctxt->contextObject = stack.top(); } break; case QDeclarativeInstruction::CreateComponent: { QDeclarativeComponent *qcomp = new QDeclarativeComponent(ctxt->engine, comp, ii + 1, instr.createComponent.count, stack.isEmpty() ? 0 : stack.top()); QDeclarativeData *ddata = QDeclarativeData::get(qcomp, true); Q_ASSERT(ddata); ctxt->addObject(qcomp); if (stack.isEmpty()) ddata->ownContext = true; ddata->setImplicitDestructible(); ddata->outerContext = ctxt; ddata->lineNumber = instr.line; ddata->columnNumber = instr.create.column; QDeclarativeComponentPrivate::get(qcomp)->creationContext = ctxt; stack.push(qcomp); ii += instr.createComponent.count; } break; case QDeclarativeInstruction::StoreMetaObject: { QObject *target = stack.top(); QMetaObject mo; const QByteArray &metadata = datas.at(instr.storeMeta.data); QMetaObjectBuilder::fromRelocatableData(&mo, 0, metadata); const QDeclarativeVMEMetaData *data = (const QDeclarativeVMEMetaData *)datas.at(instr.storeMeta.aliasData).constData(); (void)new QDeclarativeVMEMetaObject(target, &mo, data, comp); if (instr.storeMeta.propertyCache != -1) { QDeclarativeData *ddata = QDeclarativeData::get(target, true); if (ddata->propertyCache) ddata->propertyCache->release(); ddata->propertyCache = propertyCaches.at(instr.storeMeta.propertyCache); ddata->propertyCache->addref(); } } break; case QDeclarativeInstruction::StoreVariant: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); // XXX - can be more efficient QVariant v = QDeclarativeStringConverters::variantFromString(primitives.at(instr.storeString.value)); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantInteger: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeInteger.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantDouble: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeDouble.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVariantBool: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); QVariant v(instr.storeBool.value); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreString: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeString.propertyIndex); void *a[] = { (void *)&primitives.at(instr.storeString.value), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeString.propertyIndex, a); } break; case QDeclarativeInstruction::StoreUrl: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeUrl.propertyIndex); void *a[] = { (void *)&urls.at(instr.storeUrl.value), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeUrl.propertyIndex, a); } break; case QDeclarativeInstruction::StoreFloat: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeFloat.propertyIndex); float f = instr.storeFloat.value; void *a[] = { &f, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeFloat.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDouble: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDouble.propertyIndex); double d = instr.storeDouble.value; void *a[] = { &d, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDouble.propertyIndex, a); } break; case QDeclarativeInstruction::StoreBool: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeBool.propertyIndex); void *a[] = { (void *)&instr.storeBool.value, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeBool.propertyIndex, a); } break; case QDeclarativeInstruction::StoreInteger: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeInteger.propertyIndex); void *a[] = { (void *)&instr.storeInteger.value, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeInteger.propertyIndex, a); } break; case QDeclarativeInstruction::StoreColor: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeColor.propertyIndex); QColor c = QColor::fromRgba(instr.storeColor.value); void *a[] = { &c, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeColor.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDate: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDate.propertyIndex); QDate d = QDate::fromJulianDay(instr.storeDate.value); void *a[] = { &d, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDate.propertyIndex, a); } break; case QDeclarativeInstruction::StoreTime: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeTime.propertyIndex); QTime t; t.setHMS(intData.at(instr.storeTime.valueIndex), intData.at(instr.storeTime.valueIndex+1), intData.at(instr.storeTime.valueIndex+2), intData.at(instr.storeTime.valueIndex+3)); void *a[] = { &t, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeTime.propertyIndex, a); } break; case QDeclarativeInstruction::StoreDateTime: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeDateTime.propertyIndex); QTime t; t.setHMS(intData.at(instr.storeDateTime.valueIndex+1), intData.at(instr.storeDateTime.valueIndex+2), intData.at(instr.storeDateTime.valueIndex+3), intData.at(instr.storeDateTime.valueIndex+4)); QDateTime dt(QDate::fromJulianDay(intData.at(instr.storeDateTime.valueIndex)), t); void *a[] = { &dt, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeDateTime.propertyIndex, a); } break; case QDeclarativeInstruction::StorePoint: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QPoint p = QPointF(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)).toPoint(); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StorePointF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QPointF p(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreSize: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QSize p = QSizeF(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)).toSize(); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreSizeF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRealPair.propertyIndex); QSizeF s(floatData.at(instr.storeRealPair.valueIndex), floatData.at(instr.storeRealPair.valueIndex+1)); void *a[] = { &s, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRealPair.propertyIndex, a); } break; case QDeclarativeInstruction::StoreRect: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRect.propertyIndex); QRect r = QRectF(floatData.at(instr.storeRect.valueIndex), floatData.at(instr.storeRect.valueIndex+1), floatData.at(instr.storeRect.valueIndex+2), floatData.at(instr.storeRect.valueIndex+3)).toRect(); void *a[] = { &r, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRect.propertyIndex, a); } break; case QDeclarativeInstruction::StoreRectF: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeRect.propertyIndex); QRectF r(floatData.at(instr.storeRect.valueIndex), floatData.at(instr.storeRect.valueIndex+1), floatData.at(instr.storeRect.valueIndex+2), floatData.at(instr.storeRect.valueIndex+3)); void *a[] = { &r, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeRect.propertyIndex, a); } break; case QDeclarativeInstruction::StoreVector3D: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeVector3D.propertyIndex); QVector3D p(floatData.at(instr.storeVector3D.valueIndex), floatData.at(instr.storeVector3D.valueIndex+1), floatData.at(instr.storeVector3D.valueIndex+2)); void *a[] = { &p, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeVector3D.propertyIndex, a); } break; case QDeclarativeInstruction::StoreObject: { QObject *assignObj = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); void *a[] = { (void *)&assignObj, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeObject.propertyIndex, a); } break; case QDeclarativeInstruction::AssignCustomType: { QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.assignCustomType.propertyIndex); QDeclarativeCompiledData::CustomTypeData data = customTypeData.at(instr.assignCustomType.valueIndex); const QString &primitive = primitives.at(data.index); QDeclarativeMetaType::StringConverter converter = QDeclarativeMetaType::customStringConverter(data.type); QVariant v = (*converter)(primitive); QMetaProperty prop = target->metaObject()->property(instr.assignCustomType.propertyIndex); if (v.isNull() || ((int)prop.type() != data.type && prop.userType() != data.type)) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign value %1 to property %2").arg(primitive).arg(QString::fromUtf8(prop.name()))); void *a[] = { (void *)v.data(), 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.assignCustomType.propertyIndex, a); } break; case QDeclarativeInstruction::AssignSignalObject: { // XXX optimize QObject *assign = stack.pop(); QObject *target = stack.top(); int sigIdx = instr.assignSignalObject.signal; const QByteArray &pr = datas.at(sigIdx); QDeclarativeProperty prop(target, QString::fromUtf8(pr)); if (prop.type() & QDeclarativeProperty::SignalProperty) { QMetaMethod method = QDeclarativeMetaType::defaultMethod(assign); if (method.signature() == 0) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object type %1 with no default method").arg(QString::fromLatin1(assign->metaObject()->className()))); if (!QMetaObject::checkConnectArgs(prop.method().signature(), method.signature())) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot connect mismatched signal/slot %1 %vs. %2").arg(QString::fromLatin1(method.signature())).arg(QString::fromLatin1(prop.method().signature()))); QDeclarativePropertyPrivate::connect(target, prop.index(), assign, method.methodIndex()); } else { VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign an object to signal property %1").arg(QString::fromUtf8(pr))); } } break; case QDeclarativeInstruction::StoreSignal: { QObject *target = stack.top(); QObject *context = stack.at(stack.count() - 1 - instr.storeSignal.context); QMetaMethod signal = target->metaObject()->method(instr.storeSignal.signalIndex); QDeclarativeBoundSignal *bs = new QDeclarativeBoundSignal(target, signal, target); QDeclarativeExpression *expr = new QDeclarativeExpression(ctxt, context, primitives.at(instr.storeSignal.value)); expr->setSourceLocation(comp->name, instr.line); static_cast<QDeclarativeExpressionPrivate *>(QObjectPrivate::get(expr))->name = datas.at(instr.storeSignal.name); bs->setExpression(expr); } break; case QDeclarativeInstruction::StoreImportedScript: { ctxt->addImportedScript(scripts.at(instr.storeScript.value)); } break; case QDeclarativeInstruction::StoreScriptString: { QObject *target = stack.top(); QObject *scope = stack.at(stack.count() - 1 - instr.storeScriptString.scope); QDeclarativeScriptString ss; ss.setContext(ctxt->asQDeclarativeContext()); ss.setScopeObject(scope); ss.setScript(primitives.at(instr.storeScriptString.value)); void *a[] = { &ss, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeScriptString.propertyIndex, a); } break; case QDeclarativeInstruction::BeginObject: { QObject *target = stack.top(); QDeclarativeParserStatus *status = reinterpret_cast<QDeclarativeParserStatus *>(reinterpret_cast<char *>(target) + instr.begin.castValue); parserStatus.append(status); status->d = &parserStatus.values[parserStatus.count - 1]; status->classBegin(); } break; case QDeclarativeInstruction::StoreBinding: case QDeclarativeInstruction::StoreBindingOnAlias: { QObject *target = stack.at(stack.count() - 1 - instr.assignBinding.owner); QObject *context = stack.at(stack.count() - 1 - instr.assignBinding.context); QDeclarativeProperty mp = QDeclarativePropertyPrivate::restore(datas.at(instr.assignBinding.property), target, ctxt); int coreIndex = mp.index(); if ((stack.count() - instr.assignBinding.owner) == 1 && bindingSkipList.testBit(coreIndex)) break; QDeclarativeBinding *bind = new QDeclarativeBinding((void *)datas.at(instr.assignBinding.value).constData(), comp, context, ctxt, comp->name, instr.line, 0); bindValues.append(bind); bind->m_mePtr = &bindValues.values[bindValues.count - 1]; bind->setTarget(mp); if (instr.type == QDeclarativeInstruction::StoreBindingOnAlias) { QDeclarativeAbstractBinding *old = QDeclarativePropertyPrivate::setBindingNoEnable(target, coreIndex, QDeclarativePropertyPrivate::valueTypeCoreIndex(mp), bind); if (old) { old->destroy(); } } else { bind->addToObject(target, QDeclarativePropertyPrivate::bindingIndex(mp)); } } break; case QDeclarativeInstruction::StoreCompiledBinding: { QObject *target = stack.at(stack.count() - 1 - instr.assignBinding.owner); QObject *scope = stack.at(stack.count() - 1 - instr.assignBinding.context); int property = instr.assignBinding.property; if (stack.count() == 1 && bindingSkipList.testBit(property & 0xFFFF)) break; QDeclarativeAbstractBinding *binding = ctxt->optimizedBindings->configBinding(instr.assignBinding.value, target, scope, property); bindValues.append(binding); binding->m_mePtr = &bindValues.values[bindValues.count - 1]; binding->addToObject(target, property); } break; case QDeclarativeInstruction::StoreValueSource: { QObject *obj = stack.pop(); QDeclarativePropertyValueSource *vs = reinterpret_cast<QDeclarativePropertyValueSource *>(reinterpret_cast<char *>(obj) + instr.assignValueSource.castValue); QObject *target = stack.at(stack.count() - 1 - instr.assignValueSource.owner); QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueSource.property), target, ctxt); obj->setParent(target); vs->setTarget(prop); } break; case QDeclarativeInstruction::StoreValueInterceptor: { QObject *obj = stack.pop(); QDeclarativePropertyValueInterceptor *vi = reinterpret_cast<QDeclarativePropertyValueInterceptor *>(reinterpret_cast<char *>(obj) + instr.assignValueInterceptor.castValue); QObject *target = stack.at(stack.count() - 1 - instr.assignValueInterceptor.owner); QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(datas.at(instr.assignValueInterceptor.property), target, ctxt); obj->setParent(target); vi->setTarget(prop); QDeclarativeVMEMetaObject *mo = static_cast<QDeclarativeVMEMetaObject *>((QMetaObject*)target->metaObject()); mo->registerInterceptor(prop.index(), QDeclarativePropertyPrivate::valueTypeCoreIndex(prop), vi); } break; case QDeclarativeInstruction::StoreObjectQList: { QObject *assign = stack.pop(); const ListInstance &list = qliststack.top(); list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, assign); } break; case QDeclarativeInstruction::AssignObjectList: { // This is only used for assigning interfaces QObject *assign = stack.pop(); const ListInstance &list = qliststack.top(); int type = list.type; void *ptr = 0; const char *iid = QDeclarativeMetaType::interfaceIId(type); if (iid) ptr = assign->qt_metacast(iid); if (!ptr) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to list")); list.qListProperty.append((QDeclarativeListProperty<void>*)&list.qListProperty, ptr); } break; case QDeclarativeInstruction::StoreVariantObject: { QObject *assign = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); QVariant v = QVariant::fromValue(assign); void *a[] = { &v, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, instr.storeObject.propertyIndex, a); } break; case QDeclarativeInstruction::StoreInterface: { QObject *assign = stack.pop(); QObject *target = stack.top(); CLEAN_PROPERTY(target, instr.storeObject.propertyIndex); int coreIdx = instr.storeObject.propertyIndex; QMetaProperty prop = target->metaObject()->property(coreIdx); int t = prop.userType(); const char *iid = QDeclarativeMetaType::interfaceIId(t); bool ok = false; if (iid) { void *ptr = assign->qt_metacast(iid); if (ptr) { void *a[] = { &ptr, 0, &status, &flags }; QMetaObject::metacall(target, QMetaObject::WriteProperty, coreIdx, a); ok = true; } } if (!ok) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot assign object to interface property")); } break; case QDeclarativeInstruction::FetchAttached: { QObject *target = stack.top(); QObject *qmlObject = qmlAttachedPropertiesObjectById(instr.fetchAttached.id, target); if (!qmlObject) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Unable to create attached object")); stack.push(qmlObject); } break; case QDeclarativeInstruction::FetchQList: { QObject *target = stack.top(); qliststack.push(ListInstance(instr.fetchQmlList.type)); void *a[1]; a[0] = (void *)&(qliststack.top().qListProperty); QMetaObject::metacall(target, QMetaObject::ReadProperty, instr.fetchQmlList.property, a); } break; case QDeclarativeInstruction::FetchObject: { QObject *target = stack.top(); QObject *obj = 0; // NOTE: This assumes a cast to QObject does not alter the // object pointer void *a[1]; a[0] = &obj; QMetaObject::metacall(target, QMetaObject::ReadProperty, instr.fetch.property, a); if (!obj) VME_EXCEPTION(QCoreApplication::translate("QDeclarativeVME","Cannot set properties on %1 as it is null").arg(QString::fromUtf8(target->metaObject()->property(instr.fetch.property).name()))); stack.push(obj); } break; case QDeclarativeInstruction::PopQList: { qliststack.pop(); } break; case QDeclarativeInstruction::Defer: { if (instr.defer.deferCount) { QObject *target = stack.top(); QDeclarativeData *data = QDeclarativeData::get(target, true); comp->addref(); data->deferredComponent = comp; data->deferredIdx = ii; ii += instr.defer.deferCount; } } break; case QDeclarativeInstruction::PopFetchedObject: { stack.pop(); } break; case QDeclarativeInstruction::FetchValueType: { QObject *target = stack.top(); if (instr.fetchValue.bindingSkipList != 0) { // Possibly need to clear bindings QDeclarativeData *targetData = QDeclarativeData::get(target); if (targetData) { QDeclarativeAbstractBinding *binding = QDeclarativePropertyPrivate::binding(target, instr.fetchValue.property, -1); if (binding && binding->bindingType() != QDeclarativeAbstractBinding::ValueTypeProxy) { QDeclarativePropertyPrivate::setBinding(target, instr.fetchValue.property, -1, 0); binding->destroy(); } else if (binding) { QDeclarativeValueTypeProxyBinding *proxy = static_cast<QDeclarativeValueTypeProxyBinding *>(binding); proxy->removeBindings(instr.fetchValue.bindingSkipList); } } } QDeclarativeValueType *valueHandler = ep->valueTypes[instr.fetchValue.type]; valueHandler->read(target, instr.fetchValue.property); stack.push(valueHandler); } break; case QDeclarativeInstruction::PopValueType: { QDeclarativeValueType *valueHandler = static_cast<QDeclarativeValueType *>(stack.pop()); QObject *target = stack.top(); valueHandler->write(target, instr.fetchValue.property, QDeclarativePropertyPrivate::BypassInterceptor); } break; default: qFatal("QDeclarativeCompiledData: Internal error - unknown instruction %d", instr.type); break; } } if (isError()) { if (!stack.isEmpty()) { delete stack.at(0); // ### What about failures in deferred creation? } else { ctxt->destroy(); } QDeclarativeEnginePrivate::clear(bindValues); QDeclarativeEnginePrivate::clear(parserStatus); return 0; } if (bindValues.count) ep->bindValues << bindValues; else if (bindValues.values) bindValues.clear(); if (parserStatus.count) ep->parserStatus << parserStatus; else if (parserStatus.values) parserStatus.clear(); Q_ASSERT(stack.count() == 1); return stack.top(); }
bool qtSDLTreeModel::setData(const QModelIndex &index, const QVariant &value, int role) { if(role != Qt::EditRole || value.type() != QVariant::String || index.column() != 0) return false; QString* strVal = (QString*)value.data(); SDLModelIndex myIndex = indices[index.internalId()]; if(myIndex.type != kVal) return false; plSimpleStateVariable* var = (plSimpleStateVariable*)myIndex.ptr.sv; switch(var->getDescriptor()->getType()) { case plVarDescriptor::kBool: if(*strVal == "True") var->Bool(index.row()) = true; else if(*strVal == "False") var->Bool(index.row()) = false; else return false; break; case plVarDescriptor::kInt: { bool result; int value = strVal->toInt(&result); if(result) var->Int(index.row()) = value; else return false; break; } case plVarDescriptor::kByte: { bool result; int value = strVal->toInt(&result); if(result && value >= 0 && value < 256) var->Byte(index.row()) = (unsigned char)value; else return false; break; } case plVarDescriptor::kChar: { char* str = strVal->toLocal8Bit().data(); if(strlen(str) == 1) var->Char(index.row()) = str[0]; else return false; break; } case plVarDescriptor::kFloat: { bool result; float value = strVal->toFloat(&result); if(result) var->Float(index.row()) = value; else return false; break; } case plVarDescriptor::kDouble: { bool result; double value = strVal->toDouble(&result); if(result) var->Double(index.row()) = value; else return false; break; } case plVarDescriptor::kString: var->String(index.row()) = plString(strVal->toLocal8Bit().data()); break; default: return false; } emit sdlChanged(sdl); return true; }
void TabbedMainWindow::findUsers(QString hostname, QString usernamepassword, int condition1, QString condition2, QString argument, QListWidget * list, QListWidget * list2) { //First maybe we clear the dang list?! QString condition1String, condition2String; if (condition1 == 0) { condition1String = "enduser.firstname"; } else if (condition1 == 1) { condition1String = "enduser.middlename"; } else if (condition1 == 2) { condition1String = "enduser.lastname"; } else if (condition1 == 3) { condition1String = "enduser.userid"; } else if (condition1 == 4) { condition1String = "enduser.islocaluser"; } else if (condition1 == 5) { condition1String = "enduser.telephonenumber"; } if (condition2 == "Equals") { condition2String = "= '" + argument.toLower() + "'"; } else if (condition2 == "Contains") { condition2String = "LIKE '%" + argument.toLower() + "%'"; } else if (condition2 == "Begins with") { condition2String = "LIKE '" + argument.toLower() + "%'"; } else if (condition2 == "Ends with") { condition2String = "LIKE '%" + argument.toLower() + "'"; } else if (condition2 == "Is Empty") { condition2String = "IS NULL"; } else if (condition2 == "Is not Empty") { condition2String = "IS NOT NULL"; } else if (condition2 == "True") { condition2String = "= 't'"; } else if (condition2 == "False") { condition2String = "= 'f'"; } ProgressDialog progbar("CMClusters - Connecting...", "Please wait while a connection to the selected clusters are established!"); progbar.show(); QByteArray jsonString = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:ns=\"http://www.cisco.com/AXL/API/8.5\">"; if (condition1 == 4) { jsonString += "<soapenv:Body><ns:executeSQLQuery><sql>SELECT enduser.userid,enduser.firstname,enduser.middlename,enduser.lastname,enduser.islocaluser,enduser.telephonenumber from enduser where " + condition1String + condition2String + "</sql></ns:executeSQLQuery></SOAP-ENV:Envelope>"; } else { jsonString += "<soapenv:Body><ns:executeSQLQuery><sql>SELECT enduser.userid,enduser.firstname,enduser.middlename,enduser.lastname,enduser.islocaluser,enduser.telephonenumber from enduser where lower(" + condition1String + ") " + condition2String + "</sql></ns:executeSQLQuery></SOAP-ENV:Envelope>"; } QByteArray postDataSize = QByteArray::number(jsonString.size()); QUrl req("https://" + hostname.toLocal8Bit() + ":8443/axl/"); QNetworkRequest request(req); request.setRawHeader("SOAPAction", "\"CUCM:DB ver=8.5 executeSQLQuery\""); request.setRawHeader("Authorization", "Basic " + usernamepassword.toLocal8Bit()); request.setRawHeader("Content-Type", "text/xml"); request.setRawHeader("Content-Length", postDataSize); QNetworkAccessManager test; QEventLoop loop; connect(&test, SIGNAL(finished(QNetworkReply*)), &loop, SLOT(quit())); QNetworkReply * reply = test.post(request, jsonString); reply->ignoreSslErrors(); // Ignore only unsigned later on connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onError(QNetworkReply::NetworkError))); loop.exec(); QByteArray response = reply->readAll(); QVariant statusCode = reply->attribute( QNetworkRequest::HttpStatusCodeAttribute ); if ( !statusCode.isValid() ) { qDebug() << "Failed..."; qDebug() << statusCode.data(); } int status = statusCode.toInt(); if ( status != 200 ) { QString reason = reply->attribute( QNetworkRequest::HttpReasonPhraseAttribute ).toString(); qDebug() << reason; } else { qDebug() << "Good reply"; //qDebug() << response; QDomDocument doc; doc.setContent(response); QDomNodeList rates = doc.elementsByTagName("row"); for (int i = 0; i < rates.size(); i++) { QString finalString; QDomNode n = rates.item(i); QDomElement firstname = n.firstChildElement("firstname"); if (firstname.text() != "") finalString = firstname.text() + " "; QDomElement middlename = n.firstChildElement("middlename"); if (middlename.text() != "") finalString += middlename.text() + " "; QDomElement lastname = n.firstChildElement("lastname"); if (lastname.text() != " ") finalString += lastname.text(); QDomElement userid = n.firstChildElement("userid"); finalString += " (" + userid.text() + ") "; QDomElement islocaluser = n.firstChildElement("islocaluser"); QDomElement telephonenumber = n.firstChildElement("telephonenumber"); if (telephonenumber.text() != "") { finalString += " [" + telephonenumber.text() + "]"; } else { finalString += " [No Telephone Number]"; } QListWidgetItem* user = new QListWidgetItem(finalString); if (islocaluser.text() == "t") { user->setBackground(QColor(0, 170, 255)); list2->addItem(user); } else { user->setBackground(QColor(170, 0, 0)); list->addItem(user); } } } }
static void writeAttribute(QXmlStreamWriter *stream, const QVariant &attribute) { const QString unsignedFormat(QStringLiteral("0x%1")); switch (int(attribute.type())) { case QMetaType::Void: stream->writeEmptyElement(QStringLiteral("nil")); break; case QMetaType::UChar: stream->writeEmptyElement(QStringLiteral("uint8")); stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(attribute.value<quint8>(), 2, 16, QLatin1Char('0'))); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::UShort: stream->writeEmptyElement(QStringLiteral("uint16")); stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(attribute.value<quint16>(), 4, 16, QLatin1Char('0'))); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::UInt: stream->writeEmptyElement(QStringLiteral("uint32")); stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(attribute.value<quint32>(), 8, 16, QLatin1Char('0'))); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::Char: stream->writeEmptyElement(QStringLiteral("int8")); stream->writeAttribute(QStringLiteral("value"), QString::number(attribute.value<uchar>(), 16)); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::Short: stream->writeEmptyElement(QStringLiteral("int16")); stream->writeAttribute(QStringLiteral("value"), QString::number(attribute.value<qint16>(), 16)); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::Int: stream->writeEmptyElement(QStringLiteral("int32")); stream->writeAttribute(QStringLiteral("value"), QString::number(attribute.value<qint32>(), 16)); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::QString: stream->writeEmptyElement(QStringLiteral("text")); if (/* require hex encoding */ false) { stream->writeAttribute(QStringLiteral("value"), QString::fromLatin1( attribute.value<QString>().toUtf8().toHex().constData())); stream->writeAttribute(QStringLiteral("encoding"), QStringLiteral("hex")); } else { stream->writeAttribute(QStringLiteral("value"), attribute.value<QString>()); stream->writeAttribute(QStringLiteral("encoding"), QStringLiteral("normal")); } //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::Bool: stream->writeEmptyElement(QStringLiteral("boolean")); if (attribute.value<bool>()) stream->writeAttribute(QStringLiteral("value"), QStringLiteral("true")); else stream->writeAttribute(QStringLiteral("value"), QStringLiteral("false")); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QMetaType::QUrl: stream->writeEmptyElement(QStringLiteral("url")); stream->writeAttribute(QStringLiteral("value"), attribute.value<QUrl>().toString()); //stream->writeAttribute(QStringLiteral("name"), foo); break; case QVariant::UserType: if (attribute.userType() == qMetaTypeId<QBluetoothUuid>()) { stream->writeEmptyElement(QStringLiteral("uuid")); QBluetoothUuid uuid = attribute.value<QBluetoothUuid>(); switch (uuid.minimumSize()) { case 0: stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(quint16(0), 4, 16, QLatin1Char('0'))); break; case 2: stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(uuid.toUInt16(), 4, 16, QLatin1Char('0'))); break; case 4: stream->writeAttribute(QStringLiteral("value"), unsignedFormat.arg(uuid.toUInt32(), 8, 16, QLatin1Char('0'))); break; case 16: stream->writeAttribute(QStringLiteral("value"), uuid.toString().mid(1, 36)); break; default: stream->writeAttribute(QStringLiteral("value"), uuid.toString().mid(1, 36)); } } else if (attribute.userType() == qMetaTypeId<QBluetoothServiceInfo::Sequence>()) { stream->writeStartElement(QStringLiteral("sequence")); const QBluetoothServiceInfo::Sequence *sequence = static_cast<const QBluetoothServiceInfo::Sequence *>(attribute.data()); foreach (const QVariant &v, *sequence) writeAttribute(stream, v); stream->writeEndElement(); } else if (attribute.userType() == qMetaTypeId<QBluetoothServiceInfo::Alternative>()) {
/*! Client side method call that directly accesses the object through the DBus interface. All arguments and return types are processed and converted accordingly so that all functions satisfy the QtDBus type system. */ QVariant ObjectEndPoint::invokeRemote(int metaIndex, const QVariantList& args, int returnType) { QMetaMethod method = service->metaObject()->method(remoteToLocal[metaIndex]); Q_ASSERT(d->endPointType == ObjectEndPoint::Client); // Check is this is a signal relay if (method.methodType() == QMetaMethod::Signal) { // Convert custom arguments QVariantList convertedList; QList<QByteArray> params = method.parameterTypes(); for (int i = 0; i < params.size(); i++) { const QByteArray& type = params[i]; int variantType = QMetaType::type(type); if (variantType >= QMetaType::User || variantType == QMetaType::QVariant) { QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(args[i]); QVariant variant = dbusVariant.variant(); if (variantType == QMetaType::QVariant) { convertedList << variant; } else { QByteArray buffer = variant.toByteArray(); QDataStream stream(&buffer, QIODevice::ReadWrite); QVariant *customType = new QVariant(variantType, (const void*)0); QMetaType::load(stream, QMetaType::QVariant, customType); convertedList << *customType; } } else { convertedList << args[i]; } } // Signal relay const int numArgs = convertedList.size(); QVarLengthArray<void *, 32> a( numArgs+1 ); a[0] = 0; const QList<QByteArray> pTypes = method.parameterTypes(); for ( int arg = 0; arg < numArgs; ++arg ) { if (pTypes.at(arg) == "QVariant") { a[arg+1] = (void *)&( convertedList[arg] ); } else { a[arg+1] = (void *)( convertedList[arg].data() ); } } // Activate the service proxy signal call QMetaObject::activate(service, remoteToLocal[metaIndex], a.data()); return QVariant(); } // Method call so process arguments and convert if not a supported DBus type QVariantList convertedList; QList<QByteArray> params = method.parameterTypes(); for (int i = 0; i < params.size(); i++) { QVariant converted = toDBusVariant(params[i], args[i]); convertedList << converted; } bool validDBus = false; QDBusMessage msg; // Find the method name and try a direct DBus call QString methodName(QLatin1String(method.methodSignature().constData())); methodName.truncate(methodName.indexOf(QLatin1String("("))); if (method.methodType() == QMetaMethod::Slot || method.methodType() == QMetaMethod::Method) { // Slot or Invokable method msg = iface->callWithArgumentList(QDBus::Block, methodName, convertedList); if (msg.type() == QDBusMessage::ReplyMessage) { validDBus = true; } } // DBus call should only fail for methods with invalid type definitions if (validDBus) { if (returnType == QMetaType::Void) { // Void method call return QVariant(); } else { // Use DBus message return value QVariantList retList = msg.arguments(); // Process return const QByteArray& retType = QByteArray(method.typeName()); int variantType = QMetaType::type(retType); if (variantType == QMetaType::QVariant) { // QVariant return from QDBusVariant wrapper QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(retList[0]); return dbusVariant.variant(); } else if (variantType >= QMetaType::User) { // Custom return type QDBusVariant dbusVariant = qvariant_cast<QDBusVariant>(retList[0]); QVariant convert = dbusVariant.variant(); QServiceUserTypeDBus customType = qdbus_cast<QServiceUserTypeDBus>(convert); QByteArray buffer = customType.variantBuffer; QDataStream stream(&buffer, QIODevice::ReadWrite); // Load our buffered variant-wrapped custom return QVariant *customReturn = new QVariant(variantType, (const void*)0); QMetaType::load(stream, QMetaType::QVariant, customReturn); return QVariant(variantType, customReturn->data()); } else { // Standard return type return retList[0]; } } } else { qWarning( "%s::%s cannot be called.", service->metaObject()->className(), method.methodSignature().constData()); } return QVariant(); }
// Author & Date: Ehsan Azar 3 April 2012 // Purpose: Begin a new Xml group or navigate to it if it exists // Inputs: // nodeName - the node tag (it can be in the form of relative/path/to/node) // node index (0-based) is enclosed (relative/path/to/node<2>/subnode) // Note: nodeName tags are always created if they do not exist // attribs - attribute name, attribute value pairs // value - new node value, if non-empty // Outputs: // Returns true if nodeName is created bool XmlFile::beginGroup(QString nodeName, const QMap<QString, QVariant> attribs, const QVariant & value) { bool bRet = false; QDomElement set; if (nodeName.isEmpty()) nodeName = firstChildKey(); if (nodeName.isEmpty()) nodeName = "XmlItem"; // Get the node path QStringList nodepath = nodeName.split("/"); int level = nodepath.count(); m_levels.append(level); for (int i = 0; i < level; ++i) { QString strTagName = nodepath[i]; // Extract index int index = 0; { int idx = strTagName.indexOf("<"); if (idx >= 0) { index = strTagName.mid(idx + 1, strTagName.length() - idx - 2).toInt(); strTagName = strTagName.left(idx); nodepath[i] = strTagName; } } // Look if the element (with given index) exists then get it QDomNode parent; if (!m_nodes.isEmpty()) { // Get the current node parent = m_nodes.last(); } else { parent = m_doc; } int count = 0; for(QDomElement elem = parent.firstChildElement(strTagName); !elem.isNull(); elem = elem.nextSiblingElement(strTagName)) { count++; if (count == index + 1) { set = elem; break; } } // Create all new subnodes for (int j = 0; j < (index + 1 - count); ++j) { bRet = true; set = m_doc.createElement(strTagName); parent.appendChild(set); } // Add all the parent nodes without attribute or value if (i < level - 1) m_nodes.append(set); } // Now add the node to the end of the list m_nodes.append(set); // if there is some text/value to set if (value.isValid()) { bool bTextLeaf = false; QVariantList varlst; switch (value.type()) { case QVariant::StringList: case QVariant::List: varlst = value.toList(); if (AddList(varlst, nodepath.last())) set.setAttribute("Type", "Array"); break; default: QString text; if (value.type() == QVariant::UserType) { const XmlItem * item = static_cast<const XmlItem *>(value.data()); QVariant subval = item->XmlValue(); if (subval.type() == QVariant::UserType) { const XmlItem * subitem = static_cast<const XmlItem *>(subval.data()); QString strSubKey = subitem->XmlName(); QMap<QString, QVariant> attribs = subitem->XmlAttribs(); // Recursively add this item beginGroup(strSubKey, attribs, subval); endGroup(); } else if (subval.type() == QVariant::List || subval.type() == QVariant::StringList) { varlst = subval.toList(); if (AddList(varlst, nodepath.last())) set.setAttribute("Type", "Array"); } else { text = subval.toString(); bTextLeaf = true; } } else { text = value.toString(); bTextLeaf = true; } if (bTextLeaf) { // Remove all the children while (set.hasChildNodes()) set.removeChild(set.lastChild()); // See if this is Xml fragment string XmlFile xml; if (!xml.setContent(text)) { QDomNode frag = m_doc.importNode(xml.getFragment(), true); set.appendChild(frag); } else { QDomText domText = m_doc.createTextNode(text); set.appendChild(domText); } } } } // Add all the additional attributes QMap<QString, QVariant>::const_iterator iterator; for (iterator = attribs.begin(); iterator != attribs.end(); ++iterator) { QString attrName = iterator.key(); QVariant attrValue = iterator.value(); switch (attrValue.type()) { case QVariant::String: set.setAttribute(attrName, attrValue.toString()); break; case QVariant::Int: set.setAttribute(attrName, attrValue.toInt()); break; case QVariant::UInt: set.setAttribute(attrName, attrValue.toUInt()); break; case QVariant::LongLong: set.setAttribute(attrName, attrValue.toLongLong()); break; case QVariant::ULongLong: set.setAttribute(attrName, attrValue.toULongLong()); break; default: // everything else is treated as double floating point set.setAttribute(attrName, attrValue.toDouble()); break; } } return bRet; }
void packDataValue(QVariant_ *var, DataValue *value) { QVariant *qvar = reinterpret_cast<QVariant *>(var); // Some assumptions are made below regarding the size of types. // There's apparently no better way to handle this since that's // how the types with well defined sizes (qint64) are mapped to // meta-types (QMetaType::LongLong). switch ((int)qvar->type()) { case QVariant::Invalid: value->dataType = DTInvalid; break; case QMetaType::QUrl: *qvar = qvar->value<QUrl>().toString(); // fallthrough case QMetaType::QString: { value->dataType = DTString; QByteArray ba = qvar->toByteArray(); *(char**)(value->data) = local_strdup(ba.constData()); value->len = ba.size(); break; } case QMetaType::Bool: value->dataType = DTBool; *(qint8*)(value->data) = (qint8)qvar->toInt(); break; case QMetaType::LongLong: // Some of these entries will have to be fixed when handling platforms // where sizeof(long long) != 8 or sizeof(int) != 4. value->dataType = DTInt64; *(qint64*)(value->data) = qvar->toLongLong(); break; case QMetaType::ULongLong: value->dataType = DTUint64; *(quint64*)(value->data) = qvar->toLongLong(); break; case QMetaType::Int: value->dataType = DTInt32; *(qint32*)(value->data) = qvar->toInt(); break; case QMetaType::UInt: value->dataType = DTUint32; *(quint32*)(value->data) = qvar->toUInt(); break; case QMetaType::VoidStar: value->dataType = DTUintptr; *(uintptr_t*)(value->data) = (uintptr_t)qvar->value<void *>(); break; case QMetaType::Double: value->dataType = DTFloat64; *(double*)(value->data) = qvar->toDouble(); break; case QMetaType::Float: value->dataType = DTFloat32; *(float*)(value->data) = qvar->toFloat(); break; case QMetaType::QColor: value->dataType = DTColor; *(unsigned int*)(value->data) = qvar->value<QColor>().rgba(); break; case QMetaType::QVariantList: { QVariantList varlist = qvar->toList(); int len = varlist.size(); DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); for (int i = 0; i < len; i++) { packDataValue((void*)&varlist.at(i), &dvlist[i]); } value->dataType = DTValueList; value->len = len; *(DataValue**)(value->data) = dvlist; } break; case QMetaType::QVariantMap: { QVariantMap varmap = qvar->toMap(); int len = varmap.size() * 2; DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); QMapIterator<QString, QVariant> it(varmap); for (int i = 0; i < len; i += 2) { if (!it.hasNext()) { panicf("QVariantMap mutated during iteration"); } it.next(); QVariant key = it.key(); QVariant val = it.value(); packDataValue((void*)&key, &dvlist[i]); packDataValue((void*)&val, &dvlist[i+1]); } value->dataType = DTValueMap; value->len = len; *(DataValue**)(value->data) = dvlist; } break; default: if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) { QObject *qobject = qvar->value<QObject *>(); GoValue *goValue = dynamic_cast<GoValue *>(qobject); if (goValue) { value->dataType = DTGoAddr; *(void **)(value->data) = goValue->addr; break; } GoPaintedValue *goPaintedValue = dynamic_cast<GoPaintedValue *>(qobject); if (goPaintedValue) { value->dataType = DTGoAddr; *(void **)(value->data) = goPaintedValue->addr; break; } value->dataType = DTObject; *(void **)(value->data) = qobject; break; } { QQmlListReference ref = qvar->value<QQmlListReference>(); if (ref.isValid() && ref.canCount() && ref.canAt()) { int len = ref.count(); DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); QVariant elem; for (int i = 0; i < len; i++) { elem.setValue(ref.at(i)); packDataValue(&elem, &dvlist[i]); } value->dataType = DTValueList; value->len = len; *(DataValue**)(value->data) = dvlist; break; } } if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) { QQmlListProperty<QObject> *list = reinterpret_cast<QQmlListProperty<QObject>*>(qvar->data()); if (list->count && list->at) { int len = list->count(list); DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len); QVariant elem; for (int i = 0; i < len; i++) { elem.setValue(list->at(list, i)); packDataValue(&elem, &dvlist[i]); } value->dataType = DTValueList; value->len = len; *(DataValue**)(value->data) = dvlist; break; } } panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName()); break; } }
void QpBelongsToOneBase::setObject(const QSharedPointer<QObject> newObject) const { QSharedPointer<QObject> previousObject = object(); data->cleared = newObject.isNull(); if(previousObject == newObject) return; QpMetaProperty reverse = data->metaProperty.reverseRelation(); data->object = newObject.toWeakRef(); QSharedPointer<QObject> shared = Qp::sharedFrom(data->parent); if(previousObject) { if(reverse.isToOneRelationProperty()) { QString className = data->metaProperty.metaObject().className(); reverse.write(previousObject.data(), Qp::Private::variantCast(QSharedPointer<QObject>(), className)); } else { QVariant wrapper = Qp::Private::variantCast(shared); const QMetaObject *mo = previousObject->metaObject(); QByteArray methodName = reverse.metaObject().removeObjectMethod(reverse).methodSignature(); int index = mo->indexOfMethod(methodName); Q_ASSERT_X(index > 0, Q_FUNC_INFO, QString("You have to add a public slot with the signature '%1' to your '%2' class!") .arg(QString::fromLatin1(methodName)) .arg(mo->className()) .toLatin1()); QMetaMethod method = mo->method(index); Q_ASSERT(method.invoke(previousObject.data(), Qt::DirectConnection, QGenericArgument(data->metaProperty.typeName().toLatin1(), wrapper.data()))); } } if(newObject) { if(reverse.isToOneRelationProperty()) { reverse.write(newObject.data(), Qp::Private::variantCast(shared)); } else { QVariant wrapper = Qp::Private::variantCast(shared); const QMetaObject *mo = newObject->metaObject(); QByteArray methodName = reverse.metaObject().addObjectMethod(reverse).methodSignature(); int index = mo->indexOfMethod(methodName); Q_ASSERT_X(index > 0, Q_FUNC_INFO, QString("You have to add a public slot with the signature '%1' to your '%2' class!") .arg(QString::fromLatin1(methodName)) .arg(mo->className()) .toLatin1()); QMetaMethod method = mo->method(index); Q_ASSERT(method.invoke(newObject.data(), Qt::DirectConnection, QGenericArgument(data->metaProperty.typeName().toLatin1(), wrapper.data()))); } } // Set again, because it may happen, that resetting the previousObjects relation has also reset this value. data->object = newObject.toWeakRef(); }
foreach (const QVariant &ar, args) { vargs.append(QGenericArgument(ar.typeName(), ar.data())); }
QT_BEGIN_NAMESPACE /*! \class QDBusReply \inmodule QtDBus \since 4.2 \brief The QDBusReply class stores the reply for a method call to a remote object. A QDBusReply object is a subset of the QDBusMessage object that represents a method call's reply. It contains only the first output argument or the error code and is used by QDBusInterface-derived classes to allow returning the error code as the function's return argument. It can be used in the following manner: \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 0 If the remote method call cannot fail, you can skip the error checking: \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 1 However, if it does fail under those conditions, the value returned by QDBusReply::value() is a default-constructed value. It may be indistinguishable from a valid return value. QDBusReply objects are used for remote calls that have no output arguments or return values (i.e., they have a "void" return type). Use the isValid() function to test if the reply succeeded. \sa QDBusMessage, QDBusInterface */ /*! \fn QDBusReply::QDBusReply(const QDBusMessage &reply) Automatically construct a QDBusReply object from the reply message \a reply, extracting the first return value from it if it is a success reply. */ /*! \fn QDBusReply::QDBusReply(const QDBusPendingReply<T> &reply) Constructs a QDBusReply object from the pending reply message, \a reply. */ /*! \fn QDBusReply::QDBusReply(const QDBusPendingCall &pcall) Automatically construct a QDBusReply object from the asynchronous pending call \a pcall. If the call isn't finished yet, QDBusReply will call QDBusPendingCall::waitForFinished(), which is a blocking operation. If the return types patch, QDBusReply will extract the first return argument from the reply. */ /*! \fn QDBusReply::QDBusReply(const QDBusError &error) Constructs an error reply from the D-Bus error code given by \a error. */ /*! \fn QDBusReply::operator=(const QDBusReply &other) Makes this object be a copy of the object \a other. */ /*! \fn QDBusReply::operator=(const QDBusError &error) Sets this object to contain the error code given by \a error. You can later access it with error(). */ /*! \fn QDBusReply::operator=(const QDBusMessage &message) Makes this object contain the reply specified by message \a message. If \a message is an error message, this function will copy the error code and message into this object If \a message is a standard reply message and contains at least one parameter, it will be copied into this object, as long as it is of the correct type. If it's not of the same type as this QDBusError object, this function will instead set an error code indicating a type mismatch. */ /*! \fn QDBusReply::operator=(const QDBusPendingCall &pcall) Makes this object contain the reply specified by the pending asynchronous call \a pcall. If the call is not finished yet, this function will call QDBusPendingCall::waitForFinished() to block until the reply arrives. If \a pcall finishes with an error message, this function will copy the error code and message into this object If \a pcall finished with a standard reply message and contains at least one parameter, it will be copied into this object, as long as it is of the correct type. If it's not of the same type as this QDBusError object, this function will instead set an error code indicating a type mismatch. */ /*! \fn bool QDBusReply::isValid() const Returns true if no error occurred; otherwise, returns false. \sa error() */ /*! \fn QDBusReply::error() Returns the error code that was returned from the remote function call. If the remote call did not return an error (i.e., if it succeeded), then the QDBusError object that is returned will not be a valid error code (QDBusError::isValid() will return false). \sa isValid() */ /*! \fn QDBusReply::value() const Returns the remote function's calls return value. If the remote call returned with an error, the return value of this function is undefined and may be undistinguishable from a valid return value. This function is not available if the remote call returns \c void. */ /*! \fn QDBusReply::operator Type() const Returns the same as value(). This function is not available if the remote call returns \c void. */ /*! \internal Fills in the QDBusReply data \a error and \a data from the reply message \a reply. */ void qDBusReplyFill(const QDBusMessage &reply, QDBusError &error, QVariant &data) { error = reply; if (error.isValid()) { data = QVariant(); // clear it return; } if (reply.arguments().count() >= 1 && reply.arguments().at(0).userType() == data.userType()) { data = reply.arguments().at(0); return; } const char *expectedSignature = QDBusMetaType::typeToSignature(data.userType()); const char *receivedType = 0; QByteArray receivedSignature; if (reply.arguments().count() >= 1) { if (reply.arguments().at(0).userType() == QDBusMetaTypeId::argument) { // compare signatures instead QDBusArgument arg = qvariant_cast<QDBusArgument>(reply.arguments().at(0)); receivedSignature = arg.currentSignature().toLatin1(); if (receivedSignature == expectedSignature) { // matched. Demarshall it QDBusMetaType::demarshall(arg, data.userType(), data.data()); return; } } else { // not an argument and doesn't match? int type = reply.arguments().at(0).userType(); receivedType = QVariant::typeToName(QVariant::Type(type)); receivedSignature = QDBusMetaType::typeToSignature(type); } } // error if (receivedSignature.isEmpty()) receivedSignature = "no signature"; QString errorMsg; if (receivedType) { errorMsg = QString::fromLatin1("Unexpected reply signature: got \"%1\" (%4), " "expected \"%2\" (%3)") .arg(QLatin1String(receivedSignature), QLatin1String(expectedSignature), QLatin1String(data.typeName()), QLatin1String(receivedType)); } else { errorMsg = QString::fromLatin1("Unexpected reply signature: got \"%1\", " "expected \"%2\" (%3)") .arg(QLatin1String(receivedSignature), QLatin1String(expectedSignature), QLatin1String(data.typeName())); } error = QDBusError(QDBusError::InvalidSignature, errorMsg); data = QVariant(); // clear it }
QVariant ObjectStaticPropertyModel::data(const QModelIndex &index, int role) const { if (!index.isValid() || !m_obj || index.row() < 0 || index.row() >= m_obj.data()->metaObject()->propertyCount()) { return QVariant(); } const QMetaProperty prop = m_obj.data()->metaObject()->property(index.row()); const QVariant value = prop.read(m_obj.data()); if (role == Qt::DisplayRole) { if (index.column() == 0) { return prop.name(); } else if (index.column() == 1) { // QMetaProperty::read sets QVariant::typeName to int for enums, // so we need to handle that separately here const QString enumStr = Util::enumToString(value, prop.typeName(), m_obj.data()); if (!enumStr.isEmpty()) { return enumStr; } return VariantHandler::displayString(value); } else if (index.column() == 2) { return prop.typeName(); } else if (index.column() == 3) { const QMetaObject *mo = m_obj.data()->metaObject(); while (mo->propertyOffset() > index.row()) { mo = mo->superClass(); } return mo->className(); } } else if (role == Qt::DecorationRole) { if (index.column() == 1) { return VariantHandler::decoration(value); } } else if (role == Qt::EditRole) { if (index.column() == 1 && prop.isWritable()) { return value; } } else if (role == Qt::ToolTipRole) { return detailString(prop); } else if (role == PropertyModel::ActionRole) { return (prop.isResettable() ? PropertyModel::Reset : PropertyModel::NoAction) | ((MetaObjectRepository::instance()->metaObject(value.typeName()) && *reinterpret_cast<void* const*>(value.data())) || value.value<QObject*>() ? PropertyModel::NavigateTo : PropertyModel::NoAction); } else if (role == PropertyModel::ValueRole) { return value; } else if (role == PropertyModel::AppropriateToolRole) { ToolModel *toolModel = Probe::instance()->toolModel(); ToolFactory *factory; if (value.canConvert<QObject*>()) factory = toolModel->data(toolModel->toolForObject(value.value<QObject*>()), ToolModelRole::ToolFactory).value<ToolFactory*>(); else factory = toolModel->data(toolModel->toolForObject(*reinterpret_cast<void* const*>(value.data()), value.typeName()), ToolModelRole::ToolFactory).value<ToolFactory*>(); if (factory) { return factory->name(); } return QVariant(); } return QVariant(); }
void QpBelongsToManyBase::remove(QSharedPointer<QObject> object) { QList<QSharedPointer<QObject>> obj = objects(); Q_UNUSED(obj); // resolve and keep a strong ref, while we're working here int removeCount = data->objects.removeAll(object.toWeakRef()); Q_ASSERT(removeCount <= 1); if(removeCount == 0) return; QpMetaProperty reverse = data->metaProperty.reverseRelation(); if(object){ if(reverse.isToOneRelationProperty()) { QString className = data->metaProperty.metaObject().className(); reverse.write(object.data(), Qp::Private::variantCast(QSharedPointer<QObject>(), className)); } else { QSharedPointer<QObject> shared = Qp::sharedFrom(data->parent); QVariant wrapper = Qp::Private::variantCast(shared); const QMetaObject *mo = object->metaObject(); QByteArray methodName = reverse.metaObject().removeObjectMethod(reverse).methodSignature(); int index = mo->indexOfMethod(methodName); Q_ASSERT_X(index > 0, Q_FUNC_INFO, QString("You have to add a public slot with the signature '%1' to your '%2' class!") .arg(QString::fromLatin1(methodName)) .arg(mo->className()) .toLatin1()); QMetaMethod method = mo->method(index); Q_ASSERT(method.invoke(object.data(), Qt::DirectConnection, QGenericArgument(data->metaProperty.typeName().toLatin1(), wrapper.data()))); } } }
void WebInterface::action(const QVariantMap &actionData) { qDebug()<<actionData.value("action").toString(); QString action = actionData.value("action").toString(); QVariant data = actionData.value("data"); qDebug()<<"Traitement action"; if(data.isNull()){ this->metaObject()->invokeMethod(this,action.toUtf8().data()); }else{ this->metaObject()->invokeMethod(this,action.toUtf8().data(),QGenericArgument("QVariant",data.data())); } }