void DebuggerMainWindow::readSettings() { QSettings *settings = ICore::settings(); d->m_dockWidgetActiveStateCpp.clear(); d->m_dockWidgetActiveStateQmlCpp.clear(); settings->beginGroup(QLatin1String("DebugMode.CppMode")); foreach (const QString &key, settings->childKeys()) d->m_dockWidgetActiveStateCpp.insert(key, settings->value(key)); settings->endGroup(); settings->beginGroup(QLatin1String("DebugMode.CppQmlMode")); foreach (const QString &key, settings->childKeys()) d->m_dockWidgetActiveStateQmlCpp.insert(key, settings->value(key)); settings->endGroup(); // Reset initial settings when there are none yet. if (d->m_dockWidgetActiveStateQmlCpp.isEmpty()) { d->m_activeDebugLanguages = DebuggerLanguage(QmlLanguage|CppLanguage); d->setSimpleDockWidgetArrangement(); d->m_dockWidgetActiveStateCpp = saveSettings(); } if (d->m_dockWidgetActiveStateCpp.isEmpty()) { d->m_activeDebugLanguages = CppLanguage; d->setSimpleDockWidgetArrangement(); d->m_dockWidgetActiveStateCpp = saveSettings(); } writeSettings(); }
void update() const { QSettings settings; /// \todo Build from driver list in GDAL/OGR >= 2.0 static const std::vector<QByteArray> default_extensions = { "shp", "shx" }; enabled_vector_extensions.reserve(default_extensions.size() + 3); enabled_vector_extensions = default_extensions; settings.beginGroup(gdal_manager_group); if (settings.value(gdal_dxf_key).toBool()) enabled_vector_extensions.push_back("dxf"); if (settings.value(gdal_gpx_key).toBool()) enabled_vector_extensions.push_back("gpx"); if (settings.value(gdal_osm_key).toBool()) enabled_vector_extensions.push_back("osm"); settings.endGroup(); auto gdal_data = MapperResource::locate(MapperResource::GDAL_DATA); if (!gdal_data.isEmpty()) { // The user may overwrite this default in the settings. CPLSetConfigOption("GDAL_DATA", gdal_data.toLatin1().constData()); } settings.beginGroup(gdal_configuration_group); QStringList new_parameters = settings.childKeys(); if (new_parameters.isEmpty()) { // Default options for debugging and for some drivers settings.setValue(QString::fromLatin1("CPL_DEBUG"), QVariant{QLatin1String("OFF")}); settings.setValue(QString::fromLatin1("USE_PROJ_480_FEATURES"), QVariant{QLatin1String("YES")}); settings.setValue(QString::fromLatin1("OSM_USE_CUSTOM_INDEXING"), QVariant{QLatin1String("NO")}); new_parameters = settings.childKeys(); } new_parameters.sort(); for (auto parameter : new_parameters) { CPLSetConfigOption(parameter.toLatin1().constData(), settings.value(parameter).toByteArray().constData()); } for (auto parameter : static_cast<const QStringList&>(applied_parameters)) { if (!new_parameters.contains(parameter) && parameter != QLatin1String{ "GDAL_DATA" }) { CPLSetConfigOption(parameter.toLatin1().constData(), nullptr); } } applied_parameters.swap(new_parameters); dirty = false; }
void Properties::load(const QSettings &rSettings) { QStringList keys = rSettings.childKeys(); QString key; Q_FOREACH(key, keys) insert(key, rSettings.value(key).toString()); }
void AbstractAlgorithmInputHistory::readSettings(const QSettings &storage) { // unfortunately QSettings does not allow const when using beginGroup and // endGroup m_lastInput.clear(); const_cast<QSettings &>(storage).beginGroup(m_algorithmsGroup); // QStringList algorithms = settings.childGroups(); QListIterator<QString> algNames(storage.childGroups()); // Each property is a key of the algorithm group while (algNames.hasNext()) { QHash<QString, QString> algorithmProperties; QString group = algNames.next(); const_cast<QSettings &>(storage).beginGroup(group); QListIterator<QString> properties(storage.childKeys()); while (properties.hasNext()) { QString propName = properties.next(); QString value = storage.value(propName).toString(); if (!value.isEmpty()) algorithmProperties.insert(propName, value); } m_lastInput.insert(group, algorithmProperties); const_cast<QSettings &>(storage).endGroup(); } // The previous dir m_previousDirectory = storage.value(m_dirKey).toString(); const_cast<QSettings &>(storage).endGroup(); }
void editSimulators::applyChanges() { QSettings settings; // add path: settings.beginGroup("simulators/" + ui->comboBox->currentText()); settings.setValue("path", ui->scriptLineEdit->text()); settings.setValue("binary", ui->useBinary->isChecked()); settings.endGroup(); settings.beginGroup("simulators/" + ui->comboBox->currentText() + "/envVar"); // remove existing envVars QStringList currKeys = settings.childKeys(); for (int i = 0; i < currKeys.size(); ++i) { settings.remove(currKeys[i]); } for (int i = 0; i < this->keys.size(); ++i) { settings.setValue(keys[i], values[i]); } settings.endGroup(); edited = false; ui->buttonBox_2->button(QDialogButtonBox::Close)->setEnabled(true); ui->comboBox->setEnabled(true); ui->addSim->setEnabled(true); }
/** * Load any values that are available from persistent storage. Note: this * clears all currently values stored */ void AbstractAlgorithmInputHistory::load() { m_lastInput.clear(); QSettings settings; settings.beginGroup(m_algorithmsGroup); // QStringList algorithms = settings.childGroups(); QListIterator<QString> algNames(settings.childGroups()); // Each property is a key of the algorithm group while (algNames.hasNext()) { QHash<QString, QString> algorithmProperties; QString group = algNames.next(); settings.beginGroup(group); QListIterator<QString> properties(settings.childKeys()); while (properties.hasNext()) { QString propName = properties.next(); QString value = settings.value(propName).toString(); if (!value.isEmpty()) algorithmProperties.insert(propName, value); } m_lastInput.insert(group, algorithmProperties); settings.endGroup(); } // The previous dir m_previousDirectory = settings.value(m_dirKey).toString(); settings.endGroup(); }
void ColorThemeEngine::FillQML (QSettings& settings) { QMLColors_.clear (); for (const auto& group : settings.childGroups ()) { settings.beginGroup (group); auto& hash = QMLColors_ [group]; for (const auto& key : settings.childKeys ()) hash [key] = ParseColor (settings.value (key)); settings.endGroup (); } auto fixup = [this, &settings] (const QString& section, const QString& name, const QString& fallback) -> void { auto& sec = QMLColors_ [section]; if (sec.contains (name)) return; qWarning () << Q_FUNC_INFO << settings.fileName () << "lacks" << (section + "_" + name) << "; falling back to" << fallback; sec [name] = sec [fallback]; }; fixup ("ToolButton", "HoveredTopColor", "SelectedTopColor"); fixup ("ToolButton", "HoveredBottomColor", "SelectedBottomColor"); }
void ThemeSettings::readSettings() { QSettings settings; settings.beginGroup(EDITOR); ui->backgroundColorBox->setColor(settings.value(BACKGROUND_COLOR, QColor(255, 255, 255)).value<QColor>()); // Figure out the font and set it const QString &fontString = settings.value(FONT, SyntaxStandards::fontName()).toString(); ui->fontBox->setCurrentFont(QFont(fontString)); // Figure out the font size and set the widget const int fontSize = settings.value(FONT_SIZE, SyntaxStandards::fontSize()).toInt(); ui->fontSizeBox->setValue(fontSize); // Read the lexer settings m_lexerSettings.clear(); settings.beginGroup(LEXER); QStringList keys = settings.childKeys(); foreach(const QString &key, keys) m_lexerSettings.insert(key, settings.value(key).value<QColor>()); settings.endGroup(); settings.endGroup(); updateBoxes(); }
QScriptValue ScriptEngine::getRegKeys() { if (safeScripts) { warn("getRegKeys()", "Safe scripts is on."); return myengine.newArray(); } QSettings s; QStringList list = s.childKeys(); QStringList result_data; QStringListIterator it(list); while (it.hasNext()) { QString v = it.next(); result_data.append(v); } int len = result_data.length(); QScriptValue result_array = myengine.newArray(len); for (int i = 0; i < len; ++i) { result_array.setProperty(i, result_data.at(i)); } return result_array; }
void QuickOpenPlugin::loadSettings() { Core::ICore *core = ExtensionSystem::PluginManager::instance()->getObject<Core::ICore>(); QSettings settings; settings.beginGroup("QuickOpen"); m_refreshTimer.setInterval(settings.value("RefreshInterval", 60).toInt()*60000); foreach (IQuickOpenFilter *filter, m_filter) { if (settings.contains(filter->name())) { const QByteArray state = settings.value(filter->name()).toByteArray(); if (!state.isEmpty()) filter->restoreState(state); } } settings.beginGroup("CustomFilters"); QList<IQuickOpenFilter *> customFilters; foreach (const QString &key, settings.childKeys()) { IQuickOpenFilter *filter = new DirectoryFilter(core); filter->restoreState(settings.value(key).toByteArray()); m_filter.append(filter); customFilters.append(filter); } setCustomFilter(customFilters); settings.endGroup(); settings.endGroup(); }
ExtensionProxy::ExtensionProxy() : Proxy(), transaction(false), transflag(0) , nextRequest(1) { // loading variables QSettings set; set.beginGroup("proxy_settings"); QStringList vars = set.childKeys(); foreach(QString var, vars) variables[var] = set.value(var).toString(); set.endGroup(); set.beginGroup("extensions"); // loading extensions foreach (QObject *plugin, QPluginLoader::staticInstances()) { Extension *ex = qobject_cast<Extension *>(plugin); if (ex) { Console::Self().log(QString("Loading static extension '%1'").arg(ex->getName())); ex->setProxy(this); bool res = ex->prepare(); if(res) { Console::Self().log("... successfully"); extensions.push_back(ex); enabledFlags[ex->getName()] = set.value(ex->getName(), true).toBool(); } else { Console::Self().log("... error"); } } }
void editSimulators::selectSimulator(QString simName) { // clear old sim this->keys.clear(); this->values.clear(); QSettings settings; // load path settings.beginGroup("simulators/" + simName); path = settings.value("path").toString(); ui->useBinary->setChecked(settings.value("binary").toBool()); settings.endGroup(); settings.beginGroup("simulators/" + simName + "/envVar"); // load values QStringList keysTemp = settings.childKeys(); for (int i = 0; i < keysTemp.size(); ++i) { keys.push_back(keysTemp[i]); values.push_back(settings.value(keys[i]).toString()); } settings.endGroup(); ui->scriptLineEdit->setText(path); redrawEnvVars(); }
// read from stream void StelSkyLayerMgr::init() { QString path = StelFileMgr::findFile("nebulae/default/textures.json"); if (path.isEmpty()) qWarning() << "ERROR while loading nebula texture set default"; else insertSkyImage(path); QSettings* conf = StelApp::getInstance().getSettings(); conf->beginGroup("skylayers"); foreach (const QString& key, conf->childKeys()) { QString uri = conf->value(key, "").toString(); if (!uri.isEmpty()) { if (key=="clilayer") insertSkyImage(uri, "Command-line layer"); else insertSkyImage(uri); } } conf->endGroup(); setFlagShow(!conf->value("astro/flag_nebula_display_no_texture", false).toBool()); addAction("actionShow_DSS", N_("Display Options"), N_("Deep-sky objects background images"), "visible", "I"); }
void InternetModel::UpdateServices() { QSettings s; s.beginGroup(kSettingsGroup); QStringList keys = s.childKeys(); for (const QString& service_name : keys) { InternetService* internet_service = ServiceByName(service_name); if (internet_service == nullptr) { continue; } bool setting_val = s.value(service_name).toBool(); // Only update if values are different if (setting_val == true && shown_services_[internet_service].shown == false) { ShowService(internet_service); } else if (setting_val == false && shown_services_[internet_service].shown == true) { HideService(internet_service); } } s.endGroup(); }
/** Load settings @param options : map of user options to load into */ void QDataProcessorWidget::loadSettings( std::map<std::string, QVariant> &options) { QSettings settings; settings.beginGroup(DataProcessorSettingsGroup); QStringList keys = settings.childKeys(); for (auto it = keys.begin(); it != keys.end(); ++it) options[it->toStdString()] = settings.value(*it); settings.endGroup(); }
static QMap<QString, QVariant> readSettingsMap(const QSettings& s) { QMap<QString, QVariant> m; QStringList c = s.childKeys(); foreach ( QString k, c ) m[k] = s.value(k); return m; }
/*! \overload \brief Load format data from a QSettings object \param s QSettings object from which data will be fetched \param ignoreNewIds whether unknown format identifiers should be ignored The QSettings object is assumed to be initialized properly and to point to a correct location. \note Previous content is not discarded */ void QFormatScheme::load(QSettings& s, bool ignoreNewIds) { QString version = s.value("version").toString(); if ( version < QFORMAT_VERSION ) { qWarning("Format encoding version mismatch : [found]%s != [expected]%s", qPrintable(version), QFORMAT_VERSION); return; } s.beginGroup("data"); QStringList l = s.childGroups(); foreach ( QString id, l ) { if ( ignoreNewIds && !m_formatKeys.contains(id) ) continue; s.beginGroup(id); QFormat fmt; QStringList fields = s.childKeys(); foreach ( QString field, fields ) { QString value = s.value(field).toString(); if ( field == "bold" ) fmt.weight = bool_cast(value) ? QFont::Bold : QFont::Normal; else if ( field == "italic" ) fmt.italic = bool_cast(value); else if ( field == "overline" ) fmt.overline = bool_cast(value); else if ( field == "underline" ) fmt.underline = bool_cast(value); else if ( field == "strikeout" ) fmt.strikeout = bool_cast(value); else if ( field == "waveUnderline" ) fmt.waveUnderline = bool_cast(value); else if ( field == "color" || field == "foreground" ) fmt.foreground = QColor(value); else if ( field == "background" ) fmt.background = QColor(value); else if ( field == "linescolor" ) fmt.linescolor = QColor(value); } setFormat(id, fmt); s.endGroup(); }
QActionGroup* LibraryFilterWidget::CreateGroupByActions(QObject* parent) { QActionGroup* ret = new QActionGroup(parent); ret->addAction(CreateGroupByAction( tr("Group by Artist"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Artist))); ret->addAction( CreateGroupByAction(tr("Group by Artist/Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Artist, LibraryModel::GroupBy_Album))); ret->addAction( CreateGroupByAction(tr("Group by Album artist/Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_AlbumArtist, LibraryModel::GroupBy_Album))); ret->addAction(CreateGroupByAction( tr("Group by Artist/Year - Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Artist, LibraryModel::GroupBy_YearAlbum))); ret->addAction( CreateGroupByAction(tr("Group by Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Album))); ret->addAction( CreateGroupByAction(tr("Group by Genre/Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Genre, LibraryModel::GroupBy_Album))); ret->addAction( CreateGroupByAction(tr("Group by Genre/Artist/Album"), parent, LibraryModel::Grouping(LibraryModel::GroupBy_Genre, LibraryModel::GroupBy_Artist, LibraryModel::GroupBy_Album))); QAction* sep1 = new QAction(parent); sep1->setSeparator(true); ret->addAction(sep1); // read saved groupings QSettings s; s.beginGroup(LibraryModel::kSavedGroupingsSettingsGroup); QStringList saved = s.childKeys(); for (int i = 0; i < saved.size(); ++i) { QByteArray bytes = s.value(saved.at(i)).toByteArray(); QDataStream ds(&bytes, QIODevice::ReadOnly); LibraryModel::Grouping g; ds >> g; ret->addAction(CreateGroupByAction(saved.at(i), parent, g)); } QAction* sep2 = new QAction(parent); sep2->setSeparator(true); ret->addAction(sep2); ret->addAction(CreateGroupByAction(tr("Advanced grouping..."), parent, LibraryModel::Grouping())); return ret; }
void Service::loadSettings() { qfDebug() << "loading settings for" << settingsGroup(); m_settings.clear(); QSettings ss; ss.beginGroup(settingsGroup()); for(const QString &key : ss.childKeys()) { m_settings[key] = ss.value(key); qfDebug() << "\t" << key << "->" << m_settings.value(key); } }
void DefaultBackendManager::LoadSettings () { QSettings settings (QCoreApplication::organizationName (), QCoreApplication::applicationName () + "_Monocle"); settings.beginGroup ("BackendChoices"); for (const auto& key : settings.childKeys ()) { const auto& utf8key = key.toUtf8 (); AddToModel (utf8key, settings.value (utf8key).toByteArray ()); } settings.endGroup (); }
ActionManager::ActionManager(QObject* parent) : QObject(parent) { m_instance = this; // Load shortcuts QSettings settings; settings.beginGroup("Shortcuts"); QStringList keys = settings.childKeys(); foreach (const QString& name, keys) { m_actions[name].shortcut = settings.value(name).value<QKeySequence>(); }
static void copyKeys(QSettings &old, SettingsObject *object) { foreach (const QString &key, old.childKeys()) { QVariant value = old.value(key); if ((QMetaType::Type)value.type() == QMetaType::QDateTime) object->write(key, value.toDateTime()); else if ((QMetaType::Type)value.type() == QMetaType::QByteArray) object->write(key, Base64Encode(value.toByteArray())); else object->write(key, value.toString()); } }
/*! \overload \brief Load format data from a QSettings object \param s QSettings object from which data will be fetched \param ignoreNewIds whether unknown format identifiers should be ignored The QSettings object is assumed to be initialized properly and to point to a correct location. \note Previous content is not discarded */ void QFormatScheme::load(QSettings& s, bool ignoreNewIds) { if (s.childKeys().isEmpty() && s.childGroups().isEmpty()) return; QString version = s.value("version").toString(); if ( version < QFORMAT_VERSION ) { qWarning("Format encoding version mismatch : [found]%s != [expected]%s", qPrintable(version), QFORMAT_VERSION); return; } s.beginGroup("data"); QStringList l = s.childGroups(); foreach ( QString id, l ) { if ( ignoreNewIds && !m_formatKeys.contains(id) ) continue; s.beginGroup(id); QFormat fmt; QStringList fields = s.childKeys(); foreach ( QString field, fields ) { QString value = s.value(field).toString(); setFormatOption(fmt, field, value); } fmt.setPriority(fmt.priority); //update priority if other values changed setFormat(id, fmt); s.endGroup(); }
void QgsConfigureShortcutsDialog::saveShortcuts() { QString fileName = QFileDialog::getSaveFileName( this, tr( "Save shortcuts" ), QDir::homePath(), tr( "XML file" ) + " (*.xml);;" + tr( "All files" ) + " (*)" ); if ( fileName.isEmpty() ) return; // ensure the user never omitted the extension from the file name if ( !fileName.toLower().endsWith( ".xml" ) ) { fileName += ".xml"; } QFile file( fileName ); if ( !file.open( QIODevice::WriteOnly | QIODevice::Text ) ) { QMessageBox::warning( this, tr( "Saving shortcuts" ), tr( "Cannot write file %1:\n%2." ) .arg( fileName, file.errorString() ) ); return; } QSettings settings; QDomDocument doc( "shortcuts" ); QDomElement root = doc.createElement( "qgsshortcuts" ); root.setAttribute( "version", "1.0" ); root.setAttribute( "locale", settings.value( "locale/userLocale", "en_US" ).toString() ); doc.appendChild( root ); settings.beginGroup( "/shortcuts/" ); QStringList keys = settings.childKeys(); QString actionText; QString actionShortcut; for ( int i = 0; i < keys.count(); ++i ) { actionText = keys[ i ]; actionShortcut = settings.value( actionText, "" ).toString(); QDomElement el = doc.createElement( "act" ); el.setAttribute( "name", actionText ); el.setAttribute( "shortcut", actionShortcut ); root.appendChild( el ); } QTextStream out( &file ); doc.save( out, 4 ); }
bool DebuggerConfigurationPage::configurationExists(QString configurationKeyToCheck) { QSettings *pSettings = OpenModelica::getApplicationSettings(); pSettings->beginGroup("debuggerConfigurationList"); QStringList configurationKeys = pSettings->childKeys(); pSettings->endGroup(); foreach (QString configurationKey, configurationKeys) { if (configurationKey.compare(configurationKeyToCheck) == 0) { return true; } } return false; }
void PicasaService::ReadAccounts () { QSettings settings (QCoreApplication::organizationName (), QCoreApplication::applicationName () + "_Blasq_Vangog"); settings.beginGroup ("Accounts"); for (const auto& key : settings.childKeys ()) { const auto& serialized = settings.value (key).toByteArray (); if (auto acc = PicasaAccount::Deserialize (serialized, this, Proxy_)) AddAccount (acc); } settings.endGroup (); }
DynamoModelLoader::DynamoModelLoader(void) { DEBUG_MSG("DynamoModelLoader::DynamoModelLoader : starting\n"); action = MainWindow::getInstance()->createModuleMenuItem("Load DYNAMO Model",this,SLOT(load_dialog(void))); model_makefile_path = QString(MODEL_MAKEFILE_PATH); DEBUG_MSG("model_makefile_path = %s\n", model_makefile_path.toLatin1().constData()); DEBUG_MSG("DynamoModelLoader::DynamoModelLoader : finished\n"); MainWindow::getInstance()->insertModuleMenuSeparator(); // add recently used modules to the menu QSettings userprefs; userprefs.setPath(QSettings::NativeFormat, QSettings::SystemScope, "/usr/local/share/rtxi/"); userprefs.beginGroup("/recentFileList"); QStringList entries = userprefs.childKeys(); userprefs.endGroup(); int numRecentFiles = entries.size(); QString listmodule; QString text; for (int i = 0; i < std::min(numRecentFiles-2,10); ++i) { listmodule = userprefs.value("/recentFileList/" + entries[i]).toString(); text = tr("&%1 %2").arg(i).arg(listmodule); MainWindow::getInstance()->createModuleMenuItem(text); } // add recently used settings files to the menu userprefs.beginGroup("/recentSettingsList"); entries = userprefs.childKeys(); userprefs.endGroup(); numRecentFiles = entries.size()-1; for (int i = 0; i < std::min(numRecentFiles,10); ++i) { listmodule = userprefs.value("/recentSettingsList/" + entries[i]).toString(); text = tr("&%1 %2").arg(i).arg(listmodule); MainWindow::getInstance()->createFileMenuItem(text); } }
/*! Reads the list of debugger configurations setting from the settings file. */ void DebuggerConfigurationsDialog::readConfigurations() { // read the settings and add configurations QSettings *pSettings = OpenModelica::getApplicationSettings(); pSettings->beginGroup("debuggerConfigurationList"); QStringList configurationKeys = pSettings->childKeys(); foreach (QString configurationKey, configurationKeys) { QListWidgetItem *pListWidgetItem = new QListWidgetItem(mpConfigurationsListWidget); pListWidgetItem->setIcon(QIcon(":/Resources/icons/debugger.svg")); pListWidgetItem->setText(configurationKey); // create DebuggerConfigurationPage DebuggerConfiguration debuggerConfiguration = qvariant_cast<DebuggerConfiguration>(pSettings->value(configurationKey)); mpConfigurationPagesWidget->addWidget(new DebuggerConfigurationPage(debuggerConfiguration, pListWidgetItem, this)); }
void App::unsetPreference(const std::string &key) { QSettings settings; std::string keyrep(getKeyRepr(key)); QString qkeyrep(keyrep.c_str()); settings.beginGroup(qkeyrep); if ((settings.childGroups().length() != 0) || (settings.childKeys().length() != 0)) { settings.setValue("", ""); } else { settings.remove(""); } settings.endGroup(); settings.sync(); }
template<typename T> QHash<QString, T> GetGroupKeyValues( QSettings &setting, const QString &group ) { QHash<QString, T> hash; setting.beginGroup( group ); QStringList keys = setting.childKeys(); for ( auto item : keys ) { QVariant val = setting.value( item ); if ( !val.isNull() ) { hash.insert( item, val.value<T>() ); } } setting.endGroup(); return hash; }