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