bool LInputDevice::setPropertyValue(int prop, QVariant value){ if(!devProps.contains(prop)){ return false; } //Need the float atom for some properties - make sure we have that first /*if(ATOM_FLOAT==0){ xcb_intern_atom_reply_t *ar = xcb_intern_atom_reply(QX11Info::connection(), \ xcb_intern_atom(QX11Info::connection(), 0, 1, "FLOAT"), NULL); if(ar!=0){ ATOM_FLOAT = ar->atom; free(ar); } }*/ //Now setup the argument bool ok = false; QStringList args; args << "--set-prop"; args << QString::number(devID); args << QString::number(prop); //prop ID args << variantToString(value); ok = (0 == LUtils::runCmd("xinput", args) ); if(ok){ //Need to update the value in the hash as well propData dat = devProps[prop]; dat.value = value; devProps.insert(prop, dat); } return ok; }
static bool variantToString(const QVariant &arg, QString &out) { int argType = arg.userType(); if (argType == QVariant::StringList) { out += QLatin1Char('{'); QStringList list = arg.toStringList(); foreach (QString item, list) out += QLatin1Char('\"') + item + QLatin1String("\", "); if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QVariant::ByteArray) { out += QLatin1Char('{'); QByteArray list = arg.toByteArray(); for (int i = 0; i < list.count(); ++i) { out += QString::number(list.at(i)); out += QLatin1String(", "); } if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QVariant::List) { out += QLatin1Char('{'); QList<QVariant> list = arg.toList(); foreach (QVariant item, list) { if (!variantToString(item, out)) return false; out += QLatin1String(", "); } if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QMetaType::Char || argType == QMetaType::Short || argType == QMetaType::Int
static QString variantHashToString( const QVariantHash& variantHash ) { QStringList result; for ( auto it = variantHash.constBegin(); it != variantHash.constEnd(); ++it ) result.append( it.key() + '=' + variantToString( it.value() ) ); return '<' + result.join(',') + '>'; }
static QString variantMapToString( const QVariantMap& variantMap ) { QStringList result; for ( auto it = variantMap.constBegin(); it != variantMap.constEnd(); ++it ) result.append( it.key() + '=' + variantToString( it.value() ) ); return '[' + result.join(',') + ']'; }
static QString variantListToString( const QVariantList& variantList ) { QStringList result; for ( const QVariant& variant : variantList ) result.append( variantToString( variant ) ); return '{' + result.join(',') + '}'; }
/*! \internal \since 4.5 Dumps the contents of a Qt D-Bus argument from \a arg into a string. */ QString argumentToString(const QVariant &arg) { QString out; #ifndef QT_BOOTSTRAPPED variantToString(arg, out); #else Q_UNUSED(arg); #endif return out; }
static void variantToString(const QVariant &var, QString &str) { if (var.type() == QVariant::List) { QVector<QVariant> lst = var.toList().toVector(); str += QLatin1String("["); for (int i = 0; i < lst.count(); ++i) { QVariant val = lst[i]; variantToString(val, str); if (i < lst.count() - 1) str += QLatin1String(", "); } str += QLatin1String("]"); } else if (var.type() == QVariant::Map) { Q_ASSERT(!"unsupported state type"); } else if (var.type() == QVariant::Hash) { Q_ASSERT(!"unsupported state type"); } else { str += var.toString(); } }
static QTreeWidgetItem * variantToItem(const QString &key, const QVariant &var, const QVariant &defaultVar) { if (var == defaultVar) { return NULL; } QString val; bool deep = isVariantDeep(var); if (!deep) { variantToString(var, val); } //qDebug()<<"key = "<<key; //qDebug()<<"val = "<<val; QStringList lst; lst += key; lst += val; QTreeWidgetItem *item = new QTreeWidgetItem((QTreeWidgetItem *)0, lst); if (deep) { QList<QTreeWidgetItem *> children; if (var.type() == QVariant::Map) { QVariantMap map = var.toMap(); QVariantMap defaultMap = defaultVar.toMap(); variantMapToItems(map, defaultMap, children); } if (var.type() == QVariant::List) { QVector<QVariant> lst = var.toList().toVector(); QVector<QVariant> defaultLst = defaultVar.toList().toVector(); variantListToItems(lst, defaultLst, children); } item->addChildren(children); } return item; }
QString LInputDevice::variantToString(QVariant value){ if( value.canConvert< QList<QVariant> >() ){ //List of variants QStringList out; QList<QVariant> list = value.toList(); for(int i=0; i<list.length(); i++){ out << variantToString(list[i]); } return out.join(", "); }else{ //Single value if(value.canConvert<double>() ){ return QString::number(value.toDouble()); }else if(value.canConvert<int>() ){ return QString::number(value.toInt()); }else if( value.canConvert<QString>() ){ //See if this is an atom first QString val = value.toString(); if(val.contains("(")){ val = val.section("(",1,-1).section(")",0,0); } return val; } } return ""; //nothing to return }
void QWinSettingsPrivate::set(const QString &uKey, const QVariant &value) { if (writeHandle() == 0) { setStatus(QSettings::AccessError); return; } QString rKey = escapedKey(uKey); HKEY handle = createOrOpenKey(writeHandle(), registryPermissions, keyPath(rKey)); if (handle == 0) { setStatus(QSettings::AccessError); return; } DWORD type; QByteArray regValueBuff; // Determine the type switch (value.type()) { case QVariant::List: case QVariant::StringList: { // If none of the elements contains '\0', we can use REG_MULTI_SZ, the // native registry string list type. Otherwise we use REG_BINARY. type = REG_MULTI_SZ; QStringList l = variantListToStringList(value.toList()); QStringList::const_iterator it = l.constBegin(); for (; it != l.constEnd(); ++it) { if ((*it).length() == 0 || stringContainsNullChar(*it)) { type = REG_BINARY; break; } } if (type == REG_BINARY) { QString s = variantToString(value); regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2); } else { QStringList::const_iterator it = l.constBegin(); for (; it != l.constEnd(); ++it) { const QString &s = *it; regValueBuff += QByteArray((const char*)s.utf16(), (s.length() + 1) * 2); } regValueBuff.append((char)0); regValueBuff.append((char)0); } break; } case QVariant::Int: case QVariant::UInt: { type = REG_DWORD; qint32 i = value.toInt(); regValueBuff = QByteArray((const char*)&i, sizeof(qint32)); break; } case QVariant::LongLong: case QVariant::ULongLong: { type = REG_QWORD; qint64 i = value.toLongLong(); regValueBuff = QByteArray((const char*)&i, sizeof(qint64)); break; } case QVariant::ByteArray: // fallthrough intended default: { // If the string does not contain '\0', we can use REG_SZ, the native registry // string type. Otherwise we use REG_BINARY. QString s = variantToString(value); type = stringContainsNullChar(s) ? REG_BINARY : REG_SZ; if (type == REG_BINARY) { regValueBuff = QByteArray((const char*)s.utf16(), s.length() * 2); } else { regValueBuff = QByteArray((const char*)s.utf16(), (s.length() + 1) * 2); } break; } } // set the value LONG res = RegSetValueEx(handle, reinterpret_cast<const wchar_t *>(keyName(rKey).utf16()), 0, type, reinterpret_cast<const unsigned char*>(regValueBuff.constData()), regValueBuff.size()); if (res == ERROR_SUCCESS) { deleteWriteHandleOnExit = false; } else { qWarning("QSettings: failed to set subkey \"%s\": %s", rKey.toLatin1().data(), errorCodeToString(res).toLatin1().data()); setStatus(QSettings::AccessError); } RegCloseKey(handle); }
static bool variantToString(const QVariant &arg, QString &out) { int argType = arg.userType(); if (argType == QVariant::StringList) { out += QLatin1Char('{'); const QStringList list = arg.toStringList(); for (const QString &item : list) out += QLatin1Char('\"') + item + QLatin1String("\", "); if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QVariant::ByteArray) { out += QLatin1Char('{'); QByteArray list = arg.toByteArray(); for (int i = 0; i < list.count(); ++i) { out += QString::number(list.at(i)); out += QLatin1String(", "); } if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QVariant::List) { out += QLatin1Char('{'); const QList<QVariant> list = arg.toList(); for (const QVariant &item : list) { if (!variantToString(item, out)) return false; out += QLatin1String(", "); } if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); } else if (argType == QMetaType::Char || argType == QMetaType::Short || argType == QMetaType::Int || argType == QMetaType::Long || argType == QMetaType::LongLong) { out += QString::number(arg.toLongLong()); } else if (argType == QMetaType::UChar || argType == QMetaType::UShort || argType == QMetaType::UInt || argType == QMetaType::ULong || argType == QMetaType::ULongLong) { out += QString::number(arg.toULongLong()); } else if (argType == QMetaType::Double) { out += QString::number(arg.toDouble()); } else if (argType == QMetaType::Bool) { out += QLatin1String(arg.toBool() ? "true" : "false"); } else if (argType == qMetaTypeId<QDBusArgument>()) { argToString(qvariant_cast<QDBusArgument>(arg), out); } else if (argType == qMetaTypeId<QDBusObjectPath>()) { const QString path = qvariant_cast<QDBusObjectPath>(arg).path(); out += QLatin1String("[ObjectPath: "); out += path; out += QLatin1Char(']'); } else if (argType == qMetaTypeId<QDBusSignature>()) { out += QLatin1String("[Signature: ") + qvariant_cast<QDBusSignature>(arg).signature(); out += QLatin1Char(']'); } else if (argType == qMetaTypeId<QDBusUnixFileDescriptor>()) { out += QLatin1String("[Unix FD: "); out += QLatin1String(qvariant_cast<QDBusUnixFileDescriptor>(arg).isValid() ? "valid" : "not valid"); out += QLatin1Char(']'); } else if (argType == qMetaTypeId<QDBusVariant>()) { const QVariant v = qvariant_cast<QDBusVariant>(arg).variant(); out += QLatin1String("[Variant"); int vUserType = v.userType(); if (vUserType != qMetaTypeId<QDBusVariant>() && vUserType != qMetaTypeId<QDBusSignature>() && vUserType != qMetaTypeId<QDBusObjectPath>() && vUserType != qMetaTypeId<QDBusArgument>()) out += QLatin1Char('(') + QLatin1String(v.typeName()) + QLatin1Char(')'); out += QLatin1String(": "); if (!variantToString(v, out)) return false; out += QLatin1Char(']'); } else if (arg.canConvert(QVariant::String)) { out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"'); } else { out += QLatin1Char('['); out += QLatin1String(arg.typeName()); out += QLatin1Char(']'); } return true; }
bool argToString(const QDBusArgument &busArg, QString &out) { QString busSig = busArg.currentSignature(); bool doIterate = false; QDBusArgument::ElementType elementType = busArg.currentType(); if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType && elementType != QDBusArgument::MapEntryType) out += QLatin1String("[Argument: ") + busSig + QLatin1Char(' '); switch (elementType) { case QDBusArgument::BasicType: case QDBusArgument::VariantType: if (!variantToString(busArg.asVariant(), out)) return false; break; case QDBusArgument::StructureType: busArg.beginStructure(); doIterate = true; break; case QDBusArgument::ArrayType: busArg.beginArray(); out += QLatin1Char('{'); doIterate = true; break; case QDBusArgument::MapType: busArg.beginMap(); out += QLatin1Char('{'); doIterate = true; break; case QDBusArgument::MapEntryType: busArg.beginMapEntry(); if (!variantToString(busArg.asVariant(), out)) return false; out += QLatin1String(" = "); if (!argToString(busArg, out)) return false; busArg.endMapEntry(); break; case QDBusArgument::UnknownType: default: out += QLatin1String("<ERROR - Unknown Type>"); return false; } if (doIterate && !busArg.atEnd()) { while (!busArg.atEnd()) { if (!argToString(busArg, out)) return false; out += QLatin1String(", "); } out.chop(2); } switch (elementType) { case QDBusArgument::BasicType: case QDBusArgument::VariantType: case QDBusArgument::UnknownType: case QDBusArgument::MapEntryType: // nothing to do break; case QDBusArgument::StructureType: busArg.endStructure(); break; case QDBusArgument::ArrayType: out += QLatin1Char('}'); busArg.endArray(); break; case QDBusArgument::MapType: out += QLatin1Char('}'); busArg.endMap(); break; } if (elementType != QDBusArgument::BasicType && elementType != QDBusArgument::VariantType && elementType != QDBusArgument::MapEntryType) out += QLatin1Char(']'); return true; }