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;
}