summaryrefslogtreecommitdiffabout
path: root/microkde/kdeui
Side-by-side diff
Diffstat (limited to 'microkde/kdeui') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdeui/ktoolbar.cpp14
-rw-r--r--microkde/kdeui/ktoolbar.h4
2 files changed, 15 insertions, 3 deletions
diff --git a/microkde/kdeui/ktoolbar.cpp b/microkde/kdeui/ktoolbar.cpp
index df2aad8..027e5e9 100644
--- a/microkde/kdeui/ktoolbar.cpp
+++ b/microkde/kdeui/ktoolbar.cpp
@@ -66,384 +66,386 @@
#include "ktoolbarbutton.h"
//US
#include "kconfigbase.h"
#include <qpopupmenu.h>
#include <qmainwindow.h>
enum {
CONTEXT_TOP = 0,
CONTEXT_LEFT = 1,
CONTEXT_RIGHT = 2,
CONTEXT_BOTTOM = 3,
CONTEXT_FLOAT = 4,
CONTEXT_FLAT = 5,
CONTEXT_ICONS = 6,
CONTEXT_TEXT = 7,
CONTEXT_TEXTRIGHT = 8,
CONTEXT_TEXTUNDER = 9,
CONTEXT_ICONSIZES = 50 // starting point for the icon size list, put everything else before
};
class KToolBarPrivate
{
public:
KToolBarPrivate() {
m_iconSize = 0;
m_iconText = KToolBar::IconOnly;
m_highlight = true;
m_transparent = true;
m_honorStyle = false;
m_enableContext = true;
m_xmlguiClient = 0;
m_configurePlugged = false;
//US oldPos = Qt::DockUnmanaged;
oldPos = QMainWindow::Unmanaged;
modified = m_isHorizontal = positioned = FALSE;
HiddenDefault = false;
IconSizeDefault = 0;
IconTextDefault = "IconOnly";
IndexDefault = -1;
NewLineDefault = false;
OffsetDefault = -1;
PositionDefault = "Top";
idleButtons.setAutoDelete(true);
}
int m_iconSize;
KToolBar::IconText m_iconText;
bool m_highlight : 1;
bool m_transparent : 1;
bool m_honorStyle : 1;
bool m_isHorizontal : 1;
bool m_enableContext : 1;
bool m_configurePlugged : 1;
bool modified : 1;
bool positioned : 1;
QWidget *m_parent;
QMainWindow::ToolBarDock oldPos;
KXMLGUIClient *m_xmlguiClient;
struct ToolBarInfo
{
//US ToolBarInfo() : index( 0 ), offset( -1 ), newline( FALSE ), dock( Qt::DockTop ) {}
ToolBarInfo() : index( 0 ), offset( -1 ), newline( FALSE ), dock( QMainWindow::Top ) {}
//US ToolBarInfo( Qt::Dock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {}
ToolBarInfo( QMainWindow::ToolBarDock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {}
int index, offset;
bool newline;
//US Qt::Dock dock;
QMainWindow::ToolBarDock dock;
};
ToolBarInfo toolBarInfo;
QValueList<int> iconSizes;
QTimer repaintTimer;
// Default Values.
bool HiddenDefault;
int IconSizeDefault;
QString IconTextDefault;
int IndexDefault;
bool NewLineDefault;
int OffsetDefault;
QString PositionDefault;
QPtrList<QWidget> idleButtons;
};
KToolBarSeparator::KToolBarSeparator(Orientation o , bool l, QToolBar *parent,
const char* name )
:QFrame( parent, name ), line( l )
{
connect( parent, SIGNAL(orientationChanged(Orientation)),
this, SLOT(setOrientation(Orientation)) );
setOrientation( o );
setBackgroundMode( parent->backgroundMode() );
setBackgroundOrigin( ParentOrigin );
}
void KToolBarSeparator::setOrientation( Orientation o )
{
orient = o;
if ( line ) {
if ( orientation() == Vertical )
setFrameStyle( HLine + Sunken );
else
setFrameStyle( VLine + Sunken );
} else {
setFrameStyle( NoFrame );
}
}
void KToolBarSeparator::styleChange( QStyle& )
{
setOrientation( orient );
}
QSize KToolBarSeparator::sizeHint() const
{
return orientation() == Vertical ? QSize( 0, 6 ) : QSize( 6, 0 );
}
QSizePolicy KToolBarSeparator::sizePolicy() const
{
return QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
}
KToolBar::KToolBar( QWidget *parent, const char *name, bool honorStyle, bool readConfig )
#ifdef DESKTOP_VERSION
: QToolBar( QString::fromLatin1( name ),
parent && parent->inherits( "QMainWindow" ) ? static_cast<QMainWindow*>(parent) : 0,
parent, FALSE,
name ? name : "mainToolBar")
#else
: QPEToolBar( parent && parent->inherits( "QMainWindow" ) ? static_cast<QMainWindow*>(parent) : 0,
QString::fromLatin1( name ))
#endif
{
init( readConfig, honorStyle );
}
KToolBar::KToolBar( QMainWindow *parentWindow, QMainWindow::ToolBarDock dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
#ifdef DESKTOP_VERSION
: QToolBar( QString::fromLatin1( name ),
parentWindow, dock, newLine,
name ? name : "mainToolBar")
#else
: QPEToolBar( parentWindow,QString::fromLatin1( name ))
#endif
{
init( readConfig, honorStyle );
}
KToolBar::KToolBar( QMainWindow *parentWindow, QWidget *dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
#ifdef DESKTOP_VERSION
: QToolBar( QString::fromLatin1( name ),
parentWindow, dock, newLine,
name ? name : "mainToolBar")
#else
: QPEToolBar( parentWindow,QString::fromLatin1( name ))
#endif
{
init( readConfig, honorStyle );
}
KToolBar::~KToolBar()
{
inshutdownprocess = true;
emit toolbarDestroyed();
delete d;
}
void KToolBar::init( bool readConfig, bool honorStyle )
{
+ sizeHintW = 240;
+ sizeHintH = 22;
inshutdownprocess = false;
d = new KToolBarPrivate;
setFullSize( TRUE );
d->m_honorStyle = honorStyle;
context = 0;
layoutTimer = new QTimer( this );
connect( layoutTimer, SIGNAL( timeout() ),
this, SLOT( rebuildLayout() ) );
connect( &(d->repaintTimer), SIGNAL( timeout() ),
this, SLOT( slotRepaint() ) );
/*US
if ( kapp ) { // may be null when started inside designer
connect(kapp, SIGNAL(toolbarAppearanceChanged(int)), this, SLOT(slotAppearanceChanged()));
// request notification of changes in icon style
kapp->addKipcEventMask(KIPC::IconChanged);
connect(kapp, SIGNAL(iconChanged(int)), this, SLOT(slotIconChanged(int)));
}
*/
// finally, read in our configurable settings
if ( readConfig )
slotReadConfig();
if ( mainWindow() )
connect( mainWindow(), SIGNAL( toolBarPositionChanged( QToolBar * ) ),
this, SLOT( toolBarPosChanged( QToolBar * ) ) );
// Hack to make sure we recalculate our size when we dock.
//US connect( this, SIGNAL(placeChanged(QDockWindow::Place)), SLOT(rebuildLayout()) );
}
int KToolBar::insertButton(const QString& icon, int id, bool enabled,
const QString& text, int index/*US, KInstance *_instance*/ )
{
KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text/*US, _instance*/ );
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
doConnections( button );
return index;
}
int KToolBar::insertButton(const QString& icon, int id, const char *signal,
const QObject *receiver, const char *slot,
bool enabled, const QString& text, int index/*US, KInstance *_instance*/ )
{
KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text/*US, _instance*/);
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
connect( button, signal, receiver, slot );
doConnections( button );
return index;
}
int KToolBar::insertButton(const QPixmap& pixmap, int id, bool enabled,
const QString& text, int index )
{
KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
doConnections( button );
return index;
}
#if 0
bar->insertButton( icon, id_, SIGNAL( clicked() ), this,
SLOT( slotActivated() ),
d->isEnabled(), d->plainText(), index/*US, instance*/ );
#endif
int KToolBar::insertButton(const QPixmap& pixmap, int id, const char *signal,
const QObject *receiver, const char *slot,
bool enabled, const QString& text,
int index )
{
KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
connect( button, signal, receiver, slot );
doConnections( button );
return index;
}
int KToolBar::insertButton(const QString& icon, int id, QPopupMenu *popup,
bool enabled, const QString &text, int index )
{
KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text );
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
button->setPopup( popup );
doConnections( button );
return index;
}
int KToolBar::insertButton(const QPixmap& pixmap, int id, QPopupMenu *popup,
bool enabled, const QString &text, int index )
{
KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text );
insertWidgetInternal( button, index, id );
button->setEnabled( enabled );
button->setPopup( popup );
doConnections( button );
return index;
}
int KToolBar::insertLined (const QString& text, int id,
const char *signal,
const QObject *receiver, const char *slot,
bool enabled ,
const QString& toolTipText,
int size, int index )
{
KLineEdit *lined = new KLineEdit ( this, 0 );
if ( !toolTipText.isEmpty() )
QToolTip::add( lined, toolTipText );
if ( size > 0 )
lined->setMinimumWidth( size );
insertWidgetInternal( lined, index, id );
connect( lined, signal, receiver, slot );
lined->setText(text);
lined->setEnabled( enabled );
return index;
}
int KToolBar::insertCombo (const QStringList &list, int id, bool writable,
const char *signal, const QObject *receiver,
const char *slot, bool enabled,
const QString& tooltiptext,
int size, int index,
QComboBox::Policy policy )
{
//US KComboBox *combo = new KComboBox ( writable, this );
KComboBox *combo = new KComboBox ( this );
combo->setEditable(writable);
insertWidgetInternal( combo, index, id );
combo->insertStringList (list);
combo->setInsertionPolicy(policy);
combo->setEnabled( enabled );
if ( !tooltiptext.isEmpty() )
QToolTip::add( combo, tooltiptext );
if ( size > 0 )
combo->setMinimumWidth( size );
if (!tooltiptext.isNull())
QToolTip::add( combo, tooltiptext );
if ( signal && receiver && slot )
connect ( combo, signal, receiver, slot );
return index;
}
int KToolBar::insertCombo (const QString& text, int id, bool writable,
const char *signal, QObject *receiver,
const char *slot, bool enabled,
const QString& tooltiptext,
int size, int index,
QComboBox::Policy policy )
{
//US KComboBox *combo = new KComboBox ( writable, this );
KComboBox *combo = new KComboBox ( this );
combo->setEditable(writable);
insertWidgetInternal( combo, index, id );
combo->insertItem (text);
combo->setInsertionPolicy(policy);
combo->setEnabled( enabled );
if ( !tooltiptext.isEmpty() )
QToolTip::add( combo, tooltiptext );
if ( size > 0 )
combo->setMinimumWidth( size );
if (!tooltiptext.isNull())
QToolTip::add( combo, tooltiptext );
connect (combo, signal, receiver, slot);
return index;
}
int KToolBar::insertSeparator(int index, int id)
{
QWidget *w = new KToolBarSeparator( orientation(), FALSE, this, "tool bar separator" );
insertWidgetInternal( w, index, id );
return index;
}
int KToolBar::insertLineSeparator(int index, int id)
{
QWidget *w = new KToolBarSeparator( orientation(), TRUE, this, "tool bar separator" );
insertWidgetInternal( w, index, id );
return index;
@@ -1250,386 +1252,394 @@ void KToolBar::mousePressEvent ( QMouseEvent *m )
QMainWindow *mw = mainWindow();
if ( mw->toolBarsMovable() && d->m_enableContext ) {
if ( m->button() == RightButton ) {
int i = contextMenu()->exec( m->globalPos(), 0 );
switch ( i ) {
case -1:
return; // popup cancelled
case CONTEXT_LEFT:
//US mw->moveDockWindow( this, DockLeft );
mw->moveToolBar( this, QMainWindow::Left );
break;
case CONTEXT_RIGHT:
//US mw->moveDockWindow( this, DockRight );
mw->moveToolBar( this, QMainWindow::Right );
break;
case CONTEXT_TOP:
//US mw->moveDockWindow( this, DockTop );
mw->moveToolBar( this, QMainWindow::Top );
break;
case CONTEXT_BOTTOM:
//US mw->moveDockWindow( this, DockBottom );
mw->moveToolBar( this, QMainWindow::Bottom );
break;
case CONTEXT_FLOAT:
break;
case CONTEXT_FLAT:
//US mw->moveDockWindow( this, DockMinimized );
mw->moveToolBar( this, QMainWindow::Minimized );
break;
case CONTEXT_ICONS:
setIconText( IconOnly );
break;
case CONTEXT_TEXTRIGHT:
setIconText( IconTextRight );
break;
case CONTEXT_TEXT:
setIconText( TextOnly );
break;
case CONTEXT_TEXTUNDER:
setIconText( IconTextBottom );
break;
default:
if ( i >= CONTEXT_ICONSIZES )
setIconSize( i - CONTEXT_ICONSIZES );
else
return; // assume this was an action handled elsewhere, no need for setSettingsDirty()
}
/*US
if ( mw->inherits("KMainWindow") )
static_cast<KMainWindow *>(mw)->setSettingsDirty();
*/
}
}
}
void KToolBar::rebuildLayout()
{
for(QWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next())
w->blockSignals(false);
d->idleButtons.clear();
layoutTimer->stop();
QApplication::sendPostedEvents( this, QEvent::ChildInserted );
QBoxLayout *l = boxLayout();
l->setMargin( 1 );
// clear the old layout
QLayoutIterator it = l->iterator();
while ( it.current() ) {
it.deleteCurrent();
}
for ( QWidget *w = widgets.first(); w; w = widgets.next() ) {
if ( w == rightAligned ) {
continue;
}
if ( w->inherits( "KToolBarSeparator" ) &&
!( (KToolBarSeparator*)w )->showLine() ) {
l->addSpacing( 6 );
w->hide();
continue;
}
if ( w->inherits( "QPopupMenu" ) )
continue;
l->addWidget( w );
w->show();
}
if ( rightAligned ) {
l->addStretch();
l->addWidget( rightAligned );
rightAligned->show();
}
if ( fullSize() ) {
// This code sucks. It makes the last combo in a toolbar VERY big (e.g. zoom combo in kword).
//if ( !stretchableWidget && widgets.last() &&
// !widgets.last()->inherits( "QButton" ) && !widgets.last()->inherits( "KAnimWidget" ) )
// setStretchableWidget( widgets.last() );
if ( !rightAligned )
l->addStretch();
if ( stretchableWidget )
l->setStretchFactor( stretchableWidget, 10 );
}
l->invalidate();
QApplication::postEvent( this, new QEvent( QEvent::LayoutHint ) );
//#endif //DESKTOP_VERSION
}
void KToolBar::childEvent( QChildEvent *e )
{
if ( e->child()->isWidgetType() ) {
QWidget * w = (QWidget*)e->child();
if ( e->type() == QEvent::ChildInserted ) {
if ( !e->child()->inherits( "QPopupMenu" ) &&
::qstrcmp( "qt_dockwidget_internal", e->child()->name() ) != 0 ) {
// prevent items that have been explicitly inserted by insert*() from
// being inserted again
if ( !widget2id.contains( w ) )
{
int dummy = -1;
insertWidgetInternal( w, dummy, -1 );
}
}
} else {
removeWidgetInternal( w );
}
if ( isVisibleTo( 0 ) )
{
QBoxLayout *l = boxLayout();
// QLayout *l = layout();
// clear the old layout so that we don't get unnecassery layout
// changes till we have rebuild the thing
QLayoutIterator it = l->iterator();
while ( it.current() ) {
it.deleteCurrent();
}
layoutTimer->start( 50, TRUE );
}
}
QToolBar::childEvent( e );
}
void KToolBar::insertWidgetInternal( QWidget *w, int &index, int id )
{
// we can't have it in widgets, or something is really wrong
//widgets.removeRef( w );
connect( w, SIGNAL( destroyed() ),
this, SLOT( widgetDestroyed() ) );
if ( index == -1 || index > (int)widgets.count() ) {
widgets.append( w );
index = (int)widgets.count();
}
else
widgets.insert( index, w );
if ( id == -1 )
id = id2widget.count();
id2widget.insert( id, w );
widget2id.insert( w, id );
}
void KToolBar::repaintMe()
{
setUpdatesEnabled( true );
QToolBar::repaint( true );
qDebug(" KToolBar::repaintMe() ");
}
void KToolBar::showEvent( QShowEvent *e )
{
rebuildLayout();
QToolBar::showEvent( e );
}
void KToolBar::setStretchableWidget( QWidget *w )
{
QToolBar::setStretchableWidget( w );
stretchableWidget = w;
}
QSizePolicy KToolBar::sizePolicy() const
{
if ( orientation() == Horizontal )
return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
else
return QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Expanding );
}
QSize KToolBar::sizeHint() const
-{
- return QToolBar::sizeHint();
+{
+ QSize sh = QToolBar::sizeHint();
+ //qDebug("%x KToolBar::sizeHint() %d %d ",this, QToolBar::sizeHint().width(),QToolBar::sizeHint().height() );
+ if ( sh.height() <= 20 || sh.width() < 60 )
+ return QSize( sizeHintW, sizeHintH );
+ KToolBar* ttt = (KToolBar*) this;
+ ttt->sizeHintW = sh.width();
+ ttt->sizeHintH = sh.height();
+ return sh;
+ //return QToolBar::sizeHint();
#if 0
QWidget::polish();
static int iii = 0;
++iii;
qDebug("++++++++ KToolBar::sizeHint() %d ", iii );
int margin = static_cast<QWidget*>(ncThis)->layout()->margin();
switch( barPos() )
{
case KToolBar::Top:
case KToolBar::Bottom:
for ( QWidget *w = widgets.first(); w; w =widgets.next() )
{
if ( w->inherits( "KToolBarSeparator" ) &&
!( static_cast<KToolBarSeparator*>(w)->showLine() ) )
{
minSize += QSize(6, 0);
}
else
{
QSize sh = w->sizeHint();
if (!sh.isValid())
sh = w->minimumSize();
minSize = minSize.expandedTo(QSize(0, sh.height()));
minSize += QSize(sh.width()+1, 0);
}
}
/*US
minSize += QSize(QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ), 0);
*/
minSize += QSize(margin*2, margin*2);
break;
case KToolBar::Left:
case KToolBar::Right:
for ( QWidget *w = widgets.first(); w; w = widgets.next() )
{
if ( w->inherits( "KToolBarSeparator" ) &&
!( static_cast<KToolBarSeparator*>(w)->showLine() ) )
{
minSize += QSize(0, 6);
}
else
{
QSize sh = w->sizeHint();
if (!sh.isValid())
sh = w->minimumSize();
minSize = minSize.expandedTo(QSize(sh.width(), 0));
minSize += QSize(0, sh.height()+1);
}
}
/*US
minSize += QSize(0, QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
*/
minSize += QSize(margin*2, margin*2);
break;
default:
minSize = QToolBar::sizeHint();
break;
}
return minSize;
#endif
}
QSize KToolBar::minimumSize() const
{
return minimumSizeHint();
}
QSize KToolBar::minimumSizeHint() const
{
return sizeHint();
}
bool KToolBar::highlight() const
{
return d->m_highlight;
}
void KToolBar::hide()
{
QToolBar::hide();
}
void KToolBar::show()
{
QToolBar::show();
}
void KToolBar::resizeEvent( QResizeEvent *e )
{
bool b = isUpdatesEnabled();
setUpdatesEnabled( FALSE );
QToolBar::resizeEvent( e );
if (b)
d->repaintTimer.start( 100, true );
}
void KToolBar::slotIconChanged(int group)
{
if ((group != KIcon::Toolbar) && (group != KIcon::MainToolbar))
return;
if ((group == KIcon::MainToolbar) != !::qstrcmp(name(), "mainToolBar"))
return;
emit modechange();
if (isVisible())
updateGeometry();
}
void KToolBar::slotReadConfig()
{
//kdDebug(220) << "KToolBar::slotReadConfig" << endl;
// Read appearance settings (hmm, we used to do both here,
// but a well behaved application will call applyMainWindowSettings
// anyway, right ?)
applyAppearanceSettings(KGlobal::config(), QString::null );
}
void KToolBar::slotAppearanceChanged()
{
// Read appearance settings from global file.
applyAppearanceSettings(KGlobal::config(), QString::null, true /* lose local settings */ );
// And remember to save the new look later
/*US
if ( mainWindow() && mainWindow()->inherits( "KMainWindow" ) )
static_cast<KMainWindow *>(mainWindow())->setSettingsDirty();
*/
}
//static
bool KToolBar::highlightSetting()
{
QString grpToolbar(QString::fromLatin1("Toolbar style"));
KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
return KGlobal::config()->readBoolEntry(QString::fromLatin1("Highlighting"),true);
}
//static
bool KToolBar::transparentSetting()
{
QString grpToolbar(QString::fromLatin1("Toolbar style"));
KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
return KGlobal::config()->readBoolEntry(QString::fromLatin1("TransparentMoving"),true);
}
//static
KToolBar::IconText KToolBar::iconTextSetting()
{
QString grpToolbar(QString::fromLatin1("Toolbar style"));
KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
QString icontext = KGlobal::config()->readEntry(QString::fromLatin1("IconText"),QString::fromLatin1("IconOnly"));
if ( icontext == "IconTextRight" )
return IconTextRight;
else if ( icontext == "IconTextBottom" )
return IconTextBottom;
else if ( icontext == "TextOnly" )
return TextOnly;
else
return IconOnly;
}
void KToolBar::applyAppearanceSettings(KConfig *config, const QString &_configGroup, bool forceGlobal)
{
return;
QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup;
//kdDebug(220) << "KToolBar::applyAppearanceSettings: configGroup=" << configGroup << endl;
// We have application-specific settings in the XML file,
// and nothing in the application's config file
// -> don't apply the global defaults, the XML ones are preferred
// See applySettings for a full explanation
/*US :we do not support xml files
if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() &&
!config->hasGroup(configGroup) )
{
//kdDebug(220) << "skipping global defaults, using XML ones instead" << endl;
return;
}
*/
if ( !config->hasGroup(configGroup) )
{
//kdDebug(220) << "skipping global defaults, using XML ones instead" << endl;
return;
}
KConfig *gconfig = KGlobal::config();
/*US
static const QString &attrIconText = KGlobal::staticQString("IconText");
static const QString &attrHighlight = KGlobal::staticQString("Highlighting");
static const QString &attrTrans = KGlobal::staticQString("TransparentMoving");
static const QString &attrSize = KGlobal::staticQString("IconSize");
diff --git a/microkde/kdeui/ktoolbar.h b/microkde/kdeui/ktoolbar.h
index 7a5c114..3319fa8 100644
--- a/microkde/kdeui/ktoolbar.h
+++ b/microkde/kdeui/ktoolbar.h
@@ -892,217 +892,219 @@ public:
*/
void saveState();
/**
* Save the toolbar settings to group @p configGroup in @p config.
*/
void saveSettings(KConfig *config, const QString &configGroup);
/**
* Read the toolbar settings from group @p configGroup in @p config
* and apply them.
*/
void applySettings(KConfig *config, const QString &configGroup);
/**
* Tell the toolbar what XML-GUI resource file it should use to save
* it's state. The state of the toolbar (position, size, etc) is
* saved in KConfig files if the application does not use XML-GUI..
* but if the app does, then it's saved the XML file. This function
* allows this to happen.
*
* @param xmlfile The XML-GUI resource file to write to
* @param xml The DOM document for the XML-GUI building
*/
// void setXML(const QString& xmlfile, const QDomDocument& xml);
/* @internal */
void setXMLGUIClient( KXMLGUIClient *client );
/**
* Assign a (translated) text to this toolbar. This is used
* for the tooltip on the handle, and when listing the toolbars.
*/
void setText( const QString & txt );
/**
* @return the toolbar's text.
*/
QString text() const;
void setStretchableWidget( QWidget *w );
QSizePolicy sizePolicy() const;
bool highlight() const;
QSize sizeHint() const;
QSize minimumSizeHint() const;
QSize minimumSize() const;
void hide();
void show();
void updateRects( bool = FALSE ) {}
//US void loadState( const QDomElement &e );
//US void saveState( QDomElement &e );
/**
* @internal
*/
void positionYourself( bool force = false);
signals:
/**
* Emitted when button @p id is clicked.
*/
void clicked(int id);
/**
* Emitted when button @p id is double-clicked.
*
* Note: you will always
* recive two @ref clicked() , @ref pressed() and @ref released() signals.
* There is no way to avoid it - at least no easy way.
* If you need to resolve this all you can do is set up timers
* which wait for @ref QApplication::doubleClickInterval() to expire.
* If in that time you don't get this signal, you may belive that
* button was only clicked and not double-clicked.
* And please note that butons with popup menus do not emit this signal,
* but those with delayed popup do.
*/
void doubleClicked (int id);
/**
* Emitted when button @p id is pressed.
*/
void pressed(int);
/**
* Emits when button @p id is released.
*/
void released(int);
/**
* Emitted when a toggle button changes state.
*
* Emitted also if you change state
* with @ref setButton() or @ref toggleButton()
* If you make a button normal again, with
* setToggle(false), this signal won't
* be emitted.
*/
void toggled(int);
/**
* This signal is emitted when item id gets highlighted/unhighlighted
* (i.e when mouse enters/exits).
*
* Note that this signal is emitted from
* all buttons (normal, disabled and toggle) even when there is no visible
* change in buttons (i.e., buttons do not raise when mouse enters).
* The parameter @p isHighlighted is @p true when mouse enters and @p false when
* mouse exits.
*/
void highlighted(int id, bool isHighlighted);
/**
* This signal is emitted when item id gets highlighted/unhighlighted
* (i.e when mouse enters/exits).
*
* Note that this signal is emitted from
* all buttons (normal, disabled and toggle) even when there is no visible
* change in buttons (i.e., buttons do not raise when mouse enters).
*/
void highlighted(int id );
/**
* Emitted when toolbar changes position, or when
* an item is removed from toolbar.
*
* If you subclass @ref KMainWindow and reimplement
* @ref KMainWindow::resizeEvent() be sure to connect to
* this signal. Note: You can connect this signal to a slot that
* doesn't take parameter.
*/
void moved( BarPosition );
/**
* @internal
* This signal is emitted when toolbar detects changing of
* following parameters:
* highlighting, button-size, button-mode. This signal is
* internal, aimed to buttons.
*/
void modechange ();
/**
* This signal is emitted when the toolbar is getting deleted,
* and before ~KToolbar finishes (so it's still time to remove
* widgets from the toolbar).
* Used by KWidgetAction.
* @since 3.2
*/
void toolbarDestroyed();
public:
/**
* @return global setting for "Highlight buttons under mouse"
*/
void repaintMe();
static bool highlightSetting();
/**
* @return global setting for "Toolbars transparent when moving"
*/
static bool transparentSetting();
/**
* @return global setting for "Icon Text"
*/
static IconText iconTextSetting();
public slots:
virtual void setIconText( const QString &txt )
{ QToolBar::setIconText( txt ); }
void slotRepaint();
protected:
void mousePressEvent( QMouseEvent * );
void childEvent( QChildEvent *e );
void showEvent( QShowEvent *e );
void resizeEvent( QResizeEvent *e );
bool event( QEvent *e );
void applyAppearanceSettings(KConfig *config, const QString &_configGroup, bool forceGlobal = false);
QString settingsGroup();
private slots:
void rebuildLayout();
void slotReadConfig ();
void slotAppearanceChanged();
void slotIconChanged(int);
void toolBarPosChanged( QToolBar *tb );
void slotContextAboutToShow();
void widgetDestroyed();
-private:
+private:
+ int sizeHintW;
+ int sizeHintH;
void init( bool readConfig = true, bool honorStyle = false );
void doConnections( KToolBarButton *button );
void insertWidgetInternal( QWidget *w, int &index, int id );
void removeWidgetInternal( QWidget *w );
void getAttributes( QString &position, QString &icontext, int &index );
//US KPopupMenu *contextMenu();
QPopupMenu *contextMenu();
QMap<QWidget*, int > widget2id;
typedef QMap<int, QWidget* > Id2WidgetMap;
Id2WidgetMap id2widget;
//US KPopupMenu *context;
QPopupMenu *context;
QPtrList<QWidget> widgets;
QTimer *layoutTimer;
QGuardedPtr<QWidget> stretchableWidget, rightAligned;
protected:
virtual void virtual_hook( int id, void* data );
private:
KToolBarPrivate *d;
bool inshutdownprocess;
};
#endif