• Skip to content
  • Skip to link menu
KDE 3.5 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

kdeui

kdialogbase.cpp

Go to the documentation of this file.
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., 51 Franklin Street, Fifth Floor,
00020  *  Boston, MA 02110-1301, 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"

kdeui

Skip menu "kdeui"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • dcop
  • DNSSD
  • interfaces
  • Kate
  • kconf_update
  • KDECore
  • KDED
  • kdefx
  • KDEsu
  • kdeui
  • KDocTools
  • KHTML
  • KImgIO
  • KInit
  • kio
  • kioslave
  • KJS
  • KNewStuff
  • KParts
  • KUtils
Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal