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