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