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