# kdeui Library API Documentation

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

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 12:56:30 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001