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