kwin Library API Documentation

ruleswidget.cpp

00001 /*
00002  * Copyright (c) 2004 Lubos Lunak <l.lunak@kde.org>
00003  *
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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     // window tabs have enable signals done in designer
00072     // geometry tab
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     // preferences tab
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     // workarounds tab
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     /* leave the label readable label_##var->setEnabled( enable_##var->isChecked() && rule_##var->currentItem() != 0 );*/ \
00116     var->setEnabled( enable_##var->isChecked() && rule_##var->currentItem() != 0 ); \
00117     }
00118 
00119 // geometry tab
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 // preferences tab
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 // workarounds tab
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, // Unused
00150     0, // Don't Affect
00151     3, // Force
00152     1, // Apply
00153     2, // Remember
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, // Unused
00167     0, // Don't Affect
00168     1 // Force
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     {            // two numbers, with + or -, separated by any of , x X :
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     {            // two numbers, with + or -, separated by any of , x X :
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; // on all desktops
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, // NoPlacement
00227         0, // Default
00228         5, // Random
00229         2, // Smart
00230         3, // Cascade
00231         4, // Centered
00232         6, // ZeroCornered
00233         7, // UnderMouse
00234         8 // OnMainWindow
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; // Normal
00270     static const int conv[] =
00271         {
00272         0, // Normal
00273         7, // Desktop
00274     3, // Dock
00275     4, // Toolbar
00276         5, // Menu
00277     1, // Dialog
00278     8, // Override
00279         9, // TopMenu
00280     2, // Utility
00281     6  // Splash
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; // empty
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 ) // if all types are selected, use AllTypesMask (for future expansion)
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(); // grrr
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         // prefill values from to window to settings which already set
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     //COMBOBOX_PREFILL( placement, placementToCombo );
00564     CHECKBOX_PREFILL( above,, info.state() & NET::KeepAbove );
00565     CHECKBOX_PREFILL( below,, info.state() & NET::KeepBelow );
00566     // noborder is only internal KWin information, so let's guess
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     //CHECKBOX_PREFILL( acceptfocus, );
00571     //CHECKBOX_PREFILL( closeable, );
00572     //COMBOBOX_PREFILL( fsplevel, );
00573     //COMBOBOX_PREFILL( moveresizemode, moveresizeToCombo );
00574     COMBOBOX_PREFILL( type, typeToCombo, info.windowType( SUPPORTED_WINDOW_TYPES_MASK ) );
00575     //CHECKBOX_PREFILL( ignoreposition, );
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 ); // geometry tab, skip tabs for window identification
00615     KWin::WindowInfo info( window, -1U, -1U ); // read everything
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 // window is set only for Alt+F3/Window-specific settings, because the dialog
00627 // is then related to one specific window
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 } // namespace
00647 
00648 #include "ruleswidget.moc"
KDE Logo
This file is part of the documentation for kwin Library Version 3.3.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Sep 8 02:43:21 2005 by doxygen 1.3.6 written by Dimitri van Heesch, © 1997-2003