You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1845 lines
40 KiB
1845 lines
40 KiB
/*
|
|
* 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"
|