yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/kcmkwin/kwincompositing/main.cpp
Martin Gräßlin 987bc837d9 Remove define KWIN_HAVE_OPENGL_COMPOSITING 
Due to changes in build system we have always either OpenGL or OpenGL ES.
This allows to remove the KWIN_HAVE_OPENGL_COMPOSITING define. In the
effects the define is kept as KWIN_HAVE_OPENGL which can be used in
future to build also an XRender only effect system.
2011-08-13 16:46:43 +02:00

724 lines
30 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "main.h"
#include "kwin_interface.h"
#include <kaboutdata.h>
#include <kaction.h>
#include <kactioncollection.h>
#include <kconfig.h>
#include <kconfiggroup.h>
#include <kdebug.h>
#include <kmessagebox.h>
#include <ksettings/dispatcher.h>
#include <kpluginselector.h>
#include <kservicetypetrader.h>
#include <kplugininfo.h>
#include <kservice.h>
#include <ktitlewidget.h>
#include <knotification.h>
#include <QtDBus/QtDBus>
#include <QTimer>
#include <QLabel>
#include <KPluginFactory>
#include <KPluginLoader>
#include <KIcon>
K_PLUGIN_FACTORY(KWinCompositingConfigFactory,
registerPlugin<KWin::KWinCompositingConfig>();
)
K_EXPORT_PLUGIN(KWinCompositingConfigFactory("kcmkwincompositing"))
namespace KWin
{
ConfirmDialog::ConfirmDialog() :
KTimerDialog(10000, KTimerDialog::CountDown, 0,
i18n("Confirm Desktop Effects Change"), KTimerDialog::Ok | KTimerDialog::Cancel,
KTimerDialog::Cancel)
{
setObjectName(QLatin1String("mainKTimerDialog"));
setButtonGuiItem(KDialog::Ok, KGuiItem(i18n("&Accept Configuration"), "dialog-ok"));
setButtonGuiItem(KDialog::Cancel, KGuiItem(i18n("&Return to Previous Configuration"), "dialog-cancel"));
QLabel *label = new QLabel(i18n("Desktop effects settings have changed.\n"
"Do you want to keep the new settings?\n"
"They will be automatically reverted in 10 seconds."), this);
label->setWordWrap(true);
setMainWidget(label);
setWindowIcon(KIcon("preferences-desktop-effect"));
}
KWinCompositingConfig::KWinCompositingConfig(QWidget *parent, const QVariantList &)
: KCModule(KWinCompositingConfigFactory::componentData(), parent)
, mKWinConfig(KSharedConfig::openConfig("kwinrc"))
, m_showConfirmDialog(false)
{
KGlobal::locale()->insertCatalog("kwin_effects");
ui.setupUi(this);
layout()->setMargin(0);
ui.tabWidget->setCurrentIndex(0);
ui.statusTitleWidget->hide();
ui.rearmGlSupport->hide();
// For future use
(void) I18N_NOOP("Use GLSL shaders");
#define OPENGL_INDEX 0
#define XRENDER_INDEX 1
#ifndef KWIN_HAVE_XRENDER_COMPOSITING
ui.compositingType->removeItem(XRENDER_INDEX);
ui.xrenderGroup->setEnabled(false);
#define XRENDER_INDEX -1
#endif
connect(ui.tabWidget, SIGNAL(currentChanged(int)), this, SLOT(currentTabChanged(int)));
connect(ui.rearmGlSupportButton, SIGNAL(clicked()), this, SLOT(rearmGlSupport()));
connect(ui.useCompositing, SIGNAL(toggled(bool)), this, SLOT(changed()));
connect(ui.effectWinManagement, SIGNAL(toggled(bool)), this, SLOT(changed()));
connect(ui.effectAnimations, SIGNAL(toggled(bool)), this, SLOT(changed()));
connect(ui.effectSelector, SIGNAL(changed(bool)), this, SLOT(changed()));
connect(ui.effectSelector, SIGNAL(configCommitted(const QByteArray&)),
this, SLOT(reparseConfiguration(const QByteArray&)));
connect(ui.windowSwitchingCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.desktopSwitchingCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.animationSpeedCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.compositingType, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.compositingType, SIGNAL(currentIndexChanged(int)), this, SLOT(toogleSmoothScaleUi(int)));
connect(ui.windowThumbnails, SIGNAL(activated(int)), this, SLOT(changed()));
connect(ui.unredirectFullscreen , SIGNAL(toggled(bool)), this, SLOT(changed()));
connect(ui.glScaleFilter, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.xrScaleFilter, SIGNAL(currentIndexChanged(int)), this, SLOT(changed()));
connect(ui.glVSync, SIGNAL(toggled(bool)), this, SLOT(changed()));
connect(ui.glShaders, SIGNAL(toggled(bool)), this, SLOT(changed()));
// Open the temporary config file
// Temporary conf file is used to synchronize effect checkboxes with effect
// selector by loading/saving effects from/to temp config when active tab
// changes.
mTmpConfigFile.open();
mTmpConfig = KSharedConfig::openConfig(mTmpConfigFile.fileName());
// toggle effects shortcut button stuff - /HAS/ to happen before load!
m_actionCollection = new KActionCollection( this, KComponentData("kwin") );
m_actionCollection->setConfigGroup("Suspend Compositing");
m_actionCollection->setConfigGlobal(true);
KAction* a = static_cast<KAction*>(m_actionCollection->addAction( "Suspend Compositing" ));
a->setProperty("isConfigurationAction", true);
a->setGlobalShortcut( KShortcut( Qt::ALT + Qt::SHIFT + Qt::Key_F12 ));
connect(ui.toggleEffectsShortcut, SIGNAL(keySequenceChanged(const QKeySequence&)), this, SLOT(toggleEffectShortcutChanged(const QKeySequence&)));
// Initialize the user interface with the config loaded from kwinrc.
load();
KAboutData *about = new KAboutData(I18N_NOOP("kcmkwincompositing"), 0,
ki18n("KWin Desktop Effects Configuration Module"),
0, KLocalizedString(), KAboutData::License_GPL, ki18n("(c) 2007 Rivo Laks"));
about->addAuthor(ki18n("Rivo Laks"), KLocalizedString(), "rivolaks@hot.ee");
setAboutData(about);
// search the effect names
KServiceTypeTrader* trader = KServiceTypeTrader::self();
KService::List services;
QString boxswitch, presentwindows, coverswitch, flipswitch, slide, cube, fadedesktop;
// window switcher
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_boxswitch'");
if (!services.isEmpty())
boxswitch = services.first()->name();
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_presentwindows'");
if (!services.isEmpty())
presentwindows = services.first()->name();
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_coverswitch'");
if (!services.isEmpty())
coverswitch = services.first()->name();
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_flipswitch'");
if (!services.isEmpty())
flipswitch = services.first()->name();
// desktop switcher
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_slide'");
if (!services.isEmpty())
slide = services.first()->name();
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_cubeslide'");
if (!services.isEmpty())
cube = services.first()->name();
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_fadedesktop'");
if (!services.isEmpty())
fadedesktop = services.first()->name();
// init the combo boxes
ui.windowSwitchingCombo->addItem(i18n("No Effect"));
ui.windowSwitchingCombo->addItem(boxswitch);
ui.windowSwitchingCombo->addItem(presentwindows);
ui.windowSwitchingCombo->addItem(coverswitch);
ui.windowSwitchingCombo->addItem(flipswitch);
ui.desktopSwitchingCombo->addItem(i18n("No Effect"));
ui.desktopSwitchingCombo->addItem(slide);
ui.desktopSwitchingCombo->addItem(cube);
ui.desktopSwitchingCombo->addItem(fadedesktop);
}
KWinCompositingConfig::~KWinCompositingConfig()
{
}
void KWinCompositingConfig::reparseConfiguration(const QByteArray& conf)
{
KSettings::Dispatcher::reparseConfiguration(conf);
}
void KWinCompositingConfig::showConfirmDialog(bool reinitCompositing)
{
bool revert = false;
// Feel free to extend this to support several kwin instances (multihead) if you
// think it makes sense.
OrgKdeKWinInterface kwin("org.kde.kwin", "/KWin", QDBusConnection::sessionBus());
if (reinitCompositing ? !kwin.compositingActive().value() : !kwin.waitForCompositingSetup().value()) {
KMessageBox::sorry(this, i18n(
"Failed to activate desktop effects using the given "
"configuration options. Settings will be reverted to their previous values.\n\n"
"Check your X configuration. You may also consider changing advanced options, "
"especially changing the compositing type."));
revert = true;
} else {
ConfirmDialog confirm;
if (!confirm.exec())
revert = true;
else {
// compositing is enabled now
checkLoadedEffects();
}
}
if (revert) {
// Revert settings
KConfigGroup config(mKWinConfig, "Compositing");
config.deleteGroup();
QMap<QString, QString>::const_iterator it = mPreviousConfig.constBegin();
for (; it != mPreviousConfig.constEnd(); ++it) {
if (it.value().isEmpty())
continue;
config.writeEntry(it.key(), it.value());
}
// Sync with KWin and reload
configChanged(reinitCompositing);
load();
}
}
void KWinCompositingConfig::initEffectSelector()
{
// Find all .desktop files of the effects
KService::List offers = KServiceTypeTrader::self()->query("KWin/Effect");
QList<KPluginInfo> effectinfos = KPluginInfo::fromServices(offers);
// Add them to the plugin selector
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Appearance"), "Appearance", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Accessibility"), "Accessibility", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Focus"), "Focus", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Window Management"), "Window Management", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Candy"), "Candy", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Demos"), "Demos", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Tests"), "Tests", mTmpConfig);
ui.effectSelector->addPlugins(effectinfos, KPluginSelector::ReadConfigFile, i18n("Tools"), "Tools", mTmpConfig);
}
void KWinCompositingConfig::currentTabChanged(int tab)
{
// block signals to don't emit the changed()-signal by just switching the current tab
blockSignals(true);
// write possible changes done to synchronize effect checkboxes and selector
// TODO: This segment is prone to fail when the UI is changed;
// you'll most likely not think of the hard coded numbers here when just changing the order of the tabs.
if (tab == 0) {
// General tab was activated
saveEffectsTab();
loadGeneralTab();
} else if (tab == 1) {
// Effects tab was activated
saveGeneralTab();
loadEffectsTab();
}
blockSignals(false);
}
void KWinCompositingConfig::loadGeneralTab()
{
KConfigGroup config(mKWinConfig, "Compositing");
bool enabled = config.readEntry("Enabled", mDefaultPrefs.recommendCompositing());
ui.useCompositing->setChecked(enabled);
// this works by global shortcut magics - it will pick the current sc
// but the constructor line that adds the default alt+shift+f12 gsc is IMPORTANT!
if (KAction *a = qobject_cast<KAction*>(m_actionCollection->action("Suspend Compositing")))
ui.toggleEffectsShortcut->setKeySequence(a->globalShortcut().primary());
ui.animationSpeedCombo->setCurrentIndex(config.readEntry("AnimationSpeed", 3));
// Load effect settings
KConfigGroup effectconfig(mTmpConfig, "Plugins");
#define LOAD_EFFECT_CONFIG(effectname) effectconfig.readEntry("kwin4_effect_" effectname "Enabled", true)
int winManagementEnabled = LOAD_EFFECT_CONFIG("presentwindows")
+ LOAD_EFFECT_CONFIG("desktopgrid")
+ LOAD_EFFECT_CONFIG("dialogparent");
if (winManagementEnabled > 0 && winManagementEnabled < 3) {
ui.effectWinManagement->setTristate(true);
ui.effectWinManagement->setCheckState(Qt::PartiallyChecked);
} else
ui.effectWinManagement->setChecked(winManagementEnabled);
ui.effectAnimations->setChecked(LOAD_EFFECT_CONFIG("minimizeanimation"));
#undef LOAD_EFFECT_CONFIG
// window switching
// Set current option to "none" if no plugin is activated.
ui.windowSwitchingCombo->setCurrentIndex(0);
KConfigGroup boxswitchconfig(mKWinConfig, "Effect-BoxSwitch");
if (effectEnabled("boxswitch", effectconfig) && boxswitchconfig.readEntry("TabBox", true))
ui.windowSwitchingCombo->setCurrentIndex(1);
KConfigGroup coverswitchconfig(mKWinConfig, "Effect-CoverSwitch");
if (effectEnabled("coverswitch", effectconfig) && coverswitchconfig.readEntry("TabBox", false))
ui.windowSwitchingCombo->setCurrentIndex(3);
KConfigGroup flipswitchconfig(mKWinConfig, "Effect-FlipSwitch");
if (effectEnabled("flipswitch", effectconfig) && flipswitchconfig.readEntry("TabBox", false))
ui.windowSwitchingCombo->setCurrentIndex(4);
KConfigGroup presentwindowsconfig(mKWinConfig, "Effect-PresentWindows");
if (effectEnabled("presentwindows", effectconfig) && presentwindowsconfig.readEntry("TabBox", false))
ui.windowSwitchingCombo->setCurrentIndex(2);
// desktop switching
// Set current option to "none" if no plugin is activated.
ui.desktopSwitchingCombo->setCurrentIndex(0);
if (effectEnabled("slide", effectconfig))
ui.desktopSwitchingCombo->setCurrentIndex(1);
if (effectEnabled("cubeslide", effectconfig))
ui.desktopSwitchingCombo->setCurrentIndex(2);
if (effectEnabled("fadedesktop", effectconfig))
ui.desktopSwitchingCombo->setCurrentIndex(3);
}
void KWinCompositingConfig::rearmGlSupport()
{
// rearm config
KConfigGroup gl_workaround_config = KConfigGroup(mKWinConfig, "Compositing");
gl_workaround_config.writeEntry("OpenGLIsUnsafe", false);
gl_workaround_config.sync();
// save last changes
save();
// Initialize the user interface with the config loaded from kwinrc.
load();
}
void KWinCompositingConfig::toogleSmoothScaleUi(int compositingType)
{
ui.glScaleFilter->setVisible(compositingType == OPENGL_INDEX);
ui.xrScaleFilter->setVisible(compositingType == XRENDER_INDEX);
ui.scaleMethodLabel->setBuddy(compositingType == XRENDER_INDEX ? ui.xrScaleFilter : ui.glScaleFilter);
ui.glGroup->setEnabled(compositingType == OPENGL_INDEX);
}
void KWinCompositingConfig::toggleEffectShortcutChanged(const QKeySequence &seq)
{
if (KAction *a = qobject_cast<KAction*>(m_actionCollection->action("Suspend Compositing")))
a->setGlobalShortcut(KShortcut(seq), KAction::ActiveShortcut, KAction::NoAutoloading);
m_actionCollection->writeSettings();
}
bool KWinCompositingConfig::effectEnabled(const QString& effect, const KConfigGroup& cfg) const
{
KService::List services = KServiceTypeTrader::self()->query(
"KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_" + effect + '\'');
if (services.isEmpty())
return false;
QVariant v = services.first()->property("X-KDE-PluginInfo-EnabledByDefault");
return cfg.readEntry("kwin4_effect_" + effect + "Enabled", v.toBool());
}
void KWinCompositingConfig::loadEffectsTab()
{
ui.effectSelector->load();
}
void KWinCompositingConfig::loadAdvancedTab()
{
KConfigGroup config(mKWinConfig, "Compositing");
QString backend = config.readEntry("Backend", "OpenGL");
ui.compositingType->setCurrentIndex((backend == "XRender") ? XRENDER_INDEX : 0);
// 4 - off, 5 - shown, 6 - always, other are old values
int hps = config.readEntry("HiddenPreviews", 5);
if (hps == 6) // always
ui.windowThumbnails->setCurrentIndex(0);
else if (hps == 4) // never
ui.windowThumbnails->setCurrentIndex(2);
else // shown, or default
ui.windowThumbnails->setCurrentIndex(1);
ui.unredirectFullscreen->setChecked(config.readEntry("UnredirectFullscreen", false));
ui.xrScaleFilter->setCurrentIndex((int)config.readEntry("XRenderSmoothScale", false));
ui.glScaleFilter->setCurrentIndex(config.readEntry("GLTextureFilter", 2));
ui.glVSync->setChecked(config.readEntry("GLVSync", mDefaultPrefs.enableVSync()));
ui.glShaders->setChecked(!config.readEntry<bool>("GLLegacy", false));
toogleSmoothScaleUi(ui.compositingType->currentIndex());
}
void KWinCompositingConfig::updateStatusUI(bool compositingIsPossible)
{
if (compositingIsPossible) {
ui.compositingOptionsContainer->show();
ui.statusTitleWidget->hide();
ui.rearmGlSupport->hide();
// Driver-specific config detection
mDefaultPrefs.detect();
}
else {
ui.compositingOptionsContainer->hide();
QString text = i18n("Desktop effects are not available on this system due to the following technical issues:");
text += "<hr>";
text += CompositingPrefs::compositingNotPossibleReason();
ui.statusTitleWidget->setText(text);
ui.statusTitleWidget->setPixmap(KTitleWidget::InfoMessage, KTitleWidget::ImageLeft);
ui.statusTitleWidget->show();
ui.rearmGlSupport->setVisible(CompositingPrefs::openGlIsBroken());
}
}
void KWinCompositingConfig::load()
{
initEffectSelector();
mKWinConfig->reparseConfiguration();
updateStatusUI(CompositingPrefs::compositingPossible());
// Copy Plugins group to temp config file
QMap<QString, QString> entries = mKWinConfig->entryMap("Plugins");
QMap<QString, QString>::const_iterator it = entries.constBegin();
KConfigGroup tmpconfig(mTmpConfig, "Plugins");
tmpconfig.deleteGroup();
for (; it != entries.constEnd(); ++it)
tmpconfig.writeEntry(it.key(), it.value());
loadGeneralTab();
loadEffectsTab();
loadAdvancedTab();
emit changed(false);
}
void KWinCompositingConfig::saveGeneralTab()
{
KConfigGroup config(mKWinConfig, "Compositing");
// Check if any critical settings that need confirmation have changed
config.writeEntry("Enabled", ui.useCompositing->isChecked());
config.writeEntry("AnimationSpeed", ui.animationSpeedCombo->currentIndex());
// Save effects
KConfigGroup effectconfig(mTmpConfig, "Plugins");
#define WRITE_EFFECT_CONFIG(effectname, widget) effectconfig.writeEntry("kwin4_effect_" effectname "Enabled", widget->isChecked())
if (ui.effectWinManagement->checkState() != Qt::PartiallyChecked) {
WRITE_EFFECT_CONFIG("presentwindows", ui.effectWinManagement);
WRITE_EFFECT_CONFIG("desktopgrid", ui.effectWinManagement);
WRITE_EFFECT_CONFIG("dialogparent", ui.effectWinManagement);
}
// TODO: maybe also do some effect-specific configuration here, e.g.
// enable/disable desktopgrid's animation according to this setting
WRITE_EFFECT_CONFIG("minimizeanimation", ui.effectAnimations);
#undef WRITE_EFFECT_CONFIG
int windowSwitcher = ui.windowSwitchingCombo->currentIndex();
bool boxSwitch = false;
bool presentWindowSwitching = false;
bool coverSwitch = false;
bool flipSwitch = false;
switch(windowSwitcher) {
case 1:
boxSwitch = true;
break;
case 2:
presentWindowSwitching = true;
break;
case 3:
coverSwitch = true;
break;
case 4:
flipSwitch = true;
break;
default:
break; // nothing
}
// activate effects if not active
if (boxSwitch)
effectconfig.writeEntry("kwin4_effect_boxswitchEnabled", true);
if (presentWindowSwitching)
effectconfig.writeEntry("kwin4_effect_presentwindowsEnabled", true);
if (coverSwitch)
effectconfig.writeEntry("kwin4_effect_coverswitchEnabled", true);
if (flipSwitch)
effectconfig.writeEntry("kwin4_effect_flipswitchEnabled", true);
KConfigGroup boxswitchconfig(mKWinConfig, "Effect-BoxSwitch");
boxswitchconfig.writeEntry("TabBox", boxSwitch);
boxswitchconfig.sync();
KConfigGroup presentwindowsconfig(mKWinConfig, "Effect-PresentWindows");
presentwindowsconfig.writeEntry("TabBox", presentWindowSwitching);
presentwindowsconfig.sync();
KConfigGroup coverswitchconfig(mKWinConfig, "Effect-CoverSwitch");
coverswitchconfig.writeEntry("TabBox", coverSwitch);
coverswitchconfig.sync();
KConfigGroup flipswitchconfig(mKWinConfig, "Effect-FlipSwitch");
flipswitchconfig.writeEntry("TabBox", flipSwitch);
flipswitchconfig.sync();
int desktopSwitcher = ui.desktopSwitchingCombo->currentIndex();
switch(desktopSwitcher) {
case 0:
// no effect
effectconfig.writeEntry("kwin4_effect_slideEnabled", false);
effectconfig.writeEntry("kwin4_effect_cubeslideEnabled", false);
effectconfig.writeEntry("kwin4_effect_fadedesktopEnabled", false);
break;
case 1:
// slide
effectconfig.writeEntry("kwin4_effect_slideEnabled", true);
effectconfig.writeEntry("kwin4_effect_cubeslideEnabled", false);
effectconfig.writeEntry("kwin4_effect_fadedesktopEnabled", false);
break;
case 2:
// cube
effectconfig.writeEntry("kwin4_effect_slideEnabled", false);
effectconfig.writeEntry("kwin4_effect_cubeslideEnabled", true);
effectconfig.writeEntry("kwin4_effect_fadedesktopEnabled", false);
break;
case 3:
// fadedesktop
effectconfig.writeEntry("kwin4_effect_slideEnabled", false);
effectconfig.writeEntry("kwin4_effect_cubeslideEnabled", false);
effectconfig.writeEntry("kwin4_effect_fadedesktopEnabled", true);
break;
}
}
void KWinCompositingConfig::saveEffectsTab()
{
ui.effectSelector->save();
}
bool KWinCompositingConfig::saveAdvancedTab()
{
bool advancedChanged = false;
static const int hps[] = { 6 /*always*/, 5 /*shown*/, 4 /*never*/ };
KConfigGroup config(mKWinConfig, "Compositing");
if (config.readEntry("Backend", "OpenGL")
!= ((ui.compositingType->currentIndex() == OPENGL_INDEX) ? "OpenGL" : "XRender")
|| config.readEntry("GLVSync", mDefaultPrefs.enableVSync()) != ui.glVSync->isChecked()
|| config.readEntry<bool>("GLLegacy", false) == ui.glShaders->isChecked()) {
m_showConfirmDialog = true;
advancedChanged = true;
} else if (config.readEntry("HiddenPreviews", 5) != hps[ ui.windowThumbnails->currentIndex()]
|| (int)config.readEntry("XRenderSmoothScale", false) != ui.xrScaleFilter->currentIndex()
|| config.readEntry("GLTextureFilter", 2) != ui.glScaleFilter->currentIndex())
advancedChanged = true;
config.writeEntry("Backend", (ui.compositingType->currentIndex() == OPENGL_INDEX) ? "OpenGL" : "XRender");
config.writeEntry("HiddenPreviews", hps[ ui.windowThumbnails->currentIndex()]);
config.writeEntry("UnredirectFullscreen", ui.unredirectFullscreen->isChecked());
config.writeEntry("XRenderSmoothScale", ui.xrScaleFilter->currentIndex() == 1);
config.writeEntry("GLTextureFilter", ui.glScaleFilter->currentIndex());
config.writeEntry("GLVSync", ui.glVSync->isChecked());
config.writeEntry("GLLegacy", !ui.glShaders->isChecked());
return advancedChanged;
}
void KWinCompositingConfig::save()
{
if (ui.compositingType->currentIndex() == OPENGL_INDEX &&
CompositingPrefs::openGlIsBroken() && !ui.rearmGlSupport->isVisible())
{
KConfigGroup config(mKWinConfig, "Compositing");
QString oldBackend = config.readEntry("Backend", "OpenGL");
config.writeEntry("Backend", "OpenGL");
config.sync();
updateStatusUI(false);
config.writeEntry("Backend", oldBackend);
config.sync();
ui.tabWidget->setCurrentIndex(0);
return;
}
// Save current config. We'll use this for restoring in case something goes wrong.
KConfigGroup config(mKWinConfig, "Compositing");
mPreviousConfig = config.entryMap();
// bah; tab content being dependent on the other is really bad; and
// deprecated in the HIG for a reason. It is confusing!
// Make sure we only call save on each tab once; as they are stateful due to the revert concept
if (ui.tabWidget->currentIndex() == 0) { // "General" tab was active
saveGeneralTab();
loadEffectsTab();
saveEffectsTab();
} else {
saveEffectsTab();
loadGeneralTab();
saveGeneralTab();
}
bool advancedChanged = saveAdvancedTab();
// Copy Plugins group from temp config to real config
QMap<QString, QString> entries = mTmpConfig->entryMap("Plugins");
QMap<QString, QString>::const_iterator it = entries.constBegin();
KConfigGroup realconfig(mKWinConfig, "Plugins");
realconfig.deleteGroup();
for (; it != entries.constEnd(); ++it)
realconfig.writeEntry(it.key(), it.value());
emit changed(false);
configChanged(advancedChanged);
// This assumes that this KCM is running with the same environment variables as KWin
// TODO: Detect KWIN_COMPOSE=N as well
if (!qgetenv("KDE_FAILSAFE").isNull() && ui.useCompositing->isChecked()) {
KMessageBox::sorry(this, i18n(
"Your settings have been saved but as KDE is currently running in failsafe "
"mode desktop effects cannot be enabled at this time.\n\n"
"Please exit failsafe mode to enable desktop effects."));
m_showConfirmDialog = false; // Dangerous but there is no way to test if failsafe mode
}
if (m_showConfirmDialog) {
m_showConfirmDialog = false;
showConfirmDialog(advancedChanged);
}
}
void KWinCompositingConfig::checkLoadedEffects()
{
// check for effects not supported by Backend or hardware
// such effects are enabled but not returned by DBus method loadedEffects
QDBusMessage message = QDBusMessage::createMethodCall("org.kde.kwin", "/KWin", "org.kde.KWin", "loadedEffects");
QDBusMessage reply = QDBusConnection::sessionBus().call(message);
KConfigGroup effectConfig = KConfigGroup(mKWinConfig, "Compositing");
bool enabledAfter = effectConfig.readEntry("Enabled", mDefaultPrefs.recommendCompositing());
if (reply.type() == QDBusMessage::ReplyMessage && enabledAfter && !getenv("KDE_FAILSAFE")) {
effectConfig = KConfigGroup(mKWinConfig, "Plugins");
QStringList loadedEffects = reply.arguments()[0].toStringList();
QStringList effects = effectConfig.keyList();
QStringList disabledEffects = QStringList();
foreach (QString effect, effects) { // krazy:exclude=foreach
QString temp = effect.mid(13, effect.length() - 13 - 7);
effect.truncate(effect.length() - 7);
if (effectEnabled(temp, effectConfig) && !loadedEffects.contains(effect)) {
disabledEffects << effect;
}
}
if (!disabledEffects.isEmpty()) {
KServiceTypeTrader* trader = KServiceTypeTrader::self();
KService::List services;
QString message = i18n("The following desktop effects could not be activated:");
message.append("<ul>");
foreach (const QString & effect, disabledEffects) {
services = trader->query("KWin/Effect", "[X-KDE-PluginInfo-Name] == '" + effect + '\'');
message.append("<li>");
if (!services.isEmpty())
message.append(services.first()->name());
else
message.append(effect);
message.append("</li>");
}
message.append("</ul>");
KNotification::event("effectsnotsupported", message, QPixmap(), NULL, KNotification::CloseOnTimeout, KComponentData("kwin"));
}
}
}
void KWinCompositingConfig::configChanged(bool reinitCompositing)
{
// Send signal to kwin
mKWinConfig->sync();
// Send signal to all kwin instances
QDBusMessage message = QDBusMessage::createSignal("/KWin", "org.kde.KWin",
reinitCompositing ? "reinitCompositing" : "reloadConfig");
QDBusConnection::sessionBus().send(message);
// maybe it's ok now?
if (reinitCompositing && !ui.compositingOptionsContainer->isVisible())
load();
// HACK: We can't just do this here, due to the asynchronous nature of signals.
// We also can't change reinitCompositing into a message (which would allow
// callWithCallbac() to do this neater) due to multiple kwin instances.
if (!m_showConfirmDialog)
QTimer::singleShot(1000, this, SLOT(checkLoadedEffects()));
}
void KWinCompositingConfig::defaults()
{
ui.tabWidget->setCurrentIndex(0);
ui.useCompositing->setChecked(mDefaultPrefs.recommendCompositing());
ui.effectWinManagement->setChecked(true);
ui.effectAnimations->setChecked(true);
ui.windowSwitchingCombo->setCurrentIndex(1);
ui.desktopSwitchingCombo->setCurrentIndex(1);
ui.animationSpeedCombo->setCurrentIndex(3);
ui.effectSelector->defaults();
ui.compositingType->setCurrentIndex(0);
ui.windowThumbnails->setCurrentIndex(1);
ui.unredirectFullscreen->setChecked(false);
ui.xrScaleFilter->setCurrentIndex(0);
ui.glScaleFilter->setCurrentIndex(2);
ui.glVSync->setChecked(mDefaultPrefs.enableVSync());
ui.glShaders->setChecked(true);
}
QString KWinCompositingConfig::quickHelp() const
{
return i18n("<h1>Desktop Effects</h1>");
}
} // namespace
#include "main.moc"
Reference in a new issue View git blame Copy permalink