void ClipboardMonitor::onMessageReceived(const QByteArray &message, int messageCode) { if (messageCode == MonitorPing) { sendMessage( QByteArray(), MonitorPong ); #ifdef Q_OS_WIN // Qt BUG: This needs to be called regularly so that QClipboard emits changed() signal. QApplication::clipboard()->mimeData(); #endif } else if (messageCode == MonitorSettings) { QDataStream stream(message); QVariantMap settings; stream >> settings; if ( hasLogLevel(LogDebug) ) { COPYQ_LOG("Loading configuration:"); foreach (const QString &key, settings.keys()) { QVariant val = settings[key]; const QString str = val.canConvert<QStringList>() ? val.toStringList().join(",") : val.toString(); COPYQ_LOG( QString(" %1=%2").arg(key).arg(str) ); } } if ( settings.contains("formats") ) m_formats = settings["formats"].toStringList(); #ifdef COPYQ_WS_X11 m_x11->loadSettings(settings); #endif connect( QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)), this, SLOT(checkClipboard(QClipboard::Mode)), Qt::UniqueConnection ); COPYQ_LOG("Configured"); } else if (messageCode == MonitorChangeClipboard) {
QString ConversionUtil::toUserString(const QVariant &variant) { if (!variant.isValid()) { return "(not set)"; } switch (variant.type()) { case QVariant::Bool: return variant.toBool() ? "true" : "false"; case QVariant::Int: return QString::number(variant.toInt()); case QVariant::Double: return QString::number(variant.toDouble()); case QVariant::String: { QString string = variant.toString(); return string.isEmpty() ? "(empty string)" : string; } case QVariant::StringList: return variant.toStringList().join("\n"); case QVariant::DateTime: return variant.toDateTime().toString(); case QVariant::UserType: { MetaTypeRegistry::UserStringConverters converters = MetaTypeRegistry::userStringConverters(QMetaType::typeName(variant.userType())); if (converters.typeToUserStringConverter) { return converters.typeToUserStringConverter(variant); } } // fall-through default: return "(unknown type)"; } }
/** * Updates the list of reflection model when an analyser bank is selected. * * @param index Index of the analyser selected */ void IndirectInstrumentConfig::updateReflectionsList(int index) { bool reflectionPreviousBlocking = m_uiForm.cbReflection->signalsBlocked(); m_uiForm.cbReflection->blockSignals(true); m_uiForm.cbReflection->clear(); QVariant currentData = m_uiForm.cbAnalyser->itemData(index); bool valid = currentData != QVariant::Invalid; m_uiForm.cbReflection->setEnabled(valid); if(valid) { QStringList reflections = currentData.toStringList(); for ( int i = 0; i < reflections.count(); i++ ) m_uiForm.cbReflection->addItem(reflections[i]); } else { m_uiForm.cbReflection->addItem("No Valid Reflections"); } m_uiForm.cbReflection->blockSignals(reflectionPreviousBlocking); newInstrumentConfiguration(); }
void QTestLibPlugin::projectRunHook(ProjectExplorer::Project *proj) { return; //NBS TODO QTestlibplugin if (!proj) return; m_projectDirectory = QString(); //NBS proj->setExtraApplicationRunArguments(QStringList()); //NBS proj->setCustomApplicationOutputHandler(0); const QVariant config; //NBS = proj->projectProperty(ProjectExplorer::Constants::P_CONFIGVAR); if (!config.toStringList().contains(QLatin1String("qtestlib"))) return; { QTemporaryFile tempFile; tempFile.setAutoRemove(false); tempFile.open(); m_outputFile = tempFile.fileName(); } //NBS proj->setCustomApplicationOutputHandler(this); //NBS proj->setExtraApplicationRunArguments(QStringList() << QLatin1String("-xml") << QLatin1String("-o") << m_outputFile); const QString proFile = proj->fileName(); const QFileInfo fi(proFile); if (QFile::exists(fi.absolutePath())) m_projectDirectory = fi.absolutePath(); }
void VariantPropertyManager::setAttribute(QtProperty *property, const QString &attribute, const QVariant &val) { if (mValues.contains(property)) { if (attribute == QLatin1String("filter")) { if (val.type() != QVariant::String && !val.canConvert(QVariant::String)) return; QString str = val.toString(); Data d = mValues[property]; if (d.filter == str) return; d.filter = str; mValues[property] = d; emit attributeChanged(property, attribute, str); } return; } if (mStringAttributes.contains(property)) { if (attribute == mSuggestionsAttribute) { mStringAttributes[property].suggestions = val.toStringList(); return; } if (attribute == mMultilineAttribute) { mStringAttributes[property].multiline = val.toBool(); return; } } QtVariantPropertyManager::setAttribute(property, attribute, val); }
/*! \reimp */ void QUsbStorageGadgetProvider::saveConfig() { QSettings settings("Trolltech", "Usb"); settings.beginGroup(GADGET_NAME); QVariant v = value("product"); if (v.isValid()) settings.setValue("Product", v.toString()); v = value("productId"); if (v.isValid()) settings.setValue("ProductId", v.toUInt()); v = value("vendor"); if (v.isValid()) settings.setValue("Vendor", v.toString()); v = value("vendorId"); if (v.isValid()) settings.setValue("VendorId", v.toUInt()); v = value("backingStore"); if (v.isValid()) settings.setValue("BackingStore", v.toStringList()); settings.endGroup(); }
void RedisServerDbItem::keysLoaded(const QVariant &keys, QObject *owner) { if (owner != this) { return; } server->locked = false; server->connection->disconnect(this); rawKeys = keys.toStringList(); keysCount = rawKeys.size(); if (keysCount == 0) { server->unlockUI(); setNormalIcon(); return; } if (keysCount < keysCount) { server->error(QString("Loaded keys: %2 of %3. Error - %4 <br /> Check <a href='https://github.com/uglide/RedisDesktopManager/wiki/Known-issues'>documentation</a>") .arg(keysCount) .arg(keysCount) .arg(server->connection->getLastError())); } setDbText(); renderKeys(rawKeys); setNormalIcon(); isKeysLoaded = true; }
void itemAliasList::set(ParameterList &pParams) { QVariant param; bool valid; param = pParams.value("itemType", &valid); if (valid) { _itemType = param.toUInt(); setWindowTitle(buildItemLineEditTitle(_itemType, tr("Item Aliases"))); } else { _itemType = ItemLineEdit::cUndefined; setWindowTitle(tr("Item Aliases")); } param = pParams.value("extraClauses", &valid); if (valid) _extraClauses = param.toStringList(); _showInactive->setChecked(FALSE); _showInactive->setEnabled(!(_itemType & ItemLineEdit::cActive)); param = pParams.value("sql", &valid); if (valid) _sql = param.toString(); }
/*! Converts \a variant to a QJsonValue and returns it. The conversion will convert QVariant types as follows: \table \header \li Source type \li Destination type \row \li \list \li QMetaType::Bool \endlist \li QJsonValue::Bool \row \li \list \li QMetaType::Int \li QMetaType::UInt \li QMetaType::LongLong \li QMetaType::ULongLong \li QMetaType::Float \li QMetaType::Double \endlist \li QJsonValue::Double \row \li \list \li QMetaType::QString \endlist \li QJsonValue::String \row \li \list \li QMetaType::QStringList \li QMetaType::QVariantList \endlist \li QJsonValue::Array \row \li \list \li QMetaType::QVariantMap \endlist \li QJsonValue::Object \endtable For all other QVariant types a conversion to a QString will be attempted. If the returned string is empty, a Null QJsonValue will be stored, otherwise a String value using the returned QString. \sa toVariant() */ QJsonValue QJsonValue::fromVariant(const QVariant &variant) { switch (variant.userType()) { case QVariant::Bool: return QJsonValue(variant.toBool()); case QVariant::Int: case QMetaType::Float: case QVariant::Double: case QVariant::LongLong: case QVariant::ULongLong: case QVariant::UInt: return QJsonValue(variant.toDouble()); case QVariant::String: return QJsonValue(variant.toString()); case QVariant::StringList: return QJsonValue(QJsonArray::fromStringList(variant.toStringList())); case QVariant::List: return QJsonValue(QJsonArray::fromVariantList(variant.toList())); case QVariant::Map: return QJsonValue(QJsonObject::fromVariantMap(variant.toMap())); default: break; } QString string = variant.toString(); if (string.isEmpty()) return QJsonValue(); return QJsonValue(string); }
void Attribute::setValue( const QVariant& var ) { if ( useRelationTable() ) { QSqlQuery q; QString query = "SELECT " + mIdCol +" FROM " + mTable + " WHERE " + mStringCol + "=:string"; q.prepare( query ); // kDebug() << "Column: " << mIdCol << " | table " << mTable << " | string: " << mStringCol << ": " << query; if ( listValue() ) { QStringList idList; QStringList list = var.toStringList(); for ( QStringList::Iterator valIt = list.begin(); valIt != list.end(); ++valIt ) { QString curValue = *valIt; // kDebug() << "Searching for " << curValue << " in relation table"; q.bindValue( ":string", curValue ); q.exec(); if ( q.next() ) { idList << q.value( 0 ).toString(); } } mValue = QVariant( idList ); } else { q.bindValue( ":string", var.toString() ); q.exec(); // kDebug() << "ERROR" << q.lastError().text(); if ( q.next() ) { mValue = q.value( 0 ); } } } else { mValue = var; } }
QHash<QString, QString> VConfigManager::readShortcutsFromSettings(QSettings *p_settings, const QString &p_group) { QHash<QString, QString> ret; p_settings->beginGroup(p_group); QStringList keys = p_settings->childKeys(); for (auto const & key : keys) { if (key.isEmpty()) { continue; } QVariant varVal = p_settings->value(key); QString sequence = varVal.toString(); if (varVal.type() == QVariant::StringList) { sequence = varVal.toStringList().join(","); } sequence = sequence.trimmed(); if (isValidKeySequence(sequence)) { ret.insert(key, sequence); } } p_settings->endGroup(); return ret; }
QVariant Sailwave::loadSetting(const QString &key, const QVariant &defaultValue) { this->_settings->sync(); QVariant value = this->_settings->value(key, defaultValue); // Ugly hack. Type of value is not correct - so use type of defaultValue, assuming that this is the correct type... switch (defaultValue.type()) { case QVariant::Bool: return value.toBool(); case QVariant::Double: return value.toDouble(); case QVariant::Int: return value.toInt(); case QVariant::String: return value.toString(); case QVariant::StringList: return value.toStringList(); case QVariant::List: return value.toList(); default: return value; } }
static InspectorController::Setting variantToSetting(const QVariant& qvariant) { InspectorController::Setting retVal; switch (qvariant.type()) { case QVariant::Bool: retVal.set(qvariant.toBool()); break; case QVariant::Double: retVal.set(qvariant.toDouble()); break; case QVariant::Int: retVal.set((long)qvariant.toInt()); break; case QVariant::String: retVal.set(qvariant.toString()); break; case QVariant::StringList: { QStringList qsList = qvariant.toStringList(); int listCount = qsList.count(); Vector<String> vector(listCount); for (int i = 0; i < listCount; ++i) vector[i] = qsList[i]; retVal.set(vector); break; } } return retVal; }
void BackStageForm::loadRecents() { _settings.sync(); QVariant v = _settings.value("recentItems"); if (v.type() != QVariant::StringList && v.type() != QVariant::String) { // oddly, under linux, loading a setting value of type StringList which has // only a single string in it, gives you just a string. we QVariant::String is acceptable too qDebug() << "BackStageForm::loadRecents(); setting 'recentItems' is not a QStringList"; return; } QStringList recents = v.toStringList(); for (int i = 0; i < recents.size(); i++) { if (!QFileInfo::exists(recents[i])) { recents.removeAt(i); i -= 1; } } while (_recents.size() > 5) _recents.removeFirst(); if (recents != _recents) { _recents = recents; ui->recentDataSets->setDataSets(_recents); } }
VCXYPadFixture::VCXYPadFixture(const QVariant& variant) { if (variant.canConvert(QVariant::StringList) == true) { QStringList list(variant.toStringList()); if (list.count() == 7) { m_fixture = list.at(0).toInt(); m_xMin = list.at(1).toDouble(); m_xMax = list.at(2).toDouble(); m_xReverse = list.at(3).toInt(); m_yMin = list.at(4).toDouble(); m_yMax = list.at(5).toDouble(); m_yReverse = list.at(6).toInt(); } else { /* Construct empty fixture */ *this = VCXYPadFixture(); } } else { /* Construct empty fixture */ *this = VCXYPadFixture(); } m_xMSB = KChannelInvalid; m_xLSB = KChannelInvalid; m_yMSB = KChannelInvalid; m_yLSB = KChannelInvalid; }
static inline QFont *readKdeFontSetting(const QSettings &settings, const QString &key) { const QVariant fontValue = settings.value(key); if (fontValue.isValid()) { // Read font value: Might be a QStringList as KDE stores fonts without quotes. // Also retrieve the family for the constructor since we cannot use the // default constructor of QFont, which accesses QGuiApplication::systemFont() // causing recursion. QString fontDescription; QString fontFamily; if (fontValue.type() == QVariant::StringList) { const QStringList list = fontValue.toStringList(); if (!list.isEmpty()) { fontFamily = list.first(); fontDescription = list.join(QLatin1Char(',')); } } else { fontDescription = fontFamily = fontValue.toString(); } if (!fontDescription.isEmpty()) { QFont font(fontFamily); if (font.fromString(fontDescription)) return new QFont(font); } } return 0; }
XhtmlDoc::WellFormedError CleanSource::WellFormedXMLCheck(const QString &source, const QString mtype) { XhtmlDoc::WellFormedError error; int rv = 0; QString error_traceback; QList<QVariant> args; args.append(QVariant(source)); args.append(QVariant(mtype)); EmbeddedPython * epython = EmbeddedPython::instance(); QVariant res = epython->runInPython( QString("xmlprocessor"), QString("WellFormedXMLCheck"), args, &rv, error_traceback); if (rv != 0) { Utility::DisplayStdWarningDialog(QString("error in xmlprocessor WellFormedXMLCheck: ") + QString::number(rv), error_traceback); // an error happened during check, return well-formed as true return error; } QStringList errors = res.toStringList(); error.line = errors.at(0).toInt(); error.column = errors.at(1).toInt(); error.message = errors.at(2); return error; }
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
bool ClipboardModel::setData(const QModelIndex &index, const QVariant &value, int role) { if ( !index.isValid() ) return false; int row = index.row(); if (role == Qt::EditRole) { m_clipboardList[row]->setText(value.toString()); } else if (role == contentType::notes) { const QString notes = value.toString(); if ( notes.isEmpty() ) m_clipboardList[row]->removeData(mimeItemNotes); else m_clipboardList[row]->setData( mimeItemNotes, notes.toUtf8() ); } else if (role == contentType::updateData) { if ( !m_clipboardList[row]->updateData(value.toMap()) ) return false; } else if (role == contentType::data) { const ClipboardItemPtr &item = m_clipboardList[row]; const QVariantMap dataMap = value.toMap(); if ( item->data() == dataMap ) return false; item->setData(dataMap); } else if (role >= contentType::removeFormats) { if ( !m_clipboardList[row]->removeData(value.toStringList()) ) return false; } else { return false; } emit dataChanged(index, index); return true; }
Item::Iterator::Ptr VariableLoader::evaluateSequence(const QXmlName name, const DynamicContext::Ptr &context) { const QVariant &variant = m_bindingHash.value(name); Q_ASSERT_X(!variant.isNull(), Q_FUNC_INFO, "We assume that we have a binding."); /* Same code as in the default clause below. */ if(variant.userType() == qMetaTypeId<QIODevice *>()) return makeSingletonIterator(itemForName(name)); else if(variant.userType() == qMetaTypeId<QXmlQuery>()) { const QXmlQuery variableQuery(qvariant_cast<QXmlQuery>(variant)); return variableQuery.d->expression()->evaluateSequence(DynamicContext::Ptr(new TemporaryTreesRedirectingContext(variableQuery.d->dynamicContext(), context))); } const QVariant v(qvariant_cast<QXmlItem>(variant).toAtomicValue()); switch(v.type()) { case QVariant::StringList: return Item::Iterator::Ptr(new StringListIterator(v.toStringList())); case QVariant::List: return Item::Iterator::Ptr(new VariantListIterator(v.toList())); default: return makeSingletonIterator(itemForName(name)); } }
void QCupsPrintEngine::setProperty(PrintEnginePropertyKey key, const QVariant &value) { Q_D(QCupsPrintEngine); switch (int(key)) { case PPK_PaperSize: d->printerPaperSize = QPrinter::PaperSize(value.toInt()); d->setPaperSize(); break; case PPK_CupsPageRect: d->cupsPageRect = value.toRect(); break; case PPK_CupsPaperRect: d->cupsPaperRect = value.toRect(); break; case PPK_CupsOptions: d->cupsOptions = value.toStringList(); break; case PPK_CupsStringPageSize: d->cupsStringPageSize = value.toString(); break; case PPK_PrinterName: // prevent setting the defaults again for the same printer if (d->printerName != value.toString()) { d->printerName = value.toString(); d->setCupsDefaults(); } break; default: QPdfPrintEngine::setProperty(key, value); break; } }
BusMngr::BusMngr(QString comPort): bus(), busPrinter(bus), protocolDriver(busPrinter), deviceIdx(0), db(QSqlDatabase::addDatabase("QMYSQL")) { QString conffile = QString(QCoreApplication::applicationDirPath() + "/AccessServer.conf"); QSettings settings(conffile, QSettings::IniFormat); if (settings.status() != QSettings::NoError) { int f; f = 1; } QVariant addrV = settings.value("doorAddresses", "1"); QStringList addrs = addrV.toStringList(); QString addr; foreach (addr, addrs) { BusDevice device; device.addr = addr.toInt(); device.last_reply_time = QDateTime::currentDateTime(); device.offline = false; deviceList.append(device); }
bool GraphicalUriArray::setValue(const QVariant & value) { QStringList list; bool success = false; if(value.type() == QVariant::String) { list = value.toString().split(m_separator); list.removeAll(QString()); m_originalValue = list; m_model->setStringList(list); success = true; } else if(value.type() == QVariant::StringList) { QStringList values = value.toStringList(); QStringList::iterator it = values.begin(); success = true; for( ; it != values.end() ; it++) { if( !it->isEmpty() ) list << *it; } m_originalValue = values; list.removeDuplicates(); m_model->setStringList(list); } return success; }
void toAWR::instanceChanged(int pos) { QVariant d = dbid->itemData(pos); QStringList l = d.toStringList(); std::stringstream s; for(QList<QString>::iterator i=l.begin(); i!=l.end(); ++i) { s << ":\'" << (*i).toAscii().constData() << '\''; } TLOG(0,toDecorator,__HERE__) << "Instance changed:" << pos << s.str() << std::endl; QString dbid = l.at(0); QString inst = l.at(1); try { toQList sparams, eparams; sparams.push_back(dbid); sparams.push_back(inst); sparams.push_back(startdate->date().toString("yyyy:MM:dd")); sparams.push_back(startdate->date().toString("yyyy:MM:dd")); TLOG(1,toDecorator,__HERE__) << "FSNAP: (" << sparams.size() << ")" << std::endl; fsnap->query(toSQL::sql("toAWR:Snaps", connection()), const_cast<const toQList&>(sparams ) ); fsnap->refresh(); eparams.push_back(dbid); eparams.push_back(inst); eparams.push_back(enddate->date().toString("yyyy:MM:dd")); eparams.push_back(enddate->date().toString("yyyy:MM:dd")); TLOG(1,toDecorator,__HERE__) << "TSNAP: (" << eparams.size() << ")" << std::endl; tsnap->query(toSQL::sql("toAWR:Snaps", connection()), const_cast<const toQList&>(eparams ) ); tsnap->refresh(); } TOCATCH; };
void toAWR::endDateChanged(QDate date) { std::cerr << "endDateChanged:" << date.toString() << std::endl; int pos = dbid->currentIndex(); QVariant d = dbid->itemData(pos); QStringList l = d.toStringList(); std::stringstream s; for(QList<QString>::iterator i=l.begin(); i!=l.end(); ++i) { s << ":\'" << (*i).toAscii().constData() << '\''; } TLOG(0,toDecorator,__HERE__) << "end date changed:" << date.toString("YYYY:MM:DD") << std::endl; QString dbid = l.at(0); QString inst = l.at(1); try { toQList params; params.push_back(dbid); params.push_back(inst); params.push_back(date.toString("yyyy:MM:dd")); params.push_back(date.toString("yyyy:MM:dd")); fsnap->setSelectionPolicy(toResultCombo::None); tsnap->query(toSQL::sql("toAWR:Snaps", connection()), const_cast<const toQList&>(params ) ); tsnap->refresh(); } TOCATCH; }
QStringList QgsProject::readListEntry( QString const & scope, const QString & key, bool * ok ) const { QgsProperty * property = findKey_( scope, key, imp_->properties_ ); QVariant value; if ( property ) { value = property->value(); } bool valid = QVariant::StringList == value.type(); if ( ok ) { *ok = valid; } if ( valid ) { return value.toStringList(); } return QStringList(); } // QgsProject::readListEntry
QWidget* QmitkPropertyItemDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const { QVariant data = index.data(Qt::EditRole); if (data.isValid()) { if (data.type() == QVariant::Int) { QSpinBox* spinBox = new QSpinBox(parent); connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished())); return spinBox; } if (data.type() == QVariant::Double || static_cast<QMetaType::Type>(data.type()) == QMetaType::Float) { QDoubleSpinBox* spinBox = new QDoubleSpinBox(parent); mitk::PropertyExtensions* extensions = mitk::GetPropertyService<mitk::PropertyExtensions>(); std::string name = this->GetPropertyName(index); if (extensions != NULL && !name.empty() && extensions->HasExtension(name)) { mitk::FloatPropertyExtension* extension = static_cast<mitk::FloatPropertyExtension*>(extensions->GetExtension(name)); spinBox->setMinimum(extension->GetMinimum()); spinBox->setMaximum(extension->GetMaximum()); spinBox->setSingleStep(extension->GetSingleStep()); spinBox->setDecimals(extension->GetDecimals()); } else { spinBox->setSingleStep(0.1); spinBox->setDecimals(4); } if (name == "opacity") // TODO { spinBox->setMinimum(0.0); spinBox->setMaximum(1.0); } connect(spinBox, SIGNAL(editingFinished()), this, SLOT(OnSpinBoxEditingFinished())); return spinBox; } if (data.type() == QVariant::StringList) { QComboBox* comboBox = new QComboBox(parent); comboBox->addItems(data.toStringList()); connect(comboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboBoxCurrentIndexChanged(int))); return comboBox; } }
void DatabaseCommand_LoadDynamicPlaylistEntries::exec( DatabaseImpl* dbi ) { // qDebug() << "Loading dynamic playlist guid" << guid(); // load the entries first generateEntries( dbi ); // now load the controls etc TomahawkSqlQuery controlsQuery = dbi->newquery(); controlsQuery.prepare("SELECT playlist_revision.playlist, controls, plmode, pltype " "FROM dynamic_playlist_revision, playlist_revision " "WHERE dynamic_playlist_revision.guid = ? AND playlist_revision.guid = dynamic_playlist_revision.guid"); controlsQuery.addBindValue( revisionGuid() ); controlsQuery.exec(); QString type; GeneratorMode mode; QList< QVariantMap > controls; QString playlist_guid; // qDebug() << "Loading controls..." << revisionGuid(); // qDebug() << "SELECT playlist_revision.playlist, controls, plmode, pltype " // "FROM dynamic_playlist_revision, playlist_revision " // "WHERE dynamic_playlist_revision.guid = "<< revisionGuid() << " AND playlist_revision.guid = dynamic_playlist_revision.guid"; if( controlsQuery.first() ) { playlist_guid = controlsQuery.value( 0 ).toString(); QJson::Parser parser; bool ok; QVariant v = parser.parse( controlsQuery.value(1).toByteArray(), &ok ); Q_ASSERT( ok && v.type() == QVariant::List ); //TODO type = controlsQuery.value( 3 ).toString(); mode = static_cast<GeneratorMode>( controlsQuery.value( 2 ).toInt() ); QStringList controlIds = v.toStringList(); // qDebug() << "Got controls in dynamic playlist, loading:" << controlIds << controlsQuery.value(1); foreach( const QString& controlId, controlIds ) { TomahawkSqlQuery controlQuery = dbi->newquery(); controlQuery.prepare( "SELECT selectedType, match, input " "FROM dynamic_playlist_controls " "WHERE id = :id" ); controlQuery.bindValue( ":id", controlId ); controlQuery.exec(); if( controlQuery.next() ) { QVariantMap c; c[ "type" ] = type; c[ "id" ] = controlId; c[ "selectedType" ] = controlQuery.value( 0 ).toString(); c[ "match" ] = controlQuery.value( 1 ).toString(); c[ "input" ] = controlQuery.value( 2 ).toString(); controls << c; } }
void NetworkManagerFactory::optionChanged(const QString &option, const QVariant &value) { if (option == QLatin1String("Network/AcceptLanguage")) { m_acceptLanguage = ((value.toString().isEmpty()) ? QLatin1String(" ") : value.toString().replace(QLatin1String("system"), QLocale::system().bcp47Name())); } else if (option == QLatin1String("Network/DoNotTrackPolicy")) { const QString policyValue = value.toString(); if (policyValue == QLatin1String("allow")) { m_doNotTrackPolicy = AllowToTrackPolicy; } else if (policyValue == QLatin1String("doNotAllow")) { m_doNotTrackPolicy = DoNotAllowToTrackPolicy; } else { m_doNotTrackPolicy = SkipTrackPolicy; } } else if (option == QLatin1String("Network/EnableReferrer")) { m_canSendReferrer = value.toBool(); } else if (option == QLatin1String("Network/WorkOffline")) { m_isWorkingOffline = value.toBool(); } else if (option == QLatin1String("Proxy/UseSystemAuthentication")) { m_isUsingSystemProxyAuthentication = value.toBool(); } else if (option == QLatin1String("Security/Ciphers")) { if (value.toString() == QLatin1String("default")) { QSslSocket::setDefaultCiphers(m_defaultCiphers); return; } const QStringList selectedCiphers = value.toStringList(); const QList<QSslCipher> supportedCiphers = QSslSocket::supportedCiphers(); QList<QSslCipher> ciphers; for (int i = 0; i < supportedCiphers.count(); ++i) { if (selectedCiphers.contains(supportedCiphers.at(i).name())) { ciphers.append(supportedCiphers.at(i)); } } QSslSocket::setDefaultCiphers(ciphers); } }
sf::UserSet toUserSet (const QVariant & variant) { QStringList intermediate = variant.toStringList(); sf::UserSet result; for (int i = 0; i < intermediate.size(); i++){ result.insert(sfString(intermediate[i])); } return result; }