# kdeui Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kdialogbase.cpp

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

This file is part of the documentation for kdeui Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:20:15 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003