From b9aad1f15dc600e4dbe4c62d3fcced6363188ba3 Mon Sep 17 00:00:00 2001 From: zautrix Date: Sat, 26 Jun 2004 19:01:18 +0000 Subject: Initial revision --- (limited to 'microkde/kdeui/ktoolbar.cpp') diff --git a/microkde/kdeui/ktoolbar.cpp b/microkde/kdeui/ktoolbar.cpp new file mode 100644 index 0000000..92cb8d2 --- a/dev/null +++ b/microkde/kdeui/ktoolbar.cpp @@ -0,0 +1,2260 @@ +/* This file is part of the KDE libraries + Copyright + (C) 2000 Reginald Stadlbauer (reggie@kde.org) + (C) 1997, 1998 Stephan Kulow (coolo@kde.org) + (C) 1997, 1998 Mark Donohoe (donohoe@kde.org) + (C) 1997, 1998 Sven Radej (radej@kde.org) + (C) 1997, 1998 Matthias Ettrich (ettrich@kde.org) + (C) 1999 Chris Schlaeger (cs@kde.org) + (C) 1999 Kurt Granroth (granroth@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 version 2 as published by the Free Software Foundation. + + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifdef KDE_USE_FINAL +#undef Always +#include +#endif + + + +#include "ktoolbar.h" +#include "kmainwindow.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//US #include + +#include "klineedit.h" +#include "kseparator.h" +#include +#include +#include +#include +#include +#include +#include +#include +//US #include +//US #include +//US #include +//US #include +#include +#include + +#include "ktoolbarbutton.h" + +//US +#include "kconfigbase.h" + +#include +#include + +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 iconSizes; + QTimer repaintTimer; + + // Default Values. + bool HiddenDefault; + int IconSizeDefault; + QString IconTextDefault; + int IndexDefault; + bool NewLineDefault; + int OffsetDefault; + QString PositionDefault; + + QPtrList 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(parent) : 0, + parent, FALSE, + name ? name : "mainToolBar") +#else + : QPEToolBar( parent && parent->inherits( "QMainWindow" ) ? static_cast(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 ) +{ + 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; +} + + +int KToolBar::insertWidget(int id, int /*width*/, QWidget *widget, int index) +{ + // removeWidgetInternal( widget ); // in case we already have it ? + insertWidgetInternal( widget, index, id ); + return index; +} +/*US +int KToolBar::insertAnimatedWidget(int id, QObject *receiver, const char *slot, + const QString& icons, int index ) +{ + KAnimWidget *anim = new KAnimWidget( icons, d->m_iconSize, this ); + insertWidgetInternal( anim, index, id ); + + if ( receiver ) + connect( anim, SIGNAL(clicked()), receiver, slot); + + return index; +} + +KAnimWidget *KToolBar::animatedWidget( int id ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; + if ( (*it) && (*it)->inherits( "KAnimWidget" ) ) + return (KAnimWidget*)(*it); + QObjectList *l = queryList( "KAnimWidget" ); + if ( !l || !l->first() ) { + delete l; + return 0; + } + + for ( QObject *o = l->first(); o; o = l->next() ) { + if ( o->inherits( "KAnimWidget" ) ) + { + delete l; + return (KAnimWidget*)o; + } + } + + delete l; + return 0; +} +*/ + +void KToolBar::addConnection (int id, const char *signal, + const QObject *receiver, const char *slot) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; + if ( (*it) ) + connect( (*it), signal, receiver, slot ); +} + +void KToolBar::setItemEnabled( int id, bool enabled ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; + if ( (*it) ) + (*it)->setEnabled( enabled ); +} + + +void KToolBar::setButtonPixmap( int id, const QPixmap& _pixmap ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setPixmap( _pixmap ); +} + + +void KToolBar::setButtonIcon( int id, const QString& _icon ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setIcon( _icon ); +} + +void KToolBar::setButtonIconSet( int id, const QIconSet& iconset ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setIconSet( iconset ); +} + + +void KToolBar::setDelayedPopup (int id , QPopupMenu *_popup, bool toggle ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setDelayedPopup( _popup, toggle ); +} + + +void KToolBar::setAutoRepeat (int id, bool flag) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setAutoRepeat( flag ); +} + + +void KToolBar::setToggle (int id, bool flag ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->setToggle( flag ); +} + + +void KToolBar::toggleButton (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->toggle(); +} + + +void KToolBar::setButton (int id, bool flag) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if ( button ) + button->on( flag ); +} + + +bool KToolBar::isButtonOn (int id) const +{ + Id2WidgetMap::ConstIterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return false; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + return button ? button->isOn() : false; +} + + +void KToolBar::setLinedText (int id, const QString& text) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QLineEdit * lineEdit = dynamic_cast( *it ); + QLineEdit * lineEdit = (QLineEdit *)( *it ); + if ( lineEdit ) + lineEdit->setText( text ); +} + + +QString KToolBar::getLinedText (int id) const +{ + Id2WidgetMap::ConstIterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return QString::null; +//US QLineEdit * lineEdit = dynamic_cast( *it ); + QLineEdit * lineEdit = (QLineEdit *)( *it ); + return lineEdit ? lineEdit->text() : QString::null; +} + + +void KToolBar::insertComboItem (int id, const QString& text, int index) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->insertItem( text, index ); +} + +void KToolBar::insertComboList (int id, const QStringList &list, int index) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->insertStringList( list, index ); +} + + +void KToolBar::removeComboItem (int id, int index) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->removeItem( index ); +} + + +void KToolBar::setCurrentComboItem (int id, int index) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->setCurrentItem( index ); +} + + +void KToolBar::changeComboItem (int id, const QString& text, int index) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->changeItem( text, index ); +} + + +void KToolBar::clearCombo (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + if (comboBox) + comboBox->clear(); +} + + +QString KToolBar::getComboItem (int id, int index) const +{ + Id2WidgetMap::ConstIterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return QString::null; +//US QComboBox * comboBox = dynamic_cast( *it ); + QComboBox * comboBox = (QComboBox *)( *it ); + return comboBox ? comboBox->text( index ) : QString::null; +} + + +KComboBox * KToolBar::getCombo(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; +//US return dynamic_cast( *it ); + return (KComboBox *)( *it ); +} + + +KLineEdit * KToolBar::getLined (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; +//US return dynamic_cast( *it ); + return (KLineEdit *)( *it ); +} + + +KToolBarButton * KToolBar::getButton (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return 0; +//US return dynamic_cast( *it ); + return (KToolBarButton *)( *it ); +} + + +void KToolBar::alignItemRight (int id, bool right ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; + if ( rightAligned && !right && (*it) == rightAligned ) + rightAligned = 0; + if ( (*it) && right ) + rightAligned = (*it); +} + + +QWidget *KToolBar::getWidget (int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + return ( it == id2widget.end() ) ? 0 : (*it); +} + + +void KToolBar::setItemAutoSized (int id, bool yes ) +{ + QWidget *w = getWidget(id); + if ( w && yes ) + setStretchableWidget( w ); +} + + +void KToolBar::clear () +{ + QToolBar::clear(); + widget2id.clear(); + id2widget.clear(); +} + + +void KToolBar::removeItem(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + { + kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl; + return; + } + QWidget * w = (*it); + id2widget.remove( id ); + widget2id.remove( w ); + widgets.removeRef( w ); + delete w; +} + + +void KToolBar::removeItemDelayed(int id) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + { + kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl; + return; + } + QWidget * w = (*it); + id2widget.remove( id ); + widget2id.remove( w ); + widgets.removeRef( w ); + + w->blockSignals(true); + d->idleButtons.append(w); + layoutTimer->start( 50, TRUE ); +} + + +void KToolBar::hideItem (int id) +{ + QWidget *w = getWidget(id); + if ( w ) + w->hide(); +} + + +void KToolBar::showItem (int id) +{ + QWidget *w = getWidget(id); + if ( w ) + w->show(); +} + + +int KToolBar::itemIndex (int id) +{ + QWidget *w = getWidget(id); + return w ? widgets.findRef(w) : -1; +} + + +void KToolBar::setFullSize(bool flag ) +{ + setHorizontalStretchable( flag ); + setVerticalStretchable( flag ); +} + + +bool KToolBar::fullSize() const +{ + return isHorizontalStretchable() || isVerticalStretchable(); +} + + +void KToolBar::enableMoving(bool flag ) +{ +//US setMovingEnabled(flag); + this->mainWindow()->setToolBarsMovable(flag); +} + + +void KToolBar::setBarPos (BarPosition bpos) +{ + if ( !mainWindow() ) + return; +//US mainWindow()->moveDockWindow( this, (Dock)bpos ); + mainWindow()->moveToolBar( this, (QMainWindow::ToolBarDock)bpos ); +} + + +KToolBar::BarPosition KToolBar::barPos() +{ + if ( !(QMainWindow*)mainWindow() ) + return KToolBar::Top; +//US Dock dock; + QMainWindow::ToolBarDock dock; + int dm1, dm2; + bool dm3; + ((QMainWindow*)mainWindow())->getLocation( (QToolBar*)this, dock, dm1, dm3, dm2 ); +//US if ( dock == DockUnmanaged ) { + if ( dock == QMainWindow::Unmanaged ) { + return (KToolBar::BarPosition)Top; + } + return (BarPosition)dock; +} + + +bool KToolBar::enable(BarStatus stat) +{ + bool mystat = isVisible(); + + if ( (stat == Toggle && mystat) || stat == Hide ) + hide(); + else + show(); + + return isVisible() == mystat; +} + + +void KToolBar::setMaxHeight ( int h ) +{ + setMaximumHeight( h ); +} + +int KToolBar::maxHeight() +{ + return maximumHeight(); +} + + +void KToolBar::setMaxWidth (int dw) +{ + setMaximumWidth( dw ); +} + + +int KToolBar::maxWidth() +{ + return maximumWidth(); +} + + +void KToolBar::setTitle (const QString& _title) +{ + setLabel( _title ); +} + + +void KToolBar::enableFloating (bool ) +{ +} + + +void KToolBar::setIconText(IconText it) +{ + setIconText( it, true ); +} + + +void KToolBar::setIconText(IconText icontext, bool update) +{ + bool doUpdate=false; + + if (icontext != d->m_iconText) { + d->m_iconText = icontext; + doUpdate=true; + } + + if (update == false) + return; + + if (doUpdate) + emit modechange(); // tell buttons what happened + + // ugly hack to force a QMainWindow::triggerLayout( TRUE ) + if ( mainWindow() ) { + QMainWindow *mw = mainWindow(); + mw->setUpdatesEnabled( FALSE ); + mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setUpdatesEnabled( TRUE ); + } +} + + +KToolBar::IconText KToolBar::iconText() const +{ + return d->m_iconText; +} + + +void KToolBar::setIconSize(int size) +{ + setIconSize( size, true ); +} + +void KToolBar::setIconSize(int size, bool update) +{ + bool doUpdate=false; + + if ( size != d->m_iconSize ) { + d->m_iconSize = size; + doUpdate=true; + } + + if (update == false) + return; + + if (doUpdate) + emit modechange(); // tell buttons what happened + + // ugly hack to force a QMainWindow::triggerLayout( TRUE ) + if ( mainWindow() ) { + QMainWindow *mw = mainWindow(); + mw->setUpdatesEnabled( FALSE ); + mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setToolBarsMovable( !mw->toolBarsMovable() ); + mw->setUpdatesEnabled( TRUE ); + } +} + + +int KToolBar::iconSize() const +{ +/*US + if ( !d->m_iconSize ) // default value? + { + if (!::qstrcmp(QObject::name(), "mainToolBar")) + return KGlobal::iconLoader()->currentSize(KIcon::MainToolbar); + else + return KGlobal::iconLoader()->currentSize(KIcon::Toolbar); + } + return d->m_iconSize; +*/ + int ret = 18; + if ( QApplication::desktop()->width() > 320 && QApplication::desktop()->width() < 650 ) + ret = 30; + return ret; +} + + +void KToolBar::setEnableContextMenu(bool enable ) +{ + d->m_enableContext = enable; +} + + +bool KToolBar::contextMenuEnabled() const +{ + return d->m_enableContext; +} + + +void KToolBar::setItemNoStyle(int id, bool no_style ) +{ + Id2WidgetMap::Iterator it = id2widget.find( id ); + if ( it == id2widget.end() ) + return; +//US KToolBarButton * button = dynamic_cast( *it ); + KToolBarButton * button = (KToolBarButton *)( *it ); + if (button) + button->setNoStyle( no_style ); +} + + +void KToolBar::setFlat (bool flag) +{ + if ( !mainWindow() ) + return; + if ( flag ) +//US mainWindow()->moveDockWindow( this, DockMinimized ); + mainWindow()->moveToolBar( this, QMainWindow::Minimized ); + else +//US mainWindow()->moveDockWindow( this, DockTop ); + mainWindow()->moveToolBar( this, QMainWindow::Top ); + // And remember to save the new look later +/*US + if ( mainWindow()->inherits( "KMainWindow" ) ) + static_cast(mainWindow())->setSettingsDirty(); +*/ +} + + +int KToolBar::count() const +{ + return id2widget.count(); +} + + +void KToolBar::saveState() +{ +/*US + // first, try to save to the xml file + if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() ) { + // go down one level to get to the right tags + QDomElement elem = d->m_xmlguiClient->domDocument().documentElement().toElement(); + elem = elem.firstChild().toElement(); + QString barname(!::qstrcmp(name(), "unnamed") ? "mainToolBar" : name()); + QDomElement current; + // now try to find our toolbar + d->modified = false; + for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) { + current = elem; + + if ( current.tagName().lower() != "toolbar" ) + continue; + + QString curname(current.attribute( "name" )); + + if ( curname == barname ) { + saveState( current ); + break; + } + } + // if we didn't make changes, then just return + if ( !d->modified ) + return; + + // now we load in the (non-merged) local file + QString local_xml(KXMLGUIFactory::readConfigFile(d->m_xmlguiClient->xmlFile(), true, d->m_xmlguiClient->instance())); + QDomDocument local; + local.setContent(local_xml); + + // make sure we don't append if this toolbar already exists locally + bool just_append = true; + elem = local.documentElement().toElement(); + KXMLGUIFactory::removeDOMComments( elem ); + elem = elem.firstChild().toElement(); + for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) { + if ( elem.tagName().lower() != "toolbar" ) + continue; + + QString curname(elem.attribute( "name" )); + + if ( curname == barname ) { + just_append = false; + local.documentElement().replaceChild( current, elem ); + break; + } + } + + if (just_append) + local.documentElement().appendChild( current ); + + KXMLGUIFactory::saveConfigFile(local, d->m_xmlguiClient->localXMLFile(), d->m_xmlguiClient->instance() ); + + return; + } +*/ + // if that didn't work, we save to the config file + KConfig *config = KGlobal::config(); + saveSettings(config, QString::null); + config->sync(); +} + +QString KToolBar::settingsGroup() +{ + QString configGroup; + if (!::qstrcmp(name(), "unnamed") || !::qstrcmp(name(), "mainToolBar")) + configGroup = "Toolbar style"; + else + configGroup = QString(name()) + " Toolbar style"; + if ( this->mainWindow() ) + { + configGroup.prepend(" "); + configGroup.prepend( this->mainWindow()->name() ); + } + return configGroup; +} + +void KToolBar::saveSettings(KConfig *config, const QString &_configGroup) +{ + QString configGroup = _configGroup; + if (configGroup.isEmpty()) + configGroup = settingsGroup(); + //kdDebug(220) << "KToolBar::saveSettings group=" << _configGroup << " -> " << configGroup << endl; + + QString position, icontext; + int index; + getAttributes( position, icontext, index ); + + //kdDebug(220) << "KToolBar::saveSettings " << name() << " newLine=" << newLine << endl; + + KConfigGroupSaver saver(config, configGroup); + + if ( position != d->PositionDefault ) + config->writeEntry("Position", position); + else + config->deleteEntry("Position"); + + if ( icontext != d->IconTextDefault ) + config->writeEntry("IconText", icontext); + else + config->deleteEntry("IconText"); + + if ( iconSize() != d->IconSizeDefault ) + config->writeEntry("IconSize", iconSize()); + else + config->deleteEntry("IconSize"); + + if ( isHidden() != d->HiddenDefault ) + config->writeEntry("Hidden", isHidden()); + else + config->deleteEntry("Hidden"); + + if ( index != d->IndexDefault ) + config->writeEntry( "Index", index ); + else + config->deleteEntry("Index"); +//US the older version of KDE (used on the Zaurus) has no Offset property +/* if ( offset() != d->OffsetDefault ) + config->writeEntry( "Offset", offset() ); + else +*/ + config->deleteEntry("Offset"); + +//US the older version of KDE (used on the Zaurus) has no NewLine property +/* + if ( newLine() != d->NewLineDefault ) + config->writeEntry( "NewLine", newLine() ); + else +*/ + config->deleteEntry("NewLine"); +} + +void KToolBar::setXMLGUIClient( KXMLGUIClient *client ) +{ + d->m_xmlguiClient = client; +} + +void KToolBar::setText( const QString & txt ) +{ +//US setLabel( txt + " ( " + kapp->caption() + " ) " ); + setLabel( txt + " ( " + KGlobal::getAppName() + " ) " ); +} + + +QString KToolBar::text() const +{ + return label(); +} + + +void KToolBar::doConnections( KToolBarButton *button ) +{ + connect(button, SIGNAL(clicked(int)), this, SIGNAL( clicked( int ) ) ); + connect(button, SIGNAL(doubleClicked(int)), this, SIGNAL( doubleClicked( int ) ) ); + connect(button, SIGNAL(released(int)), this, SIGNAL( released( int ) ) ); + connect(button, SIGNAL(pressed(int)), this, SIGNAL( pressed( int ) ) ); + connect(button, SIGNAL(toggled(int)), this, SIGNAL( toggled( int ) ) ); + connect(button, SIGNAL(highlighted(int, bool)), this, SIGNAL( highlighted( int, bool ) ) ); +} + +void KToolBar::mousePressEvent ( QMouseEvent *m ) +{ + if ( !mainWindow() ) + return; + 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(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::showEvent( QShowEvent *e ) +{ + QToolBar::showEvent( e ); + rebuildLayout(); +} + +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(); +#if 0 + QWidget::polish(); + static int iii = 0; + ++iii; + qDebug("++++++++ KToolBar::sizeHint() %d ", iii ); + int margin = static_cast(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(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(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(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) +{ + 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"); +*/ + // we actually do this in two steps. + // First, we read in the global styles [Toolbar style] (from the KControl module). + // Then, if the toolbar is NOT 'mainToolBar', we will also try to read in [barname Toolbar style] + bool highlight; + int transparent; + QString icontext; + int iconsize = 0; + + // this is the first iteration + QString grpToolbar(QString::fromLatin1("Toolbar style")); + { // start block for KConfigGroupSaver + KConfigGroupSaver saver(gconfig, grpToolbar); + + // first, get the generic settings +//US highlight = gconfig->readBoolEntry(attrHighlight, true); + highlight = gconfig->readBoolEntry("Highlighting", true); +//US transparent = gconfig->readBoolEntry(attrTrans, true); + transparent = gconfig->readBoolEntry("TransparentMoving", true); + + // we read in the IconText property *only* if we intend on actually + // honoring it + if (d->m_honorStyle) +//US d->IconTextDefault = gconfig->readEntry(attrIconText, d->IconTextDefault); + d->IconTextDefault = gconfig->readEntry("IconText", d->IconTextDefault); + else + d->IconTextDefault = "IconOnly"; + + // Use the default icon size for toolbar icons. +//US d->IconSizeDefault = gconfig->readNumEntry(attrSize, d->IconSizeDefault); + d->IconSizeDefault = gconfig->readNumEntry("IconSize", d->IconSizeDefault); + + if ( !forceGlobal && config->hasGroup(configGroup) ) + { + config->setGroup(configGroup); + + // first, get the generic settings +//US highlight = config->readBoolEntry(attrHighlight, highlight); + highlight = config->readBoolEntry("Highlighting", highlight); +//US transparent = config->readBoolEntry(attrTrans, transparent); + transparent = config->readBoolEntry("TransparentMoving", transparent); + // now we always read in the IconText property +//US icontext = config->readEntry(attrIconText, d->IconTextDefault); + icontext = config->readEntry("IconText", d->IconTextDefault); + + // now get the size +//US iconsize = config->readNumEntry(attrSize, d->IconSizeDefault); + iconsize = config->readNumEntry("IconSize", d->IconSizeDefault); + } + else + { + iconsize = d->IconSizeDefault; + icontext = d->IconTextDefault; + } + + // revert back to the old group + } // end block for KConfigGroupSaver + + bool doUpdate = false; + + IconText icon_text; + if ( icontext == "IconTextRight" ) + icon_text = IconTextRight; + else if ( icontext == "IconTextBottom" ) + icon_text = IconTextBottom; + else if ( icontext == "TextOnly" ) + icon_text = TextOnly; + else + icon_text = IconOnly; + + // check if the icon/text has changed + if (icon_text != d->m_iconText) { + //kdDebug(220) << "KToolBar::applyAppearanceSettings setIconText " << icon_text << endl; + setIconText(icon_text, false); + doUpdate = true; + } + + // ...and check if the icon size has changed + if (iconsize != d->m_iconSize) { + setIconSize(iconsize, false); + doUpdate = true; + } + + QMainWindow *mw = mainWindow(); + + // ...and if we should highlight + if ( highlight != d->m_highlight ) { + d->m_highlight = highlight; + doUpdate = true; + } + + // ...and if we should move transparently + if ( mw && transparent != (!mw->opaqueMoving()) ) { + mw->setOpaqueMoving( !transparent ); + } + + if (doUpdate) + emit modechange(); // tell buttons what happened + if (isVisible ()) + updateGeometry(); +} + +void KToolBar::applySettings(KConfig *config, const QString &_configGroup) +{ + //kdDebug(220) << "KToolBar::applySettings group=" << _configGroup << endl; + + QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup; + + /* + Let's explain this a bit more in details. + The order in which we apply settings is : + Global config / user settings if no XMLGUI is used + Global config / App-XML attributes / user settings if XMLGUI is used + + So in the first case, we simply read everything from KConfig as below, + but in the second case we don't do anything here if there is no app-specific config, + and the XMLGUI uses the static methods of this class to get the global defaults. + + Global config doesn't include position (index, offset, newline and hidden/shown). + */ + + // First the appearance stuff - the one which has a global config + applyAppearanceSettings( config, _configGroup ); + + // ...and now the position stuff + if ( config->hasGroup(configGroup) ) + { + KConfigGroupSaver cgs(config, configGroup); +/*US + static const QString &attrPosition = KGlobal::staticQString("Position"); + static const QString &attrIndex = KGlobal::staticQString("Index"); + static const QString &attrOffset = KGlobal::staticQString("Offset"); + static const QString &attrNewLine = KGlobal::staticQString("NewLine"); + static const QString &attrHidden = KGlobal::staticQString("Hidden"); + + QString position = config->readEntry(attrPosition, d->PositionDefault); + int index = config->readNumEntry(attrIndex, d->IndexDefault); + int offset = config->readNumEntry(attrOffset, d->OffsetDefault); + bool newLine = config->readBoolEntry(attrNewLine, d->NewLineDefault); + bool hidden = config->readBoolEntry(attrHidden, d->HiddenDefault); +*/ + + QString position = config->readEntry("Position", d->PositionDefault); + int index = config->readNumEntry("Index", d->IndexDefault); + int offset = config->readNumEntry("Offset", d->OffsetDefault); + bool newLine = config->readBoolEntry("NewLine", d->NewLineDefault); + bool hidden = config->readBoolEntry("Hidden", d->HiddenDefault); + +/*US Dock pos(DockTop); + if ( position == "Top" ) + pos = DockTop; + else if ( position == "Bottom" ) + pos = DockBottom; + else if ( position == "Left" ) + pos = DockLeft; + else if ( position == "Right" ) + pos = DockRight; + else if ( position == "Floating" ) + pos = DockTornOff; + else if ( position == "Flat" ) + pos = DockMinimized; +*/ + QMainWindow::ToolBarDock pos(QMainWindow::Top); + if ( position == "Top" ) + pos = QMainWindow::Top; + else if ( position == "Bottom" ) + pos = QMainWindow::Bottom; + else if ( position == "Left" ) + pos = QMainWindow::Left; + else if ( position == "Right" ) + pos = QMainWindow::Right; + else if ( position == "Floating" ) + pos = QMainWindow::TornOff; + else if ( position == "Flat" ) + pos = QMainWindow::Minimized; + + //kdDebug(220) << "KToolBar::applySettings hidden=" << hidden << endl; + if (hidden) + hide(); + else + show(); + + if ( mainWindow() ) + { + QMainWindow *mw = mainWindow(); + + //kdDebug(220) << "KToolBar::applySettings updating ToolbarInfo" << endl; + d->toolBarInfo = KToolBarPrivate::ToolBarInfo( pos, index, newLine, offset ); + + // moveDockWindow calls QDockArea which does a reparent() on us with + // showIt = true, so we loose our visibility status + bool doHide = isHidden(); + +//US mw->moveDockWindow( this, pos, newLine, index, offset ); + mw->moveToolBar( this, pos, newLine, index, offset ); + + //kdDebug(220) << "KToolBar::applySettings " << name() << " moveDockWindow with pos=" << pos << " newLine=" << newLine << " idx=" << index << " offs=" << offset << endl; + if ( doHide ) + hide(); + } + if (isVisible ()) + updateGeometry(); + } +} + +bool KToolBar::event( QEvent *e ) +{ + if ( (e->type() == QEvent::LayoutHint) && isUpdatesEnabled() ) + d->repaintTimer.start( 100, true ); + + if (e->type() == QEvent::ChildInserted ) + { + // By pass QToolBar::event, + // it will show() the inserted child and we don't want to + // do that until we have rebuild the layout. + childEvent((QChildEvent *)e); + return true; + } + + return QToolBar::event( e ); +} + +void KToolBar::slotRepaint() +{ + setUpdatesEnabled( FALSE ); + // Send a resizeEvent to update the "toolbar extension arrow" + // (The button you get when your toolbar-items don't fit in + // the available space) + QResizeEvent ev(size(), size()); + resizeEvent(&ev); + //#ifdef DESKTOP_VERSION + QApplication::sendPostedEvents( this, QEvent::LayoutHint ); + //#endif //DESKTOP_VERSION + setUpdatesEnabled( TRUE ); + repaint( TRUE ); +} + +void KToolBar::toolBarPosChanged( QToolBar *tb ) +{ + if ( tb != this ) + return; +//US if ( d->oldPos == DockMinimized ) + if ( d->oldPos == QMainWindow::Minimized ) + rebuildLayout(); + d->oldPos = (QMainWindow::ToolBarDock)barPos(); +/*US + if ( mainWindow() && mainWindow()->inherits( "KMainWindow" ) ) + static_cast(mainWindow())->setSettingsDirty(); +*/ +} + +/*US +void KToolBar::loadState( const QDomElement &element ) +{ + //kdDebug(220) << "KToolBar::loadState " << this << endl; + if ( !mainWindow() ) + return; + + { + QCString text = element.namedItem( "text" ).toElement().text().utf8(); + if ( text.isEmpty() ) + text = element.namedItem( "Text" ).toElement().text().utf8(); + if ( !text.isEmpty() ) + setText( i18n( text ) ); + } + + { + QCString attrFullWidth = element.attribute( "fullWidth" ).lower().latin1(); + if ( !attrFullWidth.isEmpty() ) + setFullSize( attrFullWidth == "true" ); + } + + Dock dock = DockTop; + { + QCString attrPosition = element.attribute( "position" ).lower().latin1(); + //kdDebug(220) << "KToolBar::loadState attrPosition=" << attrPosition << endl; + if ( !attrPosition.isEmpty() ) { + if ( attrPosition == "top" ) + dock = DockTop; + else if ( attrPosition == "left" ) + dock = DockLeft; + else if ( attrPosition == "right" ) + dock = DockRight; + else if ( attrPosition == "bottom" ) + dock = DockBottom; + else if ( attrPosition == "floating" ) + dock = DockTornOff; + else if ( attrPosition == "flat" ) + dock = DockMinimized; + } + } + + { + QCString attrIconText = element.attribute( "iconText" ).lower().latin1(); + if ( !attrIconText.isEmpty() ) { + //kdDebug(220) << "KToolBar::loadState attrIconText=" << attrIconText << endl; + if ( attrIconText == "icontextright" ) + setIconText( KToolBar::IconTextRight ); + else if ( attrIconText == "textonly" ) + setIconText( KToolBar::TextOnly ); + else if ( attrIconText == "icontextbottom" ) + setIconText( KToolBar::IconTextBottom ); + else if ( attrIconText == "icononly" ) + setIconText( KToolBar::IconOnly ); + } else + // Use global setting + setIconText( iconTextSetting() ); + } + + { + QString attrIconSize = element.attribute( "iconSize" ).lower(); + if ( !attrIconSize.isEmpty() ) + d->IconSizeDefault = attrIconSize.toInt(); + setIconSize( d->IconSizeDefault ); + } + + { + QString attrIndex = element.attribute( "index" ).lower(); + if ( !attrIndex.isEmpty() ) + d->IndexDefault = attrIndex.toInt(); + } + + { + QString attrOffset = element.attribute( "offset" ).lower(); + if ( !attrOffset.isEmpty() ) + d->OffsetDefault = attrOffset.toInt(); + } + + { + QString attrNewLine = element.attribute( "newline" ).lower(); + if ( !attrNewLine.isEmpty() ) + d->NewLineDefault = attrNewLine == "true"; + } + + { + QString attrHidden = element.attribute( "hidden" ).lower(); + if ( !attrHidden.isEmpty() ) + d->HiddenDefault = attrHidden == "true"; + } + + d->toolBarInfo = KToolBarPrivate::ToolBarInfo( dock, d->IndexDefault, d->NewLineDefault, d->OffsetDefault ); + mainWindow()->addDockWindow( this, dock, d->NewLineDefault ); +//US mainWindow()->moveDockWindow( this, dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault ); + mainWindow()->moveToolBar( this, dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault ); + + // Apply the highlight button setting + d->m_highlight = highlightSetting(); + + // Apply transparent-toolbar-moving setting (ok, this is global to the mainwindow, + // but we do it only if there are toolbars...) + if ( transparentSetting() != !mainWindow()->opaqueMoving() ) + mainWindow()->setOpaqueMoving( !transparentSetting() ); + + if ( d->HiddenDefault ) + hide(); + else + show(); + + getAttributes( d->PositionDefault, d->IconTextDefault, d->IndexDefault ); +} +*/ + +void KToolBar::getAttributes( QString &position, QString &icontext, int &index ) +{ + // get all of the stuff to save + switch ( barPos() ) { + case KToolBar::Flat: + position = "Flat"; + break; + case KToolBar::Bottom: + position = "Bottom"; + break; + case KToolBar::Left: + position = "Left"; + break; + case KToolBar::Right: + position = "Right"; + break; + case KToolBar::Floating: + position = "Floating"; + break; + case KToolBar::Top: + default: + position = "Top"; + break; + } + + if ( mainWindow() ) { + QMainWindow::ToolBarDock dock; + bool newLine; + int offset; + mainWindow()->getLocation( this, dock, index, newLine, offset ); + } + + switch (d->m_iconText) { + case KToolBar::IconTextRight: + icontext = "IconTextRight"; + break; + case KToolBar::IconTextBottom: + icontext = "IconTextBottom"; + break; + case KToolBar::TextOnly: + icontext = "TextOnly"; + break; + case KToolBar::IconOnly: + default: + icontext = "IconOnly"; + break; + } +} +/*US +void KToolBar::saveState( QDomElement ¤t ) +{ + QString position, icontext; + int index = -1; + getAttributes( position, icontext, index ); + + current.setAttribute( "noMerge", "1" ); + current.setAttribute( "position", position ); + current.setAttribute( "iconText", icontext ); + current.setAttribute( "index", index ); + current.setAttribute( "offset", offset() ); + current.setAttribute( "newline", newLine() ); + if ( isHidden() ) + current.setAttribute( "hidden", "true" ); + d->modified = true; +} +*/ + +void KToolBar::positionYourself( bool force ) +{ + if (force) + d->positioned = false; + + if ( d->positioned || !mainWindow() ) + { + //kdDebug(220) << "KToolBar::positionYourself d->positioned=true ALREADY DONE" << endl; + return; + } + // we can't test for ForceHide after moveDockWindow because QDockArea + // does a reparent() with showIt == true + bool doHide = isHidden(); + //kdDebug(220) << "positionYourself " << name() << " dock=" << d->toolBarInfo.dock << " newLine=" << d->toolBarInfo.newline << " offset=" << d->toolBarInfo.offset << endl; +/*US mainWindow()->moveDockWindow( this, d->toolBarInfo.dock, + d->toolBarInfo.newline, + d->toolBarInfo.index, + d->toolBarInfo.offset ); +*/ + mainWindow()->moveToolBar( this, d->toolBarInfo.dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault ); + + if ( doHide ) + hide(); + // This method can only have an effect once - unless force is set + d->positioned = TRUE; +} + +//US KPopupMenu *KToolBar::contextMenu() +QPopupMenu *KToolBar::contextMenu() +{ + if ( context ) + return context; + + // Construct our context popup menu. Name it qt_dockwidget_internal so it + // won't be deleted by QToolBar::clear(). +//US context = new KPopupMenu( this, "qt_dockwidget_internal" ); + context = new QPopupMenu( this, "qt_dockwidget_internal" ); +//US context->insertTitle(i18n("Toolbar Menu")); + +//US KPopupMenu *orient = new KPopupMenu( context, "orient" ); + QPopupMenu *orient = new QPopupMenu( context, "orient" ); + orient->insertItem( i18n("toolbar position string","Top"), CONTEXT_TOP ); + orient->insertItem( i18n("toolbar position string","Left"), CONTEXT_LEFT ); + orient->insertItem( i18n("toolbar position string","Right"), CONTEXT_RIGHT ); + orient->insertItem( i18n("toolbar position string","Bottom"), CONTEXT_BOTTOM ); + orient->insertSeparator(-1); + //orient->insertItem( i18n("toolbar position string","Floating"), CONTEXT_FLOAT ); + orient->insertItem( i18n("min toolbar", "Flat"), CONTEXT_FLAT ); + +//US KPopupMenu *mode = new KPopupMenu( context, "mode" ); + QPopupMenu *mode = new QPopupMenu( context, "mode" ); + mode->insertItem( i18n("Icons Only"), CONTEXT_ICONS ); + mode->insertItem( i18n("Text Only"), CONTEXT_TEXT ); + mode->insertItem( i18n("Text Alongside Icons"), CONTEXT_TEXTRIGHT ); + mode->insertItem( i18n("Text Under Icons"), CONTEXT_TEXTUNDER ); + +//US KPopupMenu *size = new KPopupMenu( context, "size" ); + QPopupMenu *size = new QPopupMenu( context, "size" ); + size->insertItem( i18n("Default"), CONTEXT_ICONSIZES ); + // Query the current theme for available sizes + QValueList avSizes; +/*US + KIconTheme *theme = KGlobal::instance()->iconLoader()->theme(); + if (!::qstrcmp(QObject::name(), "mainToolBar")) + avSizes = theme->querySizes( KIcon::MainToolbar); + else + avSizes = theme->querySizes( KIcon::Toolbar); +*/ + avSizes << 16; + avSizes << 32; + + d->iconSizes = avSizes; + + QValueList::Iterator it; + for (it=avSizes.begin(); it!=avSizes.end(); it++) { + QString text; + if ( *it < 19 ) + text = i18n("Small (%1x%2)").arg(*it).arg(*it); + else if (*it < 25) + text = i18n("Medium (%1x%2)").arg(*it).arg(*it); + else + text = i18n("Large (%1x%2)").arg(*it).arg(*it); + //we use the size as an id, with an offset + size->insertItem( text, CONTEXT_ICONSIZES + *it ); + } + + context->insertItem( i18n("Orientation"), orient ); + orient->setItemChecked(CONTEXT_TOP, true); + context->insertItem( i18n("Text Position"), mode ); + context->setItemChecked(CONTEXT_ICONS, true); + context->insertItem( i18n("Icon Size"), size ); + +/*US + if (mainWindow()->inherits("KMainWindow")) + { + if ( (static_cast(mainWindow())->toolBarMenuAction()) && + (static_cast(mainWindow())->hasMenuBar()) ) + + (static_cast(mainWindow()))->toolBarMenuAction()->plug(context); + } +*/ + + connect( context, SIGNAL( aboutToShow() ), this, SLOT( slotContextAboutToShow() ) ); + return context; +} + +void KToolBar::slotContextAboutToShow() +{ + if (!d->m_configurePlugged) + { + // try to find "configure toolbars" action + + KXMLGUIClient *xmlGuiClient = d->m_xmlguiClient; + if ( !xmlGuiClient && mainWindow() && mainWindow()->inherits( "KMainWindow" ) ) + xmlGuiClient = (KXMLGUIClient *)mainWindow(); + if ( xmlGuiClient ) + { + KAction *configureAction = xmlGuiClient->actionCollection()->action(KStdAction::stdName(KStdAction::ConfigureToolbars)); + if ( configureAction ) + { + configureAction->plug(context); + d->m_configurePlugged = true; + } + } + } + + for(int i = CONTEXT_ICONS; i <= CONTEXT_TEXTUNDER; ++i) + context->setItemChecked(i, false); + + switch( d->m_iconText ) + { + case IconOnly: + default: + context->setItemChecked(CONTEXT_ICONS, true); + break; + case IconTextRight: + context->setItemChecked(CONTEXT_TEXTRIGHT, true); + break; + case TextOnly: + context->setItemChecked(CONTEXT_TEXT, true); + break; + case IconTextBottom: + context->setItemChecked(CONTEXT_TEXTUNDER, true); + break; + } + + QValueList::ConstIterator iIt = d->iconSizes.begin(); + QValueList::ConstIterator iEnd = d->iconSizes.end(); + for (; iIt != iEnd; ++iIt ) + context->setItemChecked( CONTEXT_ICONSIZES + *iIt, false ); + + context->setItemChecked( CONTEXT_ICONSIZES, false ); + + context->setItemChecked( CONTEXT_ICONSIZES + d->m_iconSize, true ); + + for ( int i = CONTEXT_TOP; i <= CONTEXT_FLAT; ++i ) + context->setItemChecked( i, false ); + + switch ( barPos() ) + { + case KToolBar::Flat: + context->setItemChecked( CONTEXT_FLAT, true ); + break; + case KToolBar::Bottom: + context->setItemChecked( CONTEXT_BOTTOM, true ); + break; + case KToolBar::Left: + context->setItemChecked( CONTEXT_LEFT, true ); + break; + case KToolBar::Right: + context->setItemChecked( CONTEXT_RIGHT, true ); + break; + case KToolBar::Floating: + context->setItemChecked( CONTEXT_FLOAT, true ); + break; + case KToolBar::Top: + context->setItemChecked( CONTEXT_TOP, true ); + break; + default: break; + } +} + +void KToolBar::widgetDestroyed() +{ + removeWidgetInternal( (QWidget*)sender() ); +} + +void KToolBar::removeWidgetInternal( QWidget * w ) +{ + if ( inshutdownprocess ) + return; + widgets.removeRef( w ); + QMap< QWidget*, int >::Iterator it = widget2id.find( w ); + if ( it == widget2id.end() ) + return; + id2widget.remove( *it ); + widget2id.remove( it ); +} + +void KToolBar::virtual_hook( int, void* ) +{ /*BASE::virtual_hook( id, data );*/ } + +//US #include "ktoolbar.moc" + -- cgit v0.9.0.2