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., 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 <tqgrid.h> 00028 #include <tqhbox.h> 00029 #include <tqlayout.h> 00030 #include <tqtooltip.h> 00031 #include <tqvbox.h> 00032 #include <tqwhatsthis.h> 00033 #include <tqtimer.h> 00034 #include <tqfocusdata.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 TQPtrList<KDialogBaseButton>; 00057 00061 namespace 00062 { 00063 struct SButton : public TQt 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 TQWidget *box; 00079 int mask; 00080 int style; 00081 TQPtrList<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 TQWidget *detailsWidget; 00093 TQSize incSize; 00094 TQSize minSize; 00095 TQString detailsButton; 00096 SButton mButton; 00097 }; 00098 00099 KDialogBase::KDialogBase( TQWidget *parent, const char *name, bool modal, 00100 const TQString &caption, int buttonMask, 00101 ButtonCode defaultButton, bool separator, 00102 const KGuiItem &user1, const KGuiItem &user2, 00103 const KGuiItem &user3 ) 00104 :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), 00105 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), 00106 mIsActivated(false), mShowTile(false), mMessageBoxMode(false), 00107 mButtonOrientation(Qt::Horizontal), d(new KDialogBasePrivate) 00108 { 00109 setCaption( caption ); 00110 00111 makeRelay(); 00112 connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_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 TQString &caption, 00122 int buttonMask, ButtonCode defaultButton, 00123 TQWidget *parent, const char *name, bool modal, 00124 bool separator, const KGuiItem &user1, 00125 const KGuiItem &user2, const KGuiItem &user3 ) 00126 :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), 00127 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), 00128 mIsActivated(false), mShowTile(false), mMessageBoxMode(false), 00129 mButtonOrientation(Qt::Horizontal), d(new KDialogBasePrivate) 00130 { 00131 setCaption( caption ); 00132 00133 makeRelay(); 00134 connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); 00135 00136 mJanus = new KJanusWidget( this, "janus", dialogFace ); 00137 connect(mJanus, TQT_SIGNAL(aboutToShowPage(TQWidget *)), 00138 this, TQT_SIGNAL(aboutToShowPage(TQWidget *))); 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, TQWidget *parent, const char *name, 00150 bool modal, 00151 const TQString &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(Qt::Horizontal), d(new KDialogBasePrivate) 00159 { 00160 setCaption( caption ); 00161 00162 makeRelay(); 00163 connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); 00164 00165 mJanus = new KJanusWidget( this, "janus", dialogFace ); 00166 connect(mJanus, TQT_SIGNAL(aboutToShowPage(TQWidget *)), 00167 this, TQT_SIGNAL(aboutToShowPage(TQWidget *))); 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 TQString &caption, int buttonMask, 00179 ButtonCode defaultButton, ButtonCode escapeButton, 00180 TQWidget *parent, const char *name, bool modal, 00181 bool separator, const KGuiItem &yes, 00182 const KGuiItem &no, const KGuiItem &cancel ) 00183 :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), 00184 mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), 00185 mIsActivated(false), mShowTile(false), mMessageBoxMode(true), 00186 mButtonOrientation(Qt::Horizontal),mEscapeButton(escapeButton), 00187 d(new KDialogBasePrivate) 00188 { 00189 setCaption( caption ); 00190 00191 makeRelay(); 00192 connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_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 TQSize s( p->sizeHint() ); 00234 if( s.height() > h ) { h = s.height(); } 00235 if( s.width() > w ) { w = s.width(); } 00236 } 00237 00238 if( orientation == Qt::Horizontal ) 00239 { 00240 for( p = list.first(); p; p = list.next() ) 00241 { 00242 TQSize 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 TQSize 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 TQTimer::singleShot( 0, this, TQT_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 TQVBoxLayout( this, marginHint(), spacingHint() ); 00300 00301 00302 if( mButtonOrientation == Qt::Horizontal ) 00303 { 00304 mTopLayout = new TQBoxLayout( this, TQBoxLayout::TopToBottom, 00305 marginHint(), spacingHint() ); 00306 } 00307 else 00308 { 00309 mTopLayout = new TQBoxLayout( this, TQBoxLayout::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 == Qt::Horizontal ? 00353 TQFrame::HLine : TQFrame::VLine ); 00354 } 00355 if( mButtonOrientation == Qt::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, TQT_SIGNAL(pixmapChanged()), TQT_SLOT(updateBackground()) ); 00377 return; 00378 } 00379 00380 mTile = new KDialogBaseTile; 00381 if( mTile ) 00382 { 00383 connect( mTile, TQT_SIGNAL(pixmapChanged()), TQT_SLOT(updateBackground()) ); 00384 connect( tqApp, TQT_SIGNAL(aboutToQuit()), mTile, TQT_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(TQ_NoFocus); 00399 mActionSep->setOrientation( mButtonOrientation == Qt::Horizontal ? 00400 TQFrame::HLine : TQFrame::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 TQFrame *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 TQSize KDialogBase::sizeHint() const 00438 { 00439 return d->minSize.expandedTo( minimumSizeHint() ) + d->incSize; 00440 } 00441 00442 TQSize KDialogBase::minimumSizeHint() const 00443 { 00444 const int m = marginHint(); 00445 const int s = spacingHint(); 00446 00447 const TQSize zeroByS(0, s); 00448 00449 TQSize s1(0,0); 00450 TQSize 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 = TQSize( 100, 100+s ); 00477 } 00478 } 00479 else 00480 { 00481 s2 = TQSize( 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 == Qt::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 TQSize &s, bool noResize ) 00538 { 00539 d->minSize = s; 00540 d->bFixed = noResize; 00541 adjustSize(); 00542 } 00543 00544 00545 void KDialogBase::incInitialSize( const TQSize &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 TQWidget( 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, TQT_SIGNAL(clicked()), TQT_SLOT(slotHelp()) ); 00580 } 00581 if( d->mButton.mask & Default ) 00582 { 00583 KPushButton *pb = d->mButton.append( Default, KStdGuiItem::defaults() ); 00584 00585 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotDefault()) ); 00586 } 00587 if( d->mButton.mask & Details ) 00588 { 00589 KPushButton *pb = d->mButton.append( Details, TQString() ); 00590 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotDetails()) ); 00591 setDetails(false); 00592 } 00593 if( d->mButton.mask & User3 ) 00594 { 00595 KPushButton *pb = d->mButton.append( User3, user3 ); 00596 connect( pb, TQT_SIGNAL(clicked()), TQT_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, TQT_SIGNAL(clicked()), TQT_SLOT(slotYes()) ); 00604 } 00605 else 00606 { 00607 connect( pb, TQT_SIGNAL(clicked()), this, TQT_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, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNo()) ); 00616 } 00617 else 00618 { 00619 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotUser1()) ); 00620 } 00621 } 00622 if( d->mButton.mask & Ok ) 00623 { 00624 KPushButton *pb = d->mButton.append( Ok, KStdGuiItem::ok() ); 00625 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotOk()) ); 00626 } 00627 if( d->mButton.mask & Apply ) 00628 { 00629 KPushButton *pb = d->mButton.append( Apply, KStdGuiItem::apply() ); 00630 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotApply()) ); 00631 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(applyPressed()) ); 00632 } 00633 if( d->mButton.mask & Try ) 00634 { 00635 KPushButton *pb = d->mButton.append( Try, 00636 i18n( "&Try" ) ); 00637 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotTry()) ); 00638 } 00639 if( d->mButton.mask & Cancel ) 00640 { 00641 KPushButton *pb = d->mButton.append( Cancel, KStdGuiItem::cancel() ); 00642 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotCancel()) ); 00643 } 00644 if( d->mButton.mask & Close ) 00645 { 00646 KPushButton *pb = d->mButton.append( Close, KStdGuiItem::close() ); 00647 connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotClose()) ); 00648 } 00649 00650 if( defaultButton != NoDefault ) 00651 { 00652 TQPushButton *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 unsigned int *layout; 00675 int layoutMax = 0; 00676 if (mMessageBoxMode) 00677 { 00678 static const unsigned 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 == Qt::Horizontal) 00690 { 00691 static const unsigned 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 unsigned 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 TQBoxLayout *lay; 00723 if( mButtonOrientation == Qt::Horizontal ) 00724 { 00725 lay = new TQBoxLayout( d->mButton.box, TQBoxLayout::LeftToRight, 0, 00726 spacingHint()); 00727 } 00728 else 00729 { 00730 lay = new TQBoxLayout( d->mButton.box, TQBoxLayout::TopToBottom, 0, 00731 spacingHint()); 00732 } 00733 00734 int numButton = 0; 00735 TQPushButton *prevButton = 0; 00736 TQPushButton *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 TQPushButton *KDialogBase::actionButton( ButtonCode id ) 00833 { 00834 return d->mButton.button(id); 00835 } 00836 00837 00838 void KDialogBase::enableButton( ButtonCode id, bool state ) 00839 { 00840 TQPushButton *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 TQPushButton *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 TQString &text, 00895 const TQString &tooltip, 00896 const TQString &quickhelp ) 00897 { 00898 TQPushButton *pb = actionButton( Ok ); 00899 if( !pb ) 00900 { 00901 return; 00902 } 00903 00904 const TQString 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 TQToolTip::add( pb, tooltip.isEmpty() ? i18n("Accept settings") : tooltip ); 00912 TQWhatsThis::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 TQString &text, 00923 const TQString &tooltip, 00924 const TQString &quickhelp ) 00925 { 00926 TQPushButton *pb = actionButton( Apply ); 00927 if( !pb ) 00928 { 00929 return; 00930 } 00931 00932 const TQString 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 TQToolTip::add( pb, tooltip.isEmpty() ? i18n("Apply settings") : tooltip ); 00942 TQWhatsThis::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 TQString& text, 00953 const TQString& tooltip, 00954 const TQString& quickhelp ) 00955 { 00956 TQPushButton *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 TQToolTip::add( pb, tooltip ); 00966 TQWhatsThis::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 TQString &text ) 00987 { 00988 if (!d->bSettingDetails && (id == Details)) 00989 { 00990 d->detailsButton = text; 00991 setDetails(d->bDetails); 00992 return; 00993 } 00994 TQPushButton *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 TQString &text ) 01004 { 01005 TQPushButton *pb = actionButton( id ); 01006 if( pb ) 01007 { 01008 if (text.isEmpty()) 01009 TQToolTip::remove( pb ); 01010 else 01011 TQToolTip::add( pb, text ); 01012 } 01013 } 01014 01015 01016 void KDialogBase::setButtonWhatsThis( ButtonCode id, const TQString &text ) 01017 { 01018 TQPushButton *pb = actionButton( id ); 01019 if( pb ) 01020 { 01021 if (text.isEmpty()) 01022 TQWhatsThis::remove( pb ); 01023 else 01024 TQWhatsThis::add( pb, text ); 01025 } 01026 } 01027 01028 01029 void KDialogBase::setButtonFocus( TQPushButton *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( TQWidget * widget ) 01068 { 01069 if( mJanus ) 01070 mJanus->addWidgetBelowList( widget ); 01071 } 01072 01073 void KDialogBase::addButtonBelowList( const TQString & text, TQObject * recv, const char * slot ) 01074 { 01075 if( mJanus ) 01076 mJanus->addButtonBelowList( text, recv, slot ); 01077 } 01078 01079 void KDialogBase::addButtonBelowList( const KGuiItem & item, TQObject * 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(TQWidget *detailsWidget) 01113 { 01114 delete d->detailsWidget; 01115 d->detailsWidget = detailsWidget; 01116 if (d->detailsWidget->parentWidget() != this) 01117 d->detailsWidget->reparent(this, TQPoint(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 TQString & ) 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,TQT_SIGNAL(leftClickedURL(const TQString &)), 01260 TQT_SLOT(helpClickedSlot(const TQString &))); 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 TQString &anchor, const TQString &appname ) 01280 { 01281 mAnchor = anchor; 01282 mHelpApp = appname; 01283 } 01284 01285 01286 void KDialogBase::setHelpLinkText( const TQString &text ) 01287 { 01288 mHelpLinkText = text; 01289 if( mUrlHelp ) 01290 { 01291 mUrlHelp->setText( helpLinkText() ); 01292 } 01293 } 01294 01295 01296 TQFrame *KDialogBase::addPage( const TQString &itemName, const TQString &header, 01297 const TQPixmap &pixmap ) 01298 { 01299 return ( mJanus ? mJanus->addPage( itemName, header, pixmap ) : 0); 01300 } 01301 01302 TQFrame *KDialogBase::addPage( const TQStringList &items, const TQString &header, 01303 const TQPixmap &pixmap ) 01304 { 01305 return ( mJanus ? mJanus->addPage( items, header, pixmap ) : 0); 01306 } 01307 01308 01309 TQVBox *KDialogBase::addVBoxPage( const TQString &itemName, 01310 const TQString &header, const TQPixmap &pixmap ) 01311 { 01312 return ( mJanus ? mJanus->addVBoxPage( itemName, header, pixmap) : 0); 01313 } 01314 01315 TQVBox *KDialogBase::addVBoxPage( const TQStringList &items, 01316 const TQString &header, const TQPixmap &pixmap ) 01317 { 01318 return ( mJanus ? mJanus->addVBoxPage( items, header, pixmap) : 0); 01319 } 01320 01321 01322 TQHBox *KDialogBase::addHBoxPage( const TQString &itemName, 01323 const TQString &header, 01324 const TQPixmap &pixmap ) 01325 { 01326 return ( mJanus ? mJanus->addHBoxPage( itemName, header, pixmap ) : 0); 01327 } 01328 01329 TQHBox *KDialogBase::addHBoxPage( const TQStringList &items, 01330 const TQString &header, 01331 const TQPixmap &pixmap ) 01332 { 01333 return ( mJanus ? mJanus->addHBoxPage( items, header, pixmap ) : 0); 01334 } 01335 01336 01337 TQGrid *KDialogBase::addGridPage( int n, Orientation dir, 01338 const TQString &itemName, 01339 const TQString &header, const TQPixmap &pixmap ) 01340 { 01341 return ( mJanus ? mJanus->addGridPage( n, dir, itemName, header, pixmap) : 0); 01342 } 01343 01344 TQGrid *KDialogBase::addGridPage( int n, Orientation dir, 01345 const TQStringList &items, 01346 const TQString &header, const TQPixmap &pixmap ) 01347 { 01348 return ( mJanus ? mJanus->addGridPage( n, dir, items, header, pixmap) : 0); 01349 } 01350 01351 void KDialogBase::setFolderIcon(const TQStringList &path, const TQPixmap &pixmap) 01352 { 01353 if (!mJanus) 01354 return; 01355 01356 mJanus->setFolderIcon(path,pixmap); 01357 } 01358 01359 TQFrame *KDialogBase::makeMainWidget() 01360 { 01361 if( mJanus || mMainWidget ) 01362 { 01363 printMakeMainWidgetError(); 01364 return 0; 01365 } 01366 01367 TQFrame *mainWidget = new TQFrame( this ); 01368 setMainWidget( mainWidget ); 01369 return mainWidget; 01370 } 01371 01372 01373 TQVBox *KDialogBase::makeVBoxMainWidget() 01374 { 01375 if( mJanus || mMainWidget ) 01376 { 01377 printMakeMainWidgetError(); 01378 return 0; 01379 } 01380 01381 TQVBox *mainWidget = new TQVBox( this ); 01382 mainWidget->setSpacing( spacingHint() ); 01383 setMainWidget( mainWidget ); 01384 return mainWidget; 01385 } 01386 01387 01388 TQHBox *KDialogBase::makeHBoxMainWidget() 01389 { 01390 if( mJanus || mMainWidget ) 01391 { 01392 printMakeMainWidgetError(); 01393 return 0; 01394 } 01395 01396 TQHBox *mainWidget = new TQHBox( this ); 01397 mainWidget->setSpacing( spacingHint() ); 01398 setMainWidget( mainWidget ); 01399 return mainWidget; 01400 } 01401 01402 01403 TQGrid *KDialogBase::makeGridMainWidget( int n, Orientation dir ) 01404 { 01405 if( mJanus || mMainWidget ) 01406 { 01407 printMakeMainWidgetError(); 01408 return 0; 01409 } 01410 01411 TQGrid *mainWidget = new TQGrid( 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( TQWidget *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 TQFocusData* fd = focusData(); 01451 TQWidget* prev = fd->last(); 01452 for( TQPtrListIterator<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 TQWidget *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( TQWidget *widget ) const 01483 { 01484 return ( mJanus ? mJanus->pageIndex( widget) : -1); 01485 } 01486 01487 01488 // Deprecated 01489 TQRect KDialogBase::getContentsRect() const 01490 { 01491 TQRect 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 TQSize KDialogBase::calculateSize(int w, int h) const 01529 { 01530 int ulx, uly, lrx, lry; 01531 getBorderWidths(ulx, uly, lrx, lry); 01532 return TQSize(ulx+w+lrx,uly+h+lry); 01533 } 01534 01535 01536 TQString 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( TQKeyEvent *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 TQPushButton *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 TQPushButton *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 TQWhatsThis::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 TQPushButton *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 TQDialog::keyPressEvent(e); 01607 } 01608 01609 01610 01611 void KDialogBase::hideEvent( TQHideEvent *ev ) 01612 { 01613 emit hidden(); 01614 if (!ev->spontaneous()) 01615 { 01616 emit finished(); 01617 } 01618 } 01619 01620 01621 01622 void KDialogBase::closeEvent( TQCloseEvent *e ) 01623 { 01624 TQPushButton *pb = actionButton( mEscapeButton ); 01625 if( pb && isShown() ) { 01626 pb->animateClick(); 01627 } else { 01628 TQDialog::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 TQPixmap *KDialogBase::getBackgroundTile() { return backgroundTile(); } 01669 01670 const TQPixmap *KDialogBase::backgroundTile() 01671 { 01672 return ( mTile ? mTile->get() : 0); 01673 } 01674 01675 01676 void KDialogBase::setBackgroundTile( const TQPixmap *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 TQPixmap 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 TQPixmap *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 TQPixmap *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 TQSize KDialogBase::configDialogSize( const TQString& groupName ) const 01742 { 01743 return configDialogSize( *KGlobal::config(), groupName ); 01744 } 01745 01746 01747 TQSize KDialogBase::configDialogSize( KConfig& config, 01748 const TQString& groupName ) const 01749 { 01750 int w, h; 01751 int scnum = TQApplication::desktop()->screenNumber(parentWidget()); 01752 TQRect desk = TQApplication::desktop()->screenGeometry(scnum); 01753 01754 w = sizeHint().width(); 01755 h = sizeHint().height(); 01756 01757 KConfigGroupSaver cs(&config, groupName); 01758 w = config.readNumEntry( TQString::fromLatin1("Width %1").arg( desk.width()), w ); 01759 h = config.readNumEntry( TQString::fromLatin1("Height %1").arg( desk.height()), h ); 01760 01761 return TQSize( w, h ); 01762 } 01763 01764 01765 void KDialogBase::saveDialogSize( const TQString& groupName, bool global ) 01766 { 01767 saveDialogSize( *KGlobal::config(), groupName, global ); 01768 } 01769 01770 01771 void KDialogBase::saveDialogSize( KConfig& config, const TQString& groupName, 01772 bool global ) const 01773 { 01774 int scnum = TQApplication::desktop()->screenNumber(parentWidget()); 01775 TQRect desk = TQApplication::desktop()->screenGeometry(scnum); 01776 01777 KConfigGroupSaver cs(&config, groupName); 01778 TQSize sizeToSave = size(); 01779 01780 config.writeEntry( TQString::fromLatin1("Width %1").arg( desk.width()), 01781 TQString::number( sizeToSave.width()), true, global); 01782 config.writeEntry( TQString::fromLatin1("Height %1").arg( desk.height()), 01783 TQString::number( sizeToSave.height()), true, global); 01784 } 01785 01786 01787 KDialogBaseButton::KDialogBaseButton( const KGuiItem &item, int key, 01788 TQWidget *parent, const char *name ) 01789 : KPushButton( item, parent, name ), mKey(key) 01790 { 01791 } 01792 01793 01794 01795 01796 KDialogBaseTile::KDialogBaseTile( TQObject *parent, const char *name ) 01797 : TQObject( parent, name ), mPixmap(0) 01798 { 01799 } 01800 01801 01802 KDialogBaseTile::~KDialogBaseTile() 01803 { 01804 cleanup(); 01805 } 01806 01807 01808 void KDialogBaseTile::set( const TQPixmap *pix ) 01809 { 01810 if( !pix ) 01811 { 01812 cleanup(); 01813 } 01814 else 01815 { 01816 if( !mPixmap ) 01817 { 01818 mPixmap = new TQPixmap(*pix); 01819 } 01820 else 01821 { 01822 *mPixmap = *pix; 01823 } 01824 } 01825 01826 emit pixmapChanged(); 01827 } 01828 01829 01830 const TQPixmap *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"