diff options
Diffstat (limited to 'tdeui/kdialogbase.cpp')
| -rw-r--r-- | tdeui/kdialogbase.cpp | 1844 |
1 files changed, 1844 insertions, 0 deletions
diff --git a/tdeui/kdialogbase.cpp b/tdeui/kdialogbase.cpp new file mode 100644 index 000000000..655eff862 --- /dev/null +++ b/tdeui/kdialogbase.cpp @@ -0,0 +1,1844 @@ +/* + * This file is part of the KDE Libraries + * Copyright (C) 1999-2001 Mirko Boehm (mirko@kde.org) and + * Espen Sand (espen@kde.org) + * Holger Freyther <freyther@kde.org> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "kdialogbase.h" +#include <stdlib.h> + +#include <tqgrid.h> +#include <tqhbox.h> +#include <tqlayout.h> +#include <tqtooltip.h> +#include <tqvbox.h> +#include <tqwhatsthis.h> +#include <tqtimer.h> +#include <tqfocusdata.h> + +#include <kapplication.h> +#include <klocale.h> +#include <kconfig.h> +#include <kiconloader.h> +#include <kglobal.h> +#include <kglobalsettings.h> +#include <kseparator.h> +#include <kurllabel.h> +#include <kdebug.h> + +#include "kdialogbase_priv.h" +#include "kdialogbase_priv.moc" + +KDialogBaseTile *KDialogBase::mTile = 0; + +int KDialogBaseButton::id() +{ + return mKey; +} + +template class TQPtrList<KDialogBaseButton>; + +/** + * @internal + */ +namespace +{ +struct SButton : public TQt +{ + SButton() + { + box = 0; + mask = 0; + style = 0; + } + + KPushButton *append( int key, const KGuiItem &item ); + + void resize( bool sameWidth, int margin, int spacing, int orientation ); + + KPushButton *button( int key ); + + TQWidget *box; + int mask; + int style; + TQPtrList<KDialogBaseButton> list; +}; +}// namespace + +class KDialogBase::KDialogBasePrivate { +public: + KDialogBasePrivate() : bDetails(false), bFixed(false), bSettingDetails(false), detailsWidget(0) { } + + bool bDetails; + bool bFixed; + bool bSettingDetails; + TQWidget *detailsWidget; + TQSize incSize; + TQSize minSize; + TQString detailsButton; + SButton mButton; +}; + +KDialogBase::KDialogBase( TQWidget *parent, const char *name, bool modal, + const TQString &caption, int buttonMask, + ButtonCode defaultButton, bool separator, + const KGuiItem &user1, const KGuiItem &user2, + const KGuiItem &user3 ) + :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), + mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), + mIsActivated(false), mShowTile(false), mMessageBoxMode(false), + mButtonOrientation(Qt::Horizontal), d(new KDialogBasePrivate) +{ + setCaption( caption ); + + makeRelay(); + connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); + + enableButtonSeparator( separator ); + makeButtonBox( buttonMask, defaultButton, user1, user2, user3 ); + + mIsActivated = true; + setupLayout(); +} + +KDialogBase::KDialogBase( int dialogFace, const TQString &caption, + int buttonMask, ButtonCode defaultButton, + TQWidget *parent, const char *name, bool modal, + bool separator, const KGuiItem &user1, + const KGuiItem &user2, const KGuiItem &user3 ) + :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), + mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), + mIsActivated(false), mShowTile(false), mMessageBoxMode(false), + mButtonOrientation(Qt::Horizontal), d(new KDialogBasePrivate) +{ + setCaption( caption ); + + makeRelay(); + connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); + + mJanus = new KJanusWidget( this, "janus", dialogFace ); + connect(mJanus, TQT_SIGNAL(aboutToShowPage(TQWidget *)), + this, TQT_SIGNAL(aboutToShowPage(TQWidget *))); + + if( !mJanus || !mJanus->isValid() ) { return; } + + enableButtonSeparator( separator ); + makeButtonBox( buttonMask, defaultButton, user1, user2, user3 ); + + mIsActivated = true; + setupLayout(); +} + +KDialogBase::KDialogBase( KDialogBase::DialogType dialogFace, WFlags f, TQWidget *parent, const char *name, + bool modal, + const TQString &caption, int buttonMask, + ButtonCode defaultButton, bool separator, + const KGuiItem &user1, const KGuiItem &user2, + const KGuiItem &user3 ) + :KDialog( parent, name, modal, f ), + mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), + mIsActivated(false), mShowTile(false), mMessageBoxMode(false), + mButtonOrientation(Qt::Horizontal), d(new KDialogBasePrivate) +{ + setCaption( caption ); + + makeRelay(); + connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); + + mJanus = new KJanusWidget( this, "janus", dialogFace ); + connect(mJanus, TQT_SIGNAL(aboutToShowPage(TQWidget *)), + this, TQT_SIGNAL(aboutToShowPage(TQWidget *))); + + if( !mJanus || !mJanus->isValid() ) { return; } + + enableButtonSeparator( separator ); + makeButtonBox( buttonMask, defaultButton, user1, user2, user3 ); + + mIsActivated = true; + setupLayout(); +} + +KDialogBase::KDialogBase( const TQString &caption, int buttonMask, + ButtonCode defaultButton, ButtonCode escapeButton, + TQWidget *parent, const char *name, bool modal, + bool separator, const KGuiItem &yes, + const KGuiItem &no, const KGuiItem &cancel ) + :KDialog( parent, name, modal, (WFlags)WStyle_DialogBorder ), + mTopLayout(0), mMainWidget(0), mUrlHelp(0), mJanus(0), mActionSep(0), + mIsActivated(false), mShowTile(false), mMessageBoxMode(true), + mButtonOrientation(Qt::Horizontal),mEscapeButton(escapeButton), + d(new KDialogBasePrivate) +{ + setCaption( caption ); + + makeRelay(); + connect( this, TQT_SIGNAL(layoutHintChanged()), TQT_SLOT(updateGeometry()) ); + + enableButtonSeparator( separator ); + + buttonMask &= Details|Yes|No|Cancel; + + makeButtonBox( buttonMask, defaultButton, + no.text().isEmpty() ? KStdGuiItem::no() : no, + yes.text().isEmpty() ? KStdGuiItem::yes() : yes ); + + setButtonCancel( cancel.text().isEmpty() ? + KStdGuiItem::cancel() : cancel ); + + mIsActivated = true; + setupLayout(); +} + + + +KDialogBase::~KDialogBase() +{ + delete d; +} + +KPushButton *SButton::append( int key, const KGuiItem &item ) +{ + KDialogBaseButton *p = new KDialogBaseButton( item, key, box ); + list.append( p ); + return p; +} + +void SButton::resize( bool sameWidth, int margin, + int spacing, int orientation ) +{ + KDialogBaseButton *p; + int h = 0; + int w = 0; + int t = 0; + + for( p = list.first(); p; p = list.next() ) + { + const TQSize s( p->tqsizeHint() ); + if( s.height() > h ) { h = s.height(); } + if( s.width() > w ) { w = s.width(); } + } + + if( orientation == Qt::Horizontal ) + { + for( p = list.first(); p; p = list.next() ) + { + TQSize s( p->tqsizeHint() ); + if( sameWidth ) { s.setWidth( w ); } + p->setFixedWidth( s.width() ); + t += s.width() + spacing; + } + + box->setMinimumHeight( margin*2 + h ); + box->setMinimumWidth( margin*2 + t - spacing ); + } + else + { + // sameWidth has no effect here + for( p = list.first(); p; p = list.next() ) + { + TQSize s( p->tqsizeHint() ); + s.setWidth( w ); + p->setFixedSize( s ); + t += s.height() + spacing; + } + box->setMinimumHeight( margin*2 + t - spacing ); + box->setMinimumWidth( margin*2 + w ); + } +} + +KPushButton *SButton::button( int key ) +{ + KDialogBaseButton *p; + for( p = list.first(); p; p = list.next() ) + { + if( p->id() == key ) + { + return p; + } + } + return 0; +} + +void +KDialogBase::delayedDestruct() +{ + if (isVisible()) + hide(); + TQTimer::singleShot( 0, this, TQT_SLOT(slotDelayedDestruct())); +} + +void +KDialogBase::slotDelayedDestruct() +{ + delete this; +} + +void KDialogBase::setupLayout() +{ + if( mTopLayout ) + { + delete mTopLayout; + } + // mTopLayout = new TQVBoxLayout( this, marginHint(), spacingHint() ); + + + if( mButtonOrientation == Qt::Horizontal ) + { + mTopLayout = new TQBoxLayout( this, TQBoxLayout::TopToBottom, + marginHint(), spacingHint() ); + } + else + { + mTopLayout = new TQBoxLayout( this, TQBoxLayout::LeftToRight, + marginHint(), spacingHint() ); + } + + if( mUrlHelp ) + { + mTopLayout->addWidget( mUrlHelp, 0, AlignRight ); + } + + if( mJanus ) + { + mTopLayout->addWidget( mJanus, 10 ); + } + else if( mMainWidget ) + { + mTopLayout->addWidget( mMainWidget, 10 ); + } + + if ( d->detailsWidget ) + { + mTopLayout->addWidget( d->detailsWidget ); + } + + if( mActionSep ) + { + mTopLayout->addWidget( mActionSep ); + } + + if( d->mButton.box ) + { + mTopLayout->addWidget( d->mButton.box ); + } +} + + + +void KDialogBase::setButtonBoxOrientation( int orientation ) +{ + if( mButtonOrientation != orientation ) + { + mButtonOrientation = orientation; + if( mActionSep ) + { + mActionSep->setOrientation( mButtonOrientation == Qt::Horizontal ? + TQFrame::HLine : TQFrame::VLine ); + } + if( mButtonOrientation == Qt::Vertical ) + { + enableLinkedHelp(false); // 2000-06-18 Espen: No support for this yet. + } + setupLayout(); + setButtonStyle( d->mButton.style ); + } +} + + +void KDialogBase::setEscapeButton( ButtonCode id ) +{ + mEscapeButton = id; +} + + + +void KDialogBase::makeRelay() +{ + if( mTile ) + { + connect( mTile, TQT_SIGNAL(pixmapChanged()), TQT_SLOT(updateBackground()) ); + return; + } + + mTile = new KDialogBaseTile; + if( mTile ) + { + connect( mTile, TQT_SIGNAL(pixmapChanged()), TQT_SLOT(updateBackground()) ); + connect( tqApp, TQT_SIGNAL(aboutToQuit()), mTile, TQT_SLOT(cleanup()) ); + } +} + + +void KDialogBase::enableButtonSeparator( bool state ) +{ + if( state ) + { + if( mActionSep ) + { + return; + } + mActionSep = new KSeparator( this ); + mActionSep->setFocusPolicy(TQ_NoFocus); + mActionSep->setOrientation( mButtonOrientation == Qt::Horizontal ? + TQFrame::HLine : TQFrame::VLine ); + mActionSep->show(); + } + else + { + if( !mActionSep ) + { + return; + } + delete mActionSep; mActionSep = 0; + } + + if( mIsActivated ) + { + setupLayout(); + } +} + + + +TQFrame *KDialogBase::plainPage() +{ + return ( mJanus ? mJanus->plainPage() : 0 ); +} + + + +void KDialogBase::adjustSize() +{ +// if (layout()) +// layout()->activate(); + if( d->bFixed ) + setFixedSize( tqsizeHint() ); + else + resize( tqsizeHint() ); +} + +TQSize KDialogBase::tqsizeHint() const +{ + return d->minSize.expandedTo( tqminimumSizeHint() ) + d->incSize; +} + +TQSize KDialogBase::tqminimumSizeHint() const +{ + const int m = marginHint(); + const int s = spacingHint(); + + const TQSize zeroByS(0, s); + + TQSize s1(0,0); + TQSize s2(0,0); + + // + // Url help area + // + if( mUrlHelp ) + { + s2 = mUrlHelp->tqminimumSize() + zeroByS; + } + s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() ); + s1.rheight() += s2.rheight(); + + // + // User widget + // + if( mJanus ) + { + s2 = mJanus->tqminimumSizeHint() + zeroByS; + } + else if( mMainWidget ) + { + s2 = mMainWidget->tqsizeHint() + zeroByS; + s2 = s2.expandedTo( mMainWidget->tqminimumSize() ); + s2 = s2.expandedTo( mMainWidget->tqminimumSizeHint() ); + if( s2.isEmpty() ) + { + s2 = TQSize( 100, 100+s ); + } + } + else + { + s2 = TQSize( 100, 100+s ); + } + s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() ); + s1.rheight() += s2.rheight(); + + if (d->detailsWidget && d->bDetails) + { + s2 = d->detailsWidget->tqsizeHint() + zeroByS; + s2 = s2.expandedTo( d->detailsWidget->tqminimumSize() ); + s2 = s2.expandedTo( d->detailsWidget->tqminimumSizeHint() ); + s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() ); + s1.rheight() += s2.rheight(); + } + + // + // Button separator + // + if( mActionSep ) + { + s1.rheight() += mActionSep->tqminimumSize().height() + s; + } + + // + // The button box + // + if( d->mButton.box ) + { + s2 = d->mButton.box->tqminimumSize(); + if( mButtonOrientation == Qt::Horizontal ) + { + s1.rwidth() = QMAX( s1.rwidth(), s2.rwidth() ); + s1.rheight() += s2.rheight(); + } + else + { + s1.rwidth() += s2.rwidth(); + s1.rheight() = QMAX( s1.rheight(), s2.rheight() ); + } + } + + // + // Outer margings + // + s1.rheight() += 2*m; + s1.rwidth() += 2*m; + + return s1; +} + + +void KDialogBase::disableResize() +{ + setFixedSize( tqsizeHint() ); +} + + +void KDialogBase::setInitialSize( const TQSize &s, bool noResize ) +{ + d->minSize = s; + d->bFixed = noResize; + adjustSize(); +} + + +void KDialogBase::incInitialSize( const TQSize &s, bool noResize ) +{ + d->incSize = s; + d->bFixed = noResize; + adjustSize(); +} + + +void KDialogBase::makeButtonBox( int buttonMask, ButtonCode defaultButton, + const KGuiItem &user1, const KGuiItem &user2, + const KGuiItem &user3 ) +{ + if( buttonMask == 0 ) + { + d->mButton.box = 0; + return; // When we want no button box + } + + if( buttonMask & Cancel ) { buttonMask &= ~Close; } + if( buttonMask & Apply ) { buttonMask &= ~Try; } + if( buttonMask & Details ) { buttonMask &= ~Default; } + + if( !mMessageBoxMode ) + { + mEscapeButton = (buttonMask&Cancel) ? Cancel : Close; + } + + d->mButton.box = new TQWidget( this ); + + d->mButton.mask = buttonMask; + if( d->mButton.mask & Help ) + { + KPushButton *pb = d->mButton.append( Help, KStdGuiItem::help() ); + + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotHelp()) ); + } + if( d->mButton.mask & Default ) + { + KPushButton *pb = d->mButton.append( Default, KStdGuiItem::defaults() ); + + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotDefault()) ); + } + if( d->mButton.mask & Details ) + { + KPushButton *pb = d->mButton.append( Details, TQString() ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotDetails()) ); + setDetails(false); + } + if( d->mButton.mask & User3 ) + { + KPushButton *pb = d->mButton.append( User3, user3 ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotUser3()) ); + } + if( d->mButton.mask & User2 ) + { + KPushButton *pb = d->mButton.append( User2, user2 ); + if( mMessageBoxMode ) + { + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotYes()) ); + } + else + { + connect( pb, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotUser2()) ); + } + } + if( d->mButton.mask & User1 ) + { + KPushButton *pb = d->mButton.append( User1, user1 ); + if( mMessageBoxMode ) + { + connect( pb, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNo()) ); + } + else + { + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotUser1()) ); + } + } + if( d->mButton.mask & Ok ) + { + KPushButton *pb = d->mButton.append( Ok, KStdGuiItem::ok() ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotOk()) ); + } + if( d->mButton.mask & Apply ) + { + KPushButton *pb = d->mButton.append( Apply, KStdGuiItem::apply() ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotApply()) ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(applyPressed()) ); + } + if( d->mButton.mask & Try ) + { + KPushButton *pb = d->mButton.append( Try, + i18n( "&Try" ) ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotTry()) ); + } + if( d->mButton.mask & Cancel ) + { + KPushButton *pb = d->mButton.append( Cancel, KStdGuiItem::cancel() ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotCancel()) ); + } + if( d->mButton.mask & Close ) + { + KPushButton *pb = d->mButton.append( Close, KStdGuiItem::close() ); + connect( pb, TQT_SIGNAL(clicked()), TQT_SLOT(slotClose()) ); + } + + if( defaultButton != NoDefault ) + { + TQPushButton *pb = actionButton( defaultButton ); + if( pb ) + { + setButtonFocus( pb, true, false ); + } + } + + setButtonStyle( KGlobalSettings::buttonLayout() ); +} + + + +void KDialogBase::setButtonStyle( int style ) +{ + if( !d->mButton.box ) + { + return; + } + + if( style < 0 || style >= ActionStyleMAX ) { style = ActionStyle0; } + d->mButton.style = style; + + const int *layout; + int layoutMax = 0; + if (mMessageBoxMode) + { + static const int layoutRule[5][6] = + { + {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler}, + {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler}, + {Details,Stretch,User2|Stretch,User1|Stretch,Cancel|Stretch, Details|Filler}, + {Details|Filler,Stretch,Cancel|Stretch,User2|Stretch,User1|Stretch,Details}, + {Details|Filler,Stretch,Cancel|Stretch,User2|Stretch,User1|Stretch,Details} + }; + layoutMax = 6; + layout = layoutRule[ d->mButton.style ]; + } + else if (mButtonOrientation == Qt::Horizontal) + { + static const int layoutRule[5][10] = + { + {Details,Help,Default,Stretch,User3,User2,User1,Ok,Apply|Try,Cancel|Close}, + {Details,Help,Default,Stretch,User3,User2,User1,Cancel|Close,Apply|Try,Ok}, + {Details,Help,Default,Stretch,User3,User2,User1,Apply|Try,Cancel|Close,Ok}, + {Ok,Apply|Try,Cancel|Close,User3,User2,User1,Stretch,Default,Help,Details}, + {Ok,Cancel|Close,Apply|Try,User3,User2,User1,Stretch,Default,Help,Details} + }; + layoutMax = 10; + layout = layoutRule[ d->mButton.style ]; + } + else + { + static const int layoutRule[5][10] = + { + {Ok,Apply|Try,User1,User2,User3,Stretch,Default,Cancel|Close,Help, Details}, + //{Ok,Apply|Try,Cancel|Close,User1,User2,User3,Stretch, Default,Help, Details}, + {Details,Help,Default,Stretch,User3,User2,User1,Cancel|Close,Apply|Try,Ok}, + {Details,Help,Default,Stretch,User3,User2,User1,Apply|Try,Cancel|Close,Ok}, + {Ok,Apply|Try,Cancel|Close,User3,User2,User1,Stretch,Default,Help,Details}, + {Ok,Cancel|Close,Apply|Try,User3,User2,User1,Stretch,Default,Help,Details} + }; + layoutMax = 10; + layout = layoutRule[ d->mButton.style ]; + } + + if( d->mButton.box->layout() ) + { + delete d->mButton.box->layout(); + } + + TQBoxLayout *lay; + if( mButtonOrientation == Qt::Horizontal ) + { + lay = new TQBoxLayout( d->mButton.box, TQBoxLayout::LeftToRight, 0, + spacingHint()); + } + else + { + lay = new TQBoxLayout( d->mButton.box, TQBoxLayout::TopToBottom, 0, + spacingHint()); + } + + int numButton = 0; + TQPushButton *prevButton = 0; + TQPushButton *newButton; + + for( int i=0; i<layoutMax; ++i ) + { + if(((ButtonCode) layout[i]) == Stretch) // Unconditional Stretch + { + lay->addStretch(1); + continue; + } + else if (layout[i] & Filler) // Conditional space + { + if (d->mButton.mask & layout[i]) + { + newButton = actionButton( (ButtonCode) (layout[i] & ~(Stretch | Filler))); + if (newButton) + lay->addSpacing(newButton->tqsizeHint().width()); + } + continue; + } + else if( d->mButton.mask & Help & layout[i] ) + { + newButton = actionButton( Help ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Default & layout[i] ) + { + newButton = actionButton( Default ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & User3 & layout[i] ) + { + newButton = actionButton( User3 ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & User2 & layout[i] ) + { + newButton = actionButton( User2 ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & User1 & layout[i] ) + { + newButton = actionButton( User1 ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Ok & layout[i] ) + { + newButton = actionButton( Ok ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Apply & layout[i] ) + { + newButton = actionButton( Apply ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Try & layout[i] ) + { + newButton = actionButton( Try ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Cancel & layout[i] ) + { + newButton = actionButton( Cancel ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Close & layout[i] ) + { + newButton = actionButton( Close ); + lay->addWidget( newButton ); ++numButton; + } + else if( d->mButton.mask & Details & layout[i] ) + { + newButton = actionButton( Details ); + lay->addWidget( newButton ); ++numButton; + } + else + { + continue; + } + + // Add conditional stretch (Only added if a button was added) + if(layout[i] & Stretch) + { + lay->addStretch(1); + } + + if( prevButton ) + { + setTabOrder( prevButton, newButton ); + } + prevButton = newButton; + } + + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); +} + + +TQPushButton *KDialogBase::actionButton( ButtonCode id ) +{ + return d->mButton.button(id); +} + + +void KDialogBase::enableButton( ButtonCode id, bool state ) +{ + TQPushButton *pb = actionButton( id ); + if( pb ) + { + pb->setEnabled( state ); + } +} + + +void KDialogBase::enableButtonOK( bool state ) +{ + enableButton( Ok, state ); +} + + +void KDialogBase::enableButtonApply( bool state ) +{ + enableButton( Apply, state ); +} + + +void KDialogBase::enableButtonCancel( bool state ) +{ + enableButton( Cancel, state ); +} + + +void KDialogBase::showButton( ButtonCode id, bool state ) +{ + TQPushButton *pb = actionButton( id ); + if( pb ) + { + state ? pb->show() : pb->hide(); + } +} + + +void KDialogBase::showButtonOK( bool state ) +{ + showButton( Ok, state ); +} + + +void KDialogBase::showButtonApply( bool state ) +{ + showButton( Apply, state ); +} + + +void KDialogBase::showButtonCancel( bool state ) +{ + showButton( Cancel, state ); +} + + +void KDialogBase::setButtonOKText( const TQString &text, + const TQString &tooltip, + const TQString &quickhelp ) +{ + TQPushButton *pb = actionButton( Ok ); + if( !pb ) + { + return; + } + + const TQString whatsThis = i18n( "" + "If you press the <b>OK</b> button, all changes\n" + "you made will be used to proceed."); + + pb->setText( text.isEmpty() ? i18n("&OK") : text ); + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); + + TQToolTip::add( pb, tooltip.isEmpty() ? i18n("Accept settings") : tooltip ); + TQWhatsThis::add( pb, quickhelp.isEmpty() ? whatsThis : quickhelp ); +} + + +void KDialogBase::setButtonOK( const KGuiItem &item /* = KStdGuiItem::ok() */ ) +{ + setButtonGuiItem( Ok, item ); +} + + +void KDialogBase::setButtonApplyText( const TQString &text, + const TQString &tooltip, + const TQString &quickhelp ) +{ + TQPushButton *pb = actionButton( Apply ); + if( !pb ) + { + return; + } + + const TQString whatsThis = i18n( "" + "When clicking <b>Apply</b>, the settings will be\n" + "handed over to the program, but the dialog\n" + "will not be closed. " + "Use this to try different settings. "); + + pb->setText( text.isEmpty() ? i18n("&Apply") : text ); + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); + + TQToolTip::add( pb, tooltip.isEmpty() ? i18n("Apply settings") : tooltip ); + TQWhatsThis::add( pb, quickhelp.isEmpty() ? whatsThis : quickhelp ); +} + + +void KDialogBase::setButtonApply( const KGuiItem &item /* = KStdGuiItem::apply() */ ) +{ + setButtonGuiItem( Apply, item ); +} + + +void KDialogBase::setButtonCancelText( const TQString& text, + const TQString& tooltip, + const TQString& quickhelp ) +{ + TQPushButton *pb = actionButton( Cancel ); + if( !pb ) + { + return; + } + + pb->setText( text.isEmpty() ? i18n("&Cancel") : text ); + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); + + TQToolTip::add( pb, tooltip ); + TQWhatsThis::add( pb, quickhelp ); +} + + +void KDialogBase::setButtonCancel( const KGuiItem &item /* = KStdGuiItem::cancel() */ ) +{ + setButtonGuiItem( Cancel, item ); +} + +void KDialogBase::setButtonGuiItem( ButtonCode id, const KGuiItem &item ) +{ + KPushButton *pb = static_cast<KPushButton *>( actionButton( id ) ); + if( !pb ) + return; + + pb->setGuiItem( item ); + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); +} + + +void KDialogBase::setButtonText( ButtonCode id, const TQString &text ) +{ + if (!d->bSettingDetails && (id == Details)) + { + d->detailsButton = text; + setDetails(d->bDetails); + return; + } + TQPushButton *pb = actionButton( id ); + if( pb ) + { + pb->setText( text ); + d->mButton.resize( false, 0, spacingHint(), mButtonOrientation ); + } +} + + +void KDialogBase::setButtonTip( ButtonCode id, const TQString &text ) +{ + TQPushButton *pb = actionButton( id ); + if( pb ) + { + if (text.isEmpty()) + TQToolTip::remove( pb ); + else + TQToolTip::add( pb, text ); + } +} + + +void KDialogBase::setButtonWhatsThis( ButtonCode id, const TQString &text ) +{ + TQPushButton *pb = actionButton( id ); + if( pb ) + { + if (text.isEmpty()) + TQWhatsThis::remove( pb ); + else + TQWhatsThis::add( pb, text ); + } +} + + +void KDialogBase::setButtonFocus( TQPushButton *p,bool isDefault, bool isFocus ) +{ + p->setDefault( isDefault ); + if( isFocus ) + p->setFocus(); +} + + +void KDialogBase::setTreeListAutoResize( bool state ) +{ + if( mJanus ) + { + mJanus->setTreeListAutoResize( state ); + } +} + +void KDialogBase::setShowIconsInTreeList(bool state) +{ + if( mJanus ) + { + mJanus->setShowIconsInTreeList( state ); + } +} + +void KDialogBase::setRootIsDecorated( bool state ) +{ + if( mJanus ) + { + mJanus->setRootIsDecorated( state ); + } +} + +void KDialogBase::unfoldTreeList( bool persist ) +{ + if( mJanus ) + mJanus->unfoldTreeList( persist ); +} + +void KDialogBase::addWidgetBelowList( TQWidget * widget ) +{ + if( mJanus ) + mJanus->addWidgetBelowList( widget ); +} + +void KDialogBase::addButtonBelowList( const TQString & text, TQObject * recv, const char * slot ) +{ + if( mJanus ) + mJanus->addButtonBelowList( text, recv, slot ); +} + +void KDialogBase::addButtonBelowList( const KGuiItem & item, TQObject * recv, const char * slot ) +{ + if( mJanus ) + mJanus->addButtonBelowList( item, recv, slot ); +} + +void KDialogBase::setIconListAllVisible( bool state ) +{ + if( mJanus ) + { + mJanus->setIconListAllVisible( state ); + } +} + + +void KDialogBase::slotHelp() +{ + emit helpClicked(); + if ( kapp ) // may be null when used inside designer + kapp->invokeHelp( mAnchor, mHelpApp ); +} + + +void KDialogBase::slotDefault() +{ + emit defaultClicked(); +} + +void KDialogBase::slotDetails() +{ + setDetails(!d->bDetails); +} + +void KDialogBase::setDetailsWidget(TQWidget *detailsWidget) +{ + delete d->detailsWidget; + d->detailsWidget = detailsWidget; + if (d->detailsWidget->parentWidget() != this) + d->detailsWidget->reparent(this, TQPoint(0,0)); + d->detailsWidget->hide(); + if( mIsActivated ) + { + setupLayout(); + } + if (!d->bSettingDetails) + setDetails(d->bDetails); +} + +void KDialogBase::setDetails(bool showDetails) +{ + if (d->detailsButton.isEmpty()) + d->detailsButton = i18n("&Details"); + d->bSettingDetails = true; + d->bDetails = showDetails; + if (d->bDetails) + { + emit aboutToShowDetails(); + setButtonText(Details, d->detailsButton+ " <<"); + if (d->detailsWidget) + { + if (layout()) + layout()->setEnabled(false); + adjustSize(); + d->detailsWidget->show(); + if (layout()) + { + layout()->activate(); + layout()->setEnabled(true); + } + } + } + else + { + setButtonText(Details, d->detailsButton+" >>"); + if (d->detailsWidget) + { + d->detailsWidget->hide(); + } + if (layout()) + layout()->activate(); + adjustSize(); + } + d->bSettingDetails = false; +} + +void KDialogBase::slotOk() +{ + emit okClicked(); + accept(); +} + + +void KDialogBase::slotApply() +{ + emit applyClicked(); +} + + +void KDialogBase::slotTry() +{ + emit tryClicked(); +} + + +void KDialogBase::slotUser3() +{ + emit user3Clicked(); +} + + +void KDialogBase::slotUser2() +{ + emit user2Clicked(); +} + + +void KDialogBase::slotUser1() +{ + emit user1Clicked(); +} + + +void KDialogBase::slotYes() +{ + emit yesClicked(); + done( Yes ); +} + + +void KDialogBase::slotNo() +{ + emit noClicked(); + done( No ); +} + + +void KDialogBase::slotCancel() +{ + emit cancelClicked(); + done( mMessageBoxMode ? (int)Cancel : (int)Rejected ); +} + + +void KDialogBase::slotClose() +{ + emit closeClicked(); + reject(); +} + + +void KDialogBase::helpClickedSlot( const TQString & ) +{ + slotHelp(); +} + + +void KDialogBase::applyPressed() +{ + emit apply(); +} + + +void KDialogBase::enableLinkedHelp( bool state ) +{ + if( state ) + { + if( mUrlHelp ) + { + return; + } + + mUrlHelp = new KURLLabel( this, "url" ); + mUrlHelp->setText( helpLinkText() ); + mUrlHelp->setFloat(true); + mUrlHelp->setUnderline(true); + if( mShowTile && mTile->get() ) + { + mUrlHelp->setBackgroundPixmap(*mTile->get()); + } + mUrlHelp->setMinimumHeight( fontMetrics().height() + marginHint() ); + connect(mUrlHelp,TQT_SIGNAL(leftClickedURL(const TQString &)), + TQT_SLOT(helpClickedSlot(const TQString &))); + mUrlHelp->show(); + } + else + { + if( !mUrlHelp ) + { + return; + } + delete mUrlHelp; mUrlHelp = 0; + } + + if( mIsActivated ) + { + setupLayout(); + } +} + + +void KDialogBase::setHelp( const TQString &anchor, const TQString &appname ) +{ + mAnchor = anchor; + mHelpApp = appname; +} + + +void KDialogBase::setHelpLinkText( const TQString &text ) +{ + mHelpLinkText = text; + if( mUrlHelp ) + { + mUrlHelp->setText( helpLinkText() ); + } +} + + +TQFrame *KDialogBase::addPage( const TQString &itemName, const TQString &header, + const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addPage( itemName, header, pixmap ) : 0); +} + +TQFrame *KDialogBase::addPage( const TQStringList &items, const TQString &header, + const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addPage( items, header, pixmap ) : 0); +} + + +TQVBox *KDialogBase::addVBoxPage( const TQString &itemName, + const TQString &header, const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addVBoxPage( itemName, header, pixmap) : 0); +} + +TQVBox *KDialogBase::addVBoxPage( const TQStringList &items, + const TQString &header, const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addVBoxPage( items, header, pixmap) : 0); +} + + +TQHBox *KDialogBase::addHBoxPage( const TQString &itemName, + const TQString &header, + const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addHBoxPage( itemName, header, pixmap ) : 0); +} + +TQHBox *KDialogBase::addHBoxPage( const TQStringList &items, + const TQString &header, + const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addHBoxPage( items, header, pixmap ) : 0); +} + + +TQGrid *KDialogBase::addGridPage( int n, Orientation dir, + const TQString &itemName, + const TQString &header, const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addGridPage( n, dir, itemName, header, pixmap) : 0); +} + +TQGrid *KDialogBase::addGridPage( int n, Orientation dir, + const TQStringList &items, + const TQString &header, const TQPixmap &pixmap ) +{ + return ( mJanus ? mJanus->addGridPage( n, dir, items, header, pixmap) : 0); +} + +void KDialogBase::setFolderIcon(const TQStringList &path, const TQPixmap &pixmap) +{ + if (!mJanus) + return; + + mJanus->setFolderIcon(path,pixmap); +} + +TQFrame *KDialogBase::makeMainWidget() +{ + if( mJanus || mMainWidget ) + { + printMakeMainWidgetError(); + return 0; + } + + TQFrame *mainWidget = new TQFrame( this ); + setMainWidget( mainWidget ); + return mainWidget; +} + + +TQVBox *KDialogBase::makeVBoxMainWidget() +{ + if( mJanus || mMainWidget ) + { + printMakeMainWidgetError(); + return 0; + } + + TQVBox *mainWidget = new TQVBox( this ); + mainWidget->setSpacing( spacingHint() ); + setMainWidget( mainWidget ); + return mainWidget; +} + + +TQHBox *KDialogBase::makeHBoxMainWidget() +{ + if( mJanus || mMainWidget ) + { + printMakeMainWidgetError(); + return 0; + } + + TQHBox *mainWidget = new TQHBox( this ); + mainWidget->setSpacing( spacingHint() ); + setMainWidget( mainWidget ); + return mainWidget; +} + + +TQGrid *KDialogBase::makeGridMainWidget( int n, Orientation dir ) +{ + if( mJanus || mMainWidget ) + { + printMakeMainWidgetError(); + return 0; + } + + TQGrid *mainWidget = new TQGrid( n, dir, this ); + mainWidget->setSpacing( spacingHint() ); + setMainWidget( mainWidget ); + return mainWidget; +} + + +void KDialogBase::printMakeMainWidgetError() +{ + if( mJanus ) + { + kdDebug() << "makeMainWidget: Illegal mode (wrong constructor)" << endl; + } + else if( mMainWidget ) + { + kdDebug() << "makeMainWidget: Main widget already defined" << endl; + } +} + + +void KDialogBase::setMainWidget( TQWidget *widget ) +{ + if( mJanus ) + { + if( mJanus->setSwallowedWidget(widget) ) + { + mMainWidget = widget; + } + } + else + { + mMainWidget = widget; + if( mIsActivated ) + { + setupLayout(); + } + } + if( mMainWidget != NULL ) + { + TQFocusData* fd = focusData(); + TQWidget* prev = fd->last(); + for( TQPtrListIterator<KDialogBaseButton> it( d->mButton.list ); + it != NULL; + ++it ) + { + if( prev != *it ) + setTabOrder( prev, *it ); + prev = *it; + } + } +} + + +TQWidget *KDialogBase::mainWidget() +{ + return mMainWidget; +} + + +bool KDialogBase::showPage( int index ) +{ + return ( mJanus ? mJanus->showPage(index) : false); +} + + +int KDialogBase::activePageIndex() const +{ + return ( mJanus ? mJanus->activePageIndex() : -1); +} + + +int KDialogBase::pageIndex( TQWidget *widget ) const +{ + return ( mJanus ? mJanus->pageIndex( widget) : -1); +} + + +// Deprecated +TQRect KDialogBase::getContentsRect() const +{ + TQRect r; + r.setLeft( marginHint() ); + r.setTop( marginHint() + (mUrlHelp ? mUrlHelp->height() : 0) ); + r.setRight( width() - marginHint() ); + int h = (!mActionSep ? 0 : mActionSep->tqminimumSize().height()+marginHint()); + if( d->mButton.box ) + { + r.setBottom( height() - d->mButton.box->tqminimumSize().height() - h ); + } + else + { + r.setBottom( height() - h ); + } + + return r; +} + + +// Deprecated +void KDialogBase::getBorderWidths(int& ulx, int& uly, int& lrx, int& lry) const +{ + ulx = marginHint(); + uly = marginHint(); + if( mUrlHelp ) + { + uly += mUrlHelp->tqminimumSize().height(); + } + + lrx = marginHint(); + lry = d->mButton.box ? d->mButton.box->tqminimumSize().height() : 0; + if( mActionSep ) + { + lry += mActionSep->tqminimumSize().height() + marginHint(); + } +} + + +TQSize KDialogBase::calculateSize(int w, int h) const +{ + int ulx, uly, lrx, lry; + getBorderWidths(ulx, uly, lrx, lry); + return TQSize(ulx+w+lrx,uly+h+lry); +} + + +TQString KDialogBase::helpLinkText() const +{ + return ( mHelpLinkText.isNull() ? i18n("Get help...") : mHelpLinkText ); +} + + +void KDialogBase::updateGeometry() +{ + if( mTopLayout ) + { + mTopLayout->setMargin( marginHint() ); + mTopLayout->setSpacing(spacingHint() ); + } +} + + + +void KDialogBase::keyPressEvent( TQKeyEvent *e ) +{ + // + // Reimplemented from KDialog to remove the default behavior + // and to add F1 (help) sensitivity and some animation. + // + if( e->state() == 0 ) + { + if( e->key() == Key_F1 ) + { + TQPushButton *pb = actionButton( Help ); + if( pb ) + { + pb->animateClick(); + e->accept(); + return; + } + } + if( e->key() == Key_Escape ) + { + TQPushButton *pb = actionButton( mEscapeButton ); + if( pb ) + { + pb->animateClick(); + e->accept(); + return; + } + + } + } + else if( e->key() == Key_F1 && e->state() == ShiftButton ) + { + TQWhatsThis::enterWhatsThisMode(); + e->accept(); + return; + } + + // accept the dialog when Ctrl-Return is pressed + else if ( e->state() == ControlButton && + (e->key() == Key_Return || e->key() == Key_Enter) ) + { + TQPushButton *pb = actionButton( Ok ); + if ( pb ) + { + pb->animateClick(); + e->accept(); + return; + } + } + + // + // Do the default action instead. Note KDialog::keyPressEvent is bypassed + // + TQDialog::keyPressEvent(e); +} + + + +void KDialogBase::hideEvent( TQHideEvent *ev ) +{ + emit hidden(); + if (!ev->spontaneous()) + { + emit finished(); + } +} + + + +void KDialogBase::closeEvent( TQCloseEvent *e ) +{ + TQPushButton *pb = actionButton( mEscapeButton ); + if( pb && isShown() ) { + pb->animateClick(); + } else { + TQDialog::closeEvent( e ); + } +} + +void KDialogBase::cancel() +{ + switch ( mEscapeButton ) { + case Ok: + slotOk(); + break; + case User1: // == No + if ( mMessageBoxMode ) + slotNo(); + else + slotUser1(); + break; + case User2: // == Yes + if ( mMessageBoxMode ) + slotYes(); + else + slotUser2(); + break; + case User3: + slotUser3(); + break; + case Close: + slotClose(); + break; + case Cancel: + default: + slotCancel(); + } +} + +bool KDialogBase::haveBackgroundTile() +{ + return ( !mTile || mTile->get() ); +} + +// Deprecated. For compatibility only. +const TQPixmap *KDialogBase::getBackgroundTile() { return backgroundTile(); } + +const TQPixmap *KDialogBase::backgroundTile() +{ + return ( mTile ? mTile->get() : 0); +} + + +void KDialogBase::setBackgroundTile( const TQPixmap *pix ) +{ + if( mTile ) + { + mTile->set( pix ); + } +} + + +void KDialogBase::updateBackground() +{ + if( !mTile || !mTile->get() ) + { + TQPixmap nullPixmap; + setBackgroundPixmap(nullPixmap); + if( d->mButton.box ) + { + d->mButton.box->setBackgroundPixmap(nullPixmap); + d->mButton.box->setBackgroundMode(PaletteBackground); + } + setBackgroundMode(PaletteBackground); + } + else + { + const TQPixmap *pix = mTile->get(); + setBackgroundPixmap(*pix); + if( d->mButton.box ) + { + d->mButton.box->setBackgroundPixmap(*pix); + } + showTile( mShowTile ); + } +} + + +void KDialogBase::showTile( bool state ) +{ + mShowTile = state; + if( !mShowTile || !mTile || !mTile->get() ) + { + setBackgroundMode(PaletteBackground); + if( d->mButton.box ) + { + d->mButton.box->setBackgroundMode(PaletteBackground); + } + if( mUrlHelp ) + { + mUrlHelp->setBackgroundMode(PaletteBackground); + } + } + else + { + const TQPixmap *pix = mTile->get(); + setBackgroundPixmap(*pix); + if( d->mButton.box ) + { + d->mButton.box->setBackgroundPixmap(*pix); + } + if( mUrlHelp ) + { + mUrlHelp->setBackgroundPixmap(*pix); + } + } +} + +TQSize KDialogBase::configDialogSize( const TQString& groupName ) const +{ + return configDialogSize( *KGlobal::config(), groupName ); +} + + +TQSize KDialogBase::configDialogSize( KConfig& config, + const TQString& groupName ) const +{ + int w, h; + int scnum = TQApplication::desktop()->screenNumber(parentWidget()); + TQRect desk = TQApplication::desktop()->screenGeometry(scnum); + + w = tqsizeHint().width(); + h = tqsizeHint().height(); + + KConfigGroupSaver cs(&config, groupName); + w = config.readNumEntry( TQString::tqfromLatin1("Width %1").arg( desk.width()), w ); + h = config.readNumEntry( TQString::tqfromLatin1("Height %1").arg( desk.height()), h ); + + return TQSize( w, h ); +} + + +void KDialogBase::saveDialogSize( const TQString& groupName, bool global ) +{ + saveDialogSize( *KGlobal::config(), groupName, global ); +} + + +void KDialogBase::saveDialogSize( KConfig& config, const TQString& groupName, + bool global ) const +{ + int scnum = TQApplication::desktop()->screenNumber(parentWidget()); + TQRect desk = TQApplication::desktop()->screenGeometry(scnum); + + KConfigGroupSaver cs(&config, groupName); + TQSize sizeToSave = size(); + + config.writeEntry( TQString::tqfromLatin1("Width %1").arg( desk.width()), + TQString::number( sizeToSave.width()), true, global); + config.writeEntry( TQString::tqfromLatin1("Height %1").arg( desk.height()), + TQString::number( sizeToSave.height()), true, global); +} + + +KDialogBaseButton::KDialogBaseButton( const KGuiItem &item, int key, + TQWidget *parent, const char *name ) + : KPushButton( item, parent, name ), mKey(key) +{ +} + + + + +KDialogBaseTile::KDialogBaseTile( TQObject *parent, const char *name ) + : TQObject( parent, name ), mPixmap(0) +{ +} + + +KDialogBaseTile::~KDialogBaseTile() +{ + cleanup(); +} + + +void KDialogBaseTile::set( const TQPixmap *pix ) +{ + if( !pix ) + { + cleanup(); + } + else + { + if( !mPixmap ) + { + mPixmap = new TQPixmap(*pix); + } + else + { + *mPixmap = *pix; + } + } + + emit pixmapChanged(); +} + + +const TQPixmap *KDialogBaseTile::get() const +{ + return mPixmap; +} + + +void KDialogBaseTile::cleanup() +{ + delete mPixmap; mPixmap = 0; +} + +void KDialogBase::virtual_hook( int id, void* data ) +{ KDialog::virtual_hook( id, data ); } + +#include "kdialogbase.moc" |