00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
#include "ruleswidget.h"
00020
00021
#include <klineedit.h>
00022
#include <krestrictedline.h>
00023
#include <kcombobox.h>
00024
#include <qcheckbox.h>
00025
#include <kpushbutton.h>
00026
#include <qlabel.h>
00027
#include <kwinmodule.h>
00028
#include <klocale.h>
00029
#include <qregexp.h>
00030
#include <qwhatsthis.h>
00031
#include <assert.h>
00032
#include <kmessagebox.h>
00033
00034
#include "../../rules.h"
00035
00036
#include "detectwidget.h"
00037
00038
namespace KWinInternal
00039 {
00040
00041
#define SETUP( var, type ) \
00042
connect( enable_##var, SIGNAL( toggled( bool )), rule_##var, SLOT( setEnabled( bool ))); \
00043
connect( enable_##var, SIGNAL( toggled( bool )), this, SLOT( updateEnable##var())); \
00044
connect( rule_##var, SIGNAL( activated( int )), this, SLOT( updateEnable##var())); \
00045
QWhatsThis::add( enable_##var, enableDesc ); \
00046
QWhatsThis::add( rule_##var, type##RuleDesc );
00047
00048 RulesWidget::RulesWidget( QWidget* parent,
const char* name )
00049 : RulesWidgetBase( parent, name )
00050 , detect_dlg( NULL )
00051 {
00052 QString enableDesc =
00053 i18n(
"Enable this checkbox to alter this window property for the specified window(s)." );
00054 QString setRuleDesc =
00055 i18n(
"Specify how the window property should be affected:<ul>"
00056
"<li><em>Do Not Affect:</em> The window property will not be affected and therefore"
00057
" the default handling for it will be used. Specifying this will block more generic"
00058
" window settings from taking effect.</li>"
00059
"<li><em>Apply Initially:</em> The window property will be only set to the given value"
00060
" after the window is created. No further changes will be affected.</li>"
00061
"<li><em>Remember:</em> The value of the window property will be remembered and every time"
00062
" time the window is created, the last remembered value will be applied.</li>"
00063
"<li><em>Force:</em> The window property will be always forced to the given value.</li></ul>" );
00064 QString forceRuleDesc =
00065 i18n(
"Specify how the window property should be affected:<ul>"
00066
"<li><em>Do Not Affect:</em> The window property will not be affected and therefore"
00067
" the default handling for it will be used. Specifying this will block more generic"
00068
" window settings from taking effect.</li>"
00069
"<li><em>Force:</em> The window property will be always forced to the given value.</li></ul>" );
00070
00071
00072 SETUP( position, set );
00073 SETUP( size, set );
00074 SETUP( desktop, set );
00075 SETUP( maximizehoriz, set );
00076 SETUP( maximizevert, set );
00077 SETUP( minimize, set );
00078 SETUP( shade, set );
00079 SETUP( fullscreen, set );
00080 SETUP( placement, force );
00081
00082 SETUP( above, set );
00083 SETUP( below, set );
00084 SETUP( noborder, set );
00085 SETUP( skiptaskbar, set );
00086 SETUP( skippager, set );
00087 SETUP( acceptfocus, force );
00088 SETUP( closeable, force );
00089
00090 SETUP( fsplevel, force );
00091 SETUP( moveresizemode, force );
00092 SETUP( type, force );
00093 SETUP( ignoreposition, force );
00094 SETUP( minsize, force );
00095 SETUP( maxsize, force );
00096 KWinModule module;
00097
int i;
00098
for( i = 1;
00099 i <= module.numberOfDesktops();
00100 ++i )
00101
desktop->insertItem( QString::number( i ).rightJustify( 2 ) +
":" + module.desktopName( i ));
00102
for(;
00103 i <= 16;
00104 ++i )
00105
desktop->insertItem( QString::number( i ).rightJustify( 2 ));
00106
desktop->insertItem( i18n(
"All Desktops" ));
00107 }
00108
00109
#undef SETUP
00110
00111
#define UPDATE_ENABLE_SLOT( var ) \
00112
void RulesWidget::updateEnable##var() \
00113
{ \
00114
\
00115 var->setEnabled( enable_##var->isChecked() && rule_##var->currentItem() != 0 ); \
00116 }
00117
00118
00119 UPDATE_ENABLE_SLOT( position )
00120 UPDATE_ENABLE_SLOT( size )
00121 UPDATE_ENABLE_SLOT( desktop )
00122 UPDATE_ENABLE_SLOT( maximizehoriz )
00123 UPDATE_ENABLE_SLOT( maximizevert )
00124 UPDATE_ENABLE_SLOT( minimize )
00125 UPDATE_ENABLE_SLOT( shade )
00126 UPDATE_ENABLE_SLOT( fullscreen )
00127 UPDATE_ENABLE_SLOT( placement )
00128
00129 UPDATE_ENABLE_SLOT( above )
00130 UPDATE_ENABLE_SLOT( below )
00131 UPDATE_ENABLE_SLOT( noborder )
00132 UPDATE_ENABLE_SLOT( skiptaskbar )
00133 UPDATE_ENABLE_SLOT( skippager )
00134 UPDATE_ENABLE_SLOT( acceptfocus )
00135 UPDATE_ENABLE_SLOT( closeable )
00136
00137 UPDATE_ENABLE_SLOT( fsplevel )
00138 UPDATE_ENABLE_SLOT( moveresizemode )
00139 UPDATE_ENABLE_SLOT( type )
00140 UPDATE_ENABLE_SLOT( ignoreposition )
00141 UPDATE_ENABLE_SLOT( minsize )
00142 UPDATE_ENABLE_SLOT( maxsize )
00143
00144 #undef UPDATE_ENABLE_SLOT
00145
00146 static const
int set_rule_to_combo[] =
00147 {
00148 0,
00149 0,
00150 3,
00151 1,
00152 2,
00153 };
00154
00155
static const Rules::SetRule combo_to_set_rule[] =
00156 {
00157 ( Rules::SetRule )Rules::DontAffect,
00158 ( Rules::SetRule )Rules::Apply,
00159 ( Rules::SetRule )Rules::Remember,
00160 ( Rules::SetRule )Rules::Force
00161 };
00162
00163
static const int force_rule_to_combo[] =
00164 {
00165 0,
00166 0,
00167 1
00168 };
00169
00170
static const Rules::ForceRule combo_to_force_rule[] =
00171 {
00172 ( Rules::ForceRule )Rules::DontAffect,
00173 ( Rules::ForceRule )Rules::Force
00174 };
00175
00176
static QString positionToStr(
const QPoint& p )
00177 {
00178
if( p == invalidPoint )
00179
return QString::null;
00180
return QString::number( p.x()) +
"," + QString::number( p.y());
00181 }
00182
00183
static QPoint strToPosition(
const QString& str )
00184 {
00185 QRegExp reg(
"\\s*([+-]?[0-9]*)\\s*[,xX:]\\s*([+-]?[0-9]*)\\s*" );
00186
if( !reg.exactMatch( str ))
00187
return invalidPoint;
00188
return QPoint( reg.cap( 1 ).toInt(), reg.cap( 2 ).toInt());
00189 }
00190
00191
static QString sizeToStr(
const QSize& s )
00192 {
00193
if( !s.isValid())
00194
return QString::null;
00195
return QString::number( s.width()) +
"," + QString::number( s.height());
00196 }
00197
00198
static QSize strToSize(
const QString& str )
00199 {
00200 QRegExp reg(
"\\s*([+-]?[0-9]*)\\s*[,xX:]\\s*([+-]?[0-9]*)\\s*" );
00201
if( !reg.exactMatch( str ))
00202
return QSize();
00203
return QSize( reg.cap( 1 ).toInt(), reg.cap( 2 ).toInt());
00204 }
00205
00206
00207
static int desktopToCombo(
int desktop )
00208 {
00209
if( desktop >= 1 && desktop <= 16 )
00210
return desktop - 1;
00211
return 16;
00212 }
00213
00214
static int comboToDesktop(
int val )
00215 {
00216
if( val == 16 )
00217
return NET::OnAllDesktops;
00218
return val + 1;
00219 }
00220
00221
static int placementToCombo( Placement::Policy placement )
00222 {
00223
static const int conv[] =
00224 {
00225 1,
00226 0,
00227 5,
00228 2,
00229 3,
00230 4,
00231 6,
00232 7,
00233 8
00234 };
00235
return conv[ placement ];
00236 }
00237
00238
static Placement::Policy comboToPlacement(
int val )
00239 {
00240
static const Placement::Policy conv[] =
00241 {
00242 Placement::Default,
00243 Placement::NoPlacement,
00244 Placement::Smart,
00245 Placement::Cascade,
00246 Placement::Centered,
00247 Placement::Random,
00248 Placement::ZeroCornered,
00249 Placement::UnderMouse,
00250 Placement::OnMainWindow
00251 };
00252
return conv[ val ];
00253 }
00254
00255
static int moveresizeToCombo( Options::MoveResizeMode mode )
00256 {
00257
return mode == Options::Opaque ? 0 : 1;
00258 }
00259
00260
static Options::MoveResizeMode comboToMoveResize(
int val )
00261 {
00262
return val == 0 ? Options::Opaque : Options::Transparent;
00263 }
00264
00265
static int typeToCombo( NET::WindowType type )
00266 {
00267
if( type < NET::Normal || type > NET::Splash )
00268
return 0;
00269
static const int conv[] =
00270 {
00271 0,
00272 7,
00273 3,
00274 4,
00275 5,
00276 1,
00277 8,
00278 9,
00279 2,
00280 6
00281 };
00282
return conv[ type ];
00283 }
00284
00285
static NET::WindowType comboToType(
int val )
00286 {
00287
static const NET::WindowType conv[] =
00288 {
00289 NET::Normal,
00290 NET::Dialog,
00291 NET::Utility,
00292 NET::Dock,
00293 NET::Toolbar,
00294 NET::Menu,
00295 NET::Splash,
00296 NET::Desktop,
00297 NET::Override,
00298 NET::TopMenu
00299 };
00300
return conv[ val ];
00301 }
00302
00303
#define GENERIC_RULE( var, func, Type, type, uimethod, uimethod0 ) \
00304
if( rules->var##rule == Rules::Unused##Type##Rule ) \
00305
{ \
00306
enable_##var->setChecked( false ); \
00307
rule_##var->setCurrentItem( 0 ); \
00308
var->uimethod0; \
00309
updateEnable##var(); \
00310
} \
00311
else \
00312
{ \
00313
enable_##var->setChecked( true ); \
00314
rule_##var->setCurrentItem( type##_rule_to_combo[ rules->var##rule ] ); \
00315
var->uimethod( func( rules->var )); \
00316
updateEnable##var(); \
00317
}
00318
00319
#define CHECKBOX_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, setChecked, setChecked( false ))
00320
#define LINEEDIT_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, setText, setText( "" ))
00321
#define COMBOBOX_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, setCurrentItem, setCurrentItem( 0 ))
00322
#define CHECKBOX_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, setChecked, setChecked( false ))
00323
#define LINEEDIT_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, setText, setText( "" ))
00324
#define COMBOBOX_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, setCurrentItem, setCurrentItem( 0 ))
00325
00326
void RulesWidget::setRules( Rules* rules )
00327 {
00328 Rules tmp;
00329
if( rules == NULL )
00330 rules = &tmp;
00331 description->setText( rules->description );
00332 wmclass->setText( rules->wmclass );
00333 whole_wmclass->setChecked( rules->wmclasscomplete );
00334 wmclass_match->setCurrentItem( rules->wmclassmatch );
00335 wmclassMatchChanged();
00336 role->setText( rules->windowrole );
00337 role_match->setCurrentItem( rules->windowrolematch );
00338 roleMatchChanged();
00339 types->setSelected( 0, rules->types & NET::NormalMask );
00340 types->setSelected( 1, rules->types & NET::DialogMask );
00341 types->setSelected( 2, rules->types & NET::UtilityMask );
00342 types->setSelected( 3, rules->types & NET::DockMask );
00343 types->setSelected( 4, rules->types & NET::ToolbarMask );
00344 types->setSelected( 5, rules->types & NET::MenuMask );
00345 types->setSelected( 6, rules->types & NET::SplashMask );
00346 types->setSelected( 7, rules->types & NET::DesktopMask );
00347 types->setSelected( 8, rules->types & NET::OverrideMask );
00348 types->setSelected( 9, rules->types & NET::TopMenuMask );
00349 title->setText( rules->title );
00350 title_match->setCurrentItem( rules->titlematch );
00351 titleMatchChanged();
00352 extra->setText( rules->extrarole );
00353 extra_match->setCurrentItem( rules->extrarolematch );
00354 extraMatchChanged();
00355 machine->setText( rules->clientmachine );
00356 machine_match->setCurrentItem( rules->clientmachinematch );
00357 machineMatchChanged();
00358 LINEEDIT_SET_RULE( position, positionToStr );
00359 LINEEDIT_SET_RULE( size, sizeToStr );
00360 COMBOBOX_SET_RULE( desktop, desktopToCombo );
00361 CHECKBOX_SET_RULE( maximizehoriz, );
00362 CHECKBOX_SET_RULE( maximizevert, );
00363 CHECKBOX_SET_RULE( minimize, );
00364 CHECKBOX_SET_RULE( shade, );
00365 CHECKBOX_SET_RULE( fullscreen, );
00366 COMBOBOX_FORCE_RULE( placement, placementToCombo );
00367 CHECKBOX_SET_RULE( above, );
00368 CHECKBOX_SET_RULE( below, );
00369 CHECKBOX_SET_RULE( noborder, );
00370 CHECKBOX_SET_RULE( skiptaskbar, );
00371 CHECKBOX_SET_RULE( skippager, );
00372 CHECKBOX_FORCE_RULE( acceptfocus, );
00373 CHECKBOX_FORCE_RULE( closeable, );
00374 COMBOBOX_FORCE_RULE( fsplevel, );
00375 COMBOBOX_FORCE_RULE( moveresizemode, moveresizeToCombo );
00376 COMBOBOX_FORCE_RULE( type, typeToCombo );
00377 CHECKBOX_FORCE_RULE( ignoreposition, );
00378 LINEEDIT_FORCE_RULE( minsize, sizeToStr );
00379 LINEEDIT_FORCE_RULE( maxsize, sizeToStr );
00380 }
00381
00382
#undef GENERIC_RULE
00383
#undef CHECKBOX_SET_RULE
00384
#undef LINEEDIT_SET_RULE
00385
#undef COMBOBOX_SET_RULE
00386
#undef CHECKBOX_FORCE_RULE
00387
#undef LINEEDIT_FORCE_RULE
00388
#undef COMBOBOX_FORCE_RULE
00389
00390
#define GENERIC_RULE( var, func, Type, type, uimethod ) \
00391
if( enable_##var->isChecked()) \
00392
{ \
00393
rules->var##rule = combo_to_##type##_rule[ rule_##var->currentItem() ]; \
00394
rules->var = func( var->uimethod()); \
00395
} \
00396
else \
00397
rules->var##rule = Rules::Unused##Type##Rule;
00398
00399
#define CHECKBOX_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, isChecked )
00400
#define LINEEDIT_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, text )
00401
#define COMBOBOX_SET_RULE( var, func ) GENERIC_RULE( var, func, Set, set, currentItem )
00402
#define CHECKBOX_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, isChecked )
00403
#define LINEEDIT_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, text )
00404
#define COMBOBOX_FORCE_RULE( var, func ) GENERIC_RULE( var, func, Force, force, currentItem )
00405
00406 Rules* RulesWidget::rules()
const
00407
{
00408 Rules* rules =
new Rules();
00409 rules->description = description->text();
00410 rules->wmclass = wmclass->text().utf8();
00411 rules->wmclasscomplete = whole_wmclass->isChecked();
00412 rules->wmclassmatch = static_cast< Rules::StringMatch >( wmclass_match->currentItem());
00413 rules->windowrole = role->text().utf8();
00414 rules->windowrolematch = static_cast< Rules::StringMatch >( role_match->currentItem());
00415 rules->types = 0;
00416
bool all_types =
true;
00417
for(
unsigned int i = 0;
00418 i < types->count();
00419 ++i )
00420
if( !types->isSelected( i ))
00421 all_types =
false;
00422
if( all_types )
00423 rules->types = NET::AllTypesMask;
00424
else
00425 {
00426 rules->types |= types->isSelected( 0 ) ? NET::NormalMask : 0;
00427 rules->types |= types->isSelected( 1 ) ? NET::DialogMask : 0;
00428 rules->types |= types->isSelected( 2 ) ? NET::UtilityMask : 0;
00429 rules->types |= types->isSelected( 3 ) ? NET::DockMask : 0;
00430 rules->types |= types->isSelected( 4 ) ? NET::ToolbarMask : 0;
00431 rules->types |= types->isSelected( 5 ) ? NET::MenuMask : 0;
00432 rules->types |= types->isSelected( 6 ) ? NET::SplashMask : 0;
00433 rules->types |= types->isSelected( 7 ) ? NET::DesktopMask : 0;
00434 rules->types |= types->isSelected( 8 ) ? NET::OverrideMask : 0;
00435 rules->types |= types->isSelected( 9 ) ? NET::TopMenuMask : 0;
00436 }
00437 rules->title = title->text();
00438 rules->titlematch = static_cast< Rules::StringMatch >( title_match->currentItem());
00439 rules->extrarole = extra->text().utf8();
00440 rules->extrarolematch = static_cast< Rules::StringMatch >( extra_match->currentItem());
00441 rules->clientmachine = machine->text().utf8();
00442 rules->clientmachinematch = static_cast< Rules::StringMatch >( machine_match->currentItem());
00443 LINEEDIT_SET_RULE( position, strToPosition );
00444 LINEEDIT_SET_RULE( size, strToSize );
00445 COMBOBOX_SET_RULE( desktop, comboToDesktop );
00446 CHECKBOX_SET_RULE( maximizehoriz, );
00447 CHECKBOX_SET_RULE( maximizevert, );
00448 CHECKBOX_SET_RULE( minimize, );
00449 CHECKBOX_SET_RULE( shade, );
00450 CHECKBOX_SET_RULE( fullscreen, );
00451 COMBOBOX_FORCE_RULE( placement, comboToPlacement );
00452 CHECKBOX_SET_RULE( above, );
00453 CHECKBOX_SET_RULE( below, );
00454 CHECKBOX_SET_RULE( noborder, );
00455 CHECKBOX_SET_RULE( skiptaskbar, );
00456 CHECKBOX_SET_RULE( skippager, );
00457 CHECKBOX_FORCE_RULE( acceptfocus, );
00458 CHECKBOX_FORCE_RULE( closeable, );
00459 COMBOBOX_FORCE_RULE( fsplevel, );
00460 COMBOBOX_FORCE_RULE( moveresizemode, comboToMoveResize );
00461 COMBOBOX_FORCE_RULE( type, comboToType );
00462 CHECKBOX_FORCE_RULE( ignoreposition, );
00463 LINEEDIT_FORCE_RULE( minsize, strToSize );
00464 LINEEDIT_FORCE_RULE( maxsize, strToSize );
00465
return rules;
00466 }
00467
00468
#undef GENERIC_RULE
00469
#undef CHECKBOX_SET_RULE
00470
#undef LINEEDIT_SET_RULE
00471
#undef COMBOBOX_SET_RULE
00472
#undef CHECKBOX_FORCE_RULE
00473
#undef LINEEDIT_FORCE_RULE
00474
#undef COMBOBOX_FORCE_RULE
00475
00476
#define STRING_MATCH_COMBO( type ) \
00477
void RulesWidget::type##MatchChanged() \
00478
{ \
00479
edit_reg_##type->setEnabled( type##_match->currentItem() == Rules::RegExpMatch ); \
00480
type->setEnabled( type##_match->currentItem() != Rules::UnimportantMatch ); \
00481
}
00482
00483 STRING_MATCH_COMBO( wmclass )
00484 STRING_MATCH_COMBO( role )
00485 STRING_MATCH_COMBO( title )
00486 STRING_MATCH_COMBO( extra )
00487 STRING_MATCH_COMBO( machine )
00488
00489 #undef STRING_MATCH_COMBO
00490
00491
void RulesWidget::detectClicked()
00492 {
00493 assert( detect_dlg == NULL );
00494 detect_dlg =
new DetectDialog;
00495 connect( detect_dlg, SIGNAL( detectionDone(
bool )),
this, SLOT( detected(
bool )));
00496 detect_dlg->detect( 0 );
00497 }
00498
00499
bool RulesWidget::setWindow( WId w )
00500 {
00501 assert( detect_dlg == NULL );
00502 detect_dlg_ok =
false;
00503 detect_dlg =
new DetectDialog;
00504 connect( detect_dlg, SIGNAL( detectionDone(
bool )),
this, SLOT( detected(
bool )));
00505 detect_dlg->detect( w );
00506
return detect_dlg_ok;
00507 }
00508
00509
#define GENERIC_PREFILL( var, func, info, uimethod ) \
00510
if( !enable_##var->isChecked()) \
00511
{ \
00512
var->uimethod( func( info )); \
00513
}
00514
00515
#define CHECKBOX_PREFILL( var, func, info ) GENERIC_PREFILL( var, func, info, setChecked )
00516
#define LINEEDIT_PREFILL( var, func, info ) GENERIC_PREFILL( var, func, info, setText )
00517
#define COMBOBOX_PREFILL( var, func, info ) GENERIC_PREFILL( var, func, info, setCurrentItem )
00518
00519
void RulesWidget::detected(
bool ok )
00520 {
00521
if( ok )
00522 {
00523 wmclass->setText( detect_dlg->selectedClass());
00524 wmclass_match->setCurrentItem( Rules::ExactMatch );
00525 wmclassMatchChanged();
00526 whole_wmclass->setChecked( detect_dlg->selectedWholeClass());
00527 role->setText( detect_dlg->selectedRole());
00528 role_match->setCurrentItem( detect_dlg->selectedRole().isEmpty()
00529 ? Rules::UnimportantMatch : Rules::ExactMatch );
00530 roleMatchChanged();
00531
if( detect_dlg->selectedWholeApp())
00532 {
00533
for(
unsigned int i = 0;
00534 i < types->count();
00535 ++i )
00536 types->setSelected( i,
true );
00537 }
00538
else
00539 {
00540 NET::WindowType type = detect_dlg->selectedType();
00541
for(
unsigned int i = 0;
00542 i < types->count();
00543 ++i )
00544 types->setSelected( i,
false );
00545 types->setSelected( typeToCombo( type ),
true );
00546 }
00547 title->setText( detect_dlg->selectedTitle());
00548 title_match->setCurrentItem( detect_dlg->titleMatch());
00549 titleMatchChanged();
00550 machine->setText( detect_dlg->selectedMachine());
00551 machine_match->setCurrentItem( Rules::UnimportantMatch );
00552 machineMatchChanged();
00553
00554
const KWin::WindowInfo& info = detect_dlg->windowInfo();
00555 LINEEDIT_PREFILL( position, positionToStr, info.frameGeometry().topLeft() );
00556 LINEEDIT_PREFILL( size, sizeToStr, info.frameGeometry().size() );
00557 COMBOBOX_PREFILL( desktop, desktopToCombo, info.desktop() );
00558 CHECKBOX_PREFILL( maximizehoriz,, info.state() & NET::MaxHoriz );
00559 CHECKBOX_PREFILL( maximizevert,, info.state() & NET::MaxVert );
00560 CHECKBOX_PREFILL( minimize,, info.isMinimized() );
00561 CHECKBOX_PREFILL( shade,, info.state() & NET::Shaded );
00562 CHECKBOX_PREFILL( fullscreen,, info.state() & NET::FullScreen );
00563
00564 CHECKBOX_PREFILL( above,, info.state() & NET::KeepAbove );
00565 CHECKBOX_PREFILL( below,, info.state() & NET::KeepBelow );
00566
00567 CHECKBOX_PREFILL( noborder,, info.frameGeometry() == info.geometry() );
00568 CHECKBOX_PREFILL( skiptaskbar,, info.state() & NET::SkipTaskbar );
00569 CHECKBOX_PREFILL( skippager,, info.state() & NET::SkipPager );
00570
00571
00572
00573
00574 COMBOBOX_PREFILL( type, typeToCombo, info.windowType( SUPPORTED_WINDOW_TYPES_MASK ) );
00575
00576 LINEEDIT_PREFILL( minsize, sizeToStr, info.frameGeometry().size() );
00577 LINEEDIT_PREFILL( maxsize, sizeToStr, info.frameGeometry().size() );
00578 }
00579
delete detect_dlg;
00580 detect_dlg = NULL;
00581 detect_dlg_ok = ok;
00582 }
00583
00584
#undef GENERIC_PREFILL
00585
#undef CHECKBOX_PREFILL
00586
#undef LINEEDIT_PREFILL
00587
#undef COMBOBOX_PREFILL
00588
00589
bool RulesWidget::finalCheck()
00590 {
00591
if( description->text().isEmpty())
00592 {
00593
if( !wmclass->text().isEmpty())
00594 description->setText( i18n(
"Settings for %1" ).arg( wmclass->text()));
00595
else
00596 description->setText( i18n(
"Unnamed entry" ));
00597 }
00598
bool all_types =
true;
00599
for(
unsigned int i = 0;
00600 i < types->count();
00601 ++i )
00602
if( !types->isSelected( i ))
00603 all_types =
false;
00604
if( wmclass_match->currentItem() == Rules::UnimportantMatch && all_types )
00605 {
00606
if( KMessageBox::warningContinueCancel( topLevelWidget(),
00607 i18n(
"You have specified the window class as unimportant.\n"
00608
"This means the settings will possibly apply to windows from all applications. "
00609
"If you really want to create a generic setting, it is recommended you at least "
00610
"limit the window types to avoid special window types." )) != KMessageBox::Continue )
00611
return false;
00612 }
00613
return true;
00614 }
00615
00616 RulesDialog::RulesDialog( QWidget* parent,
const char* name )
00617 : KDialogBase( parent, name, true,
"", Ok | Cancel )
00618 {
00619 widget =
new RulesWidget(
this );
00620 setMainWidget( widget );
00621 }
00622
00623 Rules* RulesDialog::edit( Rules* r, WId w )
00624 {
00625 rules = r;
00626 widget->setRules( rules );
00627
if( rules == NULL && w != 0 )
00628
if( !widget->setWindow( w ))
00629
return rules;
00630 exec();
00631
return rules;
00632 }
00633
00634
void RulesDialog::accept()
00635 {
00636
if( !widget->finalCheck())
00637
return;
00638 rules = widget->rules();
00639 KDialogBase::accept();
00640 }
00641
00642 }
00643
00644
#include "ruleswidget.moc"