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