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