void CustomBuildSystemConfigWidget::loadFrom( KConfig* cfg )
{
ui->currentConfig->clear();
QStringList groupNameList;
KConfigGroup grp = cfg->group( ConfigConstants::customBuildSystemGroup );
foreach( const QString& grpName, grp.groupList() ) {
KConfigGroup subgrp = grp.group( grpName );
CustomBuildSystemConfig config;
config.title = subgrp.readEntry( ConfigConstants::configTitleKey, QString() );
config.buildDir = subgrp.readEntry( ConfigConstants::buildDirKey, QUrl() );
foreach( const QString& subgrpName, subgrp.groupList() ) {
if( subgrpName.startsWith( ConfigConstants::toolGroupPrefix ) ) {
KConfigGroup toolgrp = subgrp.group( subgrpName );
CustomBuildSystemTool tool;
tool.arguments = toolgrp.readEntry( ConfigConstants::toolArguments, "" );
tool.executable = toolgrp.readEntry( ConfigConstants::toolExecutable, QUrl() );
tool.envGrp = toolgrp.readEntry( ConfigConstants::toolEnvironment, QString() );
tool.enabled = toolgrp.readEntry( ConfigConstants::toolEnabled, false );
tool.type = CustomBuildSystemTool::ActionType( toolgrp.readEntry( ConfigConstants::toolType, 0 ) );
config.tools[tool.type] = tool;
}
}
configs << config;
ui->currentConfig->addItem( config.title );
groupNameList << grpName;
}
int idx = groupNameList.indexOf( grp.readEntry( ConfigConstants::currentConfigKey, "" ) );
if( !groupNameList.isEmpty() && idx < 0 )
idx = 0;
ui->currentConfig->setCurrentIndex( idx );
changeCurrentConfig( idx );
}
void saveToConfiguration(KConfigGroup config)
{
kDebug() << m_paths.count();
KConfigGroup cfg = config.group(PathMappings::pathMappingsEntry);
cfg.writeEntry("Count", m_paths.count());
int i=0;
foreach (const Path &p, m_paths) {
i++;
KConfigGroup pCfg = cfg.group(QString::number(i));
pCfg.writeEntry(PathMappings::pathMappingRemoteEntry, p.remote);
pCfg.writeEntry(PathMappings::pathMappingLocalEntry, p.local);
}
void ConfirmAddressConfigureTabWidget::saveSettings(KConfigGroup &grp)
{
KConfigGroup identityGroup = grp.group(QStringLiteral("Confirm Address %1").arg(mIdentity));
identityGroup.writeEntry("Domains", mDomainNameListEditor->stringList());
identityGroup.writeEntry("Emails", mWhiteListEditor->stringList());
identityGroup.writeEntry("RejectDomain", mRejectedDomain->isChecked());
}
void CustomBuildSystemConfigWidget::loadFrom( KConfig* cfg )
{
ui->currentConfig->clear();
QStringList groupNameList;
KConfigGroup grp = cfg->group( ConfigConstants::customBuildSystemGroup );
foreach( const QString& grpName, grp.groupList() ) {
KConfigGroup subgrp = grp.group( grpName );
CustomBuildSystemConfig config;
config.title = subgrp.readEntry( ConfigConstants::configTitleKey, "" );
config.buildDir = subgrp.readEntry( ConfigConstants::buildDirKey, "" );
foreach( const QString& subgrpName, subgrp.groupList() ) {
if( subgrpName.startsWith( ConfigConstants::toolGroupPrefix ) ) {
KConfigGroup toolgrp = subgrp.group( subgrpName );
CustomBuildSystemTool tool;
tool.arguments = toolgrp.readEntry( ConfigConstants::toolArguments, "" );
tool.executable = toolgrp.readEntry( ConfigConstants::toolExecutable, KUrl() );
tool.envGrp = toolgrp.readEntry( ConfigConstants::toolEnvironment, "default" );
tool.enabled = toolgrp.readEntry( ConfigConstants::toolEnabled, false );
tool.type = CustomBuildSystemTool::ActionType( toolgrp.readEntry( ConfigConstants::toolType, 0 ) );
config.tools[tool.type] = tool;
} else if( subgrpName.startsWith( ConfigConstants::projectPathPrefix ) ) {
KConfigGroup pathgrp = subgrp.group( subgrpName );
CustomBuildSystemProjectPathConfig path;
path.path = pathgrp.readEntry( ConfigConstants::projectPathKey, "" );
{
QByteArray tmp = pathgrp.readEntry( ConfigConstants::definesKey, QByteArray() );
QDataStream s(tmp);
s.setVersion( QDataStream::Qt_4_5 );
s >> path.defines;
}
{
QByteArray tmp = pathgrp.readEntry( ConfigConstants::includesKey, QByteArray() );
QDataStream s(tmp);
s.setVersion( QDataStream::Qt_4_5 );
s >> path.includes;
}
config.projectPaths << path;
}
}
configs << config;
ui->currentConfig->addItem( config.title );
groupNameList << grpName;
}
void CustomBuildSystemConfigWidget::saveConfig( KConfigGroup& grp, CustomBuildSystemConfig& c, int index )
{
// Generate group name, access and clear it
KConfigGroup subgrp = grp.group( ConfigConstants::buildConfigPrefix + QString::number(index) );
subgrp.deleteGroup();
// Write current configuration key, if our group is current
if( ui->currentConfig->currentIndex() == index )
grp.writeEntry( ConfigConstants::currentConfigKey, subgrp.name() );
subgrp.writeEntry( ConfigConstants::configTitleKey, c.title );
subgrp.writeEntry<QUrl>( ConfigConstants::buildDirKey, c.buildDir );
foreach( const CustomBuildSystemTool& tool, c.tools ) {
KConfigGroup toolgrp = subgrp.group( generateToolGroupName( tool.type ) );
toolgrp.writeEntry( ConfigConstants::toolType, int(tool.type) );
toolgrp.writeEntry( ConfigConstants::toolEnvironment , tool.envGrp );
toolgrp.writeEntry( ConfigConstants::toolEnabled, tool.enabled );
toolgrp.writeEntry<QUrl>( ConfigConstants::toolExecutable, tool.executable );
toolgrp.writeEntry( ConfigConstants::toolArguments, tool.arguments );
}
}
void ConfirmAddressConfigureTabWidget::loadSettings(const KConfigGroup &grp)
{
KConfigGroup identityGroup = grp.group(QStringLiteral("Confirm Address %1").arg(mIdentity));
mDomainNameListEditor->setStringList(identityGroup.readEntry("Domains", QStringList()));
mWhiteListEditor->setStringList(identityGroup.readEntry("Emails", QStringList()));
const bool rejectedDomain = identityGroup.readEntry("RejectDomain", false);
if (rejectedDomain) {
mRejectedDomain->setChecked(true);
} else {
mAcceptedDomain->setChecked(true);
}
}
void process(Mode mode, KConfigGroup &grp, QString key, QString value)
{
switch (mode) {
case Read:
if (IS_A_TTY(1))
std::cout << CHAR(key) << ": " << CHAR(grp.readEntry(key, "does not exist")) << " (" << CHAR(path(grp)) << ")" << std::endl;
else
std::cout << CHAR(grp.readEntry(key, ""));
break;
case Write: {
if (grp.isImmutable()) {
std::cout << "The component/group " << CHAR(path(grp)) << " cannot be modified" << std::endl;
exit(1);
}
bool added = !grp.hasKey(key);
QString oldv;
if (!added) oldv = grp.readEntry(key);
grp.writeEntry(key, QString(value));
grp.sync();
if (added)
std::cout << "New " << CHAR(key) << ": " << CHAR(grp.readEntry(key)) << std::endl;
else
std::cout << CHAR(key) << ": " << CHAR(oldv) << " -> " << CHAR(grp.readEntry(key)) << std::endl;
break;
}
case Delete: {
if (grp.isImmutable()) {
std::cout << "The component/group " << CHAR(path(grp)) << " cannot be modified" << std::endl;
exit(1);
}
if (grp.hasKey(key)) {
std::cout << "Removed " << CHAR(key) << ": " << CHAR(grp.readEntry(key)) << std::endl;
grp.deleteEntry(key);
grp.sync();
} else if (grp.hasGroup(key)) {
std::cout << "There's a group, but no key: " << CHAR(key) << "\nPlease explicitly use deletegroup" << std::endl;
exit(1);
} else {
std::cout << "There's no key " << CHAR(key) << " in " << CHAR(path(grp)) << std::endl;
exit(1);
}
break;
}
case DeleteGroup: {
if (grp.hasGroup(key)) {
grp = grp.group(key);
if (grp.isImmutable()) {
std::cout << "The component/group " << CHAR(path(grp)) << " cannot be modified" << std::endl;
exit(1);
}
QMap<QString, QString> map = grp.entryMap();
std::cout << "Removed " << CHAR(key) << gs_separator << std::endl;
for (QMap<QString, QString>::const_iterator it = map.constBegin(), end = map.constEnd(); it != end; ++it) {
std::cout << CHAR(it.key()) << ": " << CHAR(it.value()) << std::endl;
}
grp.deleteGroup();
grp.sync();
} else {
std::cout << "There's no group " << CHAR(key) << " in " << CHAR(path(grp)) << std::endl;
exit(1);
}
break;
}
case List:
case ListKeys: {
if (!grp.exists()) { // could be parent group
if (mode == ListKeys)
exit(1);
QStringList groups = grp.parent().exists() ? grp.parent().groupList() : grp.config()->groupList();
if (groups.isEmpty()) {
std::cout << "The component/group " << CHAR(path(grp)) << " does not exist" << std::endl;
exit(1);
}
std::cout << "Groups in " << CHAR(path(grp)) << gs_separator << std::endl;
foreach (const QString &s, groups)
if (key.isEmpty() || s.contains(key, Qt::CaseInsensitive))
std::cout << CHAR(s) << std::endl;
exit(0);
}
QMap<QString, QString> map = grp.entryMap();
if (map.isEmpty()) {
std::cout << "The group " << CHAR(path(grp)) << " is empty" << std::endl;
break;
}
if (mode == List) {
bool matchFound = false;
for (QMap<QString, QString>::const_iterator it = map.constBegin(), end = map.constEnd(); it != end; ++it) {
if (key.isEmpty() || it.key().contains(key, Qt::CaseInsensitive)) {
if (!matchFound)
std::cout << std::endl << CHAR(path(grp)) << gs_separator << std::endl;
matchFound = true;
std::cout << CHAR(it.key()) << ": " << CHAR(it.value()) << std::endl;
}
}
if (!matchFound)
std::cout << "No present key matches \"" << CHAR(key) << "\" in " << CHAR(path(grp));
std::cout << std::endl;
} else {
for (QMap<QString, QString>::const_iterator it = map.constBegin(), end = map.constEnd(); it != end; ++it) {
if (key.isEmpty() || it.key().contains(key, Qt::CaseInsensitive)) {
std::cout << CHAR(it.key()) << std::endl;
}
}
}
break;
}
case ListGroups: {
QStringList groups = grp.parent().exists() ? grp.parent().groupList() : grp.config()->groupList();
foreach (const QString &s, groups)
if (key.isEmpty() || s.contains(key, Qt::CaseInsensitive))
std::cout << CHAR(s) << std::endl;
exit(0);
}
case Replace: {
if (grp.isImmutable()) {
std::cout << "The component/group " << CHAR(path(grp)) << " cannot be modified" << std::endl;
exit(1);
}
QStringList match = key.split("=");
if (match.count() != 2) {
std::cout << "The match sequence must be of the form <key regexp>=<value regexp>" << std::endl;
exit(1);
}
QRegExp keyMatch(match.at(0), Qt::CaseInsensitive);
QRegExp valueMatch(match.at(1), Qt::CaseInsensitive);
QStringList replace = value.split("=");
if (replace.count() != 2) {
std::cout << "The replace sequence must be of the form <key string>=<value string>" << std::endl;
exit(1);
}
QMap<QString, QString> map = grp.entryMap();
QStringList keys;
for (QMap<QString, QString>::const_iterator it = map.constBegin(), end = map.constEnd(); it != end; ++it) {
if (keyMatch.exactMatch(it.key()) && valueMatch.exactMatch(it.value())) {
keys << it.key();
}
}
foreach (const QString &key, keys) {
QString newKey = key;
newKey.replace(keyMatch, replace.at(0));
QString newValue = grp.readEntry(key);
const QString oldValue = newValue;
newValue.replace(valueMatch, replace.at(1));
if (key != newKey)
grp.deleteEntry(key);
grp.writeEntry(newKey, newValue);
std::cout << CHAR(key) << ": " << CHAR(oldValue) << " -> " << CHAR(newKey) << ": " << CHAR(grp.readEntry(newKey)) << std::endl;
grp.sync();
}
break;
}
Invalid:
default:
break;
}
Settings SettingsIO::readSettings( KConfigGroup cg, KConfigGroup cgGlobal,
Plasma::DataEngine *publictransportEngine )
{
Settings settings;
if ( !cg.hasKey("departureTimeFlags") && (cg.hasKey("showRemainingMinutes") ||
cg.hasKey("showDepartureTime") || cg.hasKey("displayTimeBold")) )
{
// DEPRECATED This reads settings stored in old format (version < 0.11)
kDebug() << "Reading settings in old format, will be converted to new format";
settings.setShowRemainingTime( cg.readEntry("showRemainingMinutes", true) );
cg.deleteEntry( "showRemainingMinutes" );
settings.setDisplayDepartureTimeBold( cg.readEntry("displayTimeBold", true) );
cg.deleteEntry( "displayTimeBold" );
cg.writeEntry( "departureTimeFlags", static_cast<int>(settings.departureTimeFlags()) );
cg.sync();
} else {
settings.setDepartureTimeFlags( static_cast< Settings::DepartureTimeFlags >(
cg.readEntry("departureTimeFlags", static_cast<int>(Settings::DefaultDepartureTimeFlags))) );
}
const Settings::AdditionalDataRequestType requestType = static_cast< Settings::AdditionalDataRequestType >(
cg.readEntry("additionalDataRequestType", static_cast<int>(Settings::DefaultAdditionalDataRequestType)));
settings.setAdditionalDataRequestType( requestType );
// Read stop settings TODO: Store in config groups like filters
StopSettingsList stopSettingsList;
int stopSettingCount = cgGlobal.readEntry( "stopSettings", 1 );
QString test = "location";
int i = 1;
while ( cgGlobal.hasKey(test) ) {
StopSettings stopSettings;
QString suffix = i == 1 ? QString() : '_' + QString::number( i );
stopSettings.set( LocationSetting, cgGlobal.readEntry("location" + suffix, "showAll") );
stopSettings.set( ServiceProviderSetting,
cgGlobal.readEntry("serviceProvider" + suffix, "de_db") );
stopSettings.set( CitySetting, cgGlobal.readEntry("city" + suffix, QString()) );
stopSettings.setStops( cgGlobal.readEntry("stop" + suffix, QStringList()),
cgGlobal.readEntry("stopID" + suffix, QStringList()) );
stopSettings.set( TimeOffsetOfFirstDepartureSetting,
cgGlobal.readEntry("timeOffsetOfFirstDeparture" + suffix, 0) );
stopSettings.set( TimeOfFirstDepartureSetting,
QTime::fromString(cgGlobal.readEntry("timeOfFirstDepartureCustom" + suffix,
"12:00"), "hh:mm") );
stopSettings.set( FirstDepartureConfigModeSetting,
cgGlobal.readEntry("firstDepartureConfigMode" + suffix,
static_cast<int>(RelativeToCurrentTime)) );
stopSettings.set( AlarmTimeSetting, cgGlobal.readEntry("alarmTime" + suffix, 5) );
// Read favorite/recent journey search items for the current stop settings
QByteArray journeySearchesData =
cgGlobal.readEntry( "journeySearches" + suffix, QByteArray() );
stopSettings.set( Settings::JourneySearchSetting, QVariant::fromValue(
SettingsIO::decodeJourneySearchItems(&journeySearchesData)) );
stopSettingsList << stopSettings;
++i;
test = "location_" + QString::number( i );
if ( i > stopSettingCount ) {
break;
}
}
settings.setCurrentStop( cg.readEntry("currentStopIndex", 0) );
// Add initial stop settings when no settings are available
if ( stopSettingsList.isEmpty() ) {
kDebug() << "Stop settings list in settings is empty";
if ( publictransportEngine ) {
QString countryCode = KGlobal::locale()->country();
Plasma::DataEngine::Data locationData = publictransportEngine->query( "Locations" );
QString defaultServiceProviderId =
locationData[countryCode].toHash()["defaultProvider"].toString();
StopSettings stopSettings;
if ( defaultServiceProviderId.isEmpty() ) {
stopSettings.set( LocationSetting, "showAll" );
} else {
stopSettings.set( LocationSetting, countryCode );
stopSettings.set( ServiceProviderSetting, defaultServiceProviderId );
}
stopSettings.setStop( QString() );
// TODO: Get initial stop names using StopFinder
stopSettingsList << stopSettings;
} else {
stopSettingsList << StopSettings();
}
}
settings.setStops( stopSettingsList );
if ( settings.currentStopIndex() < 0 ) {
settings.setCurrentStop( 0 ); // For compatibility with versions < 0.7
} else if ( settings.currentStopIndex() >= settings.stops().count() ) {
kDebug() << "Current stop index in settings invalid";
settings.setCurrentStop( settings.stops().count() - 1 );
}
settings.setMaximalNumberOfDepartures( cg.readEntry("maximalNumberOfDepartures", 50) );
settings.setLinesPerRow( cg.readEntry("linesPerRow", 2) );
settings.setSizeFactor( Settings::sizeFactorFromSize(cg.readEntry("size", 2)) );
settings.setDepartureArrivalListType( static_cast<DepartureArrivalListType>(
cg.readEntry("departureArrivalListType", static_cast<int>(DepartureList))) );
settings.setDrawShadows( cg.readEntry("drawShadows", true) );
settings.setHideTargetColumn( cg.readEntry("hideColumnTarget", false) );
settings.setColorize( cg.readEntry("colorize", true) );
QString fontFamily = cg.readEntry( "fontFamily", QString() );
settings.setUseThemeFont( fontFamily.isEmpty() );
if ( !settings.useThemeFont() ) {
settings.setFont( QFont(fontFamily) );
} else {
settings.setFont( Plasma::Theme::defaultTheme()->font(Plasma::Theme::DefaultFont) );
}
// ***************** DEPRECATED BEGIN *****************************************************
// *** Used for migration of filter settings from versions prior to version 0.10 RC1 ******
FilterSettingsList filtersList;
if ( cgGlobal.hasKey("filterConfigurationList") ) {
kDebug() << "DEPRECATED Filter settings will be restructured for new version";
QStringList filterConfigurationList =
cgGlobal.readEntry( "filterConfigurationList", QStringList() );
for ( int i = filterConfigurationList.count() - 1; i >= 0; --i ) {
const QString &filterConfiguration = filterConfigurationList[ i ];
if ( filterConfiguration.isEmpty() ) {
filterConfigurationList.removeAt( i );
}
}
kDebug() << "Config group list" << cgGlobal.groupList();
kDebug() << "Filter config list:" << filterConfigurationList;
// Read old filter settings
foreach( const QString &filterConfiguration, filterConfigurationList ) {
FilterSettings filters =
readFilterConfig( cgGlobal.group("filterConfig_" + filterConfiguration) );
filters.name = filterConfiguration;
filtersList << filters;
}
void Configuration::save()
{
KConfigGroup configuration = m_applet->config();
QStringList arrangement;
closeActionEditors();
for (int i = 0; i < m_arrangementUi.currentEntriesListWidget->count(); ++i)
{
QListWidgetItem *item = m_arrangementUi.currentEntriesListWidget->item(i);
if (!item->toolTip().isEmpty())
{
if (arrangement.contains(item->toolTip()))
{
continue;
}
arrangement.append(item->toolTip());
const KUrl url(item->toolTip());
Launcher *launcher = new Launcher(url, m_applet);
if (m_rules.contains(item->toolTip()) && !launcher->isMenu())
{
launcher->setRules(m_rules[item->toolTip()].first);
launcher->setExcluded(m_rules[item->toolTip()].second);
}
m_applet->changeLauncher(launcher, url, true);
launcher->deleteLater();
}
else if (item->text() == i18n("--- tasks area ---"))
{
arrangement.append("tasks");
}
else if (item->text() == i18n("--- jobs area ---"))
{
arrangement.append("jobs");
}
else
{
arrangement.append("separator");
}
}
configuration.deleteGroup("Actions");
KConfigGroup actionsConfiguration = configuration.group("Actions");
for (int i = 0; i < m_actionsUi.actionsTableWidget->rowCount(); ++i)
{
QTableWidgetItem *actionItem = m_actionsUi.actionsTableWidget->item(i, 0);
QTableWidgetItem *triggerItem = m_actionsUi.actionsTableWidget->item(i, 1);
if (triggerItem->data(Qt::EditRole).toString().isEmpty() || actionItem->data(Qt::EditRole).toInt() == 0)
{
continue;
}
actionsConfiguration.writeEntry(triggerItem->data(Qt::EditRole).toString(), actionItem->data(Qt::EditRole).toInt());
}
configuration.writeEntry("moveAnimation", m_appearanceUi.moveAnimation->itemData(m_appearanceUi.moveAnimation->currentIndex()).toInt());
configuration.writeEntry("parabolicMoveAnimation", m_appearanceUi.parabolicMoveAnimation->isChecked());
configuration.writeEntry("demandsAttentionAnimation", m_appearanceUi.demandsAttentionAnimation->itemData(m_appearanceUi.demandsAttentionAnimation->currentIndex()).toInt());
configuration.writeEntry("startupAnimation", m_appearanceUi.startupAnimation->itemData(m_appearanceUi.startupAnimation->currentIndex()).toInt());
configuration.writeEntry("activeIconIndication", m_appearanceUi.activeIconIndication->itemData(m_appearanceUi.activeIconIndication->currentIndex()).toInt());
configuration.writeEntry("titleLabelMode", m_appearanceUi.titleLabelMode->itemData(m_appearanceUi.titleLabelMode->currentIndex()).toInt());
configuration.writeEntry("customBackgroundImage", (m_appearanceUi.customBackgroundImage->url().isValid()?m_appearanceUi.customBackgroundImage->url().path():QString()));
configuration.writeEntry("showOnlyCurrentDesktop", m_generalUi.showOnlyCurrentDesktop->isChecked());
configuration.writeEntry("showOnlyCurrentActivity", m_generalUi.showOnlyCurrentActivity->isChecked());
configuration.writeEntry("showOnlyCurrentScreen", m_generalUi.showOnlyCurrentScreen->isChecked());
configuration.writeEntry("showOnlyMinimized", m_generalUi.showOnlyMinimized->isChecked());
configuration.writeEntry("showOnlyTasksWithLaunchers", m_generalUi.showOnlyTasksWithLaunchers->isChecked());
configuration.writeEntry("connectJobsWithTasks", m_generalUi.connectJobsWithTasks->isChecked());
configuration.writeEntry("groupJobs", m_generalUi.groupJobs->isChecked());
configuration.writeEntry("groupingStrategy", m_generalUi.groupingStrategy->itemData(m_generalUi.groupingStrategy->currentIndex()).toInt());
configuration.writeEntry("sortingStrategy", m_generalUi.sortingStrategy->itemData(m_generalUi.sortingStrategy->currentIndex()).toInt());
configuration.writeEntry("jobCloseMode", m_generalUi.jobCloseMode->itemData(m_generalUi.jobCloseMode->currentIndex()).toInt());
configuration.writeEntry("arrangement", arrangement);
static_cast<KConfigDialog*>(parent())->enableButtonApply(false);
emit accepted();
}