yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

KWin rules setting maximizevert, maximizehoriz, minimize, shade, skiptaskbar,

Browse source 
skippager, fullscreen, noborder.

svn path=/trunk/kdebase/kwin/; revision=317377
This commit is contained in:
Luboš Luňák 2004-06-03 14:09:45 +00:00
parent 05c003dd28
commit 03bdeb94b0
5 changed files with 154 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
client.cpp
View file

@ -400,6 +400,7 @@ void Client::setUserNoBorder( bool set )
{
if( !userCanSetNoBorder())
return;
set = rules()->checkNoBorder( set );
if( user_noborder == set )
return;
user_noborder = set;
@ -687,6 +688,7 @@ void Client::setShade( ShadeMode mode )
{
if( !isShadeable())
return;
mode = rules()->checkShade( mode );
if( shade_mode == mode )
return;
bool was_shade = isShade();
@ -1053,7 +1055,10 @@ void Client::processKillerExited()
void Client::setSkipTaskbar( bool b, bool from_outside )
{
if( from_outside )
{
b = rules()->checkSkipTaskbar( b );
original_skip_taskbar = b;
}
if ( b == skipTaskbar() )
return;
skip_taskbar = b;
@ -1062,6 +1067,7 @@ void Client::setSkipTaskbar( bool b, bool from_outside )
void Client::setSkipPager( bool b )
{
b = rules()->checkSkipPager( b );
if ( b == skipPager() )
return;
skip_pager = b;

9
geometry.cpp
View file

@ -1665,8 +1665,6 @@ void Client::changeMaximize( bool vertical, bool horizontal, bool adjust )
if( !isMaximizable())
return;
++block_geometry; // TODO GeometryBlocker class?
if( isShade()) // SELI SHADE
setShade( ShadeNone );
@ -1679,6 +1677,12 @@ void Client::changeMaximize( bool vertical, bool horizontal, bool adjust )
if( horizontal )
max_mode = MaximizeMode( max_mode ^ MaximizeHorizontal );
}
max_mode = rules()->checkMaximize( max_mode );
if( !adjust && max_mode == old_mode )
return;
++block_geometry; // TODO GeometryBlocker class?
// maximing one way and unmaximizing the other way shouldn't happen
Q_ASSERT( !( vertical && horizontal )
@ -1846,6 +1850,7 @@ void Client::setFullScreen( bool set, bool user )
return;
if( user && !userCanSetFullScreen())
return;
set = rules()->checkFullScreen( set );
setShade( ShadeNone );
bool was_fs = isFullScreen();
if( !was_fs )

38
manage.cpp
View file

@ -145,6 +145,10 @@ bool Client::manage( Window w, bool isMapped )
setUserNoBorder( true );
}
init_minimize = rules()->checkMinimize( init_minimize, !isMapped );
if( rules()->checkNoBorder( false, !isMapped ))
setUserNoBorder( true );
// initial desktop placement
if ( info->desktop() )
desk = info->desktop(); // window had the initial desktop property!
@ -269,9 +273,9 @@ bool Client::manage( Window w, bool isMapped )
updateDecoration( false ); // also gravitates
// TODO is CentralGravity right here, when resizing is done after gravitating?
plainResize( rules()->checkSize( sizeForClientSize( geom.size()), true ));
plainResize( rules()->checkSize( sizeForClientSize( geom.size()), !isMapped ));
QPoint forced_pos = rules()->checkPosition( invalidPoint, true );
QPoint forced_pos = rules()->checkPosition( invalidPoint, !isMapped );
if( forced_pos != invalidPoint )
{
move( forced_pos );
@ -370,31 +374,27 @@ bool Client::manage( Window w, bool isMapped )
// done after checking that the window isn't larger than the workarea, so that
// the restore geometry from the checks above takes precedence, and window
// isn't restored larger than the workarea
if ( (info->state() & NET::Max) == NET::Max )
maximize( Client::MaximizeFull );
else if ( info->state() & NET::MaxVert )
maximize( Client::MaximizeVertical );
else if ( info->state() & NET::MaxHoriz )
maximize( Client::MaximizeHorizontal );
MaximizeMode maxmode = static_cast< MaximizeMode >
((( info->state() & NET::MaxVert ) ? MaximizeVertical : 0 )
| (( info->state() & NET::MaxHoriz ) ? MaximizeHorizontal : 0 ));
MaximizeMode forced_maxmode = rules()->checkMaximize( maxmode, !isMapped );
// either hints were set to maximize, or is forced to maximize,
// or is forced to non-maximize and hints were set to maximize
if( forced_maxmode != MaximizeRestore || maxmode != MaximizeRestore )
maximize( forced_maxmode );
// read other initial states
if( info->state() & NET::Shaded )
setShade( ShadeNormal );
setShade( rules()->checkShade( info->state() & NET::Shaded ? ShadeNormal : ShadeNone, !isMapped ));
setKeepAbove( rules()->checkKeepAbove( info->state() & NET::KeepAbove, !isMapped ));
setKeepBelow( rules()->checkKeepBelow( info->state() & NET::KeepBelow, !isMapped ));
if( info->state() & NET::SkipTaskbar )
setSkipTaskbar( true, true );
if( info->state() & NET::SkipPager )
setSkipPager( true );
setSkipTaskbar( rules()->checkSkipTaskbar( info->state() & NET::SkipTaskbar, !isMapped ), true );
setSkipPager( rules()->checkSkipPager( info->state() & NET::SkipPager, !isMapped ));
if( info->state() & NET::DemandsAttention )
demandAttention();
if( info->state() & NET::Modal )
setModal( true );
if( fullscreen_mode != FullScreenHack )
{
if(( info->state() & NET::FullScreen ) != 0 && isFullScreenable())
setFullScreen( true, false );
}
if( fullscreen_mode != FullScreenHack && isFullScreenable())
setFullScreen( rules()->checkFullScreen( info->state() & NET::FullScreen, !isMapped ), false );
}
updateAllowedActions( true );

105
rules.cpp
View file

@ -36,8 +36,16 @@ WindowRules::WindowRules()
, maxsizerule( DontCareRule )
, desktoprule( DontCareRule )
, typerule( DontCareRule )
, maximizevertrule( DontCareRule )
, maximizehorizrule( DontCareRule )
, minimizerule( DontCareRule )
, shaderule( DontCareRule )
, skiptaskbarrule( DontCareRule )
, skippagerrule( DontCareRule )
, aboverule( DontCareRule )
, belowrule( DontCareRule )
, fullscreenrule( DontCareRule )
, noborderrule( DontCareRule )
{
}
@ -77,8 +85,16 @@ WindowRules::WindowRules( KConfig& cfg )
READ_SET_RULE( desktop, Num, );
type = readType( cfg, "type" );
typerule = type != NET::Unknown ? readForceRule( cfg, "typerule" ) : DontCareRule;
READ_SET_RULE( maximizevert, Bool, );
READ_SET_RULE( maximizehoriz, Bool, );
READ_SET_RULE( minimize, Bool, );
READ_SET_RULE( shade, Bool, );
READ_SET_RULE( skiptaskbar, Bool, );
READ_SET_RULE( skippager, Bool, );
READ_SET_RULE( above, Bool, );
READ_SET_RULE( below, Bool, );
READ_SET_RULE( fullscreen, Bool, );
READ_SET_RULE( noborder, Bool, );
kdDebug() << "READ RULE:" << wmclass << endl;
}
@ -135,8 +151,16 @@ void WindowRules::write( KConfig& cfg ) const
WRITE_SET_RULE( maxsize, );
WRITE_SET_RULE( desktop, );
WRITE_SET_RULE( type, );
WRITE_SET_RULE( maximizevert, );
WRITE_SET_RULE( maximizehoriz, );
WRITE_SET_RULE( minimize, );
WRITE_SET_RULE( shade, );
WRITE_SET_RULE( skiptaskbar, );
WRITE_SET_RULE( skippager, );
WRITE_SET_RULE( above, );
WRITE_SET_RULE( below, );
WRITE_SET_RULE( fullscreen, );
WRITE_SET_RULE( noborder, );
}
#undef WRITE_MATCH_STRING
@ -222,10 +246,26 @@ void WindowRules::update( Client* c )
size = c->size();
if( desktoprule == RememberRule )
desktop = c->desktop();
if( maximizevertrule == RememberRule )
maximizevert = c->maximizeMode() & MaximizeVertical;
if( maximizehorizrule == RememberRule )
maximizehoriz = c->maximizeMode() & MaximizeHorizontal;
if( minimizerule == RememberRule )
minimize = c->isMinimized();
if( shaderule == RememberRule )
shade = c->shadeMode() != Client::ShadeNone;
if( skiptaskbarrule == RememberRule )
skiptaskbar = c->skipTaskbar();
if( skippagerrule == RememberRule )
skippager = c->skipPager();
if( aboverule == RememberRule )
above = c->keepAbove();
if( belowrule == RememberRule )
below = c->keepBelow();
if( fullscreenrule == RememberRule )
fullscreen = c->isFullScreen();
if( noborderrule == RememberRule )
noborder = c->isUserNoBorder();
}
Placement::Policy WindowRules::checkPlacement( Placement::Policy placement ) const
@ -266,21 +306,66 @@ int WindowRules::checkDesktop( int req_desktop, bool init ) const
return checkRule( desktoprule, init ) ? this->desktop : req_desktop;
}
bool WindowRules::checkKeepAbove( bool req_above, bool init ) const
{
return checkRule( aboverule, init ) ? this->above : req_above;
}
bool WindowRules::checkKeepBelow( bool req_below, bool init ) const
{
return checkRule( belowrule, init ) ? this->below : req_below;
}
NET::WindowType WindowRules::checkType( NET::WindowType req_type ) const
{
return checkForceRule( typerule ) ? this->type : req_type;
}
KDecorationDefines::MaximizeMode WindowRules::checkMaximize( MaximizeMode mode, bool init ) const
{
bool vert = checkRule( maximizevertrule, init ) ? this->maximizevert : bool( mode & MaximizeVertical );
bool horiz = checkRule( maximizehorizrule, init ) ? this->maximizehoriz : bool( mode & MaximizeHorizontal );
return static_cast< MaximizeMode >(( vert ? MaximizeVertical : 0 ) | ( horiz ? MaximizeHorizontal : 0 ));
}
bool WindowRules::checkMinimize( bool minimize, bool init ) const
{
return checkRule( minimizerule, init ) ? this->minimize : minimize;
}
Client::ShadeMode WindowRules::checkShade( Client::ShadeMode shade, bool init ) const
{
if( checkRule( shaderule, init ))
{
if( !this->shade )
return Client::ShadeNone;
if( this->shade && shade == Client::ShadeNone )
return Client::ShadeNormal;
}
return shade;
}
bool WindowRules::checkSkipTaskbar( bool skip, bool init ) const
{
return checkRule( skiptaskbarrule, init ) ? this->skiptaskbar : skip;
}
bool WindowRules::checkSkipPager( bool skip, bool init ) const
{
return checkRule( skippagerrule, init ) ? this->skippager : skip;
}
bool WindowRules::checkKeepAbove( bool above, bool init ) const
{
return checkRule( aboverule, init ) ? this->above : above;
}
bool WindowRules::checkKeepBelow( bool below, bool init ) const
{
return checkRule( belowrule, init ) ? this->below : below;
}
bool WindowRules::checkFullScreen( bool fs, bool init ) const
{
return checkRule( fullscreenrule, init ) ? this->fullscreen : fs;
}
bool WindowRules::checkNoBorder( bool noborder, bool init ) const
{
return checkRule( noborderrule, init ) ? this->noborder : noborder;
}
// Client
void Client::setupWindowRules()

28
rules.h
View file

@ -16,6 +16,8 @@ License. See the file "COPYING" for the exact licensing terms.
#include <qrect.h>
#include "placement.h"
#include "lib/kdecoration.h"
#include "client.h"
class KConfig;
@ -34,6 +36,7 @@ enum SettingRule
};
class WindowRules
: public KDecorationDefines
{
public:
WindowRules();
@ -50,8 +53,15 @@ class WindowRules
QSize checkMaxSize( const QSize& s ) const;
int checkDesktop( int desktop, bool init = false ) const;
NET::WindowType checkType( NET::WindowType type ) const;
MaximizeMode checkMaximize( MaximizeMode mode, bool init = false ) const;
bool checkMinimize( bool minimized, bool init = false ) const;
Client::ShadeMode checkShade( Client::ShadeMode shade, bool init = false ) const;
bool checkSkipTaskbar( bool skip, bool init = false ) const;
bool checkSkipPager( bool skip, bool init = false ) const;
bool checkKeepAbove( bool above, bool init = false ) const;
bool checkKeepBelow( bool above, bool init = false ) const;
bool checkKeepBelow( bool below, bool init = false ) const;
bool checkFullScreen( bool fs, bool init = false ) const;
bool checkNoBorder( bool noborder, bool init = false ) const;
private:
static SettingRule readRule( KConfig&, const QString& key );
static SettingRule readForceRule( KConfig&, const QString& key );
@ -84,10 +94,26 @@ class WindowRules
SettingRule desktoprule;
NET::WindowType type; // type for setting
SettingRule typerule;
bool maximizevert;
SettingRule maximizevertrule;
bool maximizehoriz;
SettingRule maximizehorizrule;
bool minimize;
SettingRule minimizerule;
bool shade;
SettingRule shaderule;
bool skiptaskbar;
SettingRule skiptaskbarrule;
bool skippager;
SettingRule skippagerrule;
bool above;
SettingRule aboverule;
bool below;
SettingRule belowrule;
bool fullscreen;
SettingRule fullscreenrule;
bool noborder;
SettingRule noborderrule;
};
inline