ac9c37c64d
GUI panel. This panel is currently located in System Settings -> Desktop -> Screen Edges. BUG: 174709 svn path=/trunk/KDE/kdebase/workspace/; revision=932929
418 lines
15 KiB
C++
418 lines
15 KiB
C++
/********************************************************************
|
|
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" ));
|
|
|
|
// 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() ) // WARNING: If this is false then all later items will have the 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() ) // WARNING: If this is false then all later items will have the wrong IDs
|
|
monitorAddItem( services.first()->name());
|
|
services = trader->query( "KWin/Effect", "[X-KDE-PluginInfo-Name] == 'kwin4_effect_cube'" );
|
|
if( !services.isEmpty() ) // WARNING: If this is false then all later items will have the wrong IDs
|
|
{
|
|
monitorAddItem( services.first()->name() + " - " + i18n( "Cube" ));
|
|
monitorAddItem( services.first()->name() + " - " + i18n( "Cylinder" ));
|
|
monitorAddItem( services.first()->name() + " - " + i18n( "Sphere" ));
|
|
}
|
|
|
|
monitorShowEvent();
|
|
}
|
|
|
|
void KWinScreenEdgesConfig::monitorLoad()
|
|
{
|
|
// 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::monitorSave()
|
|
{
|
|
// 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( NoEffect ))
|
|
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( NoEffect ));
|
|
}
|
|
}
|
|
|
|
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"
|