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