yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/kcmkwin/kwinscreenedges/main.cpp
Lucas Murray 0ffcc70c18 Add support for hardcoded non-KWin-related active screen edge actions, 
first to be added is one to display the Plasma dashboard. Implemented
the "trigger cooldown" option. Fixed a few edge action conflicts such
as forcing desktop switches when moving windows and the like.
BUG: 170393

svn path=/trunk/KDE/kdebase/workspace/; revision=933166
2009-02-28 08:33:16 +00:00

459 lines
17 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2008 Martin Gräßlin <kde@martin-graesslin.com>
Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
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 "kdebug.h"
#include "main.h"
#include <kservicetypetrader.h>
#include <KPluginFactory>
#include <KPluginLoader>
#include <QtDBus/QtDBus>
K_PLUGIN_FACTORY( KWinScreenEdgesConfigFactory, registerPlugin<KWin::KWinScreenEdgesConfig>(); )
K_EXPORT_PLUGIN( KWinScreenEdgesConfigFactory( "kcmkwinscreenedges" ))
namespace KWin
{
KWinScreenEdgesConfigForm::KWinScreenEdgesConfigForm( QWidget* parent )
: QWidget( parent )
{
setupUi( this );
}
KWinScreenEdgesConfig::KWinScreenEdgesConfig( QWidget* parent, const QVariantList& args )
: KCModule( KWinScreenEdgesConfigFactory::componentData(), parent, args )
, m_config( KSharedConfig::openConfig( "kwinrc" ))
{
m_ui = new KWinScreenEdgesConfigForm( this );
QVBoxLayout* layout = new QVBoxLayout( this );
layout->addWidget( m_ui );
monitorInit();
connect( m_ui->monitor, SIGNAL( changed() ), this, SLOT( changed() ));
connect( m_ui->monitor, SIGNAL( edgeSelectionChanged(int,int) ),
this, SLOT( monitorEdgeChanged(int,int) ));
connect( m_ui->desktopSwitchCombo, SIGNAL( currentIndexChanged(int) ), this, SLOT( changed() ));
connect( m_ui->quickTileBox, SIGNAL( stateChanged(int) ), this, SLOT( changed() ));
connect( m_ui->quickMaximizeBox, SIGNAL( stateChanged(int) ), this, SLOT( changed() ));
connect( m_ui->activationDelaySpin, SIGNAL( valueChanged(int) ), this, SLOT( changed() ));
connect( m_ui->triggerCooldownSpin, SIGNAL( valueChanged(int) ), this, SLOT( changed() ));
// Visual feedback of action group conflicts
connect( m_ui->desktopSwitchCombo, SIGNAL( currentIndexChanged(int) ), this, SLOT( groupChanged() ));
connect( m_ui->quickTileBox, SIGNAL( stateChanged(int) ), this, SLOT( groupChanged() ));
connect( m_ui->quickMaximizeBox, SIGNAL( stateChanged(int) ), this, SLOT( groupChanged() ));
if( CompositingPrefs::compositingPossible() )
m_defaultPrefs.detect(); // Driver-specific config detection
load();
}
KWinScreenEdgesConfig::~KWinScreenEdgesConfig()
{
}
void KWinScreenEdgesConfig::groupChanged()
{
// Monitor conflicts
bool hide = false;
if( m_ui->desktopSwitchCombo->currentIndex() == 2 )
hide = true;
monitorHideEdge( ElectricTop, hide || m_ui->quickMaximizeBox->isChecked() );
monitorHideEdge( ElectricRight, hide || m_ui->quickTileBox->isChecked() );
monitorHideEdge( ElectricBottom, hide );
monitorHideEdge( ElectricLeft, hide || m_ui->quickTileBox->isChecked() );
// Desktop switch conflicts
if( m_ui->quickTileBox->isChecked() || m_ui->quickMaximizeBox->isChecked() )
{
m_ui->desktopSwitchLabel->setEnabled( false );
m_ui->desktopSwitchCombo->setEnabled( false );
m_ui->desktopSwitchCombo->setCurrentIndex( 0 );
}
else
{
m_ui->desktopSwitchLabel->setEnabled( true );
m_ui->desktopSwitchCombo->setEnabled( true );
}
}
void KWinScreenEdgesConfig::load()
{
KCModule::load();
monitorLoad();
KConfigGroup config( m_config, "Windows" );
m_ui->desktopSwitchCombo->setCurrentIndex( config.readEntry( "ElectricBorders", 0 ));
m_ui->quickTileBox->setChecked( config.readEntry( "QuickTile", false ));
m_ui->quickMaximizeBox->setChecked( config.readEntry( "QuickMaximize", false ));
m_ui->activationDelaySpin->setValue( config.readEntry( "ElectricBorderDelay", 150 ));
m_ui->triggerCooldownSpin->setValue( config.readEntry( "ElectricBorderCooldown", 350 ));
emit changed( false );
}
void KWinScreenEdgesConfig::save()
{
KCModule::save();
monitorSave();
KConfigGroup config( m_config, "Windows" );
config.writeEntry( "ElectricBorders", m_ui->desktopSwitchCombo->currentIndex() );
config.writeEntry( "QuickTile", m_ui->quickTileBox->isChecked() );
config.writeEntry( "QuickMaximize", m_ui->quickMaximizeBox->isChecked() );
config.writeEntry( "ElectricBorderDelay", m_ui->activationDelaySpin->value() );
config.writeEntry( "ElectricBorderCooldown", m_ui->triggerCooldownSpin->value() );
config.sync();
// Reload KWin.
QDBusMessage message = QDBusMessage::createSignal( "/KWin", "org.kde.KWin", "reloadConfig" );
QDBusConnection::sessionBus().send( message );
emit changed( false );
}
void KWinScreenEdgesConfig::defaults()
{
monitorDefaults();
m_ui->desktopSwitchCombo->setCurrentIndex( 0 );
m_ui->quickTileBox->setChecked( false );
m_ui->quickMaximizeBox->setChecked( false );
m_ui->activationDelaySpin->setValue( 150 );
m_ui->triggerCooldownSpin->setValue( 350 );
emit changed( true );
}
void KWinScreenEdgesConfig::showEvent( QShowEvent* e )
{
KCModule::showEvent( e );
monitorShowEvent();
}
// Copied from kcmkwin/kwincompositing/main.cpp
bool KWinScreenEdgesConfig::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());
}
//-----------------------------------------------------------------------------
// Monitor
void KWinScreenEdgesConfig::monitorAddItem( const QString& item )
{
for( int i = 0; i < 8; i++ )
m_ui->monitor->addEdgeItem( i, item );
}
void KWinScreenEdgesConfig::monitorItemSetEnabled( int index, bool enabled )
{
for( int i = 0; i < 8; i++ )
m_ui->monitor->setEdgeItemEnabled( i, index, enabled );
}
void KWinScreenEdgesConfig::monitorInit()
{
monitorAddItem( i18n( "No Action" ));
monitorAddItem( i18n( "Show Dashboard" ));
// Search the effect names
KServiceTypeTrader* trader = KServiceTypeTrader::self();
KService::List services;
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_presentwindows'" );
if( services.isEmpty() )
abort(); // Crash is better than wrong IDs
monitorAddItem( services.first()->name() + " - " + i18n( "All Desktops" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Current Desktop" ));
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_desktopgrid'" );
if( services.isEmpty() )
abort(); // Crash is better than wrong IDs
monitorAddItem( services.first()->name());
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_cube'" );
if( services.isEmpty() )
abort(); // Crash is better than wrong IDs
monitorAddItem( services.first()->name() + " - " + i18n( "Cube" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Cylinder" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Sphere" ));
monitorShowEvent();
}
void KWinScreenEdgesConfig::monitorLoadAction( ElectricBorder edge, const QString& configName )
{
KConfigGroup config( m_config, "ElectricBorders" );
QString lowerName = config.readEntry( configName, "None" ).toLower();
if( lowerName == "dashboard" ) monitorChangeEdge( edge, int( ElectricActionDashboard ));
}
void KWinScreenEdgesConfig::monitorLoad()
{
// Load ElectricBorderActions
monitorLoadAction( ElectricTop, "Top" );
monitorLoadAction( ElectricTopRight, "TopRight" );
monitorLoadAction( ElectricRight, "Right" );
monitorLoadAction( ElectricBottomRight, "BottomRight" );
monitorLoadAction( ElectricBottom, "Bottom" );
monitorLoadAction( ElectricBottomLeft, "BottomLeft" );
monitorLoadAction( ElectricLeft, "Left" );
monitorLoadAction( ElectricTopLeft, "TopLeft" );
// Load effect-specific actions:
// Present Windows
KConfigGroup presentWindowsConfig( m_config, "Effect-PresentWindows" );
monitorChangeEdge(
ElectricBorder( presentWindowsConfig.readEntry( "BorderActivateAll", int( ElectricTopLeft ))),
int( PresentWindowsAll ));
monitorChangeEdge(
ElectricBorder( presentWindowsConfig.readEntry( "BorderActivate", int( ElectricNone ))),
int( PresentWindowsCurrent ));
// Desktop Grid
KConfigGroup gridConfig( m_config, "Effect-DesktopGrid" );
monitorChangeEdge(
ElectricBorder( gridConfig.readEntry( "BorderActivate", int( ElectricNone ))),
int( DesktopGrid ));
// Desktop Cube
KConfigGroup cubeConfig( m_config, "Effect-Cube" );
monitorChangeEdge(
ElectricBorder( cubeConfig.readEntry( "BorderActivate", int( ElectricNone ))),
int( Cube ));
monitorChangeEdge(
ElectricBorder( cubeConfig.readEntry( "BorderActivateCylinder", int( ElectricNone ))),
int( Cylinder ));
monitorChangeEdge(
ElectricBorder( cubeConfig.readEntry( "BorderActivateSphere", int( ElectricNone ))),
int( Sphere ));
}
void KWinScreenEdgesConfig::monitorSaveAction( int edge, const QString& configName )
{
KConfigGroup config( m_config, "ElectricBorders" );
int item = m_ui->monitor->selectedEdgeItem( edge );
if( item == 1 ) // Plasma dashboard
config.writeEntry( configName, "Dashboard" );
else // Anything else
config.writeEntry( configName, "None" );
}
void KWinScreenEdgesConfig::monitorSave()
{
// Save ElectricBorderActions
monitorSaveAction( int( Monitor::Top ), "Top" );
monitorSaveAction( int( Monitor::TopRight ), "TopRight" );
monitorSaveAction( int( Monitor::Right ), "Right" );
monitorSaveAction( int( Monitor::BottomRight ), "BottomRight" );
monitorSaveAction( int( Monitor::Bottom ), "Bottom" );
monitorSaveAction( int( Monitor::BottomLeft ), "BottomLeft" );
monitorSaveAction( int( Monitor::Left ), "Left" );
monitorSaveAction( int( Monitor::TopLeft ), "TopLeft" );
// Save effect-specific actions:
// Present Windows
KConfigGroup presentWindowsConfig( m_config, "Effect-PresentWindows" );
presentWindowsConfig.writeEntry( "BorderActivateAll",
int( monitorCheckEffectHasEdge( int( PresentWindowsAll ))));
presentWindowsConfig.writeEntry( "BorderActivate",
int( monitorCheckEffectHasEdge( int( PresentWindowsCurrent ))));
// Desktop Grid
KConfigGroup gridConfig( m_config, "Effect-DesktopGrid" );
gridConfig.writeEntry( "BorderActivate",
int( monitorCheckEffectHasEdge( int( DesktopGrid ))));
// Desktop Cube
KConfigGroup cubeConfig( m_config, "Effect-Cube" );
cubeConfig.writeEntry( "BorderActivate",
int( monitorCheckEffectHasEdge( int( Cube ))));
cubeConfig.writeEntry( "BorderActivateCylinder",
int( monitorCheckEffectHasEdge( int( Cylinder ))));
cubeConfig.writeEntry( "BorderActivateSphere",
int( monitorCheckEffectHasEdge( int( Sphere ))));
}
void KWinScreenEdgesConfig::monitorDefaults()
{
// Clear all edges
for( int i = 0; i < 8; i++ )
m_ui->monitor->selectEdgeItem( i, 0 );
// Present windows = Top-left
m_ui->monitor->selectEdgeItem( int( Monitor::TopLeft ), int( PresentWindowsAll ));
}
void KWinScreenEdgesConfig::monitorEdgeChanged( int edge, int index )
{
if( index == int( ElectricActionNone ))
return;
for( int i = 0; i < 8; i++ )
{
if( i == edge )
continue;
if( m_ui->monitor->selectedEdgeItem( i ) == index )
m_ui->monitor->selectEdgeItem( i, int( ElectricActionNone ));
}
}
void KWinScreenEdgesConfig::monitorShowEvent()
{
// Check if they are enabled
KConfigGroup config( m_config, "Compositing" );
if( config.readEntry( "Enabled", m_defaultPrefs.enableCompositing() ))
{ // Compositing enabled
config = KConfigGroup( m_config, "Plugins" );
// Present Windows
bool enabled = effectEnabled( "presentwindows", config );
monitorItemSetEnabled( 1, enabled );
monitorItemSetEnabled( 2, enabled );
// Desktop Grid
enabled = effectEnabled( "desktopgrid", config );
monitorItemSetEnabled( 3, enabled );
// Desktop Cube
enabled = effectEnabled( "cube", config );
monitorItemSetEnabled( 4, enabled );
monitorItemSetEnabled( 5, enabled );
monitorItemSetEnabled( 6, enabled );
}
else // Compositing disabled
{
monitorItemSetEnabled( 1, false );
monitorItemSetEnabled( 2, false );
monitorItemSetEnabled( 3, false );
monitorItemSetEnabled( 4, false );
monitorItemSetEnabled( 5, false );
monitorItemSetEnabled( 6, false );
}
}
void KWinScreenEdgesConfig::monitorChangeEdge( ElectricBorder border, int index )
{
switch( border )
{
case ElectricTop:
m_ui->monitor->selectEdgeItem( int( Monitor::Top ), index );
break;
case ElectricTopRight:
m_ui->monitor->selectEdgeItem( int( Monitor::TopRight ), index );
break;
case ElectricRight:
m_ui->monitor->selectEdgeItem( int( Monitor::Right ), index );
break;
case ElectricBottomRight:
m_ui->monitor->selectEdgeItem( int( Monitor::BottomRight ), index );
break;
case ElectricBottom:
m_ui->monitor->selectEdgeItem( int( Monitor::Bottom ), index );
break;
case ElectricBottomLeft:
m_ui->monitor->selectEdgeItem( int( Monitor::BottomLeft ), index );
break;
case ElectricLeft:
m_ui->monitor->selectEdgeItem( int( Monitor::Left ), index );
break;
case ElectricTopLeft:
m_ui->monitor->selectEdgeItem( int( Monitor::TopLeft ), index );
break;
default: // Nothing
break;
}
}
void KWinScreenEdgesConfig::monitorHideEdge( ElectricBorder border, bool hidden )
{
switch( border )
{
case ElectricTop:
m_ui->monitor->setEdgeHidden( int( Monitor::Top ), hidden );
break;
case ElectricTopRight:
m_ui->monitor->setEdgeHidden( int( Monitor::TopRight ), hidden );
break;
case ElectricRight:
m_ui->monitor->setEdgeHidden( int( Monitor::Right ), hidden );
break;
case ElectricBottomRight:
m_ui->monitor->setEdgeHidden( int( Monitor::BottomRight ), hidden );
break;
case ElectricBottom:
m_ui->monitor->setEdgeHidden( int( Monitor::Bottom ), hidden );
break;
case ElectricBottomLeft:
m_ui->monitor->setEdgeHidden( int( Monitor::BottomLeft ), hidden );
break;
case ElectricLeft:
m_ui->monitor->setEdgeHidden( int( Monitor::Left ), hidden );
break;
case ElectricTopLeft:
m_ui->monitor->setEdgeHidden( int( Monitor::TopLeft ), hidden );
break;
default: // Nothing
break;
}
}
ElectricBorder KWinScreenEdgesConfig::monitorCheckEffectHasEdge( int index )
{
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Top )) == index )
return ElectricTop;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::TopRight )) == index )
return ElectricTopRight;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Right )) == index )
return ElectricRight;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::BottomRight )) == index )
return ElectricBottomRight;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Bottom )) == index )
return ElectricBottom;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::BottomLeft )) == index )
return ElectricBottomLeft;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Left )) == index )
return ElectricLeft;
if( m_ui->monitor->selectedEdgeItem( int( Monitor::TopLeft )) == index )
return ElectricTopLeft;
return ElectricNone;
}
} // namespace
#include "main.moc"
Reference in a new issue View git blame Copy permalink