kdeui Library API Documentation

ktoolbar.cpp

00001 /* This file is part of the KDE libraries
00002     Copyright
00003     (C) 2000 Reginald Stadlbauer (reggie@kde.org)
00004     (C) 1997, 1998 Stephan Kulow (coolo@kde.org)
00005     (C) 1997, 1998 Mark Donohoe (donohoe@kde.org)
00006     (C) 1997, 1998 Sven Radej (radej@kde.org)
00007     (C) 1997, 1998 Matthias Ettrich (ettrich@kde.org)
00008     (C) 1999 Chris Schlaeger (cs@kde.org)
00009     (C) 1999 Kurt Granroth (granroth@kde.org)
00010 
00011     This library is free software; you can redistribute it and/or
00012     modify it under the terms of the GNU Library General Public
00013     License version 2 as published by the Free Software Foundation.
00014 
00015     This library is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018     Library General Public License for more details.
00019 
00020     You should have received a copy of the GNU Library General Public License
00021     along with this library; see the file COPYING.LIB.  If not, write to
00022     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00023     Boston, MA 02111-1307, USA.
00024 */
00025 
00026 #include <config.h>
00027 
00028 #ifdef KDE_USE_FINAL
00029 #undef Always
00030 #include <qdockwindow.h>
00031 #endif
00032 #include "ktoolbar.h"
00033 #include "kmainwindow.h"
00034 
00035 #include <string.h>
00036 
00037 #include <qpainter.h>
00038 #include <qtooltip.h>
00039 #include <qdrawutil.h>
00040 #include <qstring.h>
00041 #include <qrect.h>
00042 #include <qobjectlist.h>
00043 #include <qtimer.h>
00044 #include <qstyle.h>
00045 
00046 #include "klineedit.h"
00047 #include "kseparator.h"
00048 #include <klocale.h>
00049 #include <kapplication.h>
00050 #include <kaction.h>
00051 #include <kstdaction.h>
00052 #include <kglobal.h>
00053 #include <kconfig.h>
00054 #include <kiconloader.h>
00055 #include <kcombobox.h>
00056 #include <kpopupmenu.h>
00057 #include <kanimwidget.h>
00058 
00059 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00060 #include <kipc.h> // schroder
00061 #endif
00062 
00063 #include <kwin.h>
00064 #include <kdebug.h>
00065 #include <qlayout.h>
00066 
00067 #include "ktoolbarbutton.h"
00068 
00069 enum {
00070     CONTEXT_TOP = 0,
00071     CONTEXT_LEFT = 1,
00072     CONTEXT_RIGHT = 2,
00073     CONTEXT_BOTTOM = 3,
00074     CONTEXT_FLOAT = 4,
00075     CONTEXT_FLAT = 5,
00076     CONTEXT_ICONS = 6,
00077     CONTEXT_TEXT = 7,
00078     CONTEXT_TEXTRIGHT = 8,
00079     CONTEXT_TEXTUNDER = 9,
00080     CONTEXT_ICONSIZES = 50 // starting point for the icon size list, put everything else before
00081 };
00082 
00083 class KToolBarPrivate
00084 {
00085 public:
00086     KToolBarPrivate() {
00087         m_iconSize     = 0;
00088         m_iconText     = KToolBar::IconOnly;
00089         m_highlight    = true;
00090         m_transparent  = true;
00091         m_honorStyle   = false;
00092 
00093         m_enableContext  = true;
00094 
00095         m_xmlguiClient   = 0;
00096         m_configurePlugged = false;
00097 
00098         oldPos = Qt::DockUnmanaged;
00099 
00100         modified = m_isHorizontal = positioned = false;
00101 
00102         IconSizeDefault = 0;
00103         IconTextDefault = "IconOnly";
00104 
00105         NewLineDefault = false;
00106         OffsetDefault = 0;
00107         PositionDefault = "Top";
00108     HiddenDefault = false;
00109         idleButtons.setAutoDelete(true);
00110     }
00111 
00112     int m_iconSize;
00113     KToolBar::IconText m_iconText;
00114     bool m_highlight : 1;
00115     bool m_transparent : 1;
00116     bool m_honorStyle : 1;
00117     bool m_isHorizontal : 1;
00118     bool m_enableContext : 1;
00119     bool m_configurePlugged : 1;
00120     bool modified : 1;
00121     bool positioned : 1;
00122 
00123     QWidget *m_parent;
00124 
00125     QMainWindow::ToolBarDock oldPos;
00126 
00127     KXMLGUIClient *m_xmlguiClient;
00128 
00129     struct ToolBarInfo
00130     {
00131         ToolBarInfo() : index( -1 ), offset( -1 ), newline( false ), dock( Qt::DockTop ) {}
00132         ToolBarInfo( Qt::Dock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {}
00133         int index, offset;
00134         bool newline;
00135         Qt::Dock dock;
00136     };
00137 
00138     ToolBarInfo toolBarInfo;
00139     QValueList<int> iconSizes;
00140     QTimer repaintTimer;
00141 
00142   // Default Values.
00143   bool HiddenDefault;
00144   int IconSizeDefault;
00145   QString IconTextDefault;
00146   bool NewLineDefault;
00147   int OffsetDefault;
00148   QString PositionDefault;
00149 
00150    QPtrList<QWidget> idleButtons;
00151 };
00152 
00153 KToolBarSeparator::KToolBarSeparator(Orientation o , bool l, QToolBar *parent,
00154                                      const char* name )
00155     :QFrame( parent, name ), line( l )
00156 {
00157     connect( parent, SIGNAL(orientationChanged(Orientation)),
00158              this, SLOT(setOrientation(Orientation)) );
00159     setOrientation( o );
00160     setBackgroundMode( parent->backgroundMode() );
00161     setBackgroundOrigin( ParentOrigin );
00162 }
00163 
00164 void KToolBarSeparator::setOrientation( Orientation o )
00165 {
00166     orient = o;
00167     setFrameStyle( NoFrame );
00168 }
00169 
00170 void KToolBarSeparator::drawContents( QPainter* p )
00171 {
00172     if ( line ) {
00173         QStyle::SFlags flags = QStyle::Style_Default;
00174 
00175         if ( orientation() == Horizontal )
00176             flags = flags | QStyle::Style_Horizontal;
00177 
00178         style().drawPrimitive(QStyle::PE_DockWindowSeparator, p,
00179                               contentsRect(), colorGroup(), flags);
00180     } else {
00181         QFrame::drawContents(p);
00182     }
00183 }
00184 
00185 void KToolBarSeparator::styleChange( QStyle& )
00186 {
00187     setOrientation( orient );
00188 }
00189 
00190 QSize KToolBarSeparator::sizeHint() const
00191 {
00192     int dim = style().pixelMetric( QStyle::PM_DockWindowSeparatorExtent, this );
00193     return orientation() == Vertical ? QSize( 0, dim ) : QSize( dim, 0 );
00194 }
00195 
00196 QSizePolicy KToolBarSeparator::sizePolicy() const
00197 {
00198     return QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
00199 }
00200 
00201 KToolBar::KToolBar( QWidget *parent, const char *name, bool honorStyle, bool readConfig )
00202     : QToolBar( QString::fromLatin1( name ),
00203       dynamic_cast<QMainWindow*>(parent),
00204       parent, false,
00205       name ? name : "mainToolBar")
00206 {
00207     init( readConfig, honorStyle );
00208 }
00209 
00210 KToolBar::KToolBar( QMainWindow *parentWindow, QMainWindow::ToolBarDock dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
00211     : QToolBar( QString::fromLatin1( name ),
00212       parentWindow, dock, newLine,
00213       name ? name : "mainToolBar")
00214 {
00215     init( readConfig, honorStyle );
00216 }
00217 
00218 KToolBar::KToolBar( QMainWindow *parentWindow, QWidget *dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
00219     : QToolBar( QString::fromLatin1( name ),
00220       parentWindow, dock, newLine,
00221       name ? name : "mainToolBar")
00222 {
00223     init( readConfig, honorStyle );
00224 }
00225 
00226 KToolBar::~KToolBar()
00227 {
00228     emit toolbarDestroyed();
00229     delete d;
00230 }
00231 
00232 void KToolBar::init( bool readConfig, bool honorStyle )
00233 {
00234     d = new KToolBarPrivate;
00235     // Get the default iconSize sense m_iconSize == 0 which isn't the default
00236     d->IconSizeDefault = iconSize();
00237     setFullSize( true );
00238     d->m_honorStyle = honorStyle;
00239     context = 0;
00240     layoutTimer = new QTimer( this );
00241     connect( layoutTimer, SIGNAL( timeout() ),
00242              this, SLOT( rebuildLayout() ) );
00243     connect( &(d->repaintTimer), SIGNAL( timeout() ),
00244              this, SLOT( slotRepaint() ) );
00245 
00246     if ( kapp ) { // may be null when started inside designer
00247         connect(kapp, SIGNAL(toolbarAppearanceChanged(int)), this, SLOT(slotAppearanceChanged()));
00248         // request notification of changes in icon style
00249 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00250         kapp->addKipcEventMask(KIPC::IconChanged);
00251 #endif
00252         connect(kapp, SIGNAL(iconChanged(int)), this, SLOT(slotIconChanged(int)));
00253     }
00254 
00255     // finally, read in our configurable settings
00256     if ( readConfig )
00257         slotReadConfig();
00258 
00259     if ( mainWindow() )
00260         connect( mainWindow(), SIGNAL( toolBarPositionChanged( QToolBar * ) ),
00261                  this, SLOT( toolBarPosChanged( QToolBar * ) ) );
00262 
00263     // Hack to make sure we recalculate our size when we dock.
00264     connect( this, SIGNAL(placeChanged(QDockWindow::Place)), SLOT(rebuildLayout()) );
00265 }
00266 
00267 int KToolBar::insertButton(const QString& icon, int id, bool enabled,
00268                             const QString& text, int index, KInstance *_instance )
00269 {
00270     KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text, _instance );
00271 
00272     insertWidgetInternal( button, index, id );
00273     button->setEnabled( enabled );
00274     doConnections( button );
00275     return index;
00276 }
00277 
00278 
00279 int KToolBar::insertButton(const QString& icon, int id, const char *signal,
00280                             const QObject *receiver, const char *slot,
00281                             bool enabled, const QString& text, int index, KInstance *_instance )
00282 {
00283     KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text, _instance);
00284     insertWidgetInternal( button, index, id );
00285     button->setEnabled( enabled );
00286     connect( button, signal, receiver, slot );
00287     doConnections( button );
00288     return index;
00289 }
00290 
00291 
00292 int KToolBar::insertButton(const QPixmap& pixmap, int id, bool enabled,
00293                             const QString& text, int index )
00294 {
00295     KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
00296     insertWidgetInternal( button, index, id );
00297     button->setEnabled( enabled );
00298     doConnections( button );
00299     return index;
00300 }
00301 
00302 
00303 int KToolBar::insertButton(const QPixmap& pixmap, int id, const char *signal,
00304                             const QObject *receiver, const char *slot,
00305                             bool enabled, const QString& text,
00306                             int index )
00307 {
00308     KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
00309     insertWidgetInternal( button, index, id );
00310     button->setEnabled( enabled );
00311     connect( button, signal, receiver, slot );
00312     doConnections( button );
00313     return index;
00314 }
00315 
00316 
00317 int KToolBar::insertButton(const QString& icon, int id, QPopupMenu *popup,
00318                             bool enabled, const QString &text, int index )
00319 {
00320     KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text );
00321     insertWidgetInternal( button, index, id );
00322     button->setEnabled( enabled );
00323     button->setPopup( popup );
00324     doConnections( button );
00325     return index;
00326 }
00327 
00328 
00329 int KToolBar::insertButton(const QPixmap& pixmap, int id, QPopupMenu *popup,
00330                             bool enabled, const QString &text, int index )
00331 {
00332     KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text );
00333     insertWidgetInternal( button, index, id );
00334     button->setEnabled( enabled );
00335     button->setPopup( popup );
00336     doConnections( button );
00337     return index;
00338 }
00339 
00340 
00341 int KToolBar::insertLined (const QString& text, int id,
00342                             const char *signal,
00343                             const QObject *receiver, const char *slot,
00344                             bool enabled ,
00345                             const QString& toolTipText,
00346                             int size, int index )
00347 {
00348     KLineEdit *lined = new KLineEdit ( this, 0 );
00349     if ( !toolTipText.isEmpty() )
00350         QToolTip::add( lined, toolTipText );
00351     if ( size > 0 )
00352         lined->setMinimumWidth( size );
00353     insertWidgetInternal( lined, index, id );
00354     connect( lined, signal, receiver, slot );
00355     lined->setText(text);
00356     lined->setEnabled( enabled );
00357     return index;
00358 }
00359 
00360 int KToolBar::insertCombo (const QStringList &list, int id, bool writable,
00361                             const char *signal, const QObject *receiver,
00362                             const char *slot, bool enabled,
00363                             const QString& tooltiptext,
00364                             int size, int index,
00365                             QComboBox::Policy policy )
00366 {
00367     KComboBox *combo = new KComboBox ( writable, this );
00368 
00369     insertWidgetInternal( combo, index, id );
00370     combo->insertStringList (list);
00371     combo->setInsertionPolicy(policy);
00372     combo->setEnabled( enabled );
00373     if ( !tooltiptext.isEmpty() )
00374         QToolTip::add( combo, tooltiptext );
00375     if ( size > 0 )
00376         combo->setMinimumWidth( size );
00377     if (!tooltiptext.isNull())
00378         QToolTip::add( combo, tooltiptext );
00379 
00380     if ( signal && receiver && slot )
00381         connect ( combo, signal, receiver, slot );
00382     return index;
00383 }
00384 
00385 
00386 int KToolBar::insertCombo (const QString& text, int id, bool writable,
00387                             const char *signal, QObject *receiver,
00388                             const char *slot, bool enabled,
00389                             const QString& tooltiptext,
00390                             int size, int index,
00391                             QComboBox::Policy policy )
00392 {
00393     KComboBox *combo = new KComboBox ( writable, this );
00394     insertWidgetInternal( combo, index, id );
00395     combo->insertItem (text);
00396     combo->setInsertionPolicy(policy);
00397     combo->setEnabled( enabled );
00398     if ( !tooltiptext.isEmpty() )
00399         QToolTip::add( combo, tooltiptext );
00400     if ( size > 0 )
00401         combo->setMinimumWidth( size );
00402     if (!tooltiptext.isNull())
00403         QToolTip::add( combo, tooltiptext );
00404     connect (combo, signal, receiver, slot);
00405     return index;
00406 }
00407 
00408 int KToolBar::insertSeparator(int index, int id)
00409 {
00410     QWidget *w = new KToolBarSeparator( orientation(), false, this, "tool bar separator" );
00411     insertWidgetInternal( w, index, id );
00412     return index;
00413 }
00414 
00415 int KToolBar::insertLineSeparator(int index, int id)
00416 {
00417     QWidget *w = new KToolBarSeparator( orientation(), true, this, "tool bar separator" );
00418     insertWidgetInternal( w, index, id );
00419     return index;
00420 }
00421 
00422 
00423 int KToolBar::insertWidget(int id, int /*width*/, QWidget *widget, int index)
00424 {
00425     removeWidgetInternal( widget ); // in case we already have it ?
00426     insertWidgetInternal( widget, index, id );
00427     return index;
00428 }
00429 
00430 int KToolBar::insertAnimatedWidget(int id, QObject *receiver, const char *slot,
00431                                     const QString& icons, int index )
00432 {
00433     KAnimWidget *anim = new KAnimWidget( icons, d->m_iconSize, this );
00434     insertWidgetInternal( anim, index, id );
00435 
00436     if ( receiver )
00437         connect( anim, SIGNAL(clicked()), receiver, slot);
00438 
00439     return index;
00440 }
00441 
00442 KAnimWidget *KToolBar::animatedWidget( int id )
00443 {
00444     Id2WidgetMap::Iterator it = id2widget.find( id );
00445     if ( it == id2widget.end() )
00446         return 0;
00447     KAnimWidget *aw = dynamic_cast<KAnimWidget *>(*it);
00448     if ( aw )
00449         return aw;
00450     QObjectList *l = queryList( "KAnimWidget" );
00451     if ( !l || !l->first() ) {
00452         delete l;
00453         return 0;
00454     }
00455 
00456     for ( QObject *o = l->first(); o; o = l->next() ) {
00457         KAnimWidget *aw = dynamic_cast<KAnimWidget *>(o);
00458         if ( aw )
00459         {
00460             delete l;
00461             return aw;
00462         }
00463     }
00464 
00465     delete l;
00466     return 0;
00467 }
00468 
00469 
00470 void KToolBar::addConnection (int id, const char *signal,
00471                                const QObject *receiver, const char *slot)
00472 {
00473     Id2WidgetMap::Iterator it = id2widget.find( id );
00474     if ( it == id2widget.end() )
00475         return;
00476     if ( (*it) )
00477         connect( (*it), signal, receiver, slot );
00478 }
00479 
00480 void KToolBar::setItemEnabled( int id, bool enabled )
00481 {
00482     Id2WidgetMap::Iterator it = id2widget.find( id );
00483     if ( it == id2widget.end() )
00484         return;
00485     if ( (*it) )
00486         (*it)->setEnabled( enabled );
00487 }
00488 
00489 
00490 void KToolBar::setButtonPixmap( int id, const QPixmap& _pixmap )
00491 {
00492     Id2WidgetMap::Iterator it = id2widget.find( id );
00493     if ( it == id2widget.end() )
00494         return;
00495     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00496     if ( button )
00497         button->setPixmap( _pixmap );
00498 }
00499 
00500 
00501 void KToolBar::setButtonIcon( int id, const QString& _icon )
00502 {
00503     Id2WidgetMap::Iterator it = id2widget.find( id );
00504     if ( it == id2widget.end() )
00505         return;
00506     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00507     if ( button )
00508         button->setIcon( _icon );
00509 }
00510 
00511 void KToolBar::setButtonIconSet( int id, const QIconSet& iconset )
00512 {
00513     Id2WidgetMap::Iterator it = id2widget.find( id );
00514     if ( it == id2widget.end() )
00515         return;
00516     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00517     if ( button )
00518         button->setIconSet( iconset );
00519 }
00520 
00521 
00522 void KToolBar::setDelayedPopup (int id , QPopupMenu *_popup, bool toggle )
00523 {
00524     Id2WidgetMap::Iterator it = id2widget.find( id );
00525     if ( it == id2widget.end() )
00526         return;
00527     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00528     if ( button )
00529         button->setDelayedPopup( _popup, toggle );
00530 }
00531 
00532 
00533 void KToolBar::setAutoRepeat (int id, bool flag)
00534 {
00535     Id2WidgetMap::Iterator it = id2widget.find( id );
00536     if ( it == id2widget.end() )
00537         return;
00538     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00539     if ( button )
00540         button->setAutoRepeat( flag );
00541 }
00542 
00543 
00544 void KToolBar::setToggle (int id, bool flag )
00545 {
00546     Id2WidgetMap::Iterator it = id2widget.find( id );
00547     if ( it == id2widget.end() )
00548         return;
00549     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00550     if ( button )
00551         button->setToggle( flag );
00552 }
00553 
00554 
00555 void KToolBar::toggleButton (int id)
00556 {
00557     Id2WidgetMap::Iterator it = id2widget.find( id );
00558     if ( it == id2widget.end() )
00559         return;
00560     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00561     if ( button )
00562         button->toggle();
00563 }
00564 
00565 
00566 void KToolBar::setButton (int id, bool flag)
00567 {
00568     Id2WidgetMap::Iterator it = id2widget.find( id );
00569     if ( it == id2widget.end() )
00570         return;
00571     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00572     if ( button )
00573         button->on( flag );
00574 }
00575 
00576 
00577 bool KToolBar::isButtonOn (int id) const
00578 {
00579     Id2WidgetMap::ConstIterator it = id2widget.find( id );
00580     if ( it == id2widget.end() )
00581         return false;
00582     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
00583     return button ? button->isOn() : false;
00584 }
00585 
00586 
00587 void KToolBar::setLinedText (int id, const QString& text)
00588 {
00589     Id2WidgetMap::Iterator it = id2widget.find( id );
00590     if ( it == id2widget.end() )
00591         return;
00592     QLineEdit * lineEdit = dynamic_cast<QLineEdit *>( *it );
00593     if ( lineEdit )
00594         lineEdit->setText( text );
00595 }
00596 
00597 
00598 QString KToolBar::getLinedText (int id) const
00599 {
00600     Id2WidgetMap::ConstIterator it = id2widget.find( id );
00601     if ( it == id2widget.end() )
00602         return QString::null;
00603     QLineEdit * lineEdit = dynamic_cast<QLineEdit *>( *it );
00604     return lineEdit ? lineEdit->text() : QString::null;
00605 }
00606 
00607 
00608 void KToolBar::insertComboItem (int id, const QString& text, int index)
00609 {
00610     Id2WidgetMap::Iterator it = id2widget.find( id );
00611     if ( it == id2widget.end() )
00612         return;
00613     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00614     if (comboBox)
00615         comboBox->insertItem( text, index );
00616 }
00617 
00618 void KToolBar::insertComboList (int id, const QStringList &list, int index)
00619 {
00620     Id2WidgetMap::Iterator it = id2widget.find( id );
00621     if ( it == id2widget.end() )
00622         return;
00623     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00624     if (comboBox)
00625         comboBox->insertStringList( list, index );
00626 }
00627 
00628 
00629 void KToolBar::removeComboItem (int id, int index)
00630 {
00631     Id2WidgetMap::Iterator it = id2widget.find( id );
00632     if ( it == id2widget.end() )
00633         return;
00634     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00635     if (comboBox)
00636         comboBox->removeItem( index );
00637 }
00638 
00639 
00640 void KToolBar::setCurrentComboItem (int id, int index)
00641 {
00642     Id2WidgetMap::Iterator it = id2widget.find( id );
00643     if ( it == id2widget.end() )
00644         return;
00645     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00646     if (comboBox)
00647         comboBox->setCurrentItem( index );
00648 }
00649 
00650 
00651 void KToolBar::changeComboItem  (int id, const QString& text, int index)
00652 {
00653     Id2WidgetMap::Iterator it = id2widget.find( id );
00654     if ( it == id2widget.end() )
00655         return;
00656     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00657     if (comboBox)
00658         comboBox->changeItem( text, index );
00659 }
00660 
00661 
00662 void KToolBar::clearCombo (int id)
00663 {
00664     Id2WidgetMap::Iterator it = id2widget.find( id );
00665     if ( it == id2widget.end() )
00666         return;
00667     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00668     if (comboBox)
00669         comboBox->clear();
00670 }
00671 
00672 
00673 QString KToolBar::getComboItem (int id, int index) const
00674 {
00675     Id2WidgetMap::ConstIterator it = id2widget.find( id );
00676     if ( it == id2widget.end() )
00677         return QString::null;
00678     QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
00679     return comboBox ? comboBox->text( index ) : QString::null;
00680 }
00681 
00682 
00683 KComboBox * KToolBar::getCombo(int id)
00684 {
00685     Id2WidgetMap::Iterator it = id2widget.find( id );
00686     if ( it == id2widget.end() )
00687         return 0;
00688     return dynamic_cast<KComboBox *>( *it );
00689 }
00690 
00691 
00692 KLineEdit * KToolBar::getLined (int id)
00693 {
00694     Id2WidgetMap::Iterator it = id2widget.find( id );
00695     if ( it == id2widget.end() )
00696         return 0;
00697     return dynamic_cast<KLineEdit *>( *it );
00698 }
00699 
00700 
00701 KToolBarButton * KToolBar::getButton (int id)
00702 {
00703     Id2WidgetMap::Iterator it = id2widget.find( id );
00704     if ( it == id2widget.end() )
00705         return 0;
00706     return dynamic_cast<KToolBarButton *>( *it );
00707 }
00708 
00709 
00710 void KToolBar::alignItemRight (int id, bool right )
00711 {
00712     Id2WidgetMap::Iterator it = id2widget.find( id );
00713     if ( it == id2widget.end() )
00714         return;
00715     if ( rightAligned && !right && (*it) == rightAligned )
00716         rightAligned = 0;
00717     if ( (*it) && right )
00718         rightAligned = (*it);
00719 }
00720 
00721 
00722 QWidget *KToolBar::getWidget (int id)
00723 {
00724     Id2WidgetMap::Iterator it = id2widget.find( id );
00725     return ( it == id2widget.end() ) ? 0 : (*it);
00726 }
00727 
00728 
00729 void KToolBar::setItemAutoSized (int id, bool yes )
00730 {
00731     QWidget *w = getWidget(id);
00732     if ( w && yes )
00733         setStretchableWidget( w );
00734 }
00735 
00736 
00737 void KToolBar::clear ()
00738 {
00739     QToolBar::clear();
00740     widget2id.clear();
00741     id2widget.clear();
00742 }
00743 
00744 
00745 void KToolBar::removeItem(int id)
00746 {
00747     Id2WidgetMap::Iterator it = id2widget.find( id );
00748     if ( it == id2widget.end() )
00749     {
00750         kdDebug(220) << name() << " KToolBar::removeItem item " << id << " not found" << endl;
00751         return;
00752     }
00753     QWidget * w = (*it);
00754     id2widget.remove( id );
00755     widget2id.remove( w );
00756     widgets.removeRef( w );
00757     delete w;
00758 }
00759 
00760 
00761 void KToolBar::removeItemDelayed(int id)
00762 {
00763     Id2WidgetMap::Iterator it = id2widget.find( id );
00764     if ( it == id2widget.end() )
00765     {
00766         kdDebug(220) << name() << " KToolBar::removeItem item " << id << " not found" << endl;
00767         return;
00768     }
00769     QWidget * w = (*it);
00770     id2widget.remove( id );
00771     widget2id.remove( w );
00772     widgets.removeRef( w );
00773 
00774     w->blockSignals(true);
00775     d->idleButtons.append(w);
00776     layoutTimer->start( 50, true );
00777 }
00778 
00779 
00780 void KToolBar::hideItem (int id)
00781 {
00782     QWidget *w = getWidget(id);
00783     if ( w )
00784         w->hide();
00785 }
00786 
00787 
00788 void KToolBar::showItem (int id)
00789 {
00790     QWidget *w = getWidget(id);
00791     if ( w )
00792         w->show();
00793 }
00794 
00795 
00796 int KToolBar::itemIndex (int id)
00797 {
00798     QWidget *w = getWidget(id);
00799     return w ? widgets.findRef(w) : -1;
00800 }
00801 
00802 int KToolBar::idAt (int index)
00803 {
00804     QWidget *w = widgets.at(index);
00805     return widget2id[w];
00806 }
00807 
00808 void KToolBar::setFullSize(bool flag )
00809 {
00810     setHorizontalStretchable( flag );
00811     setVerticalStretchable( flag );
00812 }
00813 
00814 
00815 bool KToolBar::fullSize() const
00816 {
00817     return isHorizontalStretchable() || isVerticalStretchable();
00818 }
00819 
00820 
00821 void KToolBar::enableMoving(bool flag )
00822 {
00823     setMovingEnabled(flag);
00824 }
00825 
00826 
00827 void KToolBar::setBarPos (BarPosition bpos)
00828 {
00829     if ( !mainWindow() )
00830         return;
00831     mainWindow()->moveDockWindow( this, (Dock)bpos );
00832     //kdDebug(220) << name() << " setBarPos dockWindowIndex=" << dockWindowIndex() << endl;
00833 }
00834 
00835 
00836 KToolBar::BarPosition KToolBar::barPos() const
00837 {
00838     if ( !this->mainWindow() )
00839         return KToolBar::Top;
00840     Dock dock;
00841     int dm1, dm2;
00842     bool dm3;
00843     this->mainWindow()->getLocation( (QToolBar*)this, dock, dm1, dm3, dm2 );
00844     if ( dock == DockUnmanaged ) {
00845         return (KToolBar::BarPosition)DockTop;
00846     }
00847     return (BarPosition)dock;
00848 }
00849 
00850 
00851 bool KToolBar::enable(BarStatus stat)
00852 {
00853     bool mystat = isVisible();
00854 
00855     if ( (stat == Toggle && mystat) || stat == Hide )
00856         hide();
00857     else
00858         show();
00859 
00860     return isVisible() == mystat;
00861 }
00862 
00863 
00864 void KToolBar::setMaxHeight ( int h )
00865 {
00866     setMaximumHeight( h );
00867 }
00868 
00869 int KToolBar::maxHeight()
00870 {
00871     return maximumHeight();
00872 }
00873 
00874 
00875 void KToolBar::setMaxWidth (int dw)
00876 {
00877     setMaximumWidth( dw );
00878 }
00879 
00880 
00881 int KToolBar::maxWidth()
00882 {
00883     return maximumWidth();
00884 }
00885 
00886 
00887 void KToolBar::setTitle (const QString& _title)
00888 {
00889     setLabel( _title );
00890 }
00891 
00892 
00893 void KToolBar::enableFloating (bool )
00894 {
00895 }
00896 
00897 
00898 void KToolBar::setIconText(IconText it)
00899 {
00900     setIconText( it, true );
00901 }
00902 
00903 
00904 void KToolBar::setIconText(IconText icontext, bool update)
00905 {
00906     bool doUpdate=false;
00907 
00908     if (icontext != d->m_iconText) {
00909         d->m_iconText = icontext;
00910         doUpdate=true;
00911         //kdDebug(220) << name() << "  icontext has changed, doUpdate=true" << endl;
00912     }
00913     else {
00914         //kdDebug(220) << name() << "  icontext hasn't changed, doUpdate=false" << endl;
00915     }
00916 
00917     if (update == false)
00918         return;
00919 
00920     if (doUpdate)
00921         emit modechange(); // tell buttons what happened
00922 
00923     // ugly hack to force a QMainWindow::triggerLayout( true )
00924     QMainWindow *mw = mainWindow();
00925     if ( mw ) {
00926         mw->setUpdatesEnabled( false );
00927         mw->setToolBarsMovable( !mw->toolBarsMovable() );
00928         mw->setToolBarsMovable( !mw->toolBarsMovable() );
00929         mw->setUpdatesEnabled( true );
00930     }
00931 }
00932 
00933 
00934 KToolBar::IconText KToolBar::iconText() const
00935 {
00936     return d->m_iconText;
00937 }
00938 
00939 
00940 void KToolBar::setIconSize(int size)
00941 {
00942     setIconSize( size, true );
00943 }
00944 
00945 void KToolBar::setIconSize(int size, bool update)
00946 {
00947     bool doUpdate=false;
00948 
00949     if ( size != d->m_iconSize ) {
00950             d->m_iconSize = size;
00951             doUpdate=true;
00952     }
00953 
00954     if (update == false)
00955         return;
00956 
00957     if (doUpdate)
00958         emit modechange(); // tell buttons what happened
00959 
00960     // ugly hack to force a QMainWindow::triggerLayout( true )
00961     if ( mainWindow() ) {
00962         QMainWindow *mw = mainWindow();
00963         mw->setUpdatesEnabled( false );
00964         mw->setToolBarsMovable( !mw->toolBarsMovable() );
00965         mw->setToolBarsMovable( !mw->toolBarsMovable() );
00966         mw->setUpdatesEnabled( true );
00967     }
00968 }
00969 
00970 
00971 int KToolBar::iconSize() const
00972 {
00973     if ( !d->m_iconSize ) // default value?
00974     {
00975          if (!::qstrcmp(QObject::name(), "mainToolBar"))
00976              return KGlobal::iconLoader()->currentSize(KIcon::MainToolbar);
00977          else
00978              return KGlobal::iconLoader()->currentSize(KIcon::Toolbar);
00979     }
00980     return d->m_iconSize;
00981 }
00982 
00983 
00984 void KToolBar::setEnableContextMenu(bool enable )
00985 {
00986     d->m_enableContext = enable;
00987 }
00988 
00989 
00990 bool KToolBar::contextMenuEnabled() const
00991 {
00992     return d->m_enableContext;
00993 }
00994 
00995 
00996 void KToolBar::setItemNoStyle(int id, bool no_style )
00997 {
00998     Id2WidgetMap::Iterator it = id2widget.find( id );
00999     if ( it == id2widget.end() )
01000         return;
01001     KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
01002     if (button)
01003         button->setNoStyle( no_style );
01004 }
01005 
01006 
01007 void KToolBar::setFlat (bool flag)
01008 {
01009     if ( !mainWindow() )
01010         return;
01011     if ( flag )
01012         mainWindow()->moveDockWindow( this, DockMinimized );
01013     else
01014         mainWindow()->moveDockWindow( this, DockTop );
01015     // And remember to save the new look later
01016     KMainWindow *kmw = dynamic_cast<KMainWindow *>(mainWindow());
01017     if ( kmw )
01018         kmw->setSettingsDirty();
01019 }
01020 
01021 
01022 int KToolBar::count() const
01023 {
01024     return id2widget.count();
01025 }
01026 
01027 
01028 void KToolBar::saveState()
01029 {
01030     // first, try to save to the xml file
01031     if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() ) {
01032         //kdDebug(220) << name() << " saveState: saving to " << d->m_xmlguiClient->xmlFile() << endl;
01033         // go down one level to get to the right tags
01034         QDomElement elem = d->m_xmlguiClient->domDocument().documentElement().toElement();
01035         elem = elem.firstChild().toElement();
01036         QString barname(!::qstrcmp(name(), "unnamed") ? "mainToolBar" : name());
01037         QDomElement current;
01038         // now try to find our toolbar
01039         d->modified = false;
01040         for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) {
01041             current = elem;
01042 
01043             if ( current.tagName().lower() != "toolbar" )
01044                 continue;
01045 
01046             QString curname(current.attribute( "name" ));
01047 
01048             if ( curname == barname ) {
01049                 saveState( current );
01050                 break;
01051             }
01052         }
01053         // if we didn't make changes, then just return
01054         if ( !d->modified )
01055             return;
01056 
01057         // now we load in the (non-merged) local file
01058         QString local_xml(KXMLGUIFactory::readConfigFile(d->m_xmlguiClient->xmlFile(), true, d->m_xmlguiClient->instance()));
01059         QDomDocument local;
01060         local.setContent(local_xml);
01061 
01062         // make sure we don't append if this toolbar already exists locally
01063         bool just_append = true;
01064         elem = local.documentElement().toElement();
01065         KXMLGUIFactory::removeDOMComments( elem );
01066         elem = elem.firstChild().toElement();
01067         for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) {
01068             if ( elem.tagName().lower() != "toolbar" )
01069                 continue;
01070 
01071             QString curname(elem.attribute( "name" ));
01072 
01073             if ( curname == barname ) {
01074                 just_append = false;
01075                 local.documentElement().replaceChild( current, elem );
01076                 break;
01077             }
01078         }
01079 
01080         if (just_append)
01081             local.documentElement().appendChild( current );
01082 
01083         KXMLGUIFactory::saveConfigFile(local, d->m_xmlguiClient->localXMLFile(), d->m_xmlguiClient->instance() );
01084 
01085         return;
01086     }
01087 
01088     // if that didn't work, we save to the config file
01089     KConfig *config = KGlobal::config();
01090     saveSettings(config, QString::null);
01091     config->sync();
01092 }
01093 
01094 QString KToolBar::settingsGroup() const
01095 {
01096     QString configGroup;
01097     if (!::qstrcmp(name(), "unnamed") || !::qstrcmp(name(), "mainToolBar"))
01098         configGroup = "Toolbar style";
01099     else
01100         configGroup = QString(name()) + " Toolbar style";
01101     if ( this->mainWindow() )
01102     {
01103         configGroup.prepend(" ");
01104         configGroup.prepend( this->mainWindow()->name() );
01105     }
01106     return configGroup;
01107 }
01108 
01109 void KToolBar::saveSettings(KConfig *config, const QString &_configGroup)
01110 {
01111     QString configGroup = _configGroup;
01112     if (configGroup.isEmpty())
01113         configGroup = settingsGroup();
01114     //kdDebug(220) << name() << " saveSettings() group=" << _configGroup << " -> " << configGroup << endl;
01115 
01116     QString position, icontext;
01117     int index;
01118     getAttributes( position, icontext, index );
01119 
01120     //kdDebug(220) << name() << "                position=" << position << " index=" << index << " offset=" << offset() << " newLine=" << newLine() << endl;
01121 
01122     KConfigGroupSaver saver(config, configGroup);
01123 
01124     if(!config->hasDefault("Position") && position == d->PositionDefault )
01125       config->revertToDefault("Position");
01126     else
01127       config->writeEntry("Position", position);
01128 
01129     //kdDebug(220) << name() << "                icontext=" << icontext << " hasDefault:" << config->hasDefault( "IconText" ) << " d->IconTextDefault=" << d->IconTextDefault << endl;
01130 
01131     if(d->m_honorStyle && icontext == d->IconTextDefault && !config->hasDefault("IconText") )
01132     {
01133       //kdDebug(220) << name() << "                reverting icontext to default" << endl;
01134       config->revertToDefault("IconText");
01135     }
01136     else
01137     {
01138       //kdDebug(220) << name() << "                writing icontext " << icontext << endl;
01139       config->writeEntry("IconText", icontext);
01140     }
01141 
01142     if(!config->hasDefault("IconSize") && iconSize() == d->IconSizeDefault )
01143       config->revertToDefault("IconSize");
01144     else
01145       config->writeEntry("IconSize", iconSize());
01146 
01147     if(!config->hasDefault("Hidden") && isHidden() == d->HiddenDefault )
01148       config->revertToDefault("Hidden");
01149     else
01150       config->writeEntry("Hidden", isHidden());
01151 
01152     // Note that index, unlike the other settings, depends on the other toolbars
01153     // So on the first run with a clean local config file, even the usual
01154     // hasDefault/==IndexDefault test would save the toolbar indexes
01155     // (IndexDefault was 0, whereas index is the real index in the GUI)
01156     //
01157     // Saving the whole set of indexes is necessary though. When moving only
01158     // one toolbar, if we only saved the changed indexes, the toolbars wouldn't
01159     // reappear at the same position the next time.
01160     // The whole set of indexes has to be saved.
01161     //kdDebug(220) << name() << "                writing index " << index << endl;
01162     config->writeEntry("Index", index);
01163 
01164     if(!config->hasDefault("Offset") && offset() == d->OffsetDefault )
01165       config->revertToDefault("Offset");
01166     else
01167       config->writeEntry("Offset", offset());
01168 
01169     if(!config->hasDefault("NewLine") && newLine() == d->NewLineDefault )
01170       config->revertToDefault("NewLine");
01171     else
01172       config->writeEntry("NewLine", newLine());
01173 }
01174 
01175 
01176 void KToolBar::setXMLGUIClient( KXMLGUIClient *client )
01177 {
01178     d->m_xmlguiClient = client;
01179 }
01180 
01181 void KToolBar::setText( const QString & txt )
01182 {
01183     setLabel( txt + " (" + kapp->caption() + ") " );
01184 }
01185 
01186 
01187 QString KToolBar::text() const
01188 {
01189     return label();
01190 }
01191 
01192 
01193 void KToolBar::doConnections( KToolBarButton *button )
01194 {
01195     connect(button, SIGNAL(clicked(int)), this, SIGNAL( clicked( int ) ) );
01196     connect(button, SIGNAL(doubleClicked(int)), this, SIGNAL( doubleClicked( int ) ) );
01197     connect(button, SIGNAL(released(int)), this, SIGNAL( released( int ) ) );
01198     connect(button, SIGNAL(pressed(int)), this, SIGNAL( pressed( int ) ) );
01199     connect(button, SIGNAL(toggled(int)), this, SIGNAL( toggled( int ) ) );
01200     connect(button, SIGNAL(highlighted(int, bool)), this, SIGNAL( highlighted( int, bool ) ) );
01201 }
01202 
01203 void KToolBar::mousePressEvent ( QMouseEvent *m )
01204 {
01205     if ( !mainWindow() )
01206         return;
01207     QMainWindow *mw = mainWindow();
01208     if ( mw->toolBarsMovable() && d->m_enableContext ) {
01209         if ( m->button() == RightButton ) {
01210             int i = contextMenu()->exec( m->globalPos(), 0 );
01211             switch ( i ) {
01212             case -1:
01213                 return; // popup canceled
01214             case CONTEXT_LEFT:
01215                 mw->moveDockWindow( this, DockLeft );
01216                 break;
01217             case CONTEXT_RIGHT:
01218                 mw->moveDockWindow( this, DockRight );
01219                 break;
01220             case CONTEXT_TOP:
01221                 mw->moveDockWindow( this, DockTop );
01222                 break;
01223             case CONTEXT_BOTTOM:
01224                 mw->moveDockWindow( this, DockBottom );
01225                 break;
01226             case CONTEXT_FLOAT:
01227                 break;
01228             case CONTEXT_FLAT:
01229                 mw->moveDockWindow( this, DockMinimized );
01230                 break;
01231             case CONTEXT_ICONS:
01232                 setIconText( IconOnly );
01233                 break;
01234             case CONTEXT_TEXTRIGHT:
01235                 setIconText( IconTextRight );
01236                 break;
01237             case CONTEXT_TEXT:
01238                 setIconText( TextOnly );
01239                 break;
01240             case CONTEXT_TEXTUNDER:
01241                 setIconText( IconTextBottom );
01242                 break;
01243             default:
01244                 if ( i >= CONTEXT_ICONSIZES )
01245                     setIconSize( i - CONTEXT_ICONSIZES );
01246                 else
01247                     return; // assume this was an action handled elsewhere, no need for setSettingsDirty()
01248             }
01249             KMainWindow *kmw = dynamic_cast<KMainWindow *>(mw);
01250             if ( kmw )
01251                 kmw->setSettingsDirty();
01252         }
01253     }
01254 }
01255 
01256 
01257 void KToolBar::rebuildLayout()
01258 {
01259     for(QWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next())
01260        w->blockSignals(false);
01261     d->idleButtons.clear();
01262 
01263     layoutTimer->stop();
01264     QApplication::sendPostedEvents( this, QEvent::ChildInserted );
01265     QBoxLayout *l = boxLayout();
01266 
01267     // clear the old layout
01268     QLayoutIterator it = l->iterator();
01269     while ( it.current() )
01270         it.deleteCurrent();
01271 
01272     for ( QWidget *w = widgets.first(); w; w = widgets.next() ) {
01273         if ( w == rightAligned )
01274             continue;
01275         KToolBarSeparator *ktbs = dynamic_cast<KToolBarSeparator *>(w);
01276         if ( ktbs && !ktbs->showLine() ) {
01277             l->addSpacing( orientation() == Vertical ? w->sizeHint().height() : w->sizeHint().width() );
01278             w->hide();
01279             continue;
01280         }
01281         if ( dynamic_cast<QPopupMenu *>(w) ) // w is a QPopupMenu?
01282             continue;
01283         l->addWidget( w );
01284         w->show();
01285         if ((orientation() == Horizontal) && dynamic_cast<QLineEdit *>(w)) // w is QLineEdit ?
01286             l->addSpacing(2); // A little bit extra spacing behind it.
01287     }
01288     if ( rightAligned ) {
01289         l->addStretch();
01290         l->addWidget( rightAligned );
01291         rightAligned->show();
01292     }
01293 
01294     if ( fullSize() ) {
01295         if ( !rightAligned )
01296             l->addStretch();
01297         if ( stretchableWidget )
01298             l->setStretchFactor( stretchableWidget, 10 );
01299     }
01300     l->invalidate();
01301     QApplication::postEvent( this, new QEvent( QEvent::LayoutHint ) );
01302 }
01303 
01304 void KToolBar::childEvent( QChildEvent *e )
01305 {
01306     if ( e->child()->isWidgetType() ) {
01307         QWidget * w = dynamic_cast<QWidget *>(e->child());
01308         if (!w || (::qstrcmp( "qt_dockwidget_internal", w->name()) == 0))
01309         {
01310            QToolBar::childEvent( e );
01311            return;
01312         }
01313         if ( e->type() == QEvent::ChildInserted ) {
01314             if ( !dynamic_cast<QPopupMenu *>(w)) { // e->child() is not a QPopupMenu
01315                 // prevent items that have been explicitly inserted by insert*() from
01316                 // being inserted again
01317                 if ( !widget2id.contains( w ) )
01318                 {
01319                     int dummy = -1;
01320                     insertWidgetInternal( w, dummy, -1 );
01321                 }
01322             }
01323         } else {
01324             removeWidgetInternal( w );
01325         }
01326         if ( isVisibleTo( 0 ) )
01327         {
01328             layoutTimer->start( 50, true );
01329             QBoxLayout *l = boxLayout();
01330 
01331             // clear the old layout so that we don't get unnecassery layout
01332             // changes till we have rebuild the thing
01333             QLayoutIterator it = l->iterator();
01334             while ( it.current() )
01335                it.deleteCurrent();
01336         }
01337     }
01338     QToolBar::childEvent( e );
01339 }
01340 
01341 void KToolBar::insertWidgetInternal( QWidget *w, int &index, int id )
01342 {
01343     // we can't have it in widgets, or something is really wrong
01344     //widgets.removeRef( w );
01345 
01346     connect( w, SIGNAL( destroyed() ),
01347              this, SLOT( widgetDestroyed() ) );
01348     if ( index == -1 || index > (int)widgets.count() ) {
01349         index = (int)widgets.count();
01350         widgets.append( w );
01351     }
01352     else
01353         widgets.insert( index, w );
01354     if ( id == -1 )
01355         id = id2widget.count();
01356     id2widget.insert( id, w );
01357     widget2id.insert( w, id );
01358 }
01359 
01360 void KToolBar::showEvent( QShowEvent *e )
01361 {
01362     QToolBar::showEvent( e );
01363     rebuildLayout();
01364 }
01365 
01366 void KToolBar::setStretchableWidget( QWidget *w )
01367 {
01368     QToolBar::setStretchableWidget( w );
01369     stretchableWidget = w;
01370 }
01371 
01372 QSizePolicy KToolBar::sizePolicy() const
01373 {
01374     if ( orientation() == Horizontal )
01375         return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
01376     else
01377         return QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Expanding );
01378 }
01379 
01380 QSize KToolBar::sizeHint() const
01381 {
01382     QSize minSize(0,0);
01383     KToolBar *ncThis = const_cast<KToolBar *>(this);
01384 
01385     ncThis->polish();
01386 
01387     int margin = static_cast<QWidget*>(ncThis)->layout()->margin() + frameWidth();
01388     switch( barPos() )
01389     {
01390      case KToolBar::Top:
01391      case KToolBar::Bottom:
01392        for ( QWidget *w = ncThis->widgets.first(); w; w = ncThis->widgets.next() )
01393        {
01394           QSize sh = w->sizeHint();
01395           if ( w->sizePolicy().horData() == QSizePolicy::Ignored )
01396              sh.setWidth( 1 );
01397           if ( w->sizePolicy().verData() == QSizePolicy::Ignored )
01398              sh.setHeight( 1 );
01399           sh = sh.boundedTo( w->maximumSize() )
01400                  .expandedTo( w->minimumSize() ).expandedTo( QSize(1, 1) );
01401 
01402           minSize = minSize.expandedTo(QSize(0, sh.height()));
01403           minSize += QSize(sh.width()+1, 0);
01404           if (dynamic_cast<QLineEdit *>(w)) // w is a QLineEdit ?
01405              minSize += QSize(2, 0); // A little bit extra spacing behind it.
01406        }
01407 
01408        minSize += QSize(QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ), 0);
01409        minSize += QSize(margin*2, margin*2);
01410        break;
01411 
01412      case KToolBar::Left:
01413      case KToolBar::Right:
01414        for ( QWidget *w = ncThis->widgets.first(); w; w = ncThis->widgets.next() )
01415        {
01416           QSize sh = w->sizeHint();
01417           if ( w->sizePolicy().horData() == QSizePolicy::Ignored )
01418              sh.setWidth( 1 );
01419           if ( w->sizePolicy().verData() == QSizePolicy::Ignored )
01420              sh.setHeight( 1 );
01421           sh = sh.boundedTo( w->maximumSize() )
01422                  .expandedTo( w->minimumSize() ).expandedTo( QSize(1, 1) );
01423 
01424           minSize = minSize.expandedTo(QSize(sh.width(), 0));
01425           minSize += QSize(0, sh.height()+1);
01426        }
01427        minSize += QSize(0, QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
01428        minSize += QSize(margin*2, margin*2);
01429        break;
01430 
01431      default:
01432        minSize = QToolBar::sizeHint();
01433        break;
01434     }
01435     return minSize;
01436 }
01437 
01438 QSize KToolBar::minimumSize() const
01439 {
01440     return minimumSizeHint();
01441 }
01442 
01443 QSize KToolBar::minimumSizeHint() const
01444 {
01445     return sizeHint();
01446 }
01447 
01448 bool KToolBar::highlight() const
01449 {
01450     return d->m_highlight;
01451 }
01452 
01453 void KToolBar::hide()
01454 {
01455     QToolBar::hide();
01456 }
01457 
01458 void KToolBar::show()
01459 {
01460     QToolBar::show();
01461 }
01462 
01463 void KToolBar::resizeEvent( QResizeEvent *e )
01464 {
01465     bool b = isUpdatesEnabled();
01466     setUpdatesEnabled( false );
01467     QToolBar::resizeEvent( e );
01468     if (b)
01469     {
01470       if (layoutTimer->isActive())
01471       {
01472          // Wait with repainting till layout is complete.
01473          d->repaintTimer.start( 100, true );
01474       }
01475       else
01476       {
01477          // Repaint now
01478          slotRepaint();
01479       }
01480     }
01481 }
01482 
01483 void KToolBar::slotIconChanged(int group)
01484 {
01485     if ((group != KIcon::Toolbar) && (group != KIcon::MainToolbar))
01486         return;
01487     if ((group == KIcon::MainToolbar) != !::qstrcmp(name(), "mainToolBar"))
01488         return;
01489 
01490     emit modechange();
01491     if (isVisible())
01492         updateGeometry();
01493 }
01494 
01495 void KToolBar::slotReadConfig()
01496 {
01497     //kdDebug(220) << name() << " slotReadConfig" << endl;
01498     // Read appearance settings (hmm, we used to do both here,
01499     // but a well behaved application will call applyMainWindowSettings
01500     // anyway, right ?)
01501     applyAppearanceSettings(KGlobal::config(), QString::null );
01502 }
01503 
01504 void KToolBar::slotAppearanceChanged()
01505 {
01506     // Read appearance settings from global file.
01507     applyAppearanceSettings(KGlobal::config(), QString::null, true /* lose local settings */ );
01508 
01509     // And remember to save the new look later
01510     KMainWindow *kmw = dynamic_cast<KMainWindow *>(mainWindow());
01511     if ( kmw )
01512         kmw->setSettingsDirty();
01513 }
01514 
01515 //static
01516 bool KToolBar::highlightSetting()
01517 {
01518     QString grpToolbar(QString::fromLatin1("Toolbar style"));
01519     KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
01520     return KGlobal::config()->readBoolEntry(QString::fromLatin1("Highlighting"),true);
01521 }
01522 
01523 //static
01524 bool KToolBar::transparentSetting()
01525 {
01526     QString grpToolbar(QString::fromLatin1("Toolbar style"));
01527     KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
01528     return KGlobal::config()->readBoolEntry(QString::fromLatin1("TransparentMoving"),true);
01529 }
01530 
01531 //static
01532 KToolBar::IconText KToolBar::iconTextSetting()
01533 {
01534     QString grpToolbar(QString::fromLatin1("Toolbar style"));
01535     KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
01536     QString icontext = KGlobal::config()->readEntry(QString::fromLatin1("IconText"),QString::fromLatin1("IconOnly"));
01537     if ( icontext == "IconTextRight" )
01538         return IconTextRight;
01539     else if ( icontext == "IconTextBottom" )
01540         return IconTextBottom;
01541     else if ( icontext == "TextOnly" )
01542         return TextOnly;
01543     else
01544         return IconOnly;
01545 }
01546 
01547 void KToolBar::applyAppearanceSettings(KConfig *config, const QString &_configGroup, bool forceGlobal)
01548 {
01549     QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup;
01550     //kdDebug(220) << name() << " applyAppearanceSettings: configGroup=" << configGroup << " forceGlobal=" << forceGlobal << endl;
01551 
01552     // If we have application-specific settings in the XML file,
01553     // and nothing in the application's config file, then
01554     // we don't apply the global defaults, the XML ones are preferred
01555     // (see applySettings for a full explanation)
01556     // This is the reason for the xmlgui tests below.
01557     bool xmlgui = d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty();
01558 
01559     KConfig *gconfig = KGlobal::config();
01560 
01561     static const QString &attrIconText  = KGlobal::staticQString("IconText");
01562     static const QString &attrHighlight = KGlobal::staticQString("Highlighting");
01563     static const QString &attrTrans     = KGlobal::staticQString("TransparentMoving");
01564     static const QString &attrIconSize  = KGlobal::staticQString("IconSize");
01565 
01566     // we actually do this in two steps.
01567     // First, we read in the global styles [Toolbar style] (from the KControl module).
01568     // Then, if the toolbar is NOT 'mainToolBar', we will also try to read in [barname Toolbar style]
01569     bool highlight;
01570     int transparent;
01571     bool applyIconText = !xmlgui; // if xmlgui is used, global defaults won't apply
01572     bool applyIconSize = !xmlgui;
01573 
01574     int iconSize = d->IconSizeDefault;
01575     QString iconText = d->IconTextDefault;
01576 
01577     // this is the first iteration
01578     QString grpToolbar(QString::fromLatin1("Toolbar style"));
01579     { // start block for KConfigGroupSaver
01580         KConfigGroupSaver saver(gconfig, grpToolbar);
01581 
01582         // first, get the generic settings
01583         highlight   = gconfig->readBoolEntry(attrHighlight, true);
01584         transparent = gconfig->readBoolEntry(attrTrans, true);
01585 
01586         // we read in the IconText property *only* if we intend on actually
01587         // honoring it
01588         if (d->m_honorStyle)
01589             d->IconTextDefault = gconfig->readEntry(attrIconText, d->IconTextDefault);
01590         else
01591             d->IconTextDefault = "IconOnly";
01592 
01593         // Use the default icon size for toolbar icons.
01594         d->IconSizeDefault = gconfig->readNumEntry(attrIconSize, d->IconSizeDefault);
01595 
01596         iconSize = d->IconSizeDefault;
01597         iconText = d->IconTextDefault;
01598     
01599         if ( !forceGlobal && config->hasGroup(configGroup) )
01600         {
01601             config->setGroup(configGroup);
01602 
01603             // first, get the generic settings
01604             highlight   = config->readBoolEntry(attrHighlight, highlight);
01605             transparent = config->readBoolEntry(attrTrans, transparent);
01606 
01607             // read in the IconText property
01608             if ( config->hasKey( attrIconText ) ) {
01609                 iconText = config->readEntry(attrIconText);
01610                 applyIconText = true;
01611                 //kdDebug(220) << name() << " read icontext=" << d->IconTextDefault << ", that will be the default" << endl;
01612             }
01613 
01614             // now get the size
01615             if ( config->hasKey( attrIconSize ) ) {
01616                 iconSize = config->readNumEntry(attrIconSize);
01617                 applyIconSize = true;
01618             }
01619         }
01620 
01621         // revert back to the old group
01622     } // end block for KConfigGroupSaver
01623 
01624     bool doUpdate = false;
01625 
01626     IconText icon_text;
01627     if ( iconText == "IconTextRight" )
01628         icon_text = IconTextRight;
01629     else if ( iconText == "IconTextBottom" )
01630         icon_text = IconTextBottom;
01631     else if ( iconText == "TextOnly" )
01632         icon_text = TextOnly;
01633     else
01634         icon_text = IconOnly;
01635 
01636     // check if the icon/text has changed
01637     if (icon_text != d->m_iconText && applyIconText) {
01638         //kdDebug(220) << name() << " applyAppearanceSettings setIconText " << icon_text << endl;
01639         setIconText(icon_text, false);
01640         doUpdate = true;
01641     }
01642 
01643     // ...and check if the icon size has changed
01644     if (iconSize != d->m_iconSize && applyIconSize) {
01645         setIconSize(iconSize, false);
01646         doUpdate = true;
01647     }
01648 
01649     QMainWindow *mw = mainWindow();
01650 
01651     // ...and if we should highlight
01652     if ( highlight != d->m_highlight ) {
01653         d->m_highlight = highlight;
01654         doUpdate = true;
01655     }
01656 
01657     // ...and if we should move transparently
01658     if ( mw && transparent != (!mw->opaqueMoving()) ) {
01659         mw->setOpaqueMoving( !transparent );
01660     }
01661 
01662     if (doUpdate)
01663         emit modechange(); // tell buttons what happened
01664     if (isVisible ())
01665         updateGeometry();
01666 }
01667 
01668 void KToolBar::applySettings(KConfig *config, const QString &_configGroup)
01669 {
01670     //kdDebug(220) << name() << " applySettings group=" << _configGroup << endl;
01671 
01672     QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup;
01673 
01674     /*
01675       Let's explain this a bit more in details.
01676       The order in which we apply settings is :
01677        Global config / <appnamerc> user settings                        if no XMLGUI is used
01678        Global config / App-XML attributes / <appnamerc> user settings   if XMLGUI is used
01679 
01680       So in the first case, we simply read everything from KConfig as below,
01681       but in the second case we don't do anything here if there is no app-specific config,
01682       and the XMLGUI-related code (loadState()) uses the static methods of this class
01683       to get the global defaults.
01684 
01685       Global config doesn't include position (index, offset, newline and hidden/shown).
01686     */
01687 
01688     // First the appearance stuff - the one which has a global config
01689     applyAppearanceSettings( config, configGroup );
01690 
01691     // ...and now the position stuff
01692     if ( config->hasGroup(configGroup) )
01693     {
01694         KConfigGroupSaver cgs(config, configGroup);
01695 
01696         static const QString &attrPosition  = KGlobal::staticQString("Position");
01697         static const QString &attrIndex  = KGlobal::staticQString("Index");
01698         static const QString &attrOffset  = KGlobal::staticQString("Offset");
01699         static const QString &attrNewLine  = KGlobal::staticQString("NewLine");
01700         static const QString &attrHidden  = KGlobal::staticQString("Hidden");
01701 
01702         QString position = config->readEntry(attrPosition, d->PositionDefault);
01703         int index = config->readNumEntry(attrIndex, -1);
01704         int offset = config->readNumEntry(attrOffset, d->OffsetDefault);
01705         bool newLine = config->readBoolEntry(attrNewLine, d->NewLineDefault);
01706         bool hidden = config->readBoolEntry(attrHidden, d->HiddenDefault);
01707 
01708         Dock pos(DockTop);
01709         if ( position == "Top" )
01710             pos = DockTop;
01711         else if ( position == "Bottom" )
01712             pos = DockBottom;
01713         else if ( position == "Left" )
01714             pos = DockLeft;
01715         else if ( position == "Right" )
01716             pos = DockRight;
01717         else if ( position == "Floating" )
01718             pos = DockTornOff;
01719         else if ( position == "Flat" )
01720             pos = DockMinimized;
01721 
01722         //kdDebug(220) << name() << " applySettings hidden=" << hidden << endl;
01723         if (hidden)
01724             hide();
01725         else
01726             show();
01727 
01728         if ( mainWindow() )
01729         {
01730             //kdDebug(220) << name() << " applySettings updating ToolbarInfo" << endl;
01731             d->toolBarInfo = KToolBarPrivate::ToolBarInfo( pos, index, newLine, offset );
01732             positionYourself( true );
01733         }
01734         if (isVisible ())
01735             updateGeometry();
01736     }
01737 }
01738 
01739 bool KToolBar::event( QEvent *e )
01740 {
01741     if ( (e->type() == QEvent::LayoutHint) && isUpdatesEnabled() )
01742        d->repaintTimer.start( 100, true );
01743 
01744     if (e->type() == QEvent::ChildInserted )
01745     {
01746        // Bypass QToolBar::event,
01747        // it will show() the inserted child and we don't want to
01748        // do that until we have rebuilt the layout.
01749        childEvent((QChildEvent *)e);
01750        return true;
01751     }
01752 
01753     return QToolBar::event( e );
01754 }
01755 
01756 void KToolBar::slotRepaint()
01757 {
01758     setUpdatesEnabled( false );
01759     // Send a resizeEvent to update the "toolbar extension arrow"
01760     // (The button you get when your toolbar-items don't fit in
01761     // the available space)
01762     QResizeEvent ev(size(), size());
01763     resizeEvent(&ev);
01764     QApplication::sendPostedEvents( this, QEvent::LayoutHint );
01765     setUpdatesEnabled( true );
01766     repaint( true );
01767 }
01768 
01769 void KToolBar::toolBarPosChanged( QToolBar *tb )
01770 {
01771     if ( tb != this )
01772         return;
01773     if ( d->oldPos == DockMinimized )
01774         rebuildLayout();
01775     d->oldPos = (QMainWindow::ToolBarDock)barPos();
01776     KMainWindow *kmw = dynamic_cast<KMainWindow *>(mainWindow());
01777     if ( kmw )
01778         kmw->setSettingsDirty();
01779 }
01780 
01781 void KToolBar::loadState( const QDomElement &element )
01782 {
01783     //kdDebug(220) << name() << " loadState " << this << endl;
01784     QMainWindow *mw = mainWindow();
01785 
01786     if ( !mw )
01787         return;
01788 
01789     {
01790         QCString text = element.namedItem( "text" ).toElement().text().utf8();
01791         if ( text.isEmpty() )
01792             text = element.namedItem( "Text" ).toElement().text().utf8();
01793         if ( !text.isEmpty() )
01794             setText( i18n( text ) );
01795     }
01796 
01797     {
01798         QCString attrFullWidth = element.attribute( "fullWidth" ).lower().latin1();
01799         if ( !attrFullWidth.isEmpty() )
01800             setFullSize( attrFullWidth == "true" );
01801     }
01802 
01803     Dock dock = DockTop;
01804     {
01805         QCString attrPosition = element.attribute( "position" ).lower().latin1();
01806         //kdDebug(220) << name() << " loadState attrPosition=" << attrPosition << endl;
01807         if ( !attrPosition.isEmpty() ) {
01808             if ( attrPosition == "top" )
01809                 dock = DockTop;
01810             else if ( attrPosition == "left" )
01811                 dock = DockLeft;
01812             else if ( attrPosition == "right" )
01813                 dock = DockRight;
01814             else if ( attrPosition == "bottom" )
01815                 dock = DockBottom;
01816             else if ( attrPosition == "floating" )
01817                 dock = DockTornOff;
01818             else if ( attrPosition == "flat" )
01819                 dock = DockMinimized;
01820         }
01821     }
01822 
01823     {
01824         QCString attrIconText = element.attribute( "iconText" ).lower().latin1();
01825         if ( !attrIconText.isEmpty() ) {
01826             //kdDebug(220) << name() << " loadState attrIconText=" << attrIconText << endl;
01827             if ( attrIconText == "icontextright" )
01828                 setIconText( KToolBar::IconTextRight );
01829             else if ( attrIconText == "textonly" )
01830                 setIconText( KToolBar::TextOnly );
01831             else if ( attrIconText == "icontextbottom" )
01832                 setIconText( KToolBar::IconTextBottom );
01833             else if ( attrIconText == "icononly" )
01834                 setIconText( KToolBar::IconOnly );
01835         } else
01836     {
01837         //kdDebug(220) << name() << " loadState no iconText attribute in XML, using iconTextSetting=" << iconTextSetting() << endl;
01838             // Use global setting
01839             if (d->m_honorStyle) 
01840                 setIconText( iconTextSetting() );
01841             else
01842                 setIconText( d->IconTextDefault);
01843     }
01844     }
01845 
01846     {
01847         QString attrIconSize = element.attribute( "iconSize" ).lower();
01848         if ( !attrIconSize.isEmpty() )
01849             d->IconSizeDefault = attrIconSize.toInt();
01850         setIconSize( d->IconSizeDefault );
01851     }
01852 
01853     int index = -1; // append by default. This is very important, otherwise
01854     // with all 0 indexes, we keep reversing the toolbars.
01855     {
01856         QString attrIndex = element.attribute( "index" ).lower();
01857         if ( !attrIndex.isEmpty() )
01858             index = attrIndex.toInt();
01859     }
01860 
01861     {
01862         QString attrOffset = element.attribute( "offset" ).lower();
01863         if ( !attrOffset.isEmpty() )
01864             d->OffsetDefault = attrOffset.toInt();
01865     }
01866 
01867     {
01868         QString attrNewLine = element.attribute( "newline" ).lower();
01869         if ( !attrNewLine.isEmpty() )
01870             d->NewLineDefault = attrNewLine == "true";
01871     }
01872 
01873     {
01874         QString attrHidden = element.attribute( "hidden" ).lower();
01875         if ( !attrHidden.isEmpty() )
01876             d->HiddenDefault = attrHidden  == "true";
01877     }
01878 
01879     d->toolBarInfo = KToolBarPrivate::ToolBarInfo( dock, index, d->NewLineDefault, d->OffsetDefault );
01880     mw->addDockWindow( this, dock, d->NewLineDefault );
01881     mw->moveDockWindow( this, dock, d->NewLineDefault, index, d->OffsetDefault );
01882 
01883     // Apply the highlight button setting
01884     d->m_highlight = highlightSetting();
01885 
01886     // Apply transparent-toolbar-moving setting (ok, this is global to the mainwindow,
01887     // but we do it only if there are toolbars...)
01888     if ( transparentSetting() != !mw->opaqueMoving() )
01889         mw->setOpaqueMoving( !transparentSetting() );
01890 
01891     if ( d->HiddenDefault )
01892         hide();
01893     else
01894         show();
01895 
01896     getAttributes( d->PositionDefault, d->IconTextDefault, index );
01897     //kdDebug(220) << name() << " loadState IconTextDefault=" << d->IconTextDefault << endl;
01898 }
01899 
01900 int KToolBar::dockWindowIndex()
01901 {
01902     int index = 0;
01903     Q_ASSERT( mainWindow() );
01904     if ( mainWindow() ) {
01905         QMainWindow::ToolBarDock dock;
01906         bool newLine;
01907         int offset;
01908         mainWindow()->getLocation( this, dock, index, newLine, offset );
01909     }
01910     return index;
01911 }
01912 
01913 void KToolBar::getAttributes( QString &position, QString &icontext, int &index )
01914 {
01915     // get all of the stuff to save
01916     switch ( barPos() ) {
01917     case KToolBar::Flat:
01918         position = "Flat";
01919         break;
01920     case KToolBar::Bottom:
01921         position = "Bottom";
01922         break;
01923     case KToolBar::Left:
01924         position = "Left";
01925         break;
01926     case KToolBar::Right:
01927         position = "Right";
01928         break;
01929     case KToolBar::Floating:
01930         position = "Floating";
01931         break;
01932     case KToolBar::Top:
01933     default:
01934         position = "Top";
01935         break;
01936     }
01937 
01938     index = dockWindowIndex();
01939 
01940     switch (d->m_iconText) {
01941     case KToolBar::IconTextRight:
01942         icontext = "IconTextRight";
01943         break;
01944     case KToolBar::IconTextBottom:
01945         icontext = "IconTextBottom";
01946         break;
01947     case KToolBar::TextOnly:
01948         icontext = "TextOnly";
01949         break;
01950     case KToolBar::IconOnly:
01951     default:
01952         icontext = "IconOnly";
01953         break;
01954     }
01955     //kdDebug(220) << name() << " getAttributes: icontext=" << icontext << endl;
01956 }
01957 
01958 void KToolBar::saveState( QDomElement &current )
01959 {
01960     Q_ASSERT( !current.isNull() );
01961     QString position, icontext;
01962     int index = -1;
01963     getAttributes( position, icontext, index );
01964 
01965     current.setAttribute( "noMerge", "1" );
01966     current.setAttribute( "position", position );
01967     current.setAttribute( "iconText", icontext );
01968     current.setAttribute( "index", index );
01969     current.setAttribute( "offset", offset() );
01970     current.setAttribute( "newline", newLine() );
01971     if ( isHidden() )
01972         current.setAttribute( "hidden", "true" );
01973     d->modified = true;
01974     //kdDebug(220) << name() << " saveState: saving index=" << index << " iconText=" << icontext << endl;
01975 }
01976 
01977 // Called by KMainWindow::finalizeGUI
01978 void KToolBar::positionYourself( bool force )
01979 {
01980     if (force)
01981         d->positioned = false;
01982 
01983     if ( d->positioned || !mainWindow() )
01984     {
01985         //kdDebug(220) << name() << " positionYourself d->positioned=true  ALREADY DONE" << endl;
01986         return;
01987     }
01988     // we can't test for ForceHide after moveDockWindow because QDockArea
01989     // does a reparent() with showIt == true
01990     bool doHide = isHidden();
01991     //kdDebug(220) << name() << " positionYourself  dock=" << d->toolBarInfo.dock << " newLine=" << d->toolBarInfo.newline << " index=" << d->toolBarInfo.index << " offset=" << d->toolBarInfo.offset << endl;
01992     mainWindow()->moveDockWindow( this, d->toolBarInfo.dock,
01993                                   d->toolBarInfo.newline,
01994                                   d->toolBarInfo.index,
01995                                   d->toolBarInfo.offset );
01996 
01997     //kdDebug(220) << name() << " positionYourself dockWindowIndex=" << dockWindowIndex() << endl;
01998     if ( doHide )
01999         hide();
02000     // This method can only have an effect once - unless force is set
02001     d->positioned = true;
02002 }
02003 
02004 KPopupMenu *KToolBar::contextMenu()
02005 {
02006   if ( context )
02007     return context;
02008 
02009   // Construct our context popup menu. Name it qt_dockwidget_internal so it
02010   // won't be deleted by QToolBar::clear().
02011   context = new KPopupMenu( this, "qt_dockwidget_internal" );
02012   context->insertTitle(i18n("Toolbar Menu"));
02013 
02014   KPopupMenu *orient = new KPopupMenu( context, "orient" );
02015   orient->insertItem( i18n("toolbar position string","Top"),  CONTEXT_TOP );
02016   orient->insertItem( i18n("toolbar position string","Left"), CONTEXT_LEFT );
02017   orient->insertItem( i18n("toolbar position string","Right"), CONTEXT_RIGHT );
02018   orient->insertItem( i18n("toolbar position string","Bottom"), CONTEXT_BOTTOM );
02019   orient->insertSeparator(-1);
02020   //orient->insertItem( i18n("toolbar position string","Floating"), CONTEXT_FLOAT );
02021   orient->insertItem( i18n("min toolbar", "Flat"), CONTEXT_FLAT );
02022 
02023   KPopupMenu *mode = new KPopupMenu( context, "mode" );
02024   mode->insertItem( i18n("Icons Only"), CONTEXT_ICONS );
02025   mode->insertItem( i18n("Text Only"), CONTEXT_TEXT );
02026   mode->insertItem( i18n("Text Alongside Icons"), CONTEXT_TEXTRIGHT );
02027   mode->insertItem( i18n("Text Under Icons"), CONTEXT_TEXTUNDER );
02028 
02029   KPopupMenu *size = new KPopupMenu( context, "size" );
02030   size->insertItem( i18n("Default"), CONTEXT_ICONSIZES );
02031   // Query the current theme for available sizes
02032   KIconTheme *theme = KGlobal::instance()->iconLoader()->theme();
02033   QValueList<int> avSizes;
02034   if (theme)
02035   {
02036       if (!::qstrcmp(QObject::name(), "mainToolBar"))
02037           avSizes = theme->querySizes( KIcon::MainToolbar);
02038       else
02039           avSizes = theme->querySizes( KIcon::Toolbar);
02040   }
02041 
02042   d->iconSizes = avSizes;
02043 
02044   QValueList<int>::Iterator it;
02045   for (it=avSizes.begin(); it!=avSizes.end(); it++) {
02046       QString text;
02047       if ( *it < 19 )
02048           text = i18n("Small (%1x%2)").arg(*it).arg(*it);
02049       else if (*it < 25)
02050           text = i18n("Medium (%1x%2)").arg(*it).arg(*it);
02051       else
02052           text = i18n("Large (%1x%2)").arg(*it).arg(*it);
02053       //we use the size as an id, with an offset
02054       size->insertItem( text, CONTEXT_ICONSIZES + *it );
02055   }
02056 
02057   context->insertItem( i18n("Orientation"), orient );
02058   orient->setItemChecked(CONTEXT_TOP, true);
02059   context->insertItem( i18n("Text Position"), mode );
02060   context->setItemChecked(CONTEXT_ICONS, true);
02061   context->insertItem( i18n("Icon Size"), size );
02062 
02063   KMainWindow *kmw = dynamic_cast<KMainWindow *>(mainWindow());
02064   if ( kmw )
02065   {
02066       if ( kmw->toolBarMenuAction() && kmw->hasMenuBar() )
02067           kmw->toolBarMenuAction()->plug(context);
02068   }
02069 
02070   connect( context, SIGNAL( aboutToShow() ), this, SLOT( slotContextAboutToShow() ) );
02071   connect( context, SIGNAL( aboutToHide() ), this, SLOT( slotContextAboutToHide() ) );
02072   return context;
02073 }
02074 
02075 void KToolBar::slotContextAboutToShow()
02076 {
02077   if (!d->m_configurePlugged)
02078   {
02079     // try to find "configure toolbars" action
02080     KXMLGUIClient *xmlGuiClient = d->m_xmlguiClient;
02081 
02082     KMainWindow *kmw = dynamic_cast<KMainWindow *>(mainWindow());
02083     if ( !xmlGuiClient && kmw )
02084       xmlGuiClient = kmw;
02085     if ( xmlGuiClient )
02086     {
02087         KAction *configureAction = xmlGuiClient->actionCollection()->action(KStdAction::stdName(KStdAction::ConfigureToolbars));
02088         if ( configureAction )
02089         {
02090           configureAction->plug(context);
02091           d->m_configurePlugged = true;
02092         }
02093     }
02094   }
02095 
02096   for(int i = CONTEXT_ICONS; i <= CONTEXT_TEXTUNDER; ++i)
02097     context->setItemChecked(i, false);
02098 
02099   switch( d->m_iconText )
02100   {
02101         case IconOnly:
02102         default:
02103             context->setItemChecked(CONTEXT_ICONS, true);
02104             break;
02105         case IconTextRight:
02106             context->setItemChecked(CONTEXT_TEXTRIGHT, true);
02107             break;
02108         case TextOnly:
02109             context->setItemChecked(CONTEXT_TEXT, true);
02110             break;
02111         case IconTextBottom:
02112             context->setItemChecked(CONTEXT_TEXTUNDER, true);
02113             break;
02114   }
02115 
02116   QValueList<int>::ConstIterator iIt = d->iconSizes.begin();
02117   QValueList<int>::ConstIterator iEnd = d->iconSizes.end();
02118   for (; iIt != iEnd; ++iIt )
02119       context->setItemChecked( CONTEXT_ICONSIZES + *iIt, false );
02120 
02121   context->setItemChecked( CONTEXT_ICONSIZES, false );
02122 
02123   context->setItemChecked( CONTEXT_ICONSIZES + d->m_iconSize, true );
02124 
02125   for ( int i = CONTEXT_TOP; i <= CONTEXT_FLAT; ++i )
02126       context->setItemChecked( i, false );
02127 
02128   switch ( barPos() )
02129   {
02130   case KToolBar::Flat:
02131       context->setItemChecked( CONTEXT_FLAT, true );
02132       break;
02133   case KToolBar::Bottom:
02134       context->setItemChecked( CONTEXT_BOTTOM, true );
02135       break;
02136   case KToolBar::Left:
02137       context->setItemChecked( CONTEXT_LEFT, true );
02138       break;
02139   case KToolBar::Right:
02140       context->setItemChecked( CONTEXT_RIGHT, true );
02141       break;
02142   case KToolBar::Floating:
02143       context->setItemChecked( CONTEXT_FLOAT, true );
02144       break;
02145   case KToolBar::Top:
02146       context->setItemChecked( CONTEXT_TOP, true );
02147       break;
02148   default: break;
02149   }
02150 }
02151 
02152 void KToolBar::slotContextAboutToHide()
02153 {
02154   QPtrListIterator<QWidget> it( widgets );
02155   QWidget *wdg;
02156   while ( ( wdg = it.current() ) != 0 ) {
02157     if ( wdg->inherits( "QToolButton" ) )
02158       static_cast<QToolButton*>( wdg )->setDown( false );
02159     ++it;
02160   }
02161 }
02162 
02163 void KToolBar::widgetDestroyed()
02164 {
02165     removeWidgetInternal( (QWidget*)sender() );
02166 }
02167 
02168 void KToolBar::removeWidgetInternal( QWidget * w )
02169 {
02170     widgets.removeRef( w );
02171     QMap< QWidget*, int >::Iterator it = widget2id.find( w );
02172     if ( it == widget2id.end() )
02173         return;
02174     id2widget.remove( *it );
02175     widget2id.remove( it );
02176 }
02177 
02178 void KToolBar::virtual_hook( int, void* )
02179 { /*BASE::virtual_hook( id, data );*/ }
02180 
02181 #include "ktoolbar.moc"
02182 
KDE Logo
This file is part of the documentation for kdeui Library Version 3.2.3.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Aug 4 05:24:01 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2003