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