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