yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/kcmkwin/kwinscreenedges/main.cpp
Lucas Murray 41e5bfd793 Change how quick tiling and maximization is activated slightly. Instead 
of using electric borders just check the location of the cursor; if the
cursor is near the edge enable the resize snap. This makes the features
easier to activate, removes the conflict with desktop switching and
allows the features to be used completely on multi-screen systems.
Patch inspired by one from Marcel Schaal.
BUG: 218957

svn path=/trunk/KDE/kdebase/workspace/; revision=1071996
2010-01-09 09:49:52 +00:00

541 lines
20 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->desktopSwitchCombo, SIGNAL( currentIndexChanged(int) ), this, SLOT( changed() ));
connect( m_ui->activationDelaySpin, SIGNAL( valueChanged(int) ), this, SLOT( changed() ));
connect( m_ui->triggerCooldownSpin, SIGNAL( valueChanged(int) ), this, SLOT( changed() ));
connect( m_ui->quickMaximizeBox, SIGNAL( stateChanged(int) ), this, SLOT( changed() ));
connect( m_ui->quickTileBox, SIGNAL( stateChanged(int) ), this, SLOT( changed() ));
// Visual feedback of action group conflicts
connect( m_ui->desktopSwitchCombo, SIGNAL( currentIndexChanged(int) ), this, SLOT( groupChanged() ));
connect( m_ui->quickMaximizeBox, SIGNAL( stateChanged(int) ), this, SLOT( groupChanged() ));
connect( m_ui->quickTileBox, SIGNAL( stateChanged(int) ), this, SLOT( groupChanged() ));
// NOTICE: this is intended to workaround broken GL implementations that successfully segfault on glXQuery :-(
KConfigGroup gl_workaround_config(m_config, "Compositing");
const bool checkIsSafe = gl_workaround_config.readEntry("CheckIsSafe", true);
if( checkIsSafe && CompositingPrefs::compositingPossible() )
{
gl_workaround_config.writeEntry("CheckIsSafe", false);
gl_workaround_config.sync();
m_defaultPrefs.detect(); // Driver-specific config detection
gl_workaround_config.writeEntry("CheckIsSafe", true);
gl_workaround_config.sync();
}
load();
}
KWinScreenEdgesConfig::~KWinScreenEdgesConfig()
{
}
void KWinScreenEdgesConfig::groupChanged()
{
// Monitor conflicts
bool hide = false;
if( m_ui->desktopSwitchCombo->currentIndex() == 2 )
hide = true;
monitorHideEdge( ElectricTop, hide );
monitorHideEdge( ElectricRight, hide );
monitorHideEdge( ElectricBottom, hide );
monitorHideEdge( ElectricLeft, hide );
}
void KWinScreenEdgesConfig::load()
{
KCModule::load();
monitorLoad();
KConfigGroup config( m_config, "Windows" );
m_ui->desktopSwitchCombo->setCurrentIndex( config.readEntry( "ElectricBorders", 0 ));
m_ui->activationDelaySpin->setValue( config.readEntry( "ElectricBorderDelay", 150 ));
m_ui->triggerCooldownSpin->setValue( config.readEntry( "ElectricBorderCooldown", 350 ));
m_ui->quickMaximizeBox->setChecked( config.readEntry( "ElectricBorderMaximize", true ));
m_ui->quickTileBox->setChecked( config.readEntry( "ElectricBorderTiling", true ));
emit changed( false );
}
void KWinScreenEdgesConfig::save()
{
KCModule::save();
monitorSave();
KConfigGroup config( m_config, "Windows" );
config.writeEntry( "ElectricBorders", m_ui->desktopSwitchCombo->currentIndex() );
config.writeEntry( "ElectricBorderDelay", m_ui->activationDelaySpin->value() );
config.writeEntry( "ElectricBorderCooldown", m_ui->triggerCooldownSpin->value() );
config.writeEntry( "ElectricBorderMaximize", m_ui->quickMaximizeBox->isChecked() );
config.writeEntry( "ElectricBorderTiling", m_ui->quickTileBox->isChecked() );
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->activationDelaySpin->setValue( 150 );
m_ui->triggerCooldownSpin->setValue( 350 );
m_ui->quickMaximizeBox->setChecked( true );
m_ui->quickTileBox->setChecked( true );
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" ));
monitorAddItem( i18n( "Show Desktop" ));
// 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() )
{
// adding empty strings in case the effect is not found
// TODO: after string freeze add a info that the effect is missing
monitorAddItem( QString() );
monitorAddItem( QString() );
}
else
{
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() )
{
// adding empty strings in case the effect is not found
// TODO: after string freeze add a info that the effect is missing
monitorAddItem( QString() );
}
else
{
monitorAddItem( services.first()->name());
}
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_cube'" );
if( services.isEmpty() )
{
// adding empty strings in case the effect is not found
// TODO: after string freeze add a info that the effect is missing
monitorAddItem( QString() );
monitorAddItem( QString() );
monitorAddItem( QString() );
}
else
{
monitorAddItem( services.first()->name() + " - " + i18n( "Cube" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Cylinder" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Sphere" ));
}
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_flipswitch'" );
if( services.isEmpty() )
{
// adding empty strings in case the effect is not found
// TODO: after string freeze add a info that the effect is missing
monitorAddItem( QString() );
monitorAddItem( QString() );
}
else
{
monitorAddItem( services.first()->name() + " - " + i18n( "All Desktops" ));
monitorAddItem( services.first()->name() + " - " + i18n( "Current Desktop" ));
}
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" );
QList<int> list = QList<int>();
// PresentWindows BorderActivateAll
list.append( int( ElectricTopLeft ) );
list = presentWindowsConfig.readEntry( "BorderActivateAll", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( PresentWindowsAll ) );
}
// PresentWindows BorderActivate
list.clear();
list.append( int( ElectricNone ) );
list = presentWindowsConfig.readEntry( "BorderActivate", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( PresentWindowsCurrent ) );
}
// Desktop Grid
KConfigGroup gridConfig( m_config, "Effect-DesktopGrid" );
list.clear();
list.append( int( ElectricNone ) );
list = gridConfig.readEntry( "BorderActivate", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( DesktopGrid ) );
}
// Desktop Cube
KConfigGroup cubeConfig( m_config, "Effect-Cube" );
list.clear();
list.append( int( ElectricNone ) );
list = cubeConfig.readEntry( "BorderActivate", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( Cube ) );
}
list.clear();
list.append( int( ElectricNone ) );
list = cubeConfig.readEntry( "BorderActivateCylinder", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( Cylinder ) );
}
list.clear();
list.append( int( ElectricNone ) );
list = cubeConfig.readEntry( "BorderActivateSphere", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( Sphere ) );
}
// Flip Switch
KConfigGroup flipSwitchConfig( m_config, "Effect-FlipSwitch" );
list.clear();
// FlipSwitch BorderActivateAll
list.append( int( ElectricNone ) );
list = flipSwitchConfig.readEntry( "BorderActivateAll", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( FlipSwitchAll ) );
}
// FlipSwitch BorderActivate
list.clear();
list.append( int( ElectricNone ) );
list = flipSwitchConfig.readEntry( "BorderActivate", list );
foreach( int i, list )
{
monitorChangeEdge( ElectricBorder( i ), int( FlipSwitchCurrent ) );
}
}
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 if( item == 2 )
config.writeEntry( configName, "ShowDesktop" );
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",
monitorCheckEffectHasEdge( int( PresentWindowsAll )));
presentWindowsConfig.writeEntry( "BorderActivate",
monitorCheckEffectHasEdge( int( PresentWindowsCurrent )));
// Desktop Grid
KConfigGroup gridConfig( m_config, "Effect-DesktopGrid" );
gridConfig.writeEntry( "BorderActivate",
monitorCheckEffectHasEdge( int( DesktopGrid )));
// Desktop Cube
KConfigGroup cubeConfig( m_config, "Effect-Cube" );
cubeConfig.writeEntry( "BorderActivate",
monitorCheckEffectHasEdge( int( Cube )));
cubeConfig.writeEntry( "BorderActivateCylinder",
monitorCheckEffectHasEdge( int( Cylinder )));
cubeConfig.writeEntry( "BorderActivateSphere",
monitorCheckEffectHasEdge( int( Sphere )));
// Flip Switch
KConfigGroup flipSwitchConfig( m_config, "Effect-FlipSwitch" );
flipSwitchConfig.writeEntry( "BorderActivateAll",
monitorCheckEffectHasEdge( int( FlipSwitchAll )));
flipSwitchConfig.writeEntry( "BorderActivate",
monitorCheckEffectHasEdge( int( FlipSwitchCurrent )));
}
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::monitorShowEvent()
{
// Check if they are enabled
KConfigGroup config( m_config, "Compositing" );
if( config.readEntry( "Enabled", m_defaultPrefs.recommendCompositing() ))
{ // Compositing enabled
config = KConfigGroup( m_config, "Plugins" );
// Present Windows
bool enabled = effectEnabled( "presentwindows", config );
monitorItemSetEnabled( int( PresentWindowsCurrent ), enabled );
monitorItemSetEnabled( int( PresentWindowsAll ), enabled );
// Desktop Grid
enabled = effectEnabled( "desktopgrid", config );
monitorItemSetEnabled( int( DesktopGrid ), enabled );
// Desktop Cube
enabled = effectEnabled( "cube", config );
monitorItemSetEnabled( int( Cube ), enabled );
monitorItemSetEnabled( int( Cylinder ), enabled );
monitorItemSetEnabled( int( Sphere ), enabled );
// Flip Switch
enabled = effectEnabled( "flipswitch", config );
monitorItemSetEnabled( int( FlipSwitchAll ), enabled );
monitorItemSetEnabled( int( FlipSwitchCurrent ), enabled );
}
else // Compositing disabled
{
monitorItemSetEnabled( int( PresentWindowsCurrent ), false );
monitorItemSetEnabled( int( PresentWindowsAll ), false );
monitorItemSetEnabled( int( DesktopGrid ), false );
monitorItemSetEnabled( int( Cube ), false );
monitorItemSetEnabled( int( Cylinder ), false );
monitorItemSetEnabled( int( Sphere ), false );
monitorItemSetEnabled( int( FlipSwitchAll ), false );
monitorItemSetEnabled( int( FlipSwitchCurrent ), 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;
}
}
QList<int> KWinScreenEdgesConfig::monitorCheckEffectHasEdge( int index ) const
{
QList<int> list = QList<int>();
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Top )) == index )
list.append( int( ElectricTop ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::TopRight )) == index )
list.append( int( ElectricTopRight ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Right )) == index )
list.append( int( ElectricRight ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::BottomRight )) == index )
list.append( int( ElectricBottomRight ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Bottom )) == index )
list.append( int( ElectricBottom ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::BottomLeft )) == index )
list.append( int( ElectricBottomLeft ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::Left )) == index )
list.append( int( ElectricLeft ) );
if( m_ui->monitor->selectedEdgeItem( int( Monitor::TopLeft )) == index )
list.append( int( ElectricTopLeft ) );
if( list.isEmpty() )
list.append( int( ElectricNone ) );
return list;
}
} // namespace
#include "main.moc"
Reference in a new issue View git blame Copy permalink