int main(int argc, char **argv)
{
KLocalizedString::setApplicationDomain("krdc");
const QString appName = QStringLiteral("krdc");
QApplication app(argc, argv);
QTime startupTimer;
startupTimer.start();
app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
Kdelibs4ConfigMigrator migrate(appName);
migrate.setConfigFiles(QStringList() << QStringLiteral("krdcrc"));
if (migrate.migrate()) {
Kdelibs4Migration dataMigrator;
const QString sourceBasePath = dataMigrator.saveLocation("data", QStringLiteral("krdc"));
const QString targetBasePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/krdc/");
QString targetFilePath;
QDir sourceDir(sourceBasePath);
QDir targetDir(targetBasePath);
if (sourceDir.exists()) {
if (!targetDir.exists()) {
QDir().mkpath(targetBasePath);
}
QStringList fileNames = sourceDir.entryList(QDir::Files |
QDir::NoDotAndDotDot | QDir::NoSymLinks);
foreach (const QString &fileName, fileNames) {
targetFilePath = targetBasePath + fileName;
if (!QFile::exists(targetFilePath)) {
QFile::copy(sourceBasePath + fileName, targetFilePath);
}
}
}
void cloneColorScheme(const QString &colorScheme)
{
Kdelibs4Migration migration;
QString src = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "color-schemes/" + colorScheme + ".colors");
QString dest = migration.saveLocation("data", "color-schemes") + colorScheme + ".colors";
QDir dir;
dir.mkpath(migration.saveLocation("data", "color-schemes"));
QFile::remove(dest);
QFile::copy(src, dest);
}
Activities::Private::KDE4ConfigurationTransitionChecker::KDE4ConfigurationTransitionChecker()
{
// Checking whether we need to transfer the KActivities/KDE4
// configuration file to the new location.
const QString newConfigLocation
= QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)
+ '/' + ACTIVITY_MANAGER_CONFIG_FILE_NAME;
if (QFile(newConfigLocation).exists()) {
return;
}
// Testing for kdehome
Kdelibs4Migration migration;
if (!migration.kdeHomeFound()) {
return;
}
QString oldConfigFile(migration.locateLocal("config", "activitymanagerrc"));
if (!oldConfigFile.isEmpty()) {
QFile(oldConfigFile).copy(newConfigLocation);
}
}
//__________________________________________________________________
void StyleConfig::save( void )
{
StyleConfigData::setTabBarDrawCenteredTabs( _tabBarDrawCenteredTabs->isChecked() );
StyleConfigData::setToolBarDrawItemSeparator( _toolBarDrawItemSeparator->isChecked() );
StyleConfigData::setViewDrawFocusIndicator( _viewDrawFocusIndicator->isChecked() );
StyleConfigData::setDockWidgetDrawFrame( _dockWidgetDrawFrame->isChecked() );
StyleConfigData::setTitleWidgetDrawFrame( _titleWidgetDrawFrame->isChecked() );
StyleConfigData::setSidePanelDrawFrame( _sidePanelDrawFrame->isChecked() );
StyleConfigData::setMenuItemDrawStrongFocus( !_menuItemDrawThinFocus->isChecked() );
StyleConfigData::setSliderDrawTickMarks( _sliderDrawTickMarks->isChecked() );
StyleConfigData::setSplitterProxyEnabled( _splitterProxyEnabled->isChecked() );
StyleConfigData::setMnemonicsMode( _mnemonicsMode->currentIndex() );
StyleConfigData::setScrollBarAddLineButtons( _scrollBarAddLineButtons->currentIndex() );
StyleConfigData::setScrollBarSubLineButtons( _scrollBarSubLineButtons->currentIndex() );
StyleConfigData::setAnimationsEnabled( _animationsEnabled->isChecked() );
StyleConfigData::setAnimationsDuration( _animationsDuration->value() );
StyleConfigData::setWindowDragMode( _windowDragMode->currentIndex() );
#if BREEZE_USE_KDE4
StyleConfigData::self()->writeConfig();
#else
StyleConfigData::self()->save();
//update the KDE4 config to match
Kdelibs4Migration migration;
const QString kde4ConfigDirPath = migration.saveLocation("config");
QScopedPointer<KConfig> kde4Config(StyleConfigData::self()->config()->copyTo(kde4ConfigDirPath+"/breezerc", 0));
kde4Config->sync();
#endif
// emit dbus signal
QDBusMessage message( QDBusMessage::createSignal( QStringLiteral( "/BreezeStyle" ), QStringLiteral( "org.kde.Breeze.Style" ), QStringLiteral( "reparseConfiguration" ) ) );
QDBusConnection::sessionBus().send(message);
}
// ***
// Entry point into the Konsole terminal application.
// ***
extern "C" int Q_DECL_EXPORT kdemain(int argc, char* argv[])
{
// Check if any of the arguments makes it impossible to re-use an existing process.
// We need to do this manually and before creating a QApplication, because
// QApplication takes/removes the Qt specific arguments that are incompatible.
KDBusService::StartupOption startupOption = KDBusService::Unique;
if (shouldUseNewProcess(argc, argv)) {
startupOption = KDBusService::Multiple;
} else {
needToDeleteQApplication = true;
}
QApplication *app = new QApplication(argc, argv);
// enable high dpi support
app->setAttribute(Qt::AA_UseHighDpiPixmaps, true);
#if defined(Q_OS_OSX)
// this ensures that Ctrl and Meta are not swapped, so CTRL-C and friends
// will work correctly in the terminal
app->setAttribute(Qt::AA_MacDontSwapCtrlAndMeta);
// KDE's menuBar()->isTopLevel() hasn't worked in a while.
// For now, put menus inside Konsole window; this also make
// the keyboard shortcut to show menus look reasonable.
app->setAttribute(Qt::AA_DontUseNativeMenuBar);
#endif
KLocalizedString::setApplicationDomain("konsole");
KAboutData about(QStringLiteral("konsole"),
i18nc("@title", "Konsole"),
QStringLiteral(KONSOLE_VERSION),
i18nc("@title", "Terminal emulator"),
KAboutLicense::GPL_V2,
i18n("(c) 1997-2015, The Konsole Developers"),
QStringLiteral(),
QStringLiteral("https://konsole.kde.org/"));
fillAboutData(about);
KAboutData::setApplicationData(about);
KCrash::initialize();
QSharedPointer<QCommandLineParser> parser(new QCommandLineParser);
parser->setApplicationDescription(about.shortDescription());
parser->addHelpOption();
parser->addVersionOption();
about.setupCommandLine(parser.data());
Application::populateCommandLineParser(parser.data());
parser->process(*app);
about.processCommandLine(parser.data());
// Enable user to force multiple instances
if (!Konsole::KonsoleSettings::useSingleInstance()) {
startupOption = KDBusService::Multiple;
}
atexit(deleteQApplication);
// Ensure that we only launch a new instance if we need to
// If there is already an instance running, we will quit here
KDBusService dbusService(startupOption | KDBusService::NoExitOnFailure);
needToDeleteQApplication = false;
Kdelibs4ConfigMigrator migrate(QStringLiteral("konsole"));
migrate.setConfigFiles(QStringList() << QStringLiteral("konsolerc") << QStringLiteral("konsole.notifyrc"));
migrate.setUiFiles(QStringList() << QStringLiteral("sessionui.rc") << QStringLiteral("partui.rc") << QStringLiteral("konsoleui.rc"));
if (migrate.migrate()) {
Kdelibs4Migration dataMigrator;
const QString sourceBasePath = dataMigrator.saveLocation("data", QStringLiteral("konsole"));
const QString targetBasePath = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/konsole/");
QString targetFilePath;
QDir sourceDir(sourceBasePath);
QDir targetDir(targetBasePath);
if(sourceDir.exists()) {
if(!targetDir.exists()) {
QDir().mkpath(targetBasePath);
}
QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks);
foreach (const QString &fileName, fileNames) {
targetFilePath = targetBasePath + fileName;
if(!QFile::exists(targetFilePath)) {
QFile::copy(sourceBasePath + fileName, targetFilePath);
}
}
}
int main(int argc, char **argv)
{
// Migrate KDE4 configuration and XML files
QStringList configFiles;
configFiles << QLatin1String("smb4krc");
Kdelibs4ConfigMigrator migrator(QLatin1String("smb4k"));
migrator.setConfigFiles(configFiles);
if (migrator.migrate())
{
Kdelibs4Migration migration;
if (migration.kdeHomeFound())
{
//
// NOTE: We need the 'smb4k' subdirectory, since no QApplication
// is running at this point.
//
// New location
QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)+QDir::separator()+"smb4k";
// XML files
QString bookmarks = migration.locateLocal("data", "smb4k/bookmarks.xml");
QString options = migration.locateLocal("data", "smb4k/custom_options.xml");
QString homes = migration.locateLocal("data", "smb4k/homes_shares.xml");
// Copy the files if they don't already exist
if (!bookmarks.isEmpty() && QFile().exists(bookmarks))
{
if (!QDir().exists(path))
{
QDir().mkpath(path);
}
else
{
// Do nothing
}
QFile(bookmarks).copy(path+QDir::separator()+"bookmarks.xml");
}
else
{
// Do nothing
}
if (!options.isEmpty() && QFile().exists(options))
{
if (!QDir().exists(path))
{
QDir().mkpath(path);
}
else
{
// Do nothing
}
QFile(options).copy(path+QDir::separator()+"custom_options.xml");
}
else
{
// Do nothing
}
if (!homes.isEmpty() && QFile().exists(homes))
{
if (!QDir().exists(path))
{
QDir().mkpath(path);
}
else
{
// Do nothing
}
QFile(homes).copy(path+QDir::separator()+"homes_shares.xml");
}
else
{
// Do nothing
}
}
else
{
// Do nothing
}
}
else
{
// Do nothing
}
// Create the application
QApplication app(argc, argv);
// Connect the application with the translation catalog
KLocalizedString::setApplicationDomain("smb4k");
// Create the about data for Smb4K
KAboutData aboutData(QStringLiteral("smb4k"), i18n("Smb4K"), QStringLiteral(VERSION),
i18n("Advanced network neighborhood browser and Samba share mounting utility"),
KAboutLicense::GPL_V2, i18n("\u00A9 2003-2016 Alexander Reinholdt"), QString(),
QStringLiteral("http://smb4k.sourceforge.net"));
// DBus prefix
aboutData.setOrganizationDomain("kde.org");
// Authors
aboutData.addAuthor(i18n("Alexander Reinholdt"),
i18n("Developer"),
QStringLiteral("*****@*****.**"));
// Credits:
// People who supported the Smb4K development by donating
// money
aboutData.addCredit(i18n("Wolfgang Geisendörfer"), i18n("Donator"), QStringLiteral("*****@*****.**"));
// Register about data
KAboutData::setApplicationData(aboutData);
// Now add the data to the application
app.setApplicationName(aboutData.componentName());
app.setApplicationDisplayName(aboutData.displayName());
app.setOrganizationDomain(aboutData.organizationDomain());
app.setApplicationVersion(aboutData.version());
// We need to set this property because otherwise the application
// will quit when it is embedded into the system tray, the main window
// is hidden and the last window that was opened through the system
// tray is closed.
app.setQuitOnLastWindowClosed(false);
// Support high dpi screens
app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
// Program icon
app.setWindowIcon(QIcon::fromTheme(QLatin1String("smb4k")));
// Launch the main window
Smb4KMainWindow *mainWindow = new Smb4KMainWindow();
mainWindow->setVisible(!Smb4KSettings::startMainWindowDocked());
// Initialize the core. Use a busy cursor.
initCore(true);
// Unique application
const KDBusService service(KDBusService::Unique);
// Start the application
return app.exec();
}
void runRdb( uint flags )
{
// Obtain the application palette that is about to be set.
bool exportColors = flags & KRdbExportColors;
bool exportQtColors = flags & KRdbExportQtColors;
bool exportQtSettings = flags & KRdbExportQtSettings;
bool exportXftSettings = flags & KRdbExportXftSettings;
bool exportGtkTheme = flags & KRdbExportGtkTheme;
KSharedConfigPtr kglobalcfg = KSharedConfig::openConfig( QStringLiteral("kdeglobals") );
KConfigGroup kglobals(kglobalcfg, "KDE");
QPalette newPal = KColorScheme::createApplicationPalette(kglobalcfg);
QTemporaryFile tmpFile;
if (!tmpFile.open())
{
qDebug() << "Couldn't open temp file";
exit(0);
}
KConfigGroup generalCfgGroup(kglobalcfg, "General");
QString gtkTheme;
if (kglobals.hasKey("widgetStyle"))
gtkTheme = kglobals.readEntry("widgetStyle");
else
gtkTheme = QStringLiteral("oxygen");
createGtkrc( exportColors, newPal, exportGtkTheme, gtkTheme, 1 );
createGtkrc( exportColors, newPal, exportGtkTheme, gtkTheme, 2 );
// Export colors to non-(KDE/Qt) apps (e.g. Motif, GTK+ apps)
if (exportColors)
{
KConfigGroup g(KSharedConfig::openConfig(), "WM");
QString preproc;
QColor backCol = newPal.color( QPalette::Active, QPalette::Background );
addColorDef(preproc, "FOREGROUND" , newPal.color( QPalette::Active, QPalette::Foreground ) );
addColorDef(preproc, "BACKGROUND" , backCol);
addColorDef(preproc, "HIGHLIGHT" , backCol.light(100+(2*KColorScheme::contrast()+4)*16/1));
addColorDef(preproc, "LOWLIGHT" , backCol.dark(100+(2*KColorScheme::contrast()+4)*10));
addColorDef(preproc, "SELECT_BACKGROUND" , newPal.color( QPalette::Active, QPalette::Highlight));
addColorDef(preproc, "SELECT_FOREGROUND" , newPal.color( QPalette::Active, QPalette::HighlightedText));
addColorDef(preproc, "WINDOW_BACKGROUND" , newPal.color( QPalette::Active, QPalette::Base ) );
addColorDef(preproc, "WINDOW_FOREGROUND" , newPal.color( QPalette::Active, QPalette::Text ) );
addColorDef(preproc, "INACTIVE_BACKGROUND", g.readEntry("inactiveBackground", QColor(224, 223, 222)));
addColorDef(preproc, "INACTIVE_FOREGROUND", g.readEntry("inactiveBackground", QColor(224, 223, 222)));
addColorDef(preproc, "ACTIVE_BACKGROUND" , g.readEntry("activeBackground", QColor(48, 174, 232)));
addColorDef(preproc, "ACTIVE_FOREGROUND" , g.readEntry("activeBackground", QColor(48, 174, 232)));
//---------------------------------------------------------------
tmpFile.write( preproc.toLatin1(), preproc.length() );
QStringList list;
const QStringList adPaths = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
QStringLiteral("kdisplay/app-defaults/"), QStandardPaths::LocateDirectory);
for (QStringList::ConstIterator it = adPaths.constBegin(); it != adPaths.constEnd(); ++it) {
QDir dSys( *it );
if ( dSys.exists() ) {
dSys.setFilter( QDir::Files );
dSys.setSorting( QDir::Name );
dSys.setNameFilters(QStringList(QStringLiteral("*.ad")));
list += dSys.entryList();
}
}
for (QStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it)
copyFile(tmpFile, QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kdisplay/app-defaults/"+(*it)), true);
}
// Merge ~/.Xresources or fallback to ~/.Xdefaults
QString homeDir = QDir::homePath();
QString xResources = homeDir + "/.Xresources";
// very primitive support for ~/.Xresources by appending it
if ( QFile::exists( xResources ) )
copyFile(tmpFile, xResources, true);
else
copyFile(tmpFile, homeDir + "/.Xdefaults", true);
// Export the Xcursor theme & size settings
KConfigGroup mousecfg(KSharedConfig::openConfig( QStringLiteral("kcminputrc") ), "Mouse" );
QString theme = mousecfg.readEntry("cursorTheme", QString());
QString size = mousecfg.readEntry("cursorSize", QString());
QString contents;
if (!theme.isNull())
contents = "Xcursor.theme: " + theme + '\n';
if (!size.isNull())
contents += "Xcursor.size: " + size + '\n';
if (exportXftSettings)
{
if (generalCfgGroup.hasKey("XftAntialias"))
{
contents += QLatin1String("Xft.antialias: ");
if(generalCfgGroup.readEntry("XftAntialias", true))
contents += QLatin1String("1\n");
else
contents += QLatin1String("0\n");
}
if (generalCfgGroup.hasKey("XftHintStyle"))
{
QString hintStyle = generalCfgGroup.readEntry("XftHintStyle", "hintmedium");
contents += QLatin1String("Xft.hinting: ");
if(hintStyle.isEmpty())
contents += QLatin1String("-1\n");
else
{
if(hintStyle!=QLatin1String("hintnone"))
contents += QLatin1String("1\n");
else
contents += QLatin1String("0\n");
contents += "Xft.hintstyle: " + hintStyle + '\n';
}
}
if (generalCfgGroup.hasKey("XftSubPixel"))
{
QString subPixel = generalCfgGroup.readEntry("XftSubPixel");
if(!subPixel.isEmpty())
contents += "Xft.rgba: " + subPixel + '\n';
}
KConfig _cfgfonts( QStringLiteral("kcmfonts") );
KConfigGroup cfgfonts(&_cfgfonts, "General");
if( cfgfonts.readEntry( "forceFontDPI", 0 ) != 0 )
contents += "Xft.dpi: " + cfgfonts.readEntry( "forceFontDPI" ) + '\n';
else
{
KProcess proc;
proc << QStringLiteral("xrdb") << QStringLiteral("-quiet") << QStringLiteral("-remove") << QStringLiteral("-nocpp");
proc.start();
if (proc.waitForStarted())
{
proc.write( QByteArray( "Xft.dpi\n" ) );
proc.closeWriteChannel();
proc.waitForFinished();
}
}
}
if (contents.length() > 0)
tmpFile.write( contents.toLatin1(), contents.length() );
tmpFile.flush();
KProcess proc;
#ifndef NDEBUG
proc << QStringLiteral("xrdb") << QStringLiteral("-merge") << tmpFile.fileName();
#else
proc << "xrdb" << "-quiet" << "-merge" << tmpFile.fileName();
#endif
proc.execute();
applyGtkStyles(exportColors, 1);
applyGtkStyles(exportColors, 2);
/* Qt exports */
if ( exportQtColors || exportQtSettings )
{
QSettings* settings = new QSettings(QStringLiteral("Trolltech"));
if ( exportQtColors )
applyQtColors( kglobalcfg, *settings, newPal ); // For kcmcolors
if ( exportQtSettings )
applyQtSettings( kglobalcfg, *settings ); // For kcmstyle
delete settings;
QApplication::flush();
#if HAVE_X11
if (qApp->platformName() == QStringLiteral("xcb")) {
// We let KIPC take care of ourselves, as we are in a KDE app with
// QApp::setDesktopSettingsAware(false);
// Instead of calling QApp::x11_apply_settings() directly, we instead
// modify the timestamp which propagates the settings changes onto
// Qt-only apps without adversely affecting ourselves.
// Cheat and use the current timestamp, since we just saved to qtrc.
QDateTime settingsstamp = QDateTime::currentDateTime();
static Atom qt_settings_timestamp = 0;
if (!qt_settings_timestamp) {
QString atomname(QStringLiteral("_QT_SETTINGS_TIMESTAMP_"));
atomname += XDisplayName( 0 ); // Use the $DISPLAY envvar.
qt_settings_timestamp = XInternAtom( QX11Info::display(), atomname.toLatin1(), False);
}
QBuffer stamp;
QDataStream s(&stamp.buffer(), QIODevice::WriteOnly);
s << settingsstamp;
XChangeProperty( QX11Info::display(), QX11Info::appRootWindow(), qt_settings_timestamp,
qt_settings_timestamp, 8, PropModeReplace,
(unsigned char*) stamp.buffer().data(),
stamp.buffer().size() );
QApplication::flush();
}
#endif
}
//Legacy support:
//Try to sync kde4 settings with ours
Kdelibs4Migration migration;
//kf5 congig groups for general and icons
KConfigGroup generalGroup(kglobalcfg, "General");
KConfigGroup iconsGroup(kglobalcfg, "Icons");
const QString colorSchemeName = generalGroup.readEntry("ColorScheme", QString());
//if no valid color scheme saved, something weird is going on, abort
if (colorSchemeName.isEmpty()) {
return;
}
//fix filename, copied from ColorsCM::saveScheme()
QString colorSchemeFilename = colorSchemeName;
colorSchemeFilename.remove('\''); // So Foo's does not become FooS
QRegExp fixer(QStringLiteral("[\\W,.-]+(.?)"));
int offset;
while ((offset = fixer.indexIn(colorSchemeFilename)) >= 0)
colorSchemeFilename.replace(offset, fixer.matchedLength(), fixer.cap(1).toUpper());
colorSchemeFilename.replace(0, 1, colorSchemeFilename.at(0).toUpper());
//clone the color scheme
QString src = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "color-schemes/" + colorSchemeFilename + ".colors");
QString dest = migration.saveLocation("data", QStringLiteral("color-schemes")) + colorSchemeName + ".colors";
QFile::remove(dest);
QFile::copy(src, dest);
//Apply the color scheme
QString configFilePath = migration.saveLocation("config") + "kdeglobals";
if (configFilePath.isEmpty()) {
return;
}
KConfig kde4config(configFilePath, KConfig::SimpleConfig);
KConfigGroup kde4generalGroup(&kde4config, "General");
kde4generalGroup.writeEntry("ColorScheme", colorSchemeName);
//fonts
QString font = generalGroup.readEntry("font", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("font", font);
}
font = generalGroup.readEntry("desktopFont", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("desktopFont", font);
}
font = generalGroup.readEntry("menuFont", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("menuFont", font);
}
font = generalGroup.readEntry("smallestReadableFont", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("smallestReadableFont", font);
}
font = generalGroup.readEntry("taskbarFont", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("taskbarFont", font);
}
font = generalGroup.readEntry("toolBarFont", QString());
if (!font.isEmpty()) {
kde4generalGroup.writeEntry("toolBarFont", font);
}
//TODO: does exist any way to check if a qt4 widget style is present from a qt5 app?
//kde4generalGroup.writeEntry("widgetStyle", "qtcurve");
kde4generalGroup.sync();
KConfigGroup kde4IconGroup(&kde4config, "Icons");
QString iconTheme = iconsGroup.readEntry("Theme", QString());
if (!iconTheme.isEmpty()) {
kde4IconGroup.writeEntry("Theme", iconTheme);
}
kde4IconGroup.sync();
//copy all the groups in the color scheme in kdeglobals
KSharedConfigPtr kde4ColorConfig = KSharedConfig::openConfig(src, KConfig::SimpleConfig);
foreach (const QString &grp, kde4ColorConfig->groupList()) {
KConfigGroup cg(kde4ColorConfig, grp);
KConfigGroup cg2(&kde4config, grp);
cg.copyTo(&cg2);
}
//widgets settings
KConfigGroup kglobals4(&kde4config, "KDE");
kglobals4.writeEntry("ShowIconsInMenuItems", kglobals.readEntry("ShowIconsInMenuItems", true));
kglobals4.writeEntry("ShowIconsOnPushButtons", kglobals.readEntry("ShowIconsOnPushButtons", true));
kglobals4.writeEntry("contrast", kglobals.readEntry("contrast", 4));
//FIXME: this should somehow check if the kde4 version of the style is installed
kde4generalGroup.writeEntry("widgetStyle", kglobals.readEntry("widgetStyle", "breeze"));
//toolbar style
KConfigGroup toolbars4(&kde4config, "Toolbar style");
KConfigGroup toolbars5(kglobalcfg, "Toolbar style");
toolbars4.writeEntry("ToolButtonStyle", toolbars5.readEntry("ToolButtonStyle", "TextBesideIcon"));
toolbars4.writeEntry("ToolButtonStyleOtherToolbars", toolbars5.readEntry("ToolButtonStyleOtherToolbars", "TextBesideIcon"));
}
void updateKdeGlobals()
{
Kdelibs4Migration migration;
//Apply the color scheme
KConfig config(migration.saveLocation("config") + "kdeglobals");
KSharedConfig::Ptr kf5Config = KSharedConfig::openConfig("kdeglobals");
KConfigGroup kf5Group(kf5Config, "General");
KConfigGroup kf52Group(kf5Config, "KDE");
const QString looknfeel = kf52Group.readEntry("LookAndFeelPackage", defaultLookAndFeelPackage);
KSharedConfigPtr lnfConfig;
KSharedConfigPtr defaultLnfConfig = KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "plasma/look-and-feel/" + defaultLookAndFeelPackage + "/contents/defaults"));
if (looknfeel != defaultLookAndFeelPackage) {
lnfConfig = KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::GenericDataLocation, "plasma/look-and-feel/" + looknfeel + "/contents/defaults"));
}
const QString widgetStyle = readConfigValue(lnfConfig, defaultLnfConfig, "KDE", "widgetStyle", "Menda").toString();
const QString colorScheme = readConfigValue(lnfConfig, defaultLnfConfig, "General", "ColorScheme", "Menda").toString();
const QString icons = readConfigValue(lnfConfig, defaultLnfConfig, "Icons", "Theme", "menda").toString();
cloneColorScheme(colorScheme);
//use only if the style from the look and feel package is installed
const bool hasWidgetStyle = QStyleFactory::keys().contains(widgetStyle);
KConfigGroup group(&config, "General");
group.writeEntry("ColorScheme", colorScheme);
qDebug() << "setting widget style:" << widgetStyle << hasWidgetStyle;
if (hasWidgetStyle) {
group.writeEntry("widgetStyle", widgetStyle);
//for some reason this seems necessary
group.sync();
}
applyColorScheme(colorScheme, &config);
group.sync();
KConfigGroup iconGroup(&config, "Icons");
iconGroup.writeEntry("Theme", icons);
applyColorScheme(colorScheme, &config);
iconGroup.sync();
kf5Group.writeEntry("ColorScheme", colorScheme);
kf5Group.sync();
if (hasWidgetStyle) {
kf5Group.writeEntry("widgetStyle", widgetStyle);
}
applyColorScheme(colorScheme, kf5Group.config());
kf5Group.sync();
kf52Group.writeEntry("ColorScheme", colorScheme);
if (hasWidgetStyle) {
kf52Group.writeEntry("widgetStyle", widgetStyle);
}
applyColorScheme(colorScheme, kf52Group.config());
kf52Group.sync();
KConfigGroup kf5IconGroup(kf5Config, "Icons");
kf5IconGroup.writeEntry("Theme", icons);
kf5IconGroup.sync();
}
