bool QgsField::convertCompatible( QVariant& v ) const { if ( v.isNull() ) { v.convert( d->type ); return true; } if ( d->type == QVariant::Int && v.toInt() != v.toLongLong() ) { v = QVariant( d->type ); return false; } //String representations of doubles in QVariant will return false to convert( QVariant::Int ) //work around this by first converting to double, and then checking whether the double is convertible to int if ( d->type == QVariant::Int && v.canConvert( QVariant::Double ) ) { bool ok = false; double dbl = v.toDouble( &ok ); if ( !ok ) { //couldn't convert to number v = QVariant( d->type ); return false; } double round = qgsRound( dbl ); if ( round > INT_MAX || round < -INT_MAX ) { //double too large to fit in int v = QVariant( d->type ); return false; } v = QVariant( qRound( dbl ) ); return true; } if ( !v.convert( d->type ) ) { v = QVariant( d->type ); return false; } if ( d->type == QVariant::Double && d->precision > 0 ) { double s = qPow( 10, d->precision ); double d = v.toDouble() * s; v = QVariant(( d < 0 ? ceil( d - 0.5 ) : floor( d + 0.5 ) ) / s ); return true; } if ( d->type == QVariant::String && d->length > 0 && v.toString().length() > d->length ) { v = v.toString().left( d->length ); return false; } return true; }
void QDBusViewer::setProperty(const BusSignature &sig) { QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c); QMetaProperty prop = iface.metaObject()->property(iface.metaObject()->indexOfProperty(sig.mName.toLatin1())); bool ok; QString input = QInputDialog::getText(this, tr("Arguments"), tr("Please enter the value of the property %1 (type %2)").arg( sig.mName, QString::fromLatin1(prop.typeName())), QLineEdit::Normal, QString(), &ok); if (!ok) return; QVariant value = input; if (!value.convert(prop.type())) { QMessageBox::warning(this, tr("Unable to marshall"), tr("Value conversion failed, unable to set property")); return; } QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Set")); QList<QVariant> arguments; arguments << sig.mInterface << sig.mName << qVariantFromValue(QDBusVariant(value)); message.setArguments(arguments); c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage))); }
QVariant Utils::retypeVariant(const QVariant &val, int meta_type_id) { if(meta_type_id == QVariant::Invalid) { //qfWarning() << "Cannot convert" << val << "to QVariant::Invalid type!"; // retype whatever to invalid variant return QVariant(); } if(val.userType() == meta_type_id) return val; if(!val.isValid()) return QVariant(meta_type_id); if(val.isNull()) return QVariant(meta_type_id); if(val.canConvert(meta_type_id)) { QVariant ret = val; ret.convert(meta_type_id); return ret; } //if(meta_type_id >= QVariant::UserType) { // if(val.userType() >= QVariant::UserType) { // if() // } //} qfWarning() << "Don't know, how to convert variant type" << val.typeName() << "to:" << meta_type_id << QMetaType::typeName(meta_type_id); return val; }
/** This function will try to find value of parameter corresponding to its type. * Sometimes, a parameter value is a reference to another one. This functions will recursively * seek through references until it finds one corresponding to the type specified. */ QVariant MOomc::getParameterValue(QString parentClass, QString parameterName,VariableType type, QVariant defaultValue) { QString commandRes= evalCommand("getParameterValue(" + parentClass +","+ parameterName+")"); if(commandRes=="Error" || commandRes.isEmpty()) return defaultValue; QVariant::Type variantType; switch(type) { case OMREAL: variantType = QVariant::Double; break; case OMBOOLEAN : variantType = QVariant::Bool; break; case OMINTEGER : variantType = QVariant::Int; break; case OMSTRING : variantType = QVariant::String; break; default: variantType = QVariant::String; break; } int i=0; // to avoid infinite loop (if for whatever reason, incorrect case is catched by error boolean) QVariant result = commandRes; bool error = false; while(!result.convert(variantType) && (i<100) &&!error) { parentClass = commandRes.section(".",0,-2); parameterName= commandRes.section(".",-1,-1); commandRes = evalCommand("getParameterValue(" + parentClass +","+ parameterName+")"); error = (commandRes=="Error" || commandRes.isEmpty()); result = commandRes; i++; } if(result.convert(variantType) && result.convert(variantType)) return result; else return defaultValue; }
void QJnextMainLoop::set(QObject *object, QVariantList& args, QByteArray* retval) { QByteArray property = args.takeFirst().toByteArray(); const QMetaObject * meta = object->metaObject(); int propertyIndex = meta->indexOfProperty(property); if (propertyIndex < 0) { retval->append("No such property " + property); return; } QMetaProperty metaprop = meta->property(propertyIndex); if (!metaprop.isWritable()) { retval->append("Property " + property + " is not writable"); return; } QVariant vValue = args.takeFirst(); /* handle enum inputs as text */ if (metaprop.isEnumType()) { int id; const QMetaEnum &enumerator = metaprop.enumerator(); QByteArray keys; for (int i = 0; i < enumerator.keyCount(); ++i) keys += enumerator.key(i) + QByteArray(" "); #ifdef DEBUG_QJnextMainLoop qDebug() << "[QJnextMainLoop]\tEnumerator" << enumerator.isFlag() << enumerator.scope() << enumerator.name() << keys; #endif if (enumerator.isFlag()) id = enumerator.keyToValue(vValue.toByteArray().constData()); else id = enumerator.keysToValue(vValue.toByteArray().constData()); if (id != -1) vValue = QVariant(id); } #ifdef DEBUG_QJnextMainLoop qDebug() << "[QJnextMainLoop]\tSET" << meta->className() << property << vValue << vValue.canConvert(metaprop.type()); #endif if (!vValue.convert(metaprop.type())) { retval->append( "Unable to convert \"" + vValue.toByteArray() + "\" to " + metaprop.typeName()); return; } if (!metaprop.write(object, vValue)) retval->append( QByteArray("Unable to set property ") + meta->className() + "." + property + " to " + vValue.toByteArray()); else *retval = QByteArray(); }
// Convert a QVariant to a Python object. static PyObject *convert(const Chimera *ct, const QVariant &value) { QVariant converted = value; if (!converted.convert(static_cast<QVariant::Type>(ct->metatype()))) converted = value; return ct->toPyObject(converted); }
QString write(const QVariant &variant) { if (!variant.isValid()) { qWarning() << "Trying to serialize invalid QVariant"; return QString(); } QString value; switch (variant.type()) { case QMetaType::QPoint: { QPoint p = variant.toPoint(); value = QString("%1,%2").arg(QString::number(p.x()), QString::number(p.y())); break; } case QMetaType::QPointF: { QPointF p = variant.toPointF(); value = QString("%1,%2").arg(QString::number(p.x(), 'f'), QString::number(p.y(), 'f')); break; } case QMetaType::QSize: { QSize s = variant.toSize(); value = QString("%1x%2").arg(QString::number(s.width()), QString::number(s.height())); break; } case QMetaType::QSizeF: { QSizeF s = variant.toSizeF(); value = QString("%1x%2").arg(QString::number(s.width(), 'f'), QString::number(s.height(), 'f')); break; } case QMetaType::QRect: { QRect r = variant.toRect(); value = QString("%1,%2,%3x%4").arg(QString::number(r.x()), QString::number(r.y()), QString::number(r.width()), QString::number(r.height())); break; } case QMetaType::QRectF: { QRectF r = variant.toRectF(); value = QString("%1,%2,%3x%4").arg(QString::number(r.x(), 'f'), QString::number(r.y(), 'f'), QString::number(r.width(), 'f'), QString::number(r.height(), 'f')); break; } default: QVariant strVariant = variant; strVariant.convert(QVariant::String); if (!strVariant.isValid()) qWarning() << Q_FUNC_INFO << "cannot serialize type " << QMetaType::typeName(variant.type()); value = strVariant.toString(); } return value; }
T MetaParams::typeCheckedFromSettings(const QString &name, const T &defaultValue) { QVariant cfgVariable = qsSettings->value(name, defaultValue); if (!cfgVariable.convert(QVariant(defaultValue).type())) { // Bit convoluted as canConvert<T>() only does a static check without considering whether say a string like "blub" is actually a valid double (which convert does). qCritical() << "Configuration variable" << name << "is of invalid format. Set to default value of" << defaultValue << "."; return defaultValue; } return cfgVariable.value<T>(); }
void Expression::NormalizeVariants( QVariant & l, QVariant & r ) const { if ( l.isValid() && r.isValid() ) { if ( l.type() != r.type() ) { if ( l.type() == QVariant::String && l.canConvert( r.type() ) ) l.convert( r.type() ); else if ( r.type() == QVariant::String && r.canConvert( l.type() ) ) r.convert( l.type() ); else { QVariant::Type t = l.type() > r.type() ? l.type() : r.type(); if ( r.canConvert( t ) && l.canConvert( t ) ) { l.convert( t ); r.convert( t ); } } } } }
QVariant Nuria::RestfulHttpNode::convertArgumentToVariant (const QString &argumentData, int targetType) { QVariant variant = argumentData; if (targetType == QMetaType::QVariant) { return variant; } // variant.convert (targetType); return variant; }
KJS::JSValue *callCast(KJS::ExecState *exec, KJS::JSObject *self, const KJS::List &args) { KJSEmbed::VariantBinding *imp = KJSEmbed::extractBindingImp<KJSEmbed::VariantBinding>(exec, self); if (imp) { QVariant val = imp->variant(); QVariant::Type type = QVariant::nameToType(args[0]->toString(exec).ascii()); KJS::JSValue *returnValue = KJS::jsBoolean(val.convert(type)); imp->setValue(val); return returnValue; } return KJS::jsNull(); }
bool QgsField::convertCompatible( QVariant& v ) const { if ( v.isNull() ) { v.convert( mType ); return true; } if ( !v.convert( mType ) ) { return false; } if ( mType == QVariant::Double && mPrecision > 0 ) { v = qRound64( v.toDouble() * qPow( 10, mPrecision ) ) / qPow( 10, mPrecision ); return true; } return true; }
bool convert( const QVariant & from, QVariant & to ) { const QVariant::Type toType = (QVariant::Type) to.userType(); if( from.canConvert( toType ) ) { to.setValue( from ); return to.convert( toType ); } return Data::convert( from.userType(), from.constData(), toType, const_cast<void*>(to.constData()) ); }
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); }
QVariant read(int variantType, const QString &str) { QVariant value; bool conversionOk = true; switch (variantType) { case QMetaType::QPoint: value = pointFFromString(str, &conversionOk).toPoint(); break; case QMetaType::QPointF: value = pointFFromString(str, &conversionOk); break; case QMetaType::QSize: value = sizeFFromString(str, &conversionOk).toSize(); break; case QMetaType::QSizeF: value = sizeFFromString(str, &conversionOk); break; case QMetaType::QRect: value = rectFFromString(str, &conversionOk).toRect(); break; case QMetaType::QRectF: value = rectFFromString(str, &conversionOk); break; case QMetaType::QUrl: value = QVariant(QUrl(str)); break; case QMetaType::QColor: value = colorFromString(str, &conversionOk); break; case QMetaType::QVector3D: value = vector3DFromString(str, &conversionOk); break; default: { if (variantType == QMetaType::type("Enumeration")) { value = QVariant::fromValue<Enumeration>(enumerationFromString(str, &conversionOk)); } else { value = QVariant(str); value.convert(static_cast<QVariant::Type>(variantType)); } break; } } if (!conversionOk) { qWarning() << "Could not convert" << str << "to" << QMetaType::typeName(variantType); value = QVariant(str); } return value; }
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method, const QVariantMap& args, QVariantList& converted_args) { QList<QByteArray> param_types = meta_method.parameterTypes(); if (args.size() != param_types.size()) { logError(QString("wrong number of arguments to method %1 -- " "expected %2 arguments, but got %3") .arg(QString(meta_method.methodSignature())) .arg(meta_method.parameterCount()) .arg(args.size())); return false; } for (int i = 0; i < param_types.size(); i++) { QByteArray param_name = meta_method.parameterNames().at(i); if (args.find(param_name) == args.end()) { // no arg with param name found return false; } const QVariant& arg = args.value(param_name); if (!arg.isValid()) { logError(QString("argument %1 of %2 to method %3 is invalid") .arg(i + 1) .arg(param_types.size()) .arg(QString(meta_method.methodSignature()))); return false; } QByteArray arg_type_name = arg.typeName(); QByteArray param_type_name = param_types.at(i); QVariant::Type param_type = QVariant::nameToType(param_type_name); QVariant copy = QVariant(arg); if (copy.type() != param_type) { if (copy.canConvert(param_type)) { if (!copy.convert(param_type)) { // qDebug() << "cannot convert" << arg_type_name // << "to" << param_type_name; return false; } } } converted_args << copy; } return true; }
static bool NPClass_Invoke(NPObject *npobj, NPIdentifier name, const NPVariant *args, uint32 argCount, NPVariant *result) { NPClass_Prolog; const QByteArray slotName = NPN_UTF8FromIdentifier(name); int slotIndex = publicMethodIndex(npobj, slotName, static_cast<int>(argCount)); if (slotIndex == -1) { NPN_SetException(npobj, QByteArray("No method '" + slotName + "' with " + QByteArray::number(argCount) + " parameters").constData()); return false; } const QMetaMethod slot = qobject->metaObject()->method(slotIndex); QList<QByteArray> parameterTypes = slot.parameterTypes(); if (parameterTypes.count() != static_cast<int>(argCount)) { NPN_SetException(npobj, QByteArray("Wrong parameter count for method " + slotName).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 && parameterTypes.at(p) != "QVariant") { NPN_SetException(npobj, QString("Parameter %1 in method '%2' has invalid type") .arg(p).arg(QString::fromUtf8(slotName)).toAscii().constData()); return false; } QVariant qvar = args[p]; if (type != QVariant::Invalid && !qvar.convert(type)) { NPN_SetException(npobj, QString("Parameter %1 to method '%2' needs to be convertable to '%3'") .arg(p).arg(QString::fromUtf8(slotName)).arg(QString::fromAscii(parameterTypes.at(p))).toAscii().constData()); return false; } variants[p] = qvar; if (type == QVariant::Invalid) metacallArgs[p + 1] = &variants.at(p); else 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; }
//static DbId::value_type DbId::valueOf(QVariant /*pass-by-value*/ variant) { // The parameter "variant" is passed by value since we need to use // the in place QVariant::convert(). Due to Qt's implicit sharing // the value is only copied if the type is different. The redundant // conversion inside value() is bypassed since the type already // matches. We cannot use value(), only because it returns the // valid id 0 in case of conversion errors. if (variant.convert(kVariantType)) { value_type value = variant.value<value_type>(); if (isValidValue(value)) { return value; } } return kInvalidValue; }
QVariant AMetaObject::strToVar( const QString &str, QVariant::Type t ) { QVariant v; switch ( t ) { case QVariant::ByteArray: v = QByteArray::fromHex( str.toLatin1() ); break; default: v = str; } if ( v.convert( t ) ) return v; return QVariant(); }
error *objectSetProperty(QObject_ *object, const char *name, DataValue *value) { QObject *qobject = reinterpret_cast<QObject *>(object); QVariant var; unpackDataValue(value, &var); // Give qvalue an engine reference if it doesn't yet have one. QObject *obj = var.value<QObject *>(); if (obj && !qmlEngine(obj)) { QQmlContext *context = qmlContext(qobject); if (context) { QQmlEngine::setContextForObject(obj, context); } } // Check that the types are compatible. There's probably more to be done here. const QMetaObject *metaObject = qobject->metaObject(); int propIndex = metaObject->indexOfProperty(name); if (propIndex == -1) { return errorf("cannot set non-existent property \"%s\" on type %s", name, qobject->metaObject()->className()); } QMetaProperty prop = metaObject->property(propIndex); int propType = prop.userType(); void *valueArg; if (propType == QMetaType::QVariant) { valueArg = (void *)&var; } else { int varType = var.userType(); QVariant saved = var; if (propType != varType && !var.convert(propType)) { if (varType == QMetaType::QObjectStar) { return errorf("cannot set property \"%s\" with type %s to value of %s*", name, QMetaType::typeName(propType), saved.value<QObject*>()->metaObject()->className()); } else { return errorf("cannot set property \"%s\" with type %s to value of %s", name, QMetaType::typeName(propType), QMetaType::typeName(varType)); } } valueArg = (void *)var.constData(); } int status = -1; int flags = 0; void *args[] = {valueArg, 0, &status, &flags}; QMetaObject::metacall(qobject, QMetaObject::WriteProperty, propIndex, args); return 0; }
void Settings::registerPlugin(IPlugin *plugin) { m_Plugins.push_back(plugin); m_PluginSettings.insert(plugin->name(), QMap<QString, QVariant>()); m_PluginDescriptions.insert(plugin->name(), QMap<QString, QVariant>()); foreach (const PluginSetting &setting, plugin->settings()) { QVariant temp = m_Settings.value("Plugins/" + plugin->name() + "/" + setting.key, setting.defaultValue); if (!temp.convert(setting.defaultValue.type())) { qWarning("failed to interpret \"%s\" as correct type for \"%s\" in plugin \"%s\", using default", qPrintable(temp.toString()), qPrintable(setting.key), qPrintable(plugin->name())); temp = setting.defaultValue; } m_PluginSettings[plugin->name()][setting.key] = temp; m_PluginDescriptions[plugin->name()][setting.key] = QString("%1 (default: %2)").arg(setting.description).arg(setting.defaultValue.toString()); } }
bool OptionsTreeModel::setData ( const QModelIndex & index, const QVariant & value, int role) { QString option = indexToOptionName(index); if ((role != Qt::EditRole) || ((Section) index.column() != Value) || internalNode(option)) { return false; } QVariant current = tree_->getOption(option); QVariant newval = value; if (!newval.canConvert(current.type())) { qWarning() << "Sorry don't know how to do that!"; return false; } newval.convert(current.type()); tree_->setOption(option, newval); return true; }
void InspectorClientQt::populateSetting(const String& key, InspectorController::Setting& setting) { QSettings qsettings; if (qsettings.status() == QSettings::AccessError) { // QCoreApplication::setOrganizationName and QCoreApplication::setApplicationName haven't been called qWarning("QWebInspector: QSettings couldn't read configuration setting [%s].", qPrintable(static_cast<QString>(key))); return; } QString settingKey(settingStoragePrefix + key); QString storedValueType = qsettings.value(settingKey + settingStorageTypeSuffix).toString(); QVariant storedValue = qsettings.value(settingKey); storedValue.convert(QVariant::nameToType(storedValueType.toAscii().data())); setting = variantToSetting(storedValue); }
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; }
QVariant read(int variantType, const QString &str) { QVariant value; bool conversionOk = true; switch (variantType) { case QMetaType::QPoint: value = QDeclarativeStringConverters::pointFFromString(str, &conversionOk).toPoint(); break; case QMetaType::QPointF: value = QDeclarativeStringConverters::pointFFromString(str, &conversionOk); break; case QMetaType::QSize: value = QDeclarativeStringConverters::sizeFFromString(str, &conversionOk).toSize(); break; case QMetaType::QSizeF: value = QDeclarativeStringConverters::sizeFFromString(str, &conversionOk); break; case QMetaType::QRect: value = QDeclarativeStringConverters::rectFFromString(str, &conversionOk).toRect(); break; case QMetaType::QRectF: value = QDeclarativeStringConverters::rectFFromString(str, &conversionOk); break; case QMetaType::QUrl: value = QVariant(QUrl(str)); break; case QMetaType::QColor: value = QDeclarativeStringConverters::colorFromString(str); break; default: { value = QVariant(str); value.convert(static_cast<QVariant::Type>(variantType)); break; } } if (!conversionOk) { qWarning() << "Could not convert" << str << "to" << QMetaType::typeName(variantType); value = QVariant(str); } return value; }
QVariant WebViewObject::hexUnpack(QString hexString,QString type) { char buf[4]; QByteArray qb = QByteArray::fromHex(hexString.toLatin1()); memcpy(buf,qb.data(),qb.size()); QVariant v = QVariant::Invalid; if("byte" == type) { v = QVariant::fromValue(*((unsigned char*)(buf))); } else if("sbyte" == type) { v = QVariant::fromValue(*((signed char*)(buf))); } else if("word" == type) { v = QVariant::fromValue(*((unsigned short*)(buf))); } else if("sword" == type) { v = QVariant::fromValue(*((signed short*)(buf))); } else if("float" == type) { v = QVariant::fromValue(*((float*)(buf))); return v; //return float as is } v.convert(QVariant::LongLong); //convert all integer types to higher resolution return v; }
QString debugDumpJson(QVariant json, QString name, QString indent) { int str_max_length = 70-indent.length(); QString ret; QVariant::Type type = json.type(); if (type == QVariant::Map) { ret += debugDumpJson(json.toMap(), name, indent + " "); } else if (json.canConvert<QString>()) { int ml = str_max_length - name.length(); json.convert(QVariant::String); QString s = json.toString(); if (s.length() > ml) s = s.left(ml-5) + " ... "; ret += s; } else if (type == QVariant::List) { ret += debugDumpJson(json.toList(), name, indent + " "); } else ret += "[" + QString(json.typeName()) + "]"; return ret; }
void InspectorClientQt::populateSetting(const String& key, String* setting) { #ifdef QT_NO_SETTINGS Q_UNUSED(key) Q_UNUSED(setting) qWarning("QWebInspector: QSettings is not supported by Qt."); #else QSettings qsettings; if (qsettings.status() == QSettings::AccessError) { // QCoreApplication::setOrganizationName and QCoreApplication::setApplicationName haven't been called qWarning("QWebInspector: QSettings couldn't read configuration setting [%s].", qPrintable(static_cast<QString>(key))); return; } QString settingKey(settingStoragePrefix + QString(key)); QString storedValueType = qsettings.value(settingKey + settingStorageTypeSuffix).toString(); QVariant storedValue = qsettings.value(settingKey); storedValue.convert(QVariant::nameToType(storedValueType.toAscii().data())); *setting = variantToSetting(storedValue); #endif // QT_NO_SETTINGS }
void HubConnection::onReceived(QVariant &data) { if(data.convert(QVariant::Map)) { QVariantMap map = data.value<QVariantMap>(); //if message is from hub, search hub and write message to it if(map.contains("H")) { QVariant hub = map["H"]; if(_hubs.contains(hub.toString())) { _hubs[hub.toString()]->onReceive(data); } } else if(map.contains("I")) { QVariant id = map["I"]; if(_callbacks.contains(id.toString())) { HubCallback* callback = _callbacks[id.toString()]; if(callback) Q_EMIT callback->raiseMessageReceived(data); _callbacks.remove(id.toString()); } } else { Connection::onReceived(data); } } else { Connection::onReceived(data); } }
void CameraBinMetaData::setMetaData(const QString &key, const QVariant &value) { QVariant correctedValue = value; if (value.isValid()) { if (key == QMediaMetaData::Orientation) { correctedValue = toGStreamerOrientation(value); } else if (key == QMediaMetaData::GPSSpeed) { // kilometers per hour to meters per second. correctedValue = (value.toDouble() * 1000) / 3600; } } Q_FOREACH (const QGStreamerMetaDataKey &metadataKey, *qt_gstreamerMetaDataKeys()) { if (metadataKey.qtName == key) { const char *name = metadataKey.gstName; if (correctedValue.isValid()) { correctedValue.convert(metadataKey.type); m_values.insert(QByteArray::fromRawData(name, qstrlen(name)), correctedValue); } else { m_values.remove(QByteArray::fromRawData(name, qstrlen(name))); } emit QMetaDataWriterControl::metaDataChanged(); emit metaDataChanged(m_values); return; } } }