00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "kdialogbase.h"
00025 #include <stdlib.h>
00026
00027 #include <qgrid.h>
00028 #include <qhbox.h>
00029 #include <qlayout.h>
00030 #include <qtooltip.h>
00031 #include <qvbox.h>
00032 #include <qwhatsthis.h>
00033 #include <qtimer.h>
00034 #include <qfocusdata.h>
00035
00036 #include <kapplication.h>
00037 #include <klocale.h>
00038 #include <kconfig.h>
00039 #include <kiconloader.h>
00040 #include <kglobal.h>
00041 #include <kglobalsettings.h>
00042 #include <kseparator.h>
00043 #include <kurllabel.h>
00044 #include <kdebug.h>
00045
00046 #include "kdialogbase_priv.h"
00047 #include "kdialogbase_priv.moc"
00048
00049 KDialogBaseTile *KDialogBase::mTile = 0;
00050
00051 int KDialogBaseButton::id()
00052 {
00053 return( mKey );
00054 }
00055
00056 template class QPtrList<KDialogBaseButton>;
00057
00061 namespace
00062 {
00063 struct SButton : public Qt
00064 {
00065 SButton()
00066 {
00067 box = 0;
00068 mask = 0;
00069 style = 0;
00070 }
00071
00072 KPushButton *append( int key, const KGuiItem &item );
00073
00074 void resize( bool sameWidth, int margin, int spacing, int orientation );
00075
00076 KPushButton *button( int key );
00077
00078 QWidget *box;
00079 int mask;
00080 int style;
00081 QPtrList<KDialogBaseButton> list;
00082 };
00083 }
00084
00085 class KDialogBase::KDialogBasePrivate {
00086 public:
00087 KDialogBasePrivate() : bDetails(false), bFixed(false), bSettingDetails(false), detailsWidget(0) { }
00088
00089 bool bDetails;
00090 bool bFixed;
00091 bool bSettingDetails;
00092 QWidget *detailsWidget;
00093 QSize incSize;
00094 QSize minSize;
00095 QString detailsButton;
00096 SButton mButton;
00097 };
00098
00099 KDialogBase::KDialogBase( QWidget *parent, const char *name, bool modal,
00100 const QString &caption, int buttonMask,
00101 ButtonCode defaultButton, bool separator,
00102 const KGuiItem &user1, const KGuiItem &user2,
00103 const KGuiItem &user3 )
00104 :KDialog( parent, name, modal, WStyle_DialogBorder ),
00105 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0),
00106 mIsActivated(false), mShowTile(false), mMessageBoxMode(false),
00107 mButtonOrientation(Horizontal)
00108 {
00109 d = new KDialogBasePrivate;
00110 setCaption( caption );
00111
00112 makeRelay();
00113 connect( this, SIGNAL(layoutHintChanged()), SLOT(updateGeometry()) );
00114
00115 enableButtonSeparator( separator );
00116 makeButtonBox( buttonMask, defaultButton, user1, user2, user3 );
00117
00118 mIsActivated = true;
00119 setupLayout();
00120 }
00121
00122 KDialogBase::KDialogBase( int dialogFace, const QString &caption,
00123 int buttonMask, ButtonCode defaultButton,
00124 QWidget *parent, const char *name, bool modal,
00125 bool separator, const KGuiItem &user1,
00126 const KGuiItem &user2, const KGuiItem &user3 )
00127 :KDialog( parent, name, modal, WStyle_DialogBorder ),
00128 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0),
00129 mIsActivated(false), mShowTile(false), mMessageBoxMode(false),
00130 mButtonOrientation(Horizontal)
00131 {
00132 d = new KDialogBasePrivate;
00133 setCaption( caption );
00134
00135 makeRelay();
00136 connect( this, SIGNAL(layoutHintChanged()), SLOT(updateGeometry()) );
00137
00138 mJanus = new KJanusWidget( this, "janus", dialogFace );
00139 connect(mJanus, SIGNAL(aboutToShowPage(QWidget *)),
00140 this, SIGNAL(aboutToShowPage(QWidget *)));
00141
00142 if( mJanus == 0 || mJanus->isValid() == false ) { return; }
00143
00144 enableButtonSeparator( separator );
00145 makeButtonBox( buttonMask, defaultButton, user1, user2, user3 );
00146
00147 mIsActivated = true;
00148 setupLayout();
00149 }
00150
00151 KDialogBase::KDialogBase( KDialogBase::DialogType dialogFace, WFlags f, QWidget *parent, const char *name,
00152 bool modal,
00153 const QString &caption, int buttonMask,
00154 ButtonCode defaultButton, bool separator,
00155 const KGuiItem &user1, const KGuiItem &user2,
00156 const KGuiItem &user3 )
00157 :KDialog( parent, name, modal, f ),
00158 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0),
00159 mIsActivated(false), mShowTile(false), mMessageBoxMode(false),
00160 mButtonOrientation(Horizontal)
00161 {
00162 d = new KDialogBasePrivate;
00163 setCaption( caption );
00164
00165 makeRelay();
00166 connect( this, SIGNAL(layoutHintChanged()), SLOT(updateGeometry()) );
00167
00168 mJanus = new KJanusWidget( this, "janus", dialogFace );
00169 connect(mJanus, SIGNAL(aboutToShowPage(QWidget *)),
00170 this, SIGNAL(aboutToShowPage(QWidget *)));
00171
00172 if( mJanus == 0 || mJanus->isValid() == false ) { return; }
00173
00174 enableButtonSeparator( separator );
00175 makeButtonBox( buttonMask, defaultButton, user1, user2, user3 );
00176
00177 mIsActivated = true;
00178 setupLayout();
00179 }
00180
00181 KDialogBase::KDialogBase( const QString &caption, int buttonMask,
00182 ButtonCode defaultButton, ButtonCode escapeButton,
00183 QWidget *parent, const char *name, bool modal,
00184 bool separator, const KGuiItem &yes,
00185 const KGuiItem &no, const KGuiItem &cancel )
00186 :KDialog( parent, name, modal, WStyle_DialogBorder ),
00187 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0),
00188 mIsActivated(false), mShowTile(false), mMessageBoxMode(true),
00189 mButtonOrientation(Horizontal),mEscapeButton(escapeButton)
00190 {
00191 d = new KDialogBasePrivate;
00192
00193 setCaption( caption );
00194
00195 makeRelay();
00196 connect( this, SIGNAL(layoutHintChanged()), SLOT(updateGeometry()) );
00197
00198 enableButtonSeparator( separator );
00199
00200 buttonMask &= Details|Yes|No|Cancel;
00201
00202 makeButtonBox( buttonMask, defaultButton,
00203 no.text().isEmpty() ? KStdGuiItem::no() : no,
00204 yes.text().isEmpty() ? KStdGuiItem::yes() : yes );
00205
00206 setButtonCancel( cancel.text().isEmpty() ?
00207 KStdGuiItem::cancel() : cancel );
00208
00209 mIsActivated = true;
00210 setupLayout();
00211 }
00212
00213
00214
00215 KDialogBase::~KDialogBase()
00216 {
00217 delete d;
00218 }
00219
00220 KPushButton *SButton::append( int key, const KGuiItem &item )
00221 {
00222 KDialogBaseButton *p = new KDialogBaseButton( item, key, box );
00223 list.append( p );
00224 return( p );
00225 }
00226
00227 void SButton::resize( bool sameWidth, int margin,
00228 int spacing, int orientation )
00229 {
00230 KDialogBaseButton *p;
00231 int h = 0;
00232 int w = 0;
00233 int t = 0;
00234
00235 for( p = list.first(); p!=0; p = list.next() )
00236 {
00237 const QSize s( p->sizeHint() );
00238 if( s.height() > h ) { h = s.height(); }
00239 if( s.width() > w ) { w = s.width(); }
00240 }
00241
00242 if( orientation == Horizontal )
00243 {
00244 for( p = list.first(); p!=0; p = list.next() )
00245 {
00246 QSize s( p->sizeHint() );
00247 if( sameWidth == true ) { s.setWidth( w ); }
00248 p->setFixedWidth( s.width() );
00249 t += s.width() + spacing;
00250 }
00251
00252 box->setMinimumHeight( margin*2 + h );
00253 box->setMinimumWidth( margin*2 + t - spacing );
00254 }
00255 else
00256 {
00257
00258 for( p = list.first(); p!=0; p = list.next() )
00259 {
00260 QSize s( p->sizeHint() );
00261 s.setWidth( w );
00262 p->setFixedSize( s );
00263 t += s.height() + spacing;
00264 }
00265 box->setMinimumHeight( margin*2 + t - spacing );
00266 box->setMinimumWidth( margin*2 + w );
00267 }
00268 }
00269
00270 KPushButton *SButton::button( int key )
00271 {
00272 KDialogBaseButton *p;
00273 for( p = list.first(); p != 0; p = list.next() )
00274 {
00275 if( p->id() == key )
00276 {
00277 return( p );
00278 }
00279 }
00280 return( 0 );
00281 }
00282
00283 void
00284 KDialogBase::delayedDestruct()
00285 {
00286 if (isVisible())
00287 hide();
00288 QTimer::singleShot( 0, this, SLOT(slotDelayedDestruct()));
00289 }
00290
00291 void
00292 KDialogBase::slotDelayedDestruct()
00293 {
00294 delete this;
00295 }
00296
00297 void KDialogBase::setupLayout()
00298 {
00299 if( mTopLayout != 0 )
00300 {
00301 delete mTopLayout;
00302 }
00303
00304
00305
00306 if( mButtonOrientation == Horizontal )
00307 {
00308 mTopLayout = new QBoxLayout( this, QBoxLayout::TopToBottom,
00309 marginHint(), spacingHint() );
00310 }
00311 else
00312 {
00313 mTopLayout = new QBoxLayout( this, QBoxLayout::LeftToRight,
00314 marginHint(), spacingHint() );
00315 }
00316
00317 if( mUrlHelp != 0 )
00318 {
00319 mTopLayout->addWidget( mUrlHelp, 0, AlignRight );
00320 }
00321
00322 if( mJanus != 0 )
00323 {
00324 mTopLayout->addWidget( mJanus, 10 );
00325 }
00326 else if( mMainWidget != 0 )
00327 {
00328 mTopLayout->addWidget( mMainWidget, 10 );
00329 }
00330
00331 if ( d->detailsWidget )
00332 {
00333 mTopLayout->addWidget( d->detailsWidget );
00334 }
00335
00336 if( mActionSep != 0 )
00337 {
00338 mTopLayout->addWidget( mActionSep );
00339 }
00340
00341 if( d->mButton.box != 0 )
00342 {
00343 mTopLayout->addWidget( d->mButton.box );
00344 }
00345 }
00346
00347
00348
00349 void KDialogBase::setButtonBoxOrientation( int orientation )
00350 {
00351 if( mButtonOrientation != orientation )
00352 {
00353 mButtonOrientation = orientation;
00354 if( mActionSep != 0 )
00355 {
00356 mActionSep->setOrientation( mButtonOrientation == Horizontal ?
00357 QFrame::HLine : QFrame::VLine );
00358 }
00359 if( mButtonOrientation == Vertical )
00360 {
00361 enableLinkedHelp(false);
00362 }
00363 setupLayout();
00364 setButtonStyle( d->mButton.style );
00365 }
00366 }
00367
00368
00369 void KDialogBase::setEscapeButton( ButtonCode id )
00370 {
00371 mEscapeButton = id;
00372 }
00373
00374
00375
00376 void KDialogBase::makeRelay()
00377 {
00378 if( mTile != 0 )
00379 {
00380 connect( mTile, SIGNAL(pixmapChanged()), SLOT(updateBackground()) );
00381 return;
00382 }
00383
00384 mTile = new KDialogBaseTile;
00385 if( mTile != 0 )
00386 {
00387 connect( mTile, SIGNAL(pixmapChanged()), SLOT(updateBackground()) );
00388 connect( qApp, SIGNAL(aboutToQuit()), mTile, SLOT(cleanup()) );
00389 }
00390 }
00391
00392
00393 void KDialogBase::enableButtonSeparator( bool state )
00394 {
00395 if( state == true )
00396 {
00397 if( mActionSep != 0 )
00398 {
00399 return;
00400 }
00401 mActionSep = new KSeparator( this );
00402 mActionSep->setFocusPolicy(QWidget::NoFocus);
00403 mActionSep->setOrientation( mButtonOrientation == Horizontal ?
00404 QFrame::HLine : QFrame::VLine );
00405 mActionSep->show();
00406 }
00407 else
00408 {
00409 if( mActionSep == 0 )
00410 {
00411 return;
00412 }
00413 delete mActionSep; mActionSep = 0;
00414 }
00415
00416 if( mIsActivated == true )
00417 {
00418 setupLayout();
00419 }
00420 }
00421
00422
00423
00424 QFrame *KDialogBase::plainPage()
00425 {
00426 return( mJanus == 0 ? 0 : mJanus->plainPage() );
00427 }
00428
00429
00430
00431 void KDialogBase::adjustSize()
00432 {
00433
00434
00435 if( d->bFixed )
00436 setFixedSize( sizeHint() );
00437 else
00438 resize( sizeHint() );
00439 }
00440
00441 QSize KDialogBase::sizeHint() const
00442 {
00443 return d->minSize.expandedTo( minimumSizeHint() ) + d->incSize;
00444 }
00445
00446 QSize KDialogBase::minimumSizeHint() const
00447 {
00448 int m = marginHint();
00449 int s = spacingHint();
00450
00451 QSize s1(0,0);
00452 QSize s2(0,0);
00453
00454
00455
00456
00457 if( mUrlHelp != 0 )
00458 {
00459 s2 = mUrlHelp->minimumSize() + QSize( 0, s );
00460 }
00461 s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() );
00462 s1.rheight() += s2.rheight();
00463
00464
00465
00466
00467 if( mJanus != 0 )
00468 {
00469 s2 = mJanus->minimumSizeHint() + QSize( 0, s );
00470 }
00471 else if( mMainWidget != 0 )
00472 {
00473 s2 = mMainWidget->sizeHint() + QSize( 0, s );
00474 s2 = s2.expandedTo( mMainWidget->minimumSize() );
00475 s2 = s2.expandedTo( mMainWidget->minimumSizeHint() );
00476 if( s2.isEmpty() == true )
00477 {
00478 s2 = QSize( 100, 100+s );
00479 }
00480 }
00481 else
00482 {
00483 s2 = QSize( 100, 100+s );
00484 }
00485 s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() );
00486 s1.rheight() += s2.rheight();
00487
00488 if (d->detailsWidget && d->bDetails)
00489 {
00490 s2 = d->detailsWidget->sizeHint() + QSize( 0, s );
00491 s2 = s2.expandedTo( d->detailsWidget->minimumSize() );
00492 s2 = s2.expandedTo( d->detailsWidget->minimumSizeHint() );
00493 s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() );
00494 s1.rheight() += s2.rheight();
00495 }
00496
00497
00498
00499
00500 if( mActionSep != 0 )
00501 {
00502 s1.rheight() += mActionSep->minimumSize().height() + s;
00503 }
00504
00505
00506
00507
00508 if( d->mButton.box != 0 )
00509 {
00510 s2 = d->mButton.box->minimumSize();
00511 if( mButtonOrientation == Horizontal )
00512 {
00513 s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() );
00514 s1.rheight() += s2.rheight();
00515 }
00516 else
00517 {
00518 s1.rwidth() += s2.rwidth();
00519 s1.rheight() = QMAX( s1.rheight(), s2.rheight() );
00520 }
00521 }
00522
00523
00524
00525
00526 s1.rheight() += 2*m;
00527 s1.rwidth() += 2*m;
00528
00529 return s1;
00530 }
00531
00532
00533 void KDialogBase::disableResize()
00534 {
00535 setFixedSize( sizeHint() );
00536 }
00537
00538
00539 void KDialogBase::setInitialSize( const QSize &s, bool noResize )
00540 {
00541 d->minSize = s;
00542 d->bFixed = noResize;
00543 adjustSize();
00544 }
00545
00546
00547 void KDialogBase::incInitialSize( const QSize &s, bool noResize )
00548 {
00549 d->incSize = s;
00550 d->bFixed = noResize;
00551 adjustSize();
00552 }
00553
00554
00555 void KDialogBase::makeButtonBox( int buttonMask, ButtonCode defaultButton,
00556 const KGuiItem &user1, const KGuiItem &user2,
00557 const KGuiItem &user3 )
00558 {
00559 if( buttonMask == 0 )
00560 {
00561 d->mButton.box = 0;
00562 return;
00563 }
00564
00565 if( buttonMask & Cancel ) { buttonMask &= ~Close; }
00566 if( buttonMask & Apply ) { buttonMask &= ~Try; }
00567 if( buttonMask & Details ) { buttonMask &= ~Default; }
00568
00569 if( mMessageBoxMode == false )
00570 {
00571 mEscapeButton = (buttonMask&Cancel) ? Cancel : Close;
00572 }
00573
00574 d->mButton.box = new QWidget( this );
00575
00576 d->mButton.mask = buttonMask;
00577 if( d->mButton.mask & Help )
00578 {
00579 KPushButton *pb = d->mButton.append( Help, KStdGuiItem::help() );
00580
00581 connect( pb, SIGNAL(clicked()), SLOT(slotHelp()) );
00582 }
00583 if( d->mButton.mask & Default )
00584 {
00585 KPushButton *pb = d->mButton.append( Default, KStdGuiItem::defaults() );
00586
00587 connect( pb, SIGNAL(clicked()), SLOT(slotDefault()) );
00588 }
00589 if( d->mButton.mask & Details )
00590 {
00591 KPushButton *pb = d->mButton.append( Details, QString::null );
00592 connect( pb, SIGNAL(clicked()), SLOT(slotDetails()) );
00593 setDetails(false);
00594 }
00595 if( d->mButton.mask & User3 )
00596 {
00597 KPushButton *pb = d->mButton.append( User3, user3 );
00598 connect( pb, SIGNAL(clicked()), SLOT(slotUser3()) );
00599 }
00600 if( d->mButton.mask & User2 )
00601 {
00602 KPushButton *pb = d->mButton.append( User2, user2 );
00603 if( mMessageBoxMode == true )
00604 {
00605 connect( pb, SIGNAL(clicked()), SLOT(slotYes()) );
00606 }
00607 else
00608 {
00609 connect( pb, SIGNAL(clicked()), this, SLOT(slotUser2()) );
00610 }
00611 }
00612 if( d->mButton.mask & User1 )
00613 {
00614 KPushButton *pb = d->mButton.append( User1, user1 );
00615 if( mMessageBoxMode == true )
00616 {
00617 connect( pb, SIGNAL(clicked()), this, SLOT(slotNo()) );
00618 }
00619 else
00620 {
00621 connect( pb, SIGNAL(clicked()), SLOT(slotUser1()) );
00622 }
00623 }
00624 if( d->mButton.mask & Ok )
00625 {
00626 KPushButton *pb = d->mButton.append( Ok, KStdGuiItem::ok() );
00627 connect( pb, SIGNAL(clicked()), SLOT(slotOk()) );
00628 }
00629 if( d->mButton.mask & Apply )
00630 {
00631 KPushButton *pb = d->mButton.append( Apply, KStdGuiItem::apply() );
00632 connect( pb, SIGNAL(clicked()), SLOT(slotApply()) );
00633 connect( pb, SIGNAL(clicked()), SLOT(applyPressed()) );
00634 }
00635 if( d->mButton.mask & Try )
00636 {
00637 KPushButton *pb = d->mButton.append( Try,
00638 i18n( "&Try" ) );
00639 connect( pb, SIGNAL(clicked()), SLOT(slotTry()) );
00640 }
00641 if( d->mButton.mask & Cancel )
00642 {
00643 KPushButton *pb = d->mButton.append( Cancel, KStdGuiItem::cancel() );
00644 connect( pb, SIGNAL(clicked()), SLOT(slotCancel()) );
00645 }
00646 if( d->mButton.mask & Close )
00647 {
00648 KPushButton *pb = d->mButton.append( Close, KStdGuiItem::close() );
00649 connect( pb, SIGNAL(clicked()), SLOT(slotClose()) );
00650 }
00651
00652 if( defaultButton != NoDefault )
00653 {
00654 QPushButton *pb = actionButton( defaultButton );
00655 if( pb != 0 )
00656 {
00657 setButtonFocus( pb, true, false );
00658 }
00659 }
00660
00661 setButtonStyle( KGlobalSettings::buttonLayout() );
00662 }
00663
00664
00665
00666 void KDialogBase::setButtonStyle( int style )
00667 {
00668 if( d->mButton.box == 0 )
00669 {
00670 return;
00671 }
00672
00673 if( style < 0 || style > ActionStyleMAX ) { style = ActionStyle0; }
00674 d->mButton.style = style;
00675
00676 const int *layout;
00677 int layoutMax = 0;
00678 if (mMessageBoxMode)
00679 {
00680 static const int layoutRule[5][6] =
00681 {
00682 {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler},
00683 {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler},
00684 {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler},
00685 {Details|Filler,Stretch,Cancel|Stretch,User2|Stretch,User1|Stretch,Details},
00686 {Details|Filler,Stretch,Cancel|Stretch,User2|Stretch,User1|Stretch,Details}
00687 };
00688 layoutMax = 6;
00689 layout = layoutRule[ d->mButton.style ];
00690 }
00691 else if (mButtonOrientation == Horizontal)
00692 {
00693 static const int layoutRule[5][10] =
00694 {
00695 {Details,Help,Default,Stretch,User3,User2,User1,Ok,Apply|Try,Cancel|Close},
00696 {Details,Help,Default,Stretch,User3,User2,User1,Cancel|Close,Apply|Try,Ok},
00697 {Details,Help,Default,Stretch,User3,User2,User1,Apply|Try,Cancel|Close,Ok},
00698 {Ok,Apply|Try,Cancel|Close,User3,User2,User1,Stretch,Default,Help,Details},
00699 {Ok,Cancel|Close,Apply|Try,User3,User2,User1,Stretch,Default,Help,Details}
00700 };
00701 layoutMax = 10;
00702 layout = layoutRule[ d->mButton.style ];
00703 }
00704 else
00705 {
00706 static const int layoutRule[5][10] =
00707 {
00708 {Ok,Apply|Try,User1,User2,User3,Stretch,Default,Cancel|Close,Help, Details},
00709
00710 {Details,Help,Default,Stretch,User3,User2,User1,Cancel|Close,Apply|Try,Ok},
00711 {Details,Help,Default,Stretch,User3,User2,User1,Apply|Try,Cancel|Close,Ok},
00712 {Ok,Apply|Try,Cancel|Close,User3,User2,User1,Stretch,Default,Help,Details},
00713 {Ok,Cancel|Close,Apply|Try,User3,User2,User1,Stretch,Default,Help,Details}
00714 };
00715 layoutMax = 10;
00716 layout = layoutRule[ d->mButton.style ];
00717 }
00718
00719 if( d->mButton.box->layout() )
00720 {
00721 delete d->mButton.box->layout();
00722 }
00723
00724 QBoxLayout *lay;
00725 if( mButtonOrientation == Horizontal )
00726 {
00727 lay = new QBoxLayout( d->mButton.box, QBoxLayout::LeftToRight, 0,
00728 spacingHint());
00729 }
00730 else
00731 {
00732 lay = new QBoxLayout( d->mButton.box, QBoxLayout::TopToBottom, 0,
00733 spacingHint());
00734 }
00735
00736 int numButton = 0;
00737 QPushButton *prevButton = 0;
00738 QPushButton *newButton;
00739
00740 for( int i=0; i<layoutMax; i++ )
00741 {
00742 if(((ButtonCode) layout[i]) == Stretch)
00743 {
00744 lay->addStretch(1);
00745 continue;
00746 }
00747 else if (layout[i] & Filler)
00748 {
00749 if (d->mButton.mask & layout[i])
00750 {
00751 newButton = actionButton( (ButtonCode) (layout[i] & ~(Stretch | Filler)));
00752 if (newButton)
00753 lay->addSpacing(newButton->sizeHint().width());
00754 }
00755 continue;
00756 }
00757 else if( d->mButton.mask & Help & layout[i] )
00758 {
00759 newButton = actionButton( Help );
00760 lay->addWidget( newButton ); numButton++;
00761 }
00762 else if( d->mButton.mask & Default & layout[i] )
00763 {
00764 newButton = actionButton( Default );
00765 lay->addWidget( newButton ); numButton++;
00766 }
00767 else if( d->mButton.mask & User3 & layout[i] )
00768 {
00769 newButton = actionButton( User3 );
00770 lay->addWidget( newButton ); numButton++;
00771 }
00772 else if( d->mButton.mask & User2 & layout[i] )
00773 {
00774 newButton = actionButton( User2 );
00775 lay->addWidget( newButton ); numButton++;
00776 }
00777 else if( d->mButton.mask & User1 & layout[i] )
00778 {
00779 newButton = actionButton( User1 );
00780 lay->addWidget( newButton ); numButton++;
00781 }
00782 else if( d->mButton.mask & Ok & layout[i] )
00783 {
00784 newButton = actionButton( Ok );
00785 lay->addWidget( newButton ); numButton++;
00786 }
00787 else if( d->mButton.mask & Apply & layout[i] )
00788 {
00789 newButton = actionButton( Apply );
00790 lay->addWidget( newButton ); numButton++;
00791 }
00792 else if( d->mButton.mask & Try & layout[i] )
00793 {
00794 newButton = actionButton( Try );
00795 lay->addWidget( newButton ); numButton++;
00796 }
00797 else if( d->mButton.mask & Cancel & layout[i] )
00798 {
00799 newButton = actionButton( Cancel );
00800 lay->addWidget( newButton ); numButton++;
00801 }
00802 else if( d->mButton.mask & Close & layout[i] )
00803 {
00804 newButton = actionButton( Close );
00805 lay->addWidget( newButton ); numButton++;
00806 }
00807 else if( d->mButton.mask & Details & layout[i] )
00808 {
00809 newButton = actionButton( Details );
00810 lay->addWidget( newButton ); numButton++;
00811 }
00812 else
00813 {
00814 continue;
00815 }
00816
00817
00818 if(layout[i] & Stretch)
00819 {
00820 lay->addStretch(1);
00821 }
00822
00823 if( prevButton != 0 )
00824 {
00825 setTabOrder( prevButton, newButton );
00826 }
00827 prevButton = newButton;
00828 }
00829
00830 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
00831 }
00832
00833
00834 QPushButton *KDialogBase::actionButton( ButtonCode id )
00835 {
00836 return( d->mButton.button(id) );
00837 }
00838
00839
00840 void KDialogBase::enableButton( ButtonCode id, bool state )
00841 {
00842 QPushButton *pb = actionButton( id );
00843 if( pb != 0 )
00844 {
00845 pb->setEnabled( state );
00846 }
00847 }
00848
00849
00850 void KDialogBase::enableButtonOK( bool state )
00851 {
00852 enableButton( Ok, state );
00853 }
00854
00855
00856 void KDialogBase::enableButtonApply( bool state )
00857 {
00858 enableButton( Apply, state );
00859 }
00860
00861
00862 void KDialogBase::enableButtonCancel( bool state )
00863 {
00864 enableButton( Cancel, state );
00865 }
00866
00867
00868 void KDialogBase::showButton( ButtonCode id, bool state )
00869 {
00870 QPushButton *pb = actionButton( id );
00871 if( pb != 0 )
00872 {
00873 state ? pb->show() : pb->hide();
00874 }
00875 }
00876
00877
00878 void KDialogBase::showButtonOK( bool state )
00879 {
00880 showButton( Ok, state );
00881 }
00882
00883
00884 void KDialogBase::showButtonApply( bool state )
00885 {
00886 showButton( Apply, state );
00887 }
00888
00889
00890 void KDialogBase::showButtonCancel( bool state )
00891 {
00892 showButton( Cancel, state );
00893 }
00894
00895
00896 void KDialogBase::setButtonOKText( const QString &text,
00897 const QString &tooltip,
00898 const QString &quickhelp )
00899 {
00900 QPushButton *pb = actionButton( Ok );
00901 if( pb == 0 )
00902 {
00903 return;
00904 }
00905
00906 const QString whatsThis = i18n( ""
00907 "If you press the <b>OK</b> button, all changes\n"
00908 "you made will be used to proceed.");
00909
00910 pb->setText( text.isEmpty() ? i18n("&OK") : text );
00911 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
00912
00913 QToolTip::add( pb, tooltip.isEmpty() ? i18n("Accept settings") : tooltip );
00914 QWhatsThis::add( pb, quickhelp.isEmpty() ? whatsThis : quickhelp );
00915 }
00916
00917
00918 void KDialogBase::setButtonOK( const KGuiItem &item )
00919 {
00920 setButtonGuiItem( Ok, item );
00921 }
00922
00923
00924 void KDialogBase::setButtonApplyText( const QString &text,
00925 const QString &tooltip,
00926 const QString &quickhelp )
00927 {
00928 QPushButton *pb = actionButton( Apply );
00929 if( pb == 0 )
00930 {
00931 return;
00932 }
00933
00934 const QString whatsThis = i18n( ""
00935 "When clicking <b>Apply</b>, the settings will be\n"
00936 "handed over to the program, but the dialog\n"
00937 "will not be closed. "
00938 "Use this to try different settings. ");
00939
00940 pb->setText( text.isEmpty() ? i18n("&Apply") : text );
00941 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
00942
00943 QToolTip::add( pb, tooltip.isEmpty() ? i18n("Apply settings") : tooltip );
00944 QWhatsThis::add( pb, quickhelp.isEmpty() ? whatsThis : quickhelp );
00945 }
00946
00947
00948 void KDialogBase::setButtonApply( const KGuiItem &item )
00949 {
00950 setButtonGuiItem( Apply, item );
00951 }
00952
00953
00954 void KDialogBase::setButtonCancelText( const QString& text,
00955 const QString& tooltip,
00956 const QString& quickhelp )
00957 {
00958 QPushButton *pb = actionButton( Cancel );
00959 if( pb == 0 )
00960 {
00961 return;
00962 }
00963
00964 pb->setText( text.isEmpty() ? i18n("&Cancel") : text );
00965 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
00966
00967 QToolTip::add( pb, tooltip );
00968 QWhatsThis::add( pb, quickhelp );
00969 }
00970
00971
00972 void KDialogBase::setButtonCancel( const KGuiItem &item )
00973 {
00974 setButtonGuiItem( Cancel, item );
00975 }
00976
00977 void KDialogBase::setButtonGuiItem( ButtonCode id, const KGuiItem &item )
00978 {
00979 KPushButton *pb = static_cast<KPushButton *>( actionButton( id ) );
00980 if( pb == 0 )
00981 return;
00982
00983 pb->setGuiItem( item );
00984 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
00985 }
00986
00987
00988 void KDialogBase::setButtonText( ButtonCode id, const QString &text )
00989 {
00990 if (!d->bSettingDetails && (id == Details))
00991 {
00992 d->detailsButton = text;
00993 setDetails(d->bDetails);
00994 return;
00995 }
00996 QPushButton *pb = actionButton( id );
00997 if( pb != 0 )
00998 {
00999 pb->setText( text );
01000 d->mButton.resize( false, 0, spacingHint(), mButtonOrientation );
01001 }
01002 }
01003
01004
01005 void KDialogBase::setButtonTip( ButtonCode id, const QString &text )
01006 {
01007 QPushButton *pb = actionButton( id );
01008 if( pb != 0 )
01009 {
01010 if (text.isEmpty())
01011 QToolTip::remove( pb );
01012 else
01013 QToolTip::add( pb, text );
01014 }
01015 }
01016
01017
01018 void KDialogBase::setButtonWhatsThis( ButtonCode id, const QString &text )
01019 {
01020 QPushButton *pb = actionButton( id );
01021 if( pb != 0 )
01022 {
01023 if (text.isEmpty())
01024 QWhatsThis::remove( pb );
01025 else
01026 QWhatsThis::add( pb, text );
01027 }
01028 }
01029
01030
01031 void KDialogBase::setButtonFocus( QPushButton *p,bool isDefault, bool isFocus )
01032 {
01033 p->setDefault( isDefault );
01034 if( isFocus )
01035 p->setFocus();
01036 }
01037
01038
01039 void KDialogBase::setTreeListAutoResize( bool state )
01040 {
01041 if( mJanus != 0 )
01042 {
01043 mJanus->setTreeListAutoResize( state );
01044 }
01045 }
01046
01047 void KDialogBase::setShowIconsInTreeList(bool state)
01048 {
01049 if( mJanus != 0 )
01050 {
01051 mJanus->setShowIconsInTreeList( state );
01052 }
01053 }
01054
01055 void KDialogBase::setRootIsDecorated( bool state )
01056 {
01057 if( mJanus != 0 )
01058 {
01059 mJanus->setRootIsDecorated( state );
01060 }
01061 }
01062
01063 void KDialogBase::unfoldTreeList( bool persist )
01064 {
01065 if( mJanus != 0 )
01066 mJanus->unfoldTreeList( persist );
01067 }
01068
01069 void KDialogBase::addWidgetBelowList( QWidget * widget )
01070 {
01071 if( mJanus != 0 )
01072 mJanus->addWidgetBelowList( widget );
01073 }
01074
01075 void KDialogBase::addButtonBelowList( const QString & text, QObject * recv, const char * slot )
01076 {
01077 if( mJanus != 0 )
01078 mJanus->addButtonBelowList( text, recv, slot );
01079 }
01080
01081 void KDialogBase::addButtonBelowList( const KGuiItem & item, QObject * recv, const char * slot )
01082 {
01083 if( mJanus != 0 )
01084 mJanus->addButtonBelowList( item, recv, slot );
01085 }
01086
01087 void KDialogBase::setIconListAllVisible( bool state )
01088 {
01089 if( mJanus != 0 )
01090 {
01091 mJanus->setIconListAllVisible( state );
01092 }
01093 }
01094
01095
01096 void KDialogBase::slotHelp()
01097 {
01098 emit helpClicked();
01099 if ( kapp )
01100 kapp->invokeHelp( mAnchor, mHelpApp );
01101 }
01102
01103
01104 void KDialogBase::slotDefault()
01105 {
01106 emit defaultClicked();
01107 }
01108
01109 void KDialogBase::slotDetails()
01110 {
01111 setDetails(!d->bDetails);
01112 }
01113
01114 void KDialogBase::setDetailsWidget(QWidget *detailsWidget)
01115 {
01116 delete d->detailsWidget;
01117 d->detailsWidget = detailsWidget;
01118 if (d->detailsWidget->parentWidget() != this)
01119 d->detailsWidget->reparent(this, QPoint(0,0));
01120 d->detailsWidget->hide();
01121 if( mIsActivated == true )
01122 {
01123 setupLayout();
01124 }
01125 if (!d->bSettingDetails)
01126 setDetails(d->bDetails);
01127 }
01128
01129 void KDialogBase::setDetails(bool showDetails)
01130 {
01131 if (d->detailsButton.isEmpty())
01132 d->detailsButton = i18n("&Details");
01133 d->bSettingDetails = true;
01134 d->bDetails = showDetails;
01135 if (d->bDetails)
01136 {
01137 emit aboutToShowDetails();
01138 setButtonText(Details, d->detailsButton+ " <<");
01139 if (d->detailsWidget)
01140 {
01141 if (layout())
01142 layout()->setEnabled(false);
01143 adjustSize();
01144 d->detailsWidget->show();
01145 if (layout())
01146 {
01147 layout()->activate();
01148 layout()->setEnabled(true);
01149 }
01150 }
01151 }
01152 else
01153 {
01154 setButtonText(Details, d->detailsButton+" >>");
01155 if (d->detailsWidget)
01156 {
01157 d->detailsWidget->hide();
01158 }
01159 if (layout())
01160 layout()->activate();
01161 adjustSize();
01162 }
01163 d->bSettingDetails = false;
01164 }
01165
01166 void KDialogBase::slotOk()
01167 {
01168 emit okClicked();
01169 accept();
01170 }
01171
01172
01173 void KDialogBase::slotApply()
01174 {
01175 emit applyClicked();
01176 }
01177
01178
01179 void KDialogBase::slotTry()
01180 {
01181 emit tryClicked();
01182 }
01183
01184
01185 void KDialogBase::slotUser3()
01186 {
01187 emit user3Clicked();
01188 }
01189
01190
01191 void KDialogBase::slotUser2()
01192 {
01193 emit user2Clicked();
01194 }
01195
01196
01197 void KDialogBase::slotUser1()
01198 {
01199 emit user1Clicked();
01200 }
01201
01202
01203 void KDialogBase::slotYes()
01204 {
01205 emit yesClicked();
01206 done( Yes );
01207 }
01208
01209
01210 void KDialogBase::slotNo()
01211 {
01212 emit noClicked();
01213 done( No );
01214 }
01215
01216
01217 void KDialogBase::slotCancel()
01218 {
01219 emit cancelClicked();
01220 done( mMessageBoxMode == true ? (int)Cancel : (int)Rejected );
01221 }
01222
01223
01224 void KDialogBase::slotClose()
01225 {
01226 emit closeClicked();
01227 reject();
01228 }
01229
01230
01231 void KDialogBase::helpClickedSlot( const QString & )
01232 {
01233 slotHelp();
01234 }
01235
01236
01237 void KDialogBase::applyPressed()
01238 {
01239 emit apply();
01240 }
01241
01242
01243 void KDialogBase::enableLinkedHelp( bool state )
01244 {
01245 if( state == true )
01246 {
01247 if( mUrlHelp != 0 )
01248 {
01249 return;
01250 }
01251
01252 mUrlHelp = new KURLLabel( this, "url" );
01253 mUrlHelp->setText( helpLinkText() );
01254 mUrlHelp->setFloat(true);
01255 mUrlHelp->setUnderline(true);
01256 if( mShowTile == true && mTile->get() != 0 )
01257 {
01258 mUrlHelp->setBackgroundPixmap(*mTile->get());
01259 }
01260 mUrlHelp->setMinimumHeight( fontMetrics().height() + marginHint() );
01261 connect(mUrlHelp,SIGNAL(leftClickedURL(const QString &)),
01262 SLOT(helpClickedSlot(const QString &)));
01263 mUrlHelp->show();
01264 }
01265 else
01266 {
01267 if( mUrlHelp == 0 )
01268 {
01269 return;
01270 }
01271 delete mUrlHelp; mUrlHelp = 0;
01272 }
01273
01274 if( mIsActivated == true )
01275 {
01276 setupLayout();
01277 }
01278 }
01279
01280
01281 void KDialogBase::setHelp( const QString &anchor, const QString &appname )
01282 {
01283 mAnchor = anchor;
01284 mHelpApp = appname;
01285 }
01286
01287
01288 void KDialogBase::setHelpLinkText( const QString &text )
01289 {
01290 mHelpLinkText = text;
01291 if( mUrlHelp != 0 )
01292 {
01293 mUrlHelp->setText( helpLinkText() );
01294 }
01295 }
01296
01297
01298 QFrame *KDialogBase::addPage( const QString &itemName, const QString &header,
01299 const QPixmap &pixmap )
01300 {
01301 return( mJanus == 0 ? 0 : mJanus->addPage( itemName, header, pixmap ) );
01302 }
01303
01304 QFrame *KDialogBase::addPage( const QStringList &items, const QString &header,
01305 const QPixmap &pixmap )
01306 {
01307 return( mJanus == 0 ? 0 : mJanus->addPage( items, header, pixmap ) );
01308 }
01309
01310
01311 QVBox *KDialogBase::addVBoxPage( const QString &itemName,
01312 const QString &header, const QPixmap &pixmap )
01313 {
01314 return( mJanus == 0 ? 0 : mJanus->addVBoxPage( itemName, header, pixmap) );
01315 }
01316
01317 QVBox *KDialogBase::addVBoxPage( const QStringList &items,
01318 const QString &header, const QPixmap &pixmap )
01319 {
01320 return( mJanus == 0 ? 0 : mJanus->addVBoxPage( items, header, pixmap) );
01321 }
01322
01323
01324 QHBox *KDialogBase::addHBoxPage( const QString &itemName,
01325 const QString &header,
01326 const QPixmap &pixmap )
01327 {
01328 return( mJanus == 0 ? 0 : mJanus->addHBoxPage( itemName, header, pixmap ) );
01329 }
01330
01331 QHBox *KDialogBase::addHBoxPage( const QStringList &items,
01332 const QString &header,
01333 const QPixmap &pixmap )
01334 {
01335 return( mJanus == 0 ? 0 : mJanus->addHBoxPage( items, header, pixmap ) );
01336 }
01337
01338
01339 QGrid *KDialogBase::addGridPage( int n, Orientation dir,
01340 const QString &itemName,
01341 const QString &header, const QPixmap &pixmap )
01342 {
01343 return( mJanus == 0 ? 0 : mJanus->addGridPage( n, dir, itemName, header,
01344 pixmap) );
01345 }
01346
01347 QGrid *KDialogBase::addGridPage( int n, Orientation dir,
01348 const QStringList &items,
01349 const QString &header, const QPixmap &pixmap )
01350 {
01351 return( mJanus == 0 ? 0 : mJanus->addGridPage( n, dir, items, header,
01352 pixmap) );
01353 }
01354
01355 void KDialogBase::setFolderIcon(const QStringList &path, const QPixmap &pixmap)
01356 {
01357 if (mJanus == 0)
01358 return;
01359
01360 mJanus->setFolderIcon(path,pixmap);
01361 }
01362
01363 QFrame *KDialogBase::makeMainWidget()
01364 {
01365 if( mJanus != 0 || mMainWidget != 0 )
01366 {
01367 printMakeMainWidgetError();
01368 return( 0 );
01369 }
01370
01371 QFrame *mainWidget = new QFrame( this );
01372 setMainWidget( mainWidget );
01373 return( mainWidget );
01374 }
01375
01376
01377 QVBox *KDialogBase::makeVBoxMainWidget()
01378 {
01379 if( mJanus != 0 || mMainWidget != 0 )
01380 {
01381 printMakeMainWidgetError();
01382 return( 0 );
01383 }
01384
01385 QVBox *mainWidget = new QVBox( this );
01386 mainWidget->setSpacing( spacingHint() );
01387 setMainWidget( mainWidget );
01388 return( mainWidget );
01389 }
01390
01391
01392 QHBox *KDialogBase::makeHBoxMainWidget()
01393 {
01394 if( mJanus != 0 || mMainWidget != 0 )
01395 {
01396 printMakeMainWidgetError();
01397 return( 0 );
01398 }
01399
01400 QHBox *mainWidget = new QHBox( this );
01401 mainWidget->setSpacing( spacingHint() );
01402 setMainWidget( mainWidget );
01403 return( mainWidget );
01404 }
01405
01406
01407 QGrid *KDialogBase::makeGridMainWidget( int n, Orientation dir )
01408 {
01409 if( mJanus != 0 || mMainWidget != 0 )
01410 {
01411 printMakeMainWidgetError();
01412 return( 0 );
01413 }
01414
01415 QGrid *mainWidget = new QGrid( n, dir, this );
01416 mainWidget->setSpacing( spacingHint() );
01417 setMainWidget( mainWidget );
01418 return( mainWidget );
01419 }
01420
01421
01422 void KDialogBase::printMakeMainWidgetError()
01423 {
01424 if( mJanus != 0 )
01425 {
01426 kdDebug() << "makeMainWidget: Illegal mode (wrong constructor)" << endl;
01427 }
01428 else if( mMainWidget != 0 )
01429 {
01430 kdDebug() << "makeMainWidget: Main widget already defined" << endl;
01431 }
01432 }
01433
01434
01435 void KDialogBase::setMainWidget( QWidget *widget )
01436 {
01437 if( mJanus != 0 )
01438 {
01439 if( mJanus->setSwallowedWidget(widget) == true )
01440 {
01441 mMainWidget = widget;
01442 }
01443 }
01444 else
01445 {
01446 mMainWidget = widget;
01447 if( mIsActivated == true )
01448 {
01449 setupLayout();
01450 }
01451 }
01452 if( mMainWidget != NULL )
01453 {
01454 QFocusData* fd = focusData();
01455 QWidget* prev = fd->last();
01456 for( QPtrListIterator<KDialogBaseButton> it( d->mButton.list );
01457 it != NULL;
01458 ++it )
01459 {
01460 if( prev != *it )
01461 setTabOrder( prev, *it );
01462 prev = *it;
01463 }
01464 }
01465 }
01466
01467
01468 QWidget *KDialogBase::mainWidget()
01469 {
01470 return( mMainWidget );
01471 }
01472
01473
01474 bool KDialogBase::showPage( int index )
01475 {
01476 return( mJanus == 0 ? false : mJanus->showPage(index) );
01477 }
01478
01479
01480 int KDialogBase::activePageIndex() const
01481 {
01482 return( mJanus == 0 ? -1 : mJanus->activePageIndex() );
01483 }
01484
01485
01486 int KDialogBase::pageIndex( QWidget *widget ) const
01487 {
01488 return( mJanus == 0 ? -1 : mJanus->pageIndex( widget) );
01489 }
01490
01491
01492
01493 QRect KDialogBase::getContentsRect() const
01494 {
01495 QRect r;
01496 r.setLeft( marginHint() );
01497 r.setTop( marginHint() + (mUrlHelp != 0 ? mUrlHelp->height() : 0) );
01498 r.setRight( width() - marginHint() );
01499 int h = (mActionSep==0?0:mActionSep->minimumSize().height()+marginHint());
01500 if( d->mButton.box != 0 )
01501 {
01502 r.setBottom( height() - d->mButton.box->minimumSize().height() - h );
01503 }
01504 else
01505 {
01506 r.setBottom( height() - h );
01507 }
01508
01509 return(r);
01510 }
01511
01512
01513
01514 void KDialogBase::getBorderWidths(int& ulx, int& uly, int& lrx, int& lry) const
01515 {
01516 ulx = marginHint();
01517 uly = marginHint();
01518 if( mUrlHelp != 0 )
01519 {
01520 uly += mUrlHelp->minimumSize().height();
01521 }
01522
01523 lrx = marginHint();
01524 lry = d->mButton.box != 0 ? d->mButton.box->minimumSize().height() : 0;
01525 if( mActionSep != 0 )
01526 {
01527 lry += mActionSep->minimumSize().height() + marginHint();
01528 }
01529 }
01530
01531
01532 QSize KDialogBase::calculateSize(int w, int h) const
01533 {
01534 int ulx, uly, lrx, lry;
01535 getBorderWidths(ulx, uly, lrx, lry);
01536 return( QSize(ulx+w+lrx,uly+h+lry) );
01537 }
01538
01539
01540 QString KDialogBase::helpLinkText() const
01541 {
01542 return( mHelpLinkText.isNull() ? i18n("Get help...") : mHelpLinkText );
01543 }
01544
01545
01546 void KDialogBase::updateGeometry()
01547 {
01548 if( mTopLayout != 0 )
01549 {
01550 mTopLayout->setMargin( marginHint() );
01551 mTopLayout->setSpacing(spacingHint() );
01552 }
01553 }
01554
01555
01556
01557 void KDialogBase::keyPressEvent( QKeyEvent *e )
01558 {
01559
01560
01561
01562
01563 if( e->state() == 0 )
01564 {
01565 if( e->key() == Key_F1 )
01566 {
01567 QPushButton *pb = actionButton( Help );
01568 if( pb != 0 )
01569 {
01570 pb->animateClick();
01571 e->accept();
01572 return;
01573 }
01574 }
01575 if( e->key() == Key_Escape )
01576 {
01577 QPushButton *pb = actionButton( mEscapeButton );
01578 if( pb != 0 )
01579 {
01580 pb->animateClick();
01581 e->accept();
01582 return;
01583 }
01584
01585 }
01586 }
01587 else if( e->key() == Key_F1 && e->state() == ShiftButton )
01588 {
01589 QWhatsThis::enterWhatsThisMode();
01590 e->accept();
01591 return;
01592 }
01593
01594
01595 else if ( e->state() == ControlButton &&
01596 (e->key() == Key_Return || e->key() == Key_Enter) )
01597 {
01598 QPushButton *pb = actionButton( Ok );
01599 if ( pb )
01600 {
01601 pb->animateClick();
01602 e->accept();
01603 return;
01604 }
01605 }
01606
01607
01608
01609
01610 QDialog::keyPressEvent(e);
01611 }
01612
01613
01614
01615 void KDialogBase::hideEvent( QHideEvent *ev )
01616 {
01617 emit hidden();
01618 if (!ev->spontaneous())
01619 {
01620 emit finished();
01621 }
01622 }
01623
01624
01625
01626 void KDialogBase::closeEvent( QCloseEvent *e )
01627 {
01628 QPushButton *pb = actionButton( mEscapeButton );
01629 if( pb != 0 && isShown() ) {
01630 pb->animateClick();
01631 } else {
01632 QDialog::closeEvent( e );
01633 }
01634 }
01635
01636 void KDialogBase::cancel()
01637 {
01638 switch ( mEscapeButton ) {
01639 case Ok:
01640 slotOk();
01641 break;
01642 case User1:
01643 if ( mMessageBoxMode )
01644 slotNo();
01645 else
01646 slotUser1();
01647 break;
01648 case User2:
01649 if ( mMessageBoxMode )
01650 slotYes();
01651 else
01652 slotUser2();
01653 break;
01654 case User3:
01655 slotUser3();
01656 break;
01657 case Close:
01658 slotClose();
01659 break;
01660 case Cancel:
01661 default:
01662 slotCancel();
01663 }
01664 }
01665
01666 bool KDialogBase::haveBackgroundTile()
01667 {
01668 return( mTile == 0 || mTile->get() == 0 ? false : true );
01669 }
01670
01671
01672 const QPixmap *KDialogBase::getBackgroundTile() { return backgroundTile(); }
01673
01674 const QPixmap *KDialogBase::backgroundTile()
01675 {
01676 return( mTile == 0 ? 0 : mTile->get() );
01677 }
01678
01679
01680 void KDialogBase::setBackgroundTile( const QPixmap *pix )
01681 {
01682 if( mTile != 0 )
01683 {
01684 mTile->set( pix );
01685 }
01686 }
01687
01688
01689 void KDialogBase::updateBackground()
01690 {
01691 if( mTile == 0 || mTile->get() == 0 )
01692 {
01693 QPixmap nullPixmap;
01694 setBackgroundPixmap(nullPixmap);
01695 if( d->mButton.box != 0 )
01696 {
01697 d->mButton.box->setBackgroundPixmap(nullPixmap);
01698 d->mButton.box->setBackgroundMode(PaletteBackground);
01699 }
01700 setBackgroundMode(PaletteBackground);
01701 }
01702 else
01703 {
01704 const QPixmap *pix = mTile->get();
01705 setBackgroundPixmap(*pix);
01706 if( d->mButton.box != 0 )
01707 {
01708 d->mButton.box->setBackgroundPixmap(*pix);
01709 }
01710 showTile( mShowTile );
01711 }
01712 }
01713
01714
01715 void KDialogBase::showTile( bool state )
01716 {
01717 mShowTile = state;
01718 if( mShowTile == false || mTile == 0 || mTile->get() == 0 )
01719 {
01720 setBackgroundMode(PaletteBackground);
01721 if( d->mButton.box != 0 )
01722 {
01723 d->mButton.box->setBackgroundMode(PaletteBackground);
01724 }
01725 if( mUrlHelp != 0 )
01726 {
01727 mUrlHelp->setBackgroundMode(PaletteBackground);
01728 }
01729 }
01730 else
01731 {
01732 const QPixmap *pix = mTile->get();
01733 setBackgroundPixmap(*pix);
01734 if( d->mButton.box != 0 )
01735 {
01736 d->mButton.box->setBackgroundPixmap(*pix);
01737 }
01738 if( mUrlHelp != 0 )
01739 {
01740 mUrlHelp->setBackgroundPixmap(*pix);
01741 }
01742 }
01743 }
01744
01745 QSize KDialogBase::configDialogSize( const QString& groupName ) const
01746 {
01747 return configDialogSize( *KGlobal::config(), groupName );
01748 }
01749
01750
01751 QSize KDialogBase::configDialogSize( KConfig& config,
01752 const QString& groupName ) const
01753 {
01754 int w, h;
01755 int scnum = QApplication::desktop()->screenNumber(parentWidget());
01756 QRect desk = QApplication::desktop()->screenGeometry(scnum);
01757
01758 w = sizeHint().width();
01759 h = sizeHint().height();
01760
01761 KConfigGroupSaver cs(&config, groupName);
01762 w = config.readNumEntry( QString::fromLatin1("Width %1").arg( desk.width()), w );
01763 h = config.readNumEntry( QString::fromLatin1("Height %1").arg( desk.height()), h );
01764
01765 return( QSize( w, h ) );
01766 }
01767
01768
01769 void KDialogBase::saveDialogSize( const QString& groupName, bool global )
01770 {
01771 saveDialogSize( *KGlobal::config(), groupName, global );
01772 }
01773
01774
01775 void KDialogBase::saveDialogSize( KConfig& config, const QString& groupName,
01776 bool global ) const
01777 {
01778 int scnum = QApplication::desktop()->screenNumber(parentWidget());
01779 QRect desk = QApplication::desktop()->screenGeometry(scnum);
01780
01781 KConfigGroupSaver cs(&config, groupName);
01782 QSize sizeToSave = size();
01783
01784 config.writeEntry( QString::fromLatin1("Width %1").arg( desk.width()),
01785 QString::number( sizeToSave.width()), true, global);
01786 config.writeEntry( QString::fromLatin1("Height %1").arg( desk.height()),
01787 QString::number( sizeToSave.height()), true, global);
01788 }
01789
01790
01791 KDialogBaseButton::KDialogBaseButton( const KGuiItem &item, int key,
01792 QWidget *parent, const char *name )
01793 : KPushButton( item, parent, name )
01794 {
01795 mKey = key;
01796 }
01797
01798
01799
01800
01801 KDialogBaseTile::KDialogBaseTile( QObject *parent, const char *name )
01802 : QObject( parent, name )
01803 {
01804 mPixmap = 0;
01805 }
01806
01807
01808 KDialogBaseTile::~KDialogBaseTile()
01809 {
01810 cleanup();
01811 }
01812
01813
01814 void KDialogBaseTile::set( const QPixmap *pix )
01815 {
01816 if( pix == 0 )
01817 {
01818 cleanup();
01819 }
01820 else
01821 {
01822 if( mPixmap == 0 )
01823 {
01824 mPixmap = new QPixmap(*pix);
01825 }
01826 else
01827 {
01828 *mPixmap = *pix;
01829 }
01830 }
01831
01832 emit pixmapChanged();
01833 }
01834
01835
01836 const QPixmap *KDialogBaseTile::get() const
01837 {
01838 return( mPixmap );
01839 }
01840
01841
01842 void KDialogBaseTile::cleanup()
01843 {
01844 delete mPixmap; mPixmap = 0;
01845 }
01846
01847 void KDialogBase::virtual_hook( int id, void* data )
01848 { KDialog::virtual_hook( id, data ); }
01849
01850 #include "kdialogbase.moc"