summaryrefslogtreecommitdiffabout
path: root/microkde/kdeui/ktoolbar.cpp
Unidiff
Diffstat (limited to 'microkde/kdeui/ktoolbar.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdeui/ktoolbar.cpp2260
1 files changed, 2260 insertions, 0 deletions
diff --git a/microkde/kdeui/ktoolbar.cpp b/microkde/kdeui/ktoolbar.cpp
new file mode 100644
index 0000000..92cb8d2
--- a/dev/null
+++ b/microkde/kdeui/ktoolbar.cpp
@@ -0,0 +1,2260 @@
1/* This file is part of the KDE libraries
2 Copyright
3 (C) 2000 Reginald Stadlbauer (reggie@kde.org)
4 (C) 1997, 1998 Stephan Kulow (coolo@kde.org)
5 (C) 1997, 1998 Mark Donohoe (donohoe@kde.org)
6 (C) 1997, 1998 Sven Radej (radej@kde.org)
7 (C) 1997, 1998 Matthias Ettrich (ettrich@kde.org)
8 (C) 1999 Chris Schlaeger (cs@kde.org)
9 (C) 1999 Kurt Granroth (granroth@kde.org)
10
11 This library is free software; you can redistribute it and/or
12 modify it under the terms of the GNU Library General Public
13 License version 2 as published by the Free Software Foundation.
14
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Library General Public License for more details.
19
20 You should have received a copy of the GNU Library General Public License
21 along with this library; see the file COPYING.LIB. If not, write to
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA.
24*/
25
26#ifdef KDE_USE_FINAL
27#undef Always
28#include <qdockwindow.h>
29#endif
30
31
32
33#include "ktoolbar.h"
34#include "kmainwindow.h"
35
36#include <string.h>
37
38#include <qpainter.h>
39#include <qtooltip.h>
40#include <qdrawutil.h>
41#include <qstring.h>
42#include <qrect.h>
43#include <qobjectlist.h>
44#include <qtimer.h>
45#include <qstyle.h>
46#include <qapplication.h>
47
48//US #include <config.h>
49
50#include "klineedit.h"
51#include "kseparator.h"
52#include <klocale.h>
53#include <kapplication.h>
54#include <kaction.h>
55#include <kstdaction.h>
56#include <kglobal.h>
57#include <kconfig.h>
58#include <kiconloader.h>
59#include <kcombobox.h>
60//US #include <kpopupmenu.h>
61//US #include <kanimwidget.h>
62//US #include <kipc.h>
63//US #include <kwin.h>
64#include <kdebug.h>
65#include <qlayout.h>
66
67#include "ktoolbarbutton.h"
68
69//US
70#include "kconfigbase.h"
71
72#include <qpopupmenu.h>
73#include <qmainwindow.h>
74
75enum {
76 CONTEXT_TOP = 0,
77 CONTEXT_LEFT = 1,
78 CONTEXT_RIGHT = 2,
79 CONTEXT_BOTTOM = 3,
80 CONTEXT_FLOAT = 4,
81 CONTEXT_FLAT = 5,
82 CONTEXT_ICONS = 6,
83 CONTEXT_TEXT = 7,
84 CONTEXT_TEXTRIGHT = 8,
85 CONTEXT_TEXTUNDER = 9,
86 CONTEXT_ICONSIZES = 50 // starting point for the icon size list, put everything else before
87};
88
89class KToolBarPrivate
90{
91public:
92 KToolBarPrivate() {
93 m_iconSize = 0;
94 m_iconText = KToolBar::IconOnly;
95 m_highlight = true;
96 m_transparent = true;
97 m_honorStyle = false;
98
99 m_enableContext = true;
100
101 m_xmlguiClient = 0;
102 m_configurePlugged = false;
103
104//US oldPos = Qt::DockUnmanaged;
105 oldPos = QMainWindow::Unmanaged;
106
107 modified = m_isHorizontal = positioned = FALSE;
108
109 HiddenDefault = false;
110 IconSizeDefault = 0;
111 IconTextDefault = "IconOnly";
112 IndexDefault = -1;
113 NewLineDefault = false;
114 OffsetDefault = -1;
115 PositionDefault = "Top";
116 idleButtons.setAutoDelete(true);
117 }
118
119 int m_iconSize;
120 KToolBar::IconText m_iconText;
121 bool m_highlight : 1;
122 bool m_transparent : 1;
123 bool m_honorStyle : 1;
124 bool m_isHorizontal : 1;
125 bool m_enableContext : 1;
126 bool m_configurePlugged : 1;
127 bool modified : 1;
128 bool positioned : 1;
129
130 QWidget *m_parent;
131
132 QMainWindow::ToolBarDock oldPos;
133
134 KXMLGUIClient *m_xmlguiClient;
135
136 struct ToolBarInfo
137 {
138//US ToolBarInfo() : index( 0 ), offset( -1 ), newline( FALSE ), dock( Qt::DockTop ) {}
139 ToolBarInfo() : index( 0 ), offset( -1 ), newline( FALSE ), dock( QMainWindow::Top ) {}
140//US ToolBarInfo( Qt::Dock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {}
141 ToolBarInfo( QMainWindow::ToolBarDock d, int i, bool n, int o ) : index( i ), offset( o ), newline( n ), dock( d ) {}
142 int index, offset;
143 bool newline;
144//US Qt::Dock dock;
145 QMainWindow::ToolBarDock dock;
146 };
147
148 ToolBarInfo toolBarInfo;
149 QValueList<int> iconSizes;
150 QTimer repaintTimer;
151
152 // Default Values.
153 bool HiddenDefault;
154 int IconSizeDefault;
155 QString IconTextDefault;
156 int IndexDefault;
157 bool NewLineDefault;
158 int OffsetDefault;
159 QString PositionDefault;
160
161 QPtrList<QWidget> idleButtons;
162};
163
164KToolBarSeparator::KToolBarSeparator(Orientation o , bool l, QToolBar *parent,
165 const char* name )
166 :QFrame( parent, name ), line( l )
167{
168 connect( parent, SIGNAL(orientationChanged(Orientation)),
169 this, SLOT(setOrientation(Orientation)) );
170 setOrientation( o );
171 setBackgroundMode( parent->backgroundMode() );
172 setBackgroundOrigin( ParentOrigin );
173}
174
175void KToolBarSeparator::setOrientation( Orientation o )
176{
177 orient = o;
178 if ( line ) {
179 if ( orientation() == Vertical )
180 setFrameStyle( HLine + Sunken );
181 else
182 setFrameStyle( VLine + Sunken );
183 } else {
184 setFrameStyle( NoFrame );
185 }
186}
187
188void KToolBarSeparator::styleChange( QStyle& )
189{
190 setOrientation( orient );
191}
192
193QSize KToolBarSeparator::sizeHint() const
194{
195 return orientation() == Vertical ? QSize( 0, 6 ) : QSize( 6, 0 );
196}
197
198QSizePolicy KToolBarSeparator::sizePolicy() const
199{
200 return QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Minimum );
201}
202
203KToolBar::KToolBar( QWidget *parent, const char *name, bool honorStyle, bool readConfig )
204#ifdef DESKTOP_VERSION
205 : QToolBar( QString::fromLatin1( name ),
206 parent && parent->inherits( "QMainWindow" ) ? static_cast<QMainWindow*>(parent) : 0,
207 parent, FALSE,
208 name ? name : "mainToolBar")
209#else
210 : QPEToolBar( parent && parent->inherits( "QMainWindow" ) ? static_cast<QMainWindow*>(parent) : 0,
211 QString::fromLatin1( name ))
212
213
214#endif
215{
216 init( readConfig, honorStyle );
217}
218
219KToolBar::KToolBar( QMainWindow *parentWindow, QMainWindow::ToolBarDock dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
220#ifdef DESKTOP_VERSION
221 : QToolBar( QString::fromLatin1( name ),
222 parentWindow, dock, newLine,
223 name ? name : "mainToolBar")
224#else
225 : QPEToolBar( parentWindow,QString::fromLatin1( name ))
226
227
228#endif
229
230{
231 init( readConfig, honorStyle );
232}
233
234KToolBar::KToolBar( QMainWindow *parentWindow, QWidget *dock, bool newLine, const char *name, bool honorStyle, bool readConfig )
235#ifdef DESKTOP_VERSION
236 : QToolBar( QString::fromLatin1( name ),
237 parentWindow, dock, newLine,
238 name ? name : "mainToolBar")
239#else
240 : QPEToolBar( parentWindow,QString::fromLatin1( name ))
241
242
243#endif
244
245{
246 init( readConfig, honorStyle );
247}
248
249KToolBar::~KToolBar()
250{
251 inshutdownprocess = true;
252 emit toolbarDestroyed();
253 delete d;
254}
255
256void KToolBar::init( bool readConfig, bool honorStyle )
257{
258 inshutdownprocess = false;
259 d = new KToolBarPrivate;
260 setFullSize( TRUE );
261 d->m_honorStyle = honorStyle;
262 context = 0;
263 layoutTimer = new QTimer( this );
264 connect( layoutTimer, SIGNAL( timeout() ),
265 this, SLOT( rebuildLayout() ) );
266 connect( &(d->repaintTimer), SIGNAL( timeout() ),
267 this, SLOT( slotRepaint() ) );
268/*US
269 if ( kapp ) { // may be null when started inside designer
270 connect(kapp, SIGNAL(toolbarAppearanceChanged(int)), this, SLOT(slotAppearanceChanged()));
271 // request notification of changes in icon style
272 kapp->addKipcEventMask(KIPC::IconChanged);
273 connect(kapp, SIGNAL(iconChanged(int)), this, SLOT(slotIconChanged(int)));
274 }
275*/
276 // finally, read in our configurable settings
277 if ( readConfig )
278 slotReadConfig();
279
280 if ( mainWindow() )
281 connect( mainWindow(), SIGNAL( toolBarPositionChanged( QToolBar * ) ),
282 this, SLOT( toolBarPosChanged( QToolBar * ) ) );
283
284 // Hack to make sure we recalculate our size when we dock.
285//US connect( this, SIGNAL(placeChanged(QDockWindow::Place)), SLOT(rebuildLayout()) );
286}
287
288int KToolBar::insertButton(const QString& icon, int id, bool enabled,
289 const QString& text, int index/*US, KInstance *_instance*/ )
290{
291 KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text/*US, _instance*/ );
292
293 insertWidgetInternal( button, index, id );
294 button->setEnabled( enabled );
295 doConnections( button );
296 return index;
297}
298
299
300int KToolBar::insertButton(const QString& icon, int id, const char *signal,
301 const QObject *receiver, const char *slot,
302 bool enabled, const QString& text, int index/*US, KInstance *_instance*/ )
303{
304 KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text/*US, _instance*/);
305 insertWidgetInternal( button, index, id );
306 button->setEnabled( enabled );
307 connect( button, signal, receiver, slot );
308 doConnections( button );
309 return index;
310}
311
312
313int KToolBar::insertButton(const QPixmap& pixmap, int id, bool enabled,
314 const QString& text, int index )
315{
316 KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
317 insertWidgetInternal( button, index, id );
318 button->setEnabled( enabled );
319 doConnections( button );
320 return index;
321}
322#if 0
323 bar->insertButton( icon, id_, SIGNAL( clicked() ), this,
324 SLOT( slotActivated() ),
325 d->isEnabled(), d->plainText(), index/*US, instance*/ );
326#endif
327
328int KToolBar::insertButton(const QPixmap& pixmap, int id, const char *signal,
329 const QObject *receiver, const char *slot,
330 bool enabled, const QString& text,
331 int index )
332{
333 KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text);
334 insertWidgetInternal( button, index, id );
335 button->setEnabled( enabled );
336 connect( button, signal, receiver, slot );
337 doConnections( button );
338 return index;
339}
340
341
342int KToolBar::insertButton(const QString& icon, int id, QPopupMenu *popup,
343 bool enabled, const QString &text, int index )
344{
345 KToolBarButton *button = new KToolBarButton( icon, id, this, 0, text );
346 insertWidgetInternal( button, index, id );
347 button->setEnabled( enabled );
348 button->setPopup( popup );
349 doConnections( button );
350 return index;
351}
352
353
354int KToolBar::insertButton(const QPixmap& pixmap, int id, QPopupMenu *popup,
355 bool enabled, const QString &text, int index )
356{
357 KToolBarButton *button = new KToolBarButton( pixmap, id, this, 0, text );
358 insertWidgetInternal( button, index, id );
359 button->setEnabled( enabled );
360 button->setPopup( popup );
361 doConnections( button );
362 return index;
363}
364
365
366int KToolBar::insertLined (const QString& text, int id,
367 const char *signal,
368 const QObject *receiver, const char *slot,
369 bool enabled ,
370 const QString& toolTipText,
371 int size, int index )
372{
373 KLineEdit *lined = new KLineEdit ( this, 0 );
374 if ( !toolTipText.isEmpty() )
375 QToolTip::add( lined, toolTipText );
376 if ( size > 0 )
377 lined->setMinimumWidth( size );
378 insertWidgetInternal( lined, index, id );
379 connect( lined, signal, receiver, slot );
380 lined->setText(text);
381 lined->setEnabled( enabled );
382 return index;
383}
384
385int KToolBar::insertCombo (const QStringList &list, int id, bool writable,
386 const char *signal, const QObject *receiver,
387 const char *slot, bool enabled,
388 const QString& tooltiptext,
389 int size, int index,
390 QComboBox::Policy policy )
391{
392//US KComboBox *combo = new KComboBox ( writable, this );
393 KComboBox *combo = new KComboBox ( this );
394 combo->setEditable(writable);
395
396 insertWidgetInternal( combo, index, id );
397 combo->insertStringList (list);
398 combo->setInsertionPolicy(policy);
399 combo->setEnabled( enabled );
400 if ( !tooltiptext.isEmpty() )
401 QToolTip::add( combo, tooltiptext );
402 if ( size > 0 )
403 combo->setMinimumWidth( size );
404 if (!tooltiptext.isNull())
405 QToolTip::add( combo, tooltiptext );
406
407 if ( signal && receiver && slot )
408 connect ( combo, signal, receiver, slot );
409 return index;
410}
411
412
413int KToolBar::insertCombo (const QString& text, int id, bool writable,
414 const char *signal, QObject *receiver,
415 const char *slot, bool enabled,
416 const QString& tooltiptext,
417 int size, int index,
418 QComboBox::Policy policy )
419{
420//US KComboBox *combo = new KComboBox ( writable, this );
421 KComboBox *combo = new KComboBox ( this );
422 combo->setEditable(writable);
423
424 insertWidgetInternal( combo, index, id );
425 combo->insertItem (text);
426 combo->setInsertionPolicy(policy);
427 combo->setEnabled( enabled );
428 if ( !tooltiptext.isEmpty() )
429 QToolTip::add( combo, tooltiptext );
430 if ( size > 0 )
431 combo->setMinimumWidth( size );
432 if (!tooltiptext.isNull())
433 QToolTip::add( combo, tooltiptext );
434 connect (combo, signal, receiver, slot);
435 return index;
436}
437
438int KToolBar::insertSeparator(int index, int id)
439{
440 QWidget *w = new KToolBarSeparator( orientation(), FALSE, this, "tool bar separator" );
441 insertWidgetInternal( w, index, id );
442 return index;
443}
444
445int KToolBar::insertLineSeparator(int index, int id)
446{
447 QWidget *w = new KToolBarSeparator( orientation(), TRUE, this, "tool bar separator" );
448 insertWidgetInternal( w, index, id );
449 return index;
450}
451
452
453int KToolBar::insertWidget(int id, int /*width*/, QWidget *widget, int index)
454{
455 // removeWidgetInternal( widget ); // in case we already have it ?
456 insertWidgetInternal( widget, index, id );
457 return index;
458}
459/*US
460int KToolBar::insertAnimatedWidget(int id, QObject *receiver, const char *slot,
461 const QString& icons, int index )
462{
463 KAnimWidget *anim = new KAnimWidget( icons, d->m_iconSize, this );
464 insertWidgetInternal( anim, index, id );
465
466 if ( receiver )
467 connect( anim, SIGNAL(clicked()), receiver, slot);
468
469 return index;
470}
471
472KAnimWidget *KToolBar::animatedWidget( int id )
473{
474 Id2WidgetMap::Iterator it = id2widget.find( id );
475 if ( it == id2widget.end() )
476 return 0;
477 if ( (*it) && (*it)->inherits( "KAnimWidget" ) )
478 return (KAnimWidget*)(*it);
479 QObjectList *l = queryList( "KAnimWidget" );
480 if ( !l || !l->first() ) {
481 delete l;
482 return 0;
483 }
484
485 for ( QObject *o = l->first(); o; o = l->next() ) {
486 if ( o->inherits( "KAnimWidget" ) )
487 {
488 delete l;
489 return (KAnimWidget*)o;
490 }
491 }
492
493 delete l;
494 return 0;
495}
496*/
497
498void KToolBar::addConnection (int id, const char *signal,
499 const QObject *receiver, const char *slot)
500{
501 Id2WidgetMap::Iterator it = id2widget.find( id );
502 if ( it == id2widget.end() )
503 return;
504 if ( (*it) )
505 connect( (*it), signal, receiver, slot );
506}
507
508void KToolBar::setItemEnabled( int id, bool enabled )
509{
510 Id2WidgetMap::Iterator it = id2widget.find( id );
511 if ( it == id2widget.end() )
512 return;
513 if ( (*it) )
514 (*it)->setEnabled( enabled );
515}
516
517
518void KToolBar::setButtonPixmap( int id, const QPixmap& _pixmap )
519{
520 Id2WidgetMap::Iterator it = id2widget.find( id );
521 if ( it == id2widget.end() )
522 return;
523//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
524 KToolBarButton * button = (KToolBarButton *)( *it );
525 if ( button )
526 button->setPixmap( _pixmap );
527}
528
529
530void KToolBar::setButtonIcon( int id, const QString& _icon )
531{
532 Id2WidgetMap::Iterator it = id2widget.find( id );
533 if ( it == id2widget.end() )
534 return;
535//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
536 KToolBarButton * button = (KToolBarButton *)( *it );
537 if ( button )
538 button->setIcon( _icon );
539}
540
541void KToolBar::setButtonIconSet( int id, const QIconSet& iconset )
542{
543 Id2WidgetMap::Iterator it = id2widget.find( id );
544 if ( it == id2widget.end() )
545 return;
546//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
547 KToolBarButton * button = (KToolBarButton *)( *it );
548 if ( button )
549 button->setIconSet( iconset );
550}
551
552
553void KToolBar::setDelayedPopup (int id , QPopupMenu *_popup, bool toggle )
554{
555 Id2WidgetMap::Iterator it = id2widget.find( id );
556 if ( it == id2widget.end() )
557 return;
558//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
559 KToolBarButton * button = (KToolBarButton *)( *it );
560 if ( button )
561 button->setDelayedPopup( _popup, toggle );
562}
563
564
565void KToolBar::setAutoRepeat (int id, bool flag)
566{
567 Id2WidgetMap::Iterator it = id2widget.find( id );
568 if ( it == id2widget.end() )
569 return;
570//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
571 KToolBarButton * button = (KToolBarButton *)( *it );
572 if ( button )
573 button->setAutoRepeat( flag );
574}
575
576
577void KToolBar::setToggle (int id, bool flag )
578{
579 Id2WidgetMap::Iterator it = id2widget.find( id );
580 if ( it == id2widget.end() )
581 return;
582//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
583 KToolBarButton * button = (KToolBarButton *)( *it );
584 if ( button )
585 button->setToggle( flag );
586}
587
588
589void KToolBar::toggleButton (int id)
590{
591 Id2WidgetMap::Iterator it = id2widget.find( id );
592 if ( it == id2widget.end() )
593 return;
594//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
595 KToolBarButton * button = (KToolBarButton *)( *it );
596 if ( button )
597 button->toggle();
598}
599
600
601void KToolBar::setButton (int id, bool flag)
602{
603 Id2WidgetMap::Iterator it = id2widget.find( id );
604 if ( it == id2widget.end() )
605 return;
606//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
607 KToolBarButton * button = (KToolBarButton *)( *it );
608 if ( button )
609 button->on( flag );
610}
611
612
613bool KToolBar::isButtonOn (int id) const
614{
615 Id2WidgetMap::ConstIterator it = id2widget.find( id );
616 if ( it == id2widget.end() )
617 return false;
618//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
619 KToolBarButton * button = (KToolBarButton *)( *it );
620 return button ? button->isOn() : false;
621}
622
623
624void KToolBar::setLinedText (int id, const QString& text)
625{
626 Id2WidgetMap::Iterator it = id2widget.find( id );
627 if ( it == id2widget.end() )
628 return;
629//US QLineEdit * lineEdit = dynamic_cast<QLineEdit *>( *it );
630 QLineEdit * lineEdit = (QLineEdit *)( *it );
631 if ( lineEdit )
632 lineEdit->setText( text );
633}
634
635
636QString KToolBar::getLinedText (int id) const
637{
638 Id2WidgetMap::ConstIterator it = id2widget.find( id );
639 if ( it == id2widget.end() )
640 return QString::null;
641//US QLineEdit * lineEdit = dynamic_cast<QLineEdit *>( *it );
642 QLineEdit * lineEdit = (QLineEdit *)( *it );
643 return lineEdit ? lineEdit->text() : QString::null;
644}
645
646
647void KToolBar::insertComboItem (int id, const QString& text, int index)
648{
649 Id2WidgetMap::Iterator it = id2widget.find( id );
650 if ( it == id2widget.end() )
651 return;
652//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
653 QComboBox * comboBox = (QComboBox *)( *it );
654 if (comboBox)
655 comboBox->insertItem( text, index );
656}
657
658void KToolBar::insertComboList (int id, const QStringList &list, int index)
659{
660 Id2WidgetMap::Iterator it = id2widget.find( id );
661 if ( it == id2widget.end() )
662 return;
663//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
664 QComboBox * comboBox = (QComboBox *)( *it );
665 if (comboBox)
666 comboBox->insertStringList( list, index );
667}
668
669
670void KToolBar::removeComboItem (int id, int index)
671{
672 Id2WidgetMap::Iterator it = id2widget.find( id );
673 if ( it == id2widget.end() )
674 return;
675//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
676 QComboBox * comboBox = (QComboBox *)( *it );
677 if (comboBox)
678 comboBox->removeItem( index );
679}
680
681
682void KToolBar::setCurrentComboItem (int id, int index)
683{
684 Id2WidgetMap::Iterator it = id2widget.find( id );
685 if ( it == id2widget.end() )
686 return;
687//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
688 QComboBox * comboBox = (QComboBox *)( *it );
689 if (comboBox)
690 comboBox->setCurrentItem( index );
691}
692
693
694void KToolBar::changeComboItem (int id, const QString& text, int index)
695{
696 Id2WidgetMap::Iterator it = id2widget.find( id );
697 if ( it == id2widget.end() )
698 return;
699//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
700 QComboBox * comboBox = (QComboBox *)( *it );
701 if (comboBox)
702 comboBox->changeItem( text, index );
703}
704
705
706void KToolBar::clearCombo (int id)
707{
708 Id2WidgetMap::Iterator it = id2widget.find( id );
709 if ( it == id2widget.end() )
710 return;
711//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
712 QComboBox * comboBox = (QComboBox *)( *it );
713 if (comboBox)
714 comboBox->clear();
715}
716
717
718QString KToolBar::getComboItem (int id, int index) const
719{
720 Id2WidgetMap::ConstIterator it = id2widget.find( id );
721 if ( it == id2widget.end() )
722 return QString::null;
723//US QComboBox * comboBox = dynamic_cast<QComboBox *>( *it );
724 QComboBox * comboBox = (QComboBox *)( *it );
725 return comboBox ? comboBox->text( index ) : QString::null;
726}
727
728
729KComboBox * KToolBar::getCombo(int id)
730{
731 Id2WidgetMap::Iterator it = id2widget.find( id );
732 if ( it == id2widget.end() )
733 return 0;
734//US return dynamic_cast<KComboBox *>( *it );
735 return (KComboBox *)( *it );
736}
737
738
739KLineEdit * KToolBar::getLined (int id)
740{
741 Id2WidgetMap::Iterator it = id2widget.find( id );
742 if ( it == id2widget.end() )
743 return 0;
744//US return dynamic_cast<KLineEdit *>( *it );
745 return (KLineEdit *)( *it );
746}
747
748
749KToolBarButton * KToolBar::getButton (int id)
750{
751 Id2WidgetMap::Iterator it = id2widget.find( id );
752 if ( it == id2widget.end() )
753 return 0;
754//US return dynamic_cast<KToolBarButton *>( *it );
755 return (KToolBarButton *)( *it );
756}
757
758
759void KToolBar::alignItemRight (int id, bool right )
760{
761 Id2WidgetMap::Iterator it = id2widget.find( id );
762 if ( it == id2widget.end() )
763 return;
764 if ( rightAligned && !right && (*it) == rightAligned )
765 rightAligned = 0;
766 if ( (*it) && right )
767 rightAligned = (*it);
768}
769
770
771QWidget *KToolBar::getWidget (int id)
772{
773 Id2WidgetMap::Iterator it = id2widget.find( id );
774 return ( it == id2widget.end() ) ? 0 : (*it);
775}
776
777
778void KToolBar::setItemAutoSized (int id, bool yes )
779{
780 QWidget *w = getWidget(id);
781 if ( w && yes )
782 setStretchableWidget( w );
783}
784
785
786void KToolBar::clear ()
787{
788 QToolBar::clear();
789 widget2id.clear();
790 id2widget.clear();
791}
792
793
794void KToolBar::removeItem(int id)
795{
796 Id2WidgetMap::Iterator it = id2widget.find( id );
797 if ( it == id2widget.end() )
798 {
799 kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl;
800 return;
801 }
802 QWidget * w = (*it);
803 id2widget.remove( id );
804 widget2id.remove( w );
805 widgets.removeRef( w );
806 delete w;
807}
808
809
810void KToolBar::removeItemDelayed(int id)
811{
812 Id2WidgetMap::Iterator it = id2widget.find( id );
813 if ( it == id2widget.end() )
814 {
815 kdDebug(220) << "KToolBar::removeItem item " << id << " not found" << endl;
816 return;
817 }
818 QWidget * w = (*it);
819 id2widget.remove( id );
820 widget2id.remove( w );
821 widgets.removeRef( w );
822
823 w->blockSignals(true);
824 d->idleButtons.append(w);
825 layoutTimer->start( 50, TRUE );
826}
827
828
829void KToolBar::hideItem (int id)
830{
831 QWidget *w = getWidget(id);
832 if ( w )
833 w->hide();
834}
835
836
837void KToolBar::showItem (int id)
838{
839 QWidget *w = getWidget(id);
840 if ( w )
841 w->show();
842}
843
844
845int KToolBar::itemIndex (int id)
846{
847 QWidget *w = getWidget(id);
848 return w ? widgets.findRef(w) : -1;
849}
850
851
852void KToolBar::setFullSize(bool flag )
853{
854 setHorizontalStretchable( flag );
855 setVerticalStretchable( flag );
856}
857
858
859bool KToolBar::fullSize() const
860{
861 return isHorizontalStretchable() || isVerticalStretchable();
862}
863
864
865void KToolBar::enableMoving(bool flag )
866{
867//US setMovingEnabled(flag);
868 this->mainWindow()->setToolBarsMovable(flag);
869}
870
871
872void KToolBar::setBarPos (BarPosition bpos)
873{
874 if ( !mainWindow() )
875 return;
876//US mainWindow()->moveDockWindow( this, (Dock)bpos );
877 mainWindow()->moveToolBar( this, (QMainWindow::ToolBarDock)bpos );
878}
879
880
881KToolBar::BarPosition KToolBar::barPos()
882{
883 if ( !(QMainWindow*)mainWindow() )
884 return KToolBar::Top;
885//US Dock dock;
886 QMainWindow::ToolBarDock dock;
887 int dm1, dm2;
888 bool dm3;
889 ((QMainWindow*)mainWindow())->getLocation( (QToolBar*)this, dock, dm1, dm3, dm2 );
890//US if ( dock == DockUnmanaged ) {
891 if ( dock == QMainWindow::Unmanaged ) {
892 return (KToolBar::BarPosition)Top;
893 }
894 return (BarPosition)dock;
895}
896
897
898bool KToolBar::enable(BarStatus stat)
899{
900 bool mystat = isVisible();
901
902 if ( (stat == Toggle && mystat) || stat == Hide )
903 hide();
904 else
905 show();
906
907 return isVisible() == mystat;
908}
909
910
911void KToolBar::setMaxHeight ( int h )
912{
913 setMaximumHeight( h );
914}
915
916int KToolBar::maxHeight()
917{
918 return maximumHeight();
919}
920
921
922void KToolBar::setMaxWidth (int dw)
923{
924 setMaximumWidth( dw );
925}
926
927
928int KToolBar::maxWidth()
929{
930 return maximumWidth();
931}
932
933
934void KToolBar::setTitle (const QString& _title)
935{
936 setLabel( _title );
937}
938
939
940void KToolBar::enableFloating (bool )
941{
942}
943
944
945void KToolBar::setIconText(IconText it)
946{
947 setIconText( it, true );
948}
949
950
951void KToolBar::setIconText(IconText icontext, bool update)
952{
953 bool doUpdate=false;
954
955 if (icontext != d->m_iconText) {
956 d->m_iconText = icontext;
957 doUpdate=true;
958 }
959
960 if (update == false)
961 return;
962
963 if (doUpdate)
964 emit modechange(); // tell buttons what happened
965
966 // ugly hack to force a QMainWindow::triggerLayout( TRUE )
967 if ( mainWindow() ) {
968 QMainWindow *mw = mainWindow();
969 mw->setUpdatesEnabled( FALSE );
970 mw->setToolBarsMovable( !mw->toolBarsMovable() );
971 mw->setToolBarsMovable( !mw->toolBarsMovable() );
972 mw->setUpdatesEnabled( TRUE );
973 }
974}
975
976
977KToolBar::IconText KToolBar::iconText() const
978{
979 return d->m_iconText;
980}
981
982
983void KToolBar::setIconSize(int size)
984{
985 setIconSize( size, true );
986}
987
988void KToolBar::setIconSize(int size, bool update)
989{
990 bool doUpdate=false;
991
992 if ( size != d->m_iconSize ) {
993 d->m_iconSize = size;
994 doUpdate=true;
995 }
996
997 if (update == false)
998 return;
999
1000 if (doUpdate)
1001 emit modechange(); // tell buttons what happened
1002
1003 // ugly hack to force a QMainWindow::triggerLayout( TRUE )
1004 if ( mainWindow() ) {
1005 QMainWindow *mw = mainWindow();
1006 mw->setUpdatesEnabled( FALSE );
1007 mw->setToolBarsMovable( !mw->toolBarsMovable() );
1008 mw->setToolBarsMovable( !mw->toolBarsMovable() );
1009 mw->setUpdatesEnabled( TRUE );
1010 }
1011}
1012
1013
1014int KToolBar::iconSize() const
1015{
1016/*US
1017 if ( !d->m_iconSize ) // default value?
1018 {
1019 if (!::qstrcmp(QObject::name(), "mainToolBar"))
1020 return KGlobal::iconLoader()->currentSize(KIcon::MainToolbar);
1021 else
1022 return KGlobal::iconLoader()->currentSize(KIcon::Toolbar);
1023 }
1024 return d->m_iconSize;
1025*/
1026 int ret = 18;
1027 if ( QApplication::desktop()->width() > 320 && QApplication::desktop()->width() < 650 )
1028 ret = 30;
1029 return ret;
1030}
1031
1032
1033void KToolBar::setEnableContextMenu(bool enable )
1034{
1035 d->m_enableContext = enable;
1036}
1037
1038
1039bool KToolBar::contextMenuEnabled() const
1040{
1041 return d->m_enableContext;
1042}
1043
1044
1045void KToolBar::setItemNoStyle(int id, bool no_style )
1046{
1047 Id2WidgetMap::Iterator it = id2widget.find( id );
1048 if ( it == id2widget.end() )
1049 return;
1050//US KToolBarButton * button = dynamic_cast<KToolBarButton *>( *it );
1051 KToolBarButton * button = (KToolBarButton *)( *it );
1052 if (button)
1053 button->setNoStyle( no_style );
1054}
1055
1056
1057void KToolBar::setFlat (bool flag)
1058{
1059 if ( !mainWindow() )
1060 return;
1061 if ( flag )
1062//US mainWindow()->moveDockWindow( this, DockMinimized );
1063 mainWindow()->moveToolBar( this, QMainWindow::Minimized );
1064 else
1065//US mainWindow()->moveDockWindow( this, DockTop );
1066 mainWindow()->moveToolBar( this, QMainWindow::Top );
1067 // And remember to save the new look later
1068/*US
1069 if ( mainWindow()->inherits( "KMainWindow" ) )
1070 static_cast<KMainWindow *>(mainWindow())->setSettingsDirty();
1071*/
1072}
1073
1074
1075int KToolBar::count() const
1076{
1077 return id2widget.count();
1078}
1079
1080
1081void KToolBar::saveState()
1082{
1083/*US
1084 // first, try to save to the xml file
1085 if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() ) {
1086 // go down one level to get to the right tags
1087 QDomElement elem = d->m_xmlguiClient->domDocument().documentElement().toElement();
1088 elem = elem.firstChild().toElement();
1089 QString barname(!::qstrcmp(name(), "unnamed") ? "mainToolBar" : name());
1090 QDomElement current;
1091 // now try to find our toolbar
1092 d->modified = false;
1093 for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) {
1094 current = elem;
1095
1096 if ( current.tagName().lower() != "toolbar" )
1097 continue;
1098
1099 QString curname(current.attribute( "name" ));
1100
1101 if ( curname == barname ) {
1102 saveState( current );
1103 break;
1104 }
1105 }
1106 // if we didn't make changes, then just return
1107 if ( !d->modified )
1108 return;
1109
1110 // now we load in the (non-merged) local file
1111 QString local_xml(KXMLGUIFactory::readConfigFile(d->m_xmlguiClient->xmlFile(), true, d->m_xmlguiClient->instance()));
1112 QDomDocument local;
1113 local.setContent(local_xml);
1114
1115 // make sure we don't append if this toolbar already exists locally
1116 bool just_append = true;
1117 elem = local.documentElement().toElement();
1118 KXMLGUIFactory::removeDOMComments( elem );
1119 elem = elem.firstChild().toElement();
1120 for( ; !elem.isNull(); elem = elem.nextSibling().toElement() ) {
1121 if ( elem.tagName().lower() != "toolbar" )
1122 continue;
1123
1124 QString curname(elem.attribute( "name" ));
1125
1126 if ( curname == barname ) {
1127 just_append = false;
1128 local.documentElement().replaceChild( current, elem );
1129 break;
1130 }
1131 }
1132
1133 if (just_append)
1134 local.documentElement().appendChild( current );
1135
1136 KXMLGUIFactory::saveConfigFile(local, d->m_xmlguiClient->localXMLFile(), d->m_xmlguiClient->instance() );
1137
1138 return;
1139 }
1140*/
1141 // if that didn't work, we save to the config file
1142 KConfig *config = KGlobal::config();
1143 saveSettings(config, QString::null);
1144 config->sync();
1145}
1146
1147QString KToolBar::settingsGroup()
1148{
1149 QString configGroup;
1150 if (!::qstrcmp(name(), "unnamed") || !::qstrcmp(name(), "mainToolBar"))
1151 configGroup = "Toolbar style";
1152 else
1153 configGroup = QString(name()) + " Toolbar style";
1154 if ( this->mainWindow() )
1155 {
1156 configGroup.prepend(" ");
1157 configGroup.prepend( this->mainWindow()->name() );
1158 }
1159 return configGroup;
1160}
1161
1162void KToolBar::saveSettings(KConfig *config, const QString &_configGroup)
1163{
1164 QString configGroup = _configGroup;
1165 if (configGroup.isEmpty())
1166 configGroup = settingsGroup();
1167 //kdDebug(220) << "KToolBar::saveSettings group=" << _configGroup << " -> " << configGroup << endl;
1168
1169 QString position, icontext;
1170 int index;
1171 getAttributes( position, icontext, index );
1172
1173 //kdDebug(220) << "KToolBar::saveSettings " << name() << " newLine=" << newLine << endl;
1174
1175 KConfigGroupSaver saver(config, configGroup);
1176
1177 if ( position != d->PositionDefault )
1178 config->writeEntry("Position", position);
1179 else
1180 config->deleteEntry("Position");
1181
1182 if ( icontext != d->IconTextDefault )
1183 config->writeEntry("IconText", icontext);
1184 else
1185 config->deleteEntry("IconText");
1186
1187 if ( iconSize() != d->IconSizeDefault )
1188 config->writeEntry("IconSize", iconSize());
1189 else
1190 config->deleteEntry("IconSize");
1191
1192 if ( isHidden() != d->HiddenDefault )
1193 config->writeEntry("Hidden", isHidden());
1194 else
1195 config->deleteEntry("Hidden");
1196
1197 if ( index != d->IndexDefault )
1198 config->writeEntry( "Index", index );
1199 else
1200 config->deleteEntry("Index");
1201//US the older version of KDE (used on the Zaurus) has no Offset property
1202/* if ( offset() != d->OffsetDefault )
1203 config->writeEntry( "Offset", offset() );
1204 else
1205*/
1206 config->deleteEntry("Offset");
1207
1208//US the older version of KDE (used on the Zaurus) has no NewLine property
1209/*
1210 if ( newLine() != d->NewLineDefault )
1211 config->writeEntry( "NewLine", newLine() );
1212 else
1213*/
1214 config->deleteEntry("NewLine");
1215}
1216
1217void KToolBar::setXMLGUIClient( KXMLGUIClient *client )
1218{
1219 d->m_xmlguiClient = client;
1220}
1221
1222void KToolBar::setText( const QString & txt )
1223{
1224//US setLabel( txt + " ( " + kapp->caption() + " ) " );
1225 setLabel( txt + " ( " + KGlobal::getAppName() + " ) " );
1226}
1227
1228
1229QString KToolBar::text() const
1230{
1231 return label();
1232}
1233
1234
1235void KToolBar::doConnections( KToolBarButton *button )
1236{
1237 connect(button, SIGNAL(clicked(int)), this, SIGNAL( clicked( int ) ) );
1238 connect(button, SIGNAL(doubleClicked(int)), this, SIGNAL( doubleClicked( int ) ) );
1239 connect(button, SIGNAL(released(int)), this, SIGNAL( released( int ) ) );
1240 connect(button, SIGNAL(pressed(int)), this, SIGNAL( pressed( int ) ) );
1241 connect(button, SIGNAL(toggled(int)), this, SIGNAL( toggled( int ) ) );
1242 connect(button, SIGNAL(highlighted(int, bool)), this, SIGNAL( highlighted( int, bool ) ) );
1243}
1244
1245void KToolBar::mousePressEvent ( QMouseEvent *m )
1246{
1247 if ( !mainWindow() )
1248 return;
1249 QMainWindow *mw = mainWindow();
1250 if ( mw->toolBarsMovable() && d->m_enableContext ) {
1251 if ( m->button() == RightButton ) {
1252 int i = contextMenu()->exec( m->globalPos(), 0 );
1253 switch ( i ) {
1254 case -1:
1255 return; // popup cancelled
1256 case CONTEXT_LEFT:
1257//US mw->moveDockWindow( this, DockLeft );
1258 mw->moveToolBar( this, QMainWindow::Left );
1259 break;
1260 case CONTEXT_RIGHT:
1261//US mw->moveDockWindow( this, DockRight );
1262 mw->moveToolBar( this, QMainWindow::Right );
1263 break;
1264 case CONTEXT_TOP:
1265//US mw->moveDockWindow( this, DockTop );
1266 mw->moveToolBar( this, QMainWindow::Top );
1267 break;
1268 case CONTEXT_BOTTOM:
1269//US mw->moveDockWindow( this, DockBottom );
1270 mw->moveToolBar( this, QMainWindow::Bottom );
1271 break;
1272 case CONTEXT_FLOAT:
1273 break;
1274 case CONTEXT_FLAT:
1275//US mw->moveDockWindow( this, DockMinimized );
1276 mw->moveToolBar( this, QMainWindow::Minimized );
1277 break;
1278 case CONTEXT_ICONS:
1279 setIconText( IconOnly );
1280 break;
1281 case CONTEXT_TEXTRIGHT:
1282 setIconText( IconTextRight );
1283 break;
1284 case CONTEXT_TEXT:
1285 setIconText( TextOnly );
1286 break;
1287 case CONTEXT_TEXTUNDER:
1288 setIconText( IconTextBottom );
1289 break;
1290 default:
1291 if ( i >= CONTEXT_ICONSIZES )
1292 setIconSize( i - CONTEXT_ICONSIZES );
1293 else
1294 return; // assume this was an action handled elsewhere, no need for setSettingsDirty()
1295 }
1296/*US
1297 if ( mw->inherits("KMainWindow") )
1298 static_cast<KMainWindow *>(mw)->setSettingsDirty();
1299*/
1300 }
1301 }
1302}
1303
1304
1305void KToolBar::rebuildLayout()
1306{
1307
1308 for(QWidget *w=d->idleButtons.first(); w; w=d->idleButtons.next())
1309 w->blockSignals(false);
1310 d->idleButtons.clear();
1311
1312 layoutTimer->stop();
1313 QApplication::sendPostedEvents( this, QEvent::ChildInserted );
1314 QBoxLayout *l = boxLayout();
1315 l->setMargin( 1 );
1316 // clear the old layout
1317 QLayoutIterator it = l->iterator();
1318
1319 while ( it.current() ) {
1320 it.deleteCurrent();
1321 }
1322 for ( QWidget *w = widgets.first(); w; w = widgets.next() ) {
1323 if ( w == rightAligned ) {
1324 continue;
1325 }
1326 if ( w->inherits( "KToolBarSeparator" ) &&
1327 !( (KToolBarSeparator*)w )->showLine() ) {
1328 l->addSpacing( 6 );
1329 w->hide();
1330 continue;
1331 }
1332 if ( w->inherits( "QPopupMenu" ) )
1333 continue;
1334 l->addWidget( w );
1335 w->show();
1336 }
1337 if ( rightAligned ) {
1338 l->addStretch();
1339 l->addWidget( rightAligned );
1340 rightAligned->show();
1341 }
1342
1343 if ( fullSize() ) {
1344 // This code sucks. It makes the last combo in a toolbar VERY big (e.g. zoom combo in kword).
1345 //if ( !stretchableWidget && widgets.last() &&
1346 // !widgets.last()->inherits( "QButton" ) && !widgets.last()->inherits( "KAnimWidget" ) )
1347 // setStretchableWidget( widgets.last() );
1348 if ( !rightAligned )
1349 l->addStretch();
1350 if ( stretchableWidget )
1351 l->setStretchFactor( stretchableWidget, 10 );
1352 }
1353 l->invalidate();
1354 QApplication::postEvent( this, new QEvent( QEvent::LayoutHint ) );
1355 //#endif //DESKTOP_VERSION
1356}
1357
1358void KToolBar::childEvent( QChildEvent *e )
1359{
1360
1361 if ( e->child()->isWidgetType() ) {
1362 QWidget * w = (QWidget*)e->child();
1363 if ( e->type() == QEvent::ChildInserted ) {
1364 if ( !e->child()->inherits( "QPopupMenu" ) &&
1365 ::qstrcmp( "qt_dockwidget_internal", e->child()->name() ) != 0 ) {
1366
1367 // prevent items that have been explicitly inserted by insert*() from
1368 // being inserted again
1369 if ( !widget2id.contains( w ) )
1370 {
1371 int dummy = -1;
1372 insertWidgetInternal( w, dummy, -1 );
1373 }
1374 }
1375 } else {
1376 removeWidgetInternal( w );
1377 }
1378 if ( isVisibleTo( 0 ) )
1379 {
1380 QBoxLayout *l = boxLayout();
1381 // QLayout *l = layout();
1382
1383 // clear the old layout so that we don't get unnecassery layout
1384 // changes till we have rebuild the thing
1385 QLayoutIterator it = l->iterator();
1386 while ( it.current() ) {
1387 it.deleteCurrent();
1388 }
1389 layoutTimer->start( 50, TRUE );
1390 }
1391 }
1392 QToolBar::childEvent( e );
1393}
1394
1395void KToolBar::insertWidgetInternal( QWidget *w, int &index, int id )
1396{
1397 // we can't have it in widgets, or something is really wrong
1398 //widgets.removeRef( w );
1399
1400 connect( w, SIGNAL( destroyed() ),
1401 this, SLOT( widgetDestroyed() ) );
1402 if ( index == -1 || index > (int)widgets.count() ) {
1403 widgets.append( w );
1404 index = (int)widgets.count();
1405 }
1406 else
1407 widgets.insert( index, w );
1408 if ( id == -1 )
1409 id = id2widget.count();
1410 id2widget.insert( id, w );
1411 widget2id.insert( w, id );
1412}
1413
1414void KToolBar::showEvent( QShowEvent *e )
1415{
1416 QToolBar::showEvent( e );
1417 rebuildLayout();
1418}
1419
1420void KToolBar::setStretchableWidget( QWidget *w )
1421{
1422 QToolBar::setStretchableWidget( w );
1423 stretchableWidget = w;
1424}
1425
1426QSizePolicy KToolBar::sizePolicy() const
1427{
1428 if ( orientation() == Horizontal )
1429 return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
1430 else
1431 return QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Expanding );
1432}
1433
1434QSize KToolBar::sizeHint() const
1435{
1436 return QToolBar::sizeHint();
1437#if 0
1438 QWidget::polish();
1439 static int iii = 0;
1440 ++iii;
1441 qDebug("++++++++ KToolBar::sizeHint() %d ", iii );
1442 int margin = static_cast<QWidget*>(ncThis)->layout()->margin();
1443 switch( barPos() )
1444 {
1445 case KToolBar::Top:
1446 case KToolBar::Bottom:
1447 for ( QWidget *w = widgets.first(); w; w =widgets.next() )
1448 {
1449 if ( w->inherits( "KToolBarSeparator" ) &&
1450 !( static_cast<KToolBarSeparator*>(w)->showLine() ) )
1451 {
1452 minSize += QSize(6, 0);
1453 }
1454 else
1455 {
1456 QSize sh = w->sizeHint();
1457 if (!sh.isValid())
1458 sh = w->minimumSize();
1459 minSize = minSize.expandedTo(QSize(0, sh.height()));
1460 minSize += QSize(sh.width()+1, 0);
1461 }
1462 }
1463/*US
1464 minSize += QSize(QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ), 0);
1465*/
1466 minSize += QSize(margin*2, margin*2);
1467 break;
1468
1469 case KToolBar::Left:
1470 case KToolBar::Right:
1471 for ( QWidget *w = widgets.first(); w; w = widgets.next() )
1472 {
1473 if ( w->inherits( "KToolBarSeparator" ) &&
1474 !( static_cast<KToolBarSeparator*>(w)->showLine() ) )
1475 {
1476 minSize += QSize(0, 6);
1477 }
1478 else
1479 {
1480 QSize sh = w->sizeHint();
1481 if (!sh.isValid())
1482 sh = w->minimumSize();
1483 minSize = minSize.expandedTo(QSize(sh.width(), 0));
1484 minSize += QSize(0, sh.height()+1);
1485 }
1486 }
1487/*US
1488 minSize += QSize(0, QApplication::style().pixelMetric( QStyle::PM_DockWindowHandleExtent ));
1489*/
1490 minSize += QSize(margin*2, margin*2);
1491 break;
1492
1493 default:
1494 minSize = QToolBar::sizeHint();
1495 break;
1496 }
1497 return minSize;
1498#endif
1499}
1500
1501QSize KToolBar::minimumSize() const
1502{
1503 return minimumSizeHint();
1504}
1505
1506QSize KToolBar::minimumSizeHint() const
1507{
1508 return sizeHint();
1509}
1510
1511bool KToolBar::highlight() const
1512{
1513 return d->m_highlight;
1514}
1515
1516void KToolBar::hide()
1517{
1518 QToolBar::hide();
1519}
1520
1521void KToolBar::show()
1522{
1523 QToolBar::show();
1524}
1525
1526void KToolBar::resizeEvent( QResizeEvent *e )
1527{
1528 bool b = isUpdatesEnabled();
1529 setUpdatesEnabled( FALSE );
1530 QToolBar::resizeEvent( e );
1531 if (b)
1532 d->repaintTimer.start( 100, true );
1533}
1534
1535void KToolBar::slotIconChanged(int group)
1536{
1537 if ((group != KIcon::Toolbar) && (group != KIcon::MainToolbar))
1538 return;
1539 if ((group == KIcon::MainToolbar) != !::qstrcmp(name(), "mainToolBar"))
1540 return;
1541
1542 emit modechange();
1543 if (isVisible())
1544 updateGeometry();
1545}
1546
1547void KToolBar::slotReadConfig()
1548{
1549 //kdDebug(220) << "KToolBar::slotReadConfig" << endl;
1550 // Read appearance settings (hmm, we used to do both here,
1551 // but a well behaved application will call applyMainWindowSettings
1552 // anyway, right ?)
1553 applyAppearanceSettings(KGlobal::config(), QString::null );
1554}
1555
1556void KToolBar::slotAppearanceChanged()
1557{
1558 // Read appearance settings from global file.
1559 applyAppearanceSettings(KGlobal::config(), QString::null, true /* lose local settings */ );
1560 // And remember to save the new look later
1561/*US
1562 if ( mainWindow() && mainWindow()->inherits( "KMainWindow" ) )
1563 static_cast<KMainWindow *>(mainWindow())->setSettingsDirty();
1564*/
1565}
1566
1567//static
1568bool KToolBar::highlightSetting()
1569{
1570 QString grpToolbar(QString::fromLatin1("Toolbar style"));
1571 KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
1572 return KGlobal::config()->readBoolEntry(QString::fromLatin1("Highlighting"),true);
1573}
1574
1575//static
1576bool KToolBar::transparentSetting()
1577{
1578 QString grpToolbar(QString::fromLatin1("Toolbar style"));
1579 KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
1580 return KGlobal::config()->readBoolEntry(QString::fromLatin1("TransparentMoving"),true);
1581}
1582
1583//static
1584KToolBar::IconText KToolBar::iconTextSetting()
1585{
1586 QString grpToolbar(QString::fromLatin1("Toolbar style"));
1587 KConfigGroupSaver saver(KGlobal::config(), grpToolbar);
1588 QString icontext = KGlobal::config()->readEntry(QString::fromLatin1("IconText"),QString::fromLatin1("IconOnly"));
1589 if ( icontext == "IconTextRight" )
1590 return IconTextRight;
1591 else if ( icontext == "IconTextBottom" )
1592 return IconTextBottom;
1593 else if ( icontext == "TextOnly" )
1594 return TextOnly;
1595 else
1596 return IconOnly;
1597}
1598
1599void KToolBar::applyAppearanceSettings(KConfig *config, const QString &_configGroup, bool forceGlobal)
1600{
1601 QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup;
1602 //kdDebug(220) << "KToolBar::applyAppearanceSettings: configGroup=" << configGroup << endl;
1603 // We have application-specific settings in the XML file,
1604 // and nothing in the application's config file
1605 // -> don't apply the global defaults, the XML ones are preferred
1606 // See applySettings for a full explanation
1607/*US :we do not support xml files
1608 if ( d->m_xmlguiClient && !d->m_xmlguiClient->xmlFile().isEmpty() &&
1609 !config->hasGroup(configGroup) )
1610 {
1611 //kdDebug(220) << "skipping global defaults, using XML ones instead" << endl;
1612 return;
1613 }
1614*/
1615 if ( !config->hasGroup(configGroup) )
1616 {
1617 //kdDebug(220) << "skipping global defaults, using XML ones instead" << endl;
1618 return;
1619 }
1620
1621
1622 KConfig *gconfig = KGlobal::config();
1623/*US
1624 static const QString &attrIconText = KGlobal::staticQString("IconText");
1625 static const QString &attrHighlight = KGlobal::staticQString("Highlighting");
1626 static const QString &attrTrans = KGlobal::staticQString("TransparentMoving");
1627 static const QString &attrSize = KGlobal::staticQString("IconSize");
1628*/
1629 // we actually do this in two steps.
1630 // First, we read in the global styles [Toolbar style] (from the KControl module).
1631 // Then, if the toolbar is NOT 'mainToolBar', we will also try to read in [barname Toolbar style]
1632 bool highlight;
1633 int transparent;
1634 QString icontext;
1635 int iconsize = 0;
1636
1637 // this is the first iteration
1638 QString grpToolbar(QString::fromLatin1("Toolbar style"));
1639 { // start block for KConfigGroupSaver
1640 KConfigGroupSaver saver(gconfig, grpToolbar);
1641
1642 // first, get the generic settings
1643//US highlight = gconfig->readBoolEntry(attrHighlight, true);
1644 highlight = gconfig->readBoolEntry("Highlighting", true);
1645//US transparent = gconfig->readBoolEntry(attrTrans, true);
1646 transparent = gconfig->readBoolEntry("TransparentMoving", true);
1647
1648 // we read in the IconText property *only* if we intend on actually
1649 // honoring it
1650 if (d->m_honorStyle)
1651//US d->IconTextDefault = gconfig->readEntry(attrIconText, d->IconTextDefault);
1652 d->IconTextDefault = gconfig->readEntry("IconText", d->IconTextDefault);
1653 else
1654 d->IconTextDefault = "IconOnly";
1655
1656 // Use the default icon size for toolbar icons.
1657//US d->IconSizeDefault = gconfig->readNumEntry(attrSize, d->IconSizeDefault);
1658 d->IconSizeDefault = gconfig->readNumEntry("IconSize", d->IconSizeDefault);
1659
1660 if ( !forceGlobal && config->hasGroup(configGroup) )
1661 {
1662 config->setGroup(configGroup);
1663
1664 // first, get the generic settings
1665//US highlight = config->readBoolEntry(attrHighlight, highlight);
1666 highlight = config->readBoolEntry("Highlighting", highlight);
1667//US transparent = config->readBoolEntry(attrTrans, transparent);
1668 transparent = config->readBoolEntry("TransparentMoving", transparent);
1669 // now we always read in the IconText property
1670//US icontext = config->readEntry(attrIconText, d->IconTextDefault);
1671 icontext = config->readEntry("IconText", d->IconTextDefault);
1672
1673 // now get the size
1674//US iconsize = config->readNumEntry(attrSize, d->IconSizeDefault);
1675 iconsize = config->readNumEntry("IconSize", d->IconSizeDefault);
1676 }
1677 else
1678 {
1679 iconsize = d->IconSizeDefault;
1680 icontext = d->IconTextDefault;
1681 }
1682
1683 // revert back to the old group
1684 } // end block for KConfigGroupSaver
1685
1686 bool doUpdate = false;
1687
1688 IconText icon_text;
1689 if ( icontext == "IconTextRight" )
1690 icon_text = IconTextRight;
1691 else if ( icontext == "IconTextBottom" )
1692 icon_text = IconTextBottom;
1693 else if ( icontext == "TextOnly" )
1694 icon_text = TextOnly;
1695 else
1696 icon_text = IconOnly;
1697
1698 // check if the icon/text has changed
1699 if (icon_text != d->m_iconText) {
1700 //kdDebug(220) << "KToolBar::applyAppearanceSettings setIconText " << icon_text << endl;
1701 setIconText(icon_text, false);
1702 doUpdate = true;
1703 }
1704
1705 // ...and check if the icon size has changed
1706 if (iconsize != d->m_iconSize) {
1707 setIconSize(iconsize, false);
1708 doUpdate = true;
1709 }
1710
1711 QMainWindow *mw = mainWindow();
1712
1713 // ...and if we should highlight
1714 if ( highlight != d->m_highlight ) {
1715 d->m_highlight = highlight;
1716 doUpdate = true;
1717 }
1718
1719 // ...and if we should move transparently
1720 if ( mw && transparent != (!mw->opaqueMoving()) ) {
1721 mw->setOpaqueMoving( !transparent );
1722 }
1723
1724 if (doUpdate)
1725 emit modechange(); // tell buttons what happened
1726 if (isVisible ())
1727 updateGeometry();
1728}
1729
1730void KToolBar::applySettings(KConfig *config, const QString &_configGroup)
1731{
1732 //kdDebug(220) << "KToolBar::applySettings group=" << _configGroup << endl;
1733
1734 QString configGroup = _configGroup.isEmpty() ? settingsGroup() : _configGroup;
1735
1736 /*
1737 Let's explain this a bit more in details.
1738 The order in which we apply settings is :
1739 Global config / <appnamerc> user settings if no XMLGUI is used
1740 Global config / App-XML attributes / <appnamerc> user settings if XMLGUI is used
1741
1742 So in the first case, we simply read everything from KConfig as below,
1743 but in the second case we don't do anything here if there is no app-specific config,
1744 and the XMLGUI uses the static methods of this class to get the global defaults.
1745
1746 Global config doesn't include position (index, offset, newline and hidden/shown).
1747 */
1748
1749 // First the appearance stuff - the one which has a global config
1750 applyAppearanceSettings( config, _configGroup );
1751
1752 // ...and now the position stuff
1753 if ( config->hasGroup(configGroup) )
1754 {
1755 KConfigGroupSaver cgs(config, configGroup);
1756/*US
1757 static const QString &attrPosition = KGlobal::staticQString("Position");
1758 static const QString &attrIndex = KGlobal::staticQString("Index");
1759 static const QString &attrOffset = KGlobal::staticQString("Offset");
1760 static const QString &attrNewLine = KGlobal::staticQString("NewLine");
1761 static const QString &attrHidden = KGlobal::staticQString("Hidden");
1762
1763 QString position = config->readEntry(attrPosition, d->PositionDefault);
1764 int index = config->readNumEntry(attrIndex, d->IndexDefault);
1765 int offset = config->readNumEntry(attrOffset, d->OffsetDefault);
1766 bool newLine = config->readBoolEntry(attrNewLine, d->NewLineDefault);
1767 bool hidden = config->readBoolEntry(attrHidden, d->HiddenDefault);
1768*/
1769
1770 QString position = config->readEntry("Position", d->PositionDefault);
1771 int index = config->readNumEntry("Index", d->IndexDefault);
1772 int offset = config->readNumEntry("Offset", d->OffsetDefault);
1773 bool newLine = config->readBoolEntry("NewLine", d->NewLineDefault);
1774 bool hidden = config->readBoolEntry("Hidden", d->HiddenDefault);
1775
1776/*US Dock pos(DockTop);
1777 if ( position == "Top" )
1778 pos = DockTop;
1779 else if ( position == "Bottom" )
1780 pos = DockBottom;
1781 else if ( position == "Left" )
1782 pos = DockLeft;
1783 else if ( position == "Right" )
1784 pos = DockRight;
1785 else if ( position == "Floating" )
1786 pos = DockTornOff;
1787 else if ( position == "Flat" )
1788 pos = DockMinimized;
1789*/
1790 QMainWindow::ToolBarDock pos(QMainWindow::Top);
1791 if ( position == "Top" )
1792 pos = QMainWindow::Top;
1793 else if ( position == "Bottom" )
1794 pos = QMainWindow::Bottom;
1795 else if ( position == "Left" )
1796 pos = QMainWindow::Left;
1797 else if ( position == "Right" )
1798 pos = QMainWindow::Right;
1799 else if ( position == "Floating" )
1800 pos = QMainWindow::TornOff;
1801 else if ( position == "Flat" )
1802 pos = QMainWindow::Minimized;
1803
1804 //kdDebug(220) << "KToolBar::applySettings hidden=" << hidden << endl;
1805 if (hidden)
1806 hide();
1807 else
1808 show();
1809
1810 if ( mainWindow() )
1811 {
1812 QMainWindow *mw = mainWindow();
1813
1814 //kdDebug(220) << "KToolBar::applySettings updating ToolbarInfo" << endl;
1815 d->toolBarInfo = KToolBarPrivate::ToolBarInfo( pos, index, newLine, offset );
1816
1817 // moveDockWindow calls QDockArea which does a reparent() on us with
1818 // showIt = true, so we loose our visibility status
1819 bool doHide = isHidden();
1820
1821//US mw->moveDockWindow( this, pos, newLine, index, offset );
1822 mw->moveToolBar( this, pos, newLine, index, offset );
1823
1824 //kdDebug(220) << "KToolBar::applySettings " << name() << " moveDockWindow with pos=" << pos << " newLine=" << newLine << " idx=" << index << " offs=" << offset << endl;
1825 if ( doHide )
1826 hide();
1827 }
1828 if (isVisible ())
1829 updateGeometry();
1830 }
1831}
1832
1833bool KToolBar::event( QEvent *e )
1834{
1835 if ( (e->type() == QEvent::LayoutHint) && isUpdatesEnabled() )
1836 d->repaintTimer.start( 100, true );
1837
1838 if (e->type() == QEvent::ChildInserted )
1839 {
1840 // By pass QToolBar::event,
1841 // it will show() the inserted child and we don't want to
1842 // do that until we have rebuild the layout.
1843 childEvent((QChildEvent *)e);
1844 return true;
1845 }
1846
1847 return QToolBar::event( e );
1848}
1849
1850void KToolBar::slotRepaint()
1851{
1852 setUpdatesEnabled( FALSE );
1853 // Send a resizeEvent to update the "toolbar extension arrow"
1854 // (The button you get when your toolbar-items don't fit in
1855 // the available space)
1856 QResizeEvent ev(size(), size());
1857 resizeEvent(&ev);
1858 //#ifdef DESKTOP_VERSION
1859 QApplication::sendPostedEvents( this, QEvent::LayoutHint );
1860 //#endif //DESKTOP_VERSION
1861 setUpdatesEnabled( TRUE );
1862 repaint( TRUE );
1863}
1864
1865void KToolBar::toolBarPosChanged( QToolBar *tb )
1866{
1867 if ( tb != this )
1868 return;
1869//US if ( d->oldPos == DockMinimized )
1870 if ( d->oldPos == QMainWindow::Minimized )
1871 rebuildLayout();
1872 d->oldPos = (QMainWindow::ToolBarDock)barPos();
1873/*US
1874 if ( mainWindow() && mainWindow()->inherits( "KMainWindow" ) )
1875 static_cast<KMainWindow *>(mainWindow())->setSettingsDirty();
1876*/
1877}
1878
1879/*US
1880void KToolBar::loadState( const QDomElement &element )
1881{
1882 //kdDebug(220) << "KToolBar::loadState " << this << endl;
1883 if ( !mainWindow() )
1884 return;
1885
1886 {
1887 QCString text = element.namedItem( "text" ).toElement().text().utf8();
1888 if ( text.isEmpty() )
1889 text = element.namedItem( "Text" ).toElement().text().utf8();
1890 if ( !text.isEmpty() )
1891 setText( i18n( text ) );
1892 }
1893
1894 {
1895 QCString attrFullWidth = element.attribute( "fullWidth" ).lower().latin1();
1896 if ( !attrFullWidth.isEmpty() )
1897 setFullSize( attrFullWidth == "true" );
1898 }
1899
1900 Dock dock = DockTop;
1901 {
1902 QCString attrPosition = element.attribute( "position" ).lower().latin1();
1903 //kdDebug(220) << "KToolBar::loadState attrPosition=" << attrPosition << endl;
1904 if ( !attrPosition.isEmpty() ) {
1905 if ( attrPosition == "top" )
1906 dock = DockTop;
1907 else if ( attrPosition == "left" )
1908 dock = DockLeft;
1909 else if ( attrPosition == "right" )
1910 dock = DockRight;
1911 else if ( attrPosition == "bottom" )
1912 dock = DockBottom;
1913 else if ( attrPosition == "floating" )
1914 dock = DockTornOff;
1915 else if ( attrPosition == "flat" )
1916 dock = DockMinimized;
1917 }
1918 }
1919
1920 {
1921 QCString attrIconText = element.attribute( "iconText" ).lower().latin1();
1922 if ( !attrIconText.isEmpty() ) {
1923 //kdDebug(220) << "KToolBar::loadState attrIconText=" << attrIconText << endl;
1924 if ( attrIconText == "icontextright" )
1925 setIconText( KToolBar::IconTextRight );
1926 else if ( attrIconText == "textonly" )
1927 setIconText( KToolBar::TextOnly );
1928 else if ( attrIconText == "icontextbottom" )
1929 setIconText( KToolBar::IconTextBottom );
1930 else if ( attrIconText == "icononly" )
1931 setIconText( KToolBar::IconOnly );
1932 } else
1933 // Use global setting
1934 setIconText( iconTextSetting() );
1935 }
1936
1937 {
1938 QString attrIconSize = element.attribute( "iconSize" ).lower();
1939 if ( !attrIconSize.isEmpty() )
1940 d->IconSizeDefault = attrIconSize.toInt();
1941 setIconSize( d->IconSizeDefault );
1942 }
1943
1944 {
1945 QString attrIndex = element.attribute( "index" ).lower();
1946 if ( !attrIndex.isEmpty() )
1947 d->IndexDefault = attrIndex.toInt();
1948 }
1949
1950 {
1951 QString attrOffset = element.attribute( "offset" ).lower();
1952 if ( !attrOffset.isEmpty() )
1953 d->OffsetDefault = attrOffset.toInt();
1954 }
1955
1956 {
1957 QString attrNewLine = element.attribute( "newline" ).lower();
1958 if ( !attrNewLine.isEmpty() )
1959 d->NewLineDefault = attrNewLine == "true";
1960 }
1961
1962 {
1963 QString attrHidden = element.attribute( "hidden" ).lower();
1964 if ( !attrHidden.isEmpty() )
1965 d->HiddenDefault = attrHidden == "true";
1966 }
1967
1968 d->toolBarInfo = KToolBarPrivate::ToolBarInfo( dock, d->IndexDefault, d->NewLineDefault, d->OffsetDefault );
1969 mainWindow()->addDockWindow( this, dock, d->NewLineDefault );
1970//US mainWindow()->moveDockWindow( this, dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault );
1971 mainWindow()->moveToolBar( this, dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault );
1972
1973 // Apply the highlight button setting
1974 d->m_highlight = highlightSetting();
1975
1976 // Apply transparent-toolbar-moving setting (ok, this is global to the mainwindow,
1977 // but we do it only if there are toolbars...)
1978 if ( transparentSetting() != !mainWindow()->opaqueMoving() )
1979 mainWindow()->setOpaqueMoving( !transparentSetting() );
1980
1981 if ( d->HiddenDefault )
1982 hide();
1983 else
1984 show();
1985
1986 getAttributes( d->PositionDefault, d->IconTextDefault, d->IndexDefault );
1987}
1988*/
1989
1990void KToolBar::getAttributes( QString &position, QString &icontext, int &index )
1991{
1992 // get all of the stuff to save
1993 switch ( barPos() ) {
1994 case KToolBar::Flat:
1995 position = "Flat";
1996 break;
1997 case KToolBar::Bottom:
1998 position = "Bottom";
1999 break;
2000 case KToolBar::Left:
2001 position = "Left";
2002 break;
2003 case KToolBar::Right:
2004 position = "Right";
2005 break;
2006 case KToolBar::Floating:
2007 position = "Floating";
2008 break;
2009 case KToolBar::Top:
2010 default:
2011 position = "Top";
2012 break;
2013 }
2014
2015 if ( mainWindow() ) {
2016 QMainWindow::ToolBarDock dock;
2017 bool newLine;
2018 int offset;
2019 mainWindow()->getLocation( this, dock, index, newLine, offset );
2020 }
2021
2022 switch (d->m_iconText) {
2023 case KToolBar::IconTextRight:
2024 icontext = "IconTextRight";
2025 break;
2026 case KToolBar::IconTextBottom:
2027 icontext = "IconTextBottom";
2028 break;
2029 case KToolBar::TextOnly:
2030 icontext = "TextOnly";
2031 break;
2032 case KToolBar::IconOnly:
2033 default:
2034 icontext = "IconOnly";
2035 break;
2036 }
2037}
2038/*US
2039void KToolBar::saveState( QDomElement &current )
2040{
2041 QString position, icontext;
2042 int index = -1;
2043 getAttributes( position, icontext, index );
2044
2045 current.setAttribute( "noMerge", "1" );
2046 current.setAttribute( "position", position );
2047 current.setAttribute( "iconText", icontext );
2048 current.setAttribute( "index", index );
2049 current.setAttribute( "offset", offset() );
2050 current.setAttribute( "newline", newLine() );
2051 if ( isHidden() )
2052 current.setAttribute( "hidden", "true" );
2053 d->modified = true;
2054}
2055*/
2056
2057void KToolBar::positionYourself( bool force )
2058{
2059 if (force)
2060 d->positioned = false;
2061
2062 if ( d->positioned || !mainWindow() )
2063 {
2064 //kdDebug(220) << "KToolBar::positionYourself d->positioned=true ALREADY DONE" << endl;
2065 return;
2066 }
2067 // we can't test for ForceHide after moveDockWindow because QDockArea
2068 // does a reparent() with showIt == true
2069 bool doHide = isHidden();
2070 //kdDebug(220) << "positionYourself " << name() << " dock=" << d->toolBarInfo.dock << " newLine=" << d->toolBarInfo.newline << " offset=" << d->toolBarInfo.offset << endl;
2071/*US mainWindow()->moveDockWindow( this, d->toolBarInfo.dock,
2072 d->toolBarInfo.newline,
2073 d->toolBarInfo.index,
2074 d->toolBarInfo.offset );
2075*/
2076 mainWindow()->moveToolBar( this, d->toolBarInfo.dock, d->NewLineDefault, d->IndexDefault, d->OffsetDefault );
2077
2078 if ( doHide )
2079 hide();
2080 // This method can only have an effect once - unless force is set
2081 d->positioned = TRUE;
2082}
2083
2084//US KPopupMenu *KToolBar::contextMenu()
2085QPopupMenu *KToolBar::contextMenu()
2086{
2087 if ( context )
2088 return context;
2089
2090 // Construct our context popup menu. Name it qt_dockwidget_internal so it
2091 // won't be deleted by QToolBar::clear().
2092//US context = new KPopupMenu( this, "qt_dockwidget_internal" );
2093 context = new QPopupMenu( this, "qt_dockwidget_internal" );
2094//US context->insertTitle(i18n("Toolbar Menu"));
2095
2096//US KPopupMenu *orient = new KPopupMenu( context, "orient" );
2097 QPopupMenu *orient = new QPopupMenu( context, "orient" );
2098 orient->insertItem( i18n("toolbar position string","Top"), CONTEXT_TOP );
2099 orient->insertItem( i18n("toolbar position string","Left"), CONTEXT_LEFT );
2100 orient->insertItem( i18n("toolbar position string","Right"), CONTEXT_RIGHT );
2101 orient->insertItem( i18n("toolbar position string","Bottom"), CONTEXT_BOTTOM );
2102 orient->insertSeparator(-1);
2103 //orient->insertItem( i18n("toolbar position string","Floating"), CONTEXT_FLOAT );
2104 orient->insertItem( i18n("min toolbar", "Flat"), CONTEXT_FLAT );
2105
2106//US KPopupMenu *mode = new KPopupMenu( context, "mode" );
2107 QPopupMenu *mode = new QPopupMenu( context, "mode" );
2108 mode->insertItem( i18n("Icons Only"), CONTEXT_ICONS );
2109 mode->insertItem( i18n("Text Only"), CONTEXT_TEXT );
2110 mode->insertItem( i18n("Text Alongside Icons"), CONTEXT_TEXTRIGHT );
2111 mode->insertItem( i18n("Text Under Icons"), CONTEXT_TEXTUNDER );
2112
2113//US KPopupMenu *size = new KPopupMenu( context, "size" );
2114 QPopupMenu *size = new QPopupMenu( context, "size" );
2115 size->insertItem( i18n("Default"), CONTEXT_ICONSIZES );
2116 // Query the current theme for available sizes
2117 QValueList<int> avSizes;
2118/*US
2119 KIconTheme *theme = KGlobal::instance()->iconLoader()->theme();
2120 if (!::qstrcmp(QObject::name(), "mainToolBar"))
2121 avSizes = theme->querySizes( KIcon::MainToolbar);
2122 else
2123 avSizes = theme->querySizes( KIcon::Toolbar);
2124*/
2125 avSizes << 16;
2126 avSizes << 32;
2127
2128 d->iconSizes = avSizes;
2129
2130 QValueList<int>::Iterator it;
2131 for (it=avSizes.begin(); it!=avSizes.end(); it++) {
2132 QString text;
2133 if ( *it < 19 )
2134 text = i18n("Small (%1x%2)").arg(*it).arg(*it);
2135 else if (*it < 25)
2136 text = i18n("Medium (%1x%2)").arg(*it).arg(*it);
2137 else
2138 text = i18n("Large (%1x%2)").arg(*it).arg(*it);
2139 //we use the size as an id, with an offset
2140 size->insertItem( text, CONTEXT_ICONSIZES + *it );
2141 }
2142
2143 context->insertItem( i18n("Orientation"), orient );
2144 orient->setItemChecked(CONTEXT_TOP, true);
2145 context->insertItem( i18n("Text Position"), mode );
2146 context->setItemChecked(CONTEXT_ICONS, true);
2147 context->insertItem( i18n("Icon Size"), size );
2148
2149/*US
2150 if (mainWindow()->inherits("KMainWindow"))
2151 {
2152 if ( (static_cast<KMainWindow*>(mainWindow())->toolBarMenuAction()) &&
2153 (static_cast<KMainWindow*>(mainWindow())->hasMenuBar()) )
2154
2155 (static_cast<KMainWindow*>(mainWindow()))->toolBarMenuAction()->plug(context);
2156 }
2157*/
2158
2159 connect( context, SIGNAL( aboutToShow() ), this, SLOT( slotContextAboutToShow() ) );
2160 return context;
2161}
2162
2163void KToolBar::slotContextAboutToShow()
2164{
2165 if (!d->m_configurePlugged)
2166 {
2167 // try to find "configure toolbars" action
2168
2169 KXMLGUIClient *xmlGuiClient = d->m_xmlguiClient;
2170 if ( !xmlGuiClient && mainWindow() && mainWindow()->inherits( "KMainWindow" ) )
2171 xmlGuiClient = (KXMLGUIClient *)mainWindow();
2172 if ( xmlGuiClient )
2173 {
2174 KAction *configureAction = xmlGuiClient->actionCollection()->action(KStdAction::stdName(KStdAction::ConfigureToolbars));
2175 if ( configureAction )
2176 {
2177 configureAction->plug(context);
2178 d->m_configurePlugged = true;
2179 }
2180 }
2181 }
2182
2183 for(int i = CONTEXT_ICONS; i <= CONTEXT_TEXTUNDER; ++i)
2184 context->setItemChecked(i, false);
2185
2186 switch( d->m_iconText )
2187 {
2188 case IconOnly:
2189 default:
2190 context->setItemChecked(CONTEXT_ICONS, true);
2191 break;
2192 case IconTextRight:
2193 context->setItemChecked(CONTEXT_TEXTRIGHT, true);
2194 break;
2195 case TextOnly:
2196 context->setItemChecked(CONTEXT_TEXT, true);
2197 break;
2198 case IconTextBottom:
2199 context->setItemChecked(CONTEXT_TEXTUNDER, true);
2200 break;
2201 }
2202
2203 QValueList<int>::ConstIterator iIt = d->iconSizes.begin();
2204 QValueList<int>::ConstIterator iEnd = d->iconSizes.end();
2205 for (; iIt != iEnd; ++iIt )
2206 context->setItemChecked( CONTEXT_ICONSIZES + *iIt, false );
2207
2208 context->setItemChecked( CONTEXT_ICONSIZES, false );
2209
2210 context->setItemChecked( CONTEXT_ICONSIZES + d->m_iconSize, true );
2211
2212 for ( int i = CONTEXT_TOP; i <= CONTEXT_FLAT; ++i )
2213 context->setItemChecked( i, false );
2214
2215 switch ( barPos() )
2216 {
2217 case KToolBar::Flat:
2218 context->setItemChecked( CONTEXT_FLAT, true );
2219 break;
2220 case KToolBar::Bottom:
2221 context->setItemChecked( CONTEXT_BOTTOM, true );
2222 break;
2223 case KToolBar::Left:
2224 context->setItemChecked( CONTEXT_LEFT, true );
2225 break;
2226 case KToolBar::Right:
2227 context->setItemChecked( CONTEXT_RIGHT, true );
2228 break;
2229 case KToolBar::Floating:
2230 context->setItemChecked( CONTEXT_FLOAT, true );
2231 break;
2232 case KToolBar::Top:
2233 context->setItemChecked( CONTEXT_TOP, true );
2234 break;
2235 default: break;
2236 }
2237}
2238
2239void KToolBar::widgetDestroyed()
2240{
2241 removeWidgetInternal( (QWidget*)sender() );
2242}
2243
2244void KToolBar::removeWidgetInternal( QWidget * w )
2245{
2246 if ( inshutdownprocess )
2247 return;
2248 widgets.removeRef( w );
2249 QMap< QWidget*, int >::Iterator it = widget2id.find( w );
2250 if ( it == widget2id.end() )
2251 return;
2252 id2widget.remove( *it );
2253 widget2id.remove( it );
2254}
2255
2256void KToolBar::virtual_hook( int, void* )
2257{ /*BASE::virtual_hook( id, data );*/ }
2258
2259//US #include "ktoolbar.moc"
2260