source: trunk/src/gui/widgets/qtoolbarlayout.cpp@ 728

Last change on this file since 728 was 651, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.2 sources.
File size: 22.7 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtGui module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include <qaction.h>
43#include <qwidgetaction.h>
44#include <qtoolbar.h>
45#include <qstyleoption.h>
46#include <qtoolbutton.h>
47#include <qmenu.h>
48#include <qdebug.h>
49#include <qmath.h>
50
51#include "qmainwindowlayout_p.h"
52#include "qtoolbarextension_p.h"
53#include "qtoolbarlayout_p.h"
54#include "qtoolbarseparator_p.h"
55
56#ifndef QT_NO_TOOLBAR
57
58QT_BEGIN_NAMESPACE
59
60/******************************************************************************
61** QToolBarItem
62*/
63
64QToolBarItem::QToolBarItem(QWidget *widget)
65 : QWidgetItem(widget), action(0), customWidget(false)
66{
67}
68
69bool QToolBarItem::isEmpty() const
70{
71 return action == 0 || !action->isVisible();
72}
73
74/******************************************************************************
75** QToolBarLayout
76*/
77
78QToolBarLayout::QToolBarLayout(QWidget *parent)
79 : QLayout(parent), expanded(false), animating(false), dirty(true),
80 expanding(false), empty(true), expandFlag(false), popupMenu(0)
81{
82 QToolBar *tb = qobject_cast<QToolBar*>(parent);
83 if (!tb)
84 return;
85
86 extension = new QToolBarExtension(tb);
87 extension->setFocusPolicy(Qt::NoFocus);
88 extension->hide();
89 QObject::connect(tb, SIGNAL(orientationChanged(Qt::Orientation)),
90 extension, SLOT(setOrientation(Qt::Orientation)));
91
92 setUsePopupMenu(qobject_cast<QMainWindow*>(tb->parentWidget()) == 0);
93}
94
95QToolBarLayout::~QToolBarLayout()
96{
97 while (!items.isEmpty()) {
98 QToolBarItem *item = items.takeFirst();
99 if (QWidgetAction *widgetAction = qobject_cast<QWidgetAction*>(item->action)) {
100 if (item->customWidget)
101 widgetAction->releaseWidget(item->widget());
102 }
103 delete item;
104 }
105}
106
107void QToolBarLayout::updateMarginAndSpacing()
108{
109 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
110 if (!tb)
111 return;
112 QStyle *style = tb->style();
113 QStyleOptionToolBar opt;
114 tb->initStyleOption(&opt);
115 setMargin(style->pixelMetric(QStyle::PM_ToolBarItemMargin, &opt, tb)
116 + style->pixelMetric(QStyle::PM_ToolBarFrameWidth, &opt, tb));
117 setSpacing(style->pixelMetric(QStyle::PM_ToolBarItemSpacing, &opt, tb));
118}
119
120bool QToolBarLayout::hasExpandFlag() const
121{
122 return expandFlag;
123}
124
125void QToolBarLayout::setUsePopupMenu(bool set)
126{
127 if (!dirty && ((popupMenu == 0) == set))
128 invalidate();
129 if (!set) {
130 QObject::connect(extension, SIGNAL(clicked(bool)),
131 this, SLOT(setExpanded(bool)), Qt::UniqueConnection);
132 extension->setPopupMode(QToolButton::DelayedPopup);
133 extension->setMenu(0);
134 delete popupMenu;
135 popupMenu = 0;
136 } else {
137 QObject::disconnect(extension, SIGNAL(clicked(bool)),
138 this, SLOT(setExpanded(bool)));
139 extension->setPopupMode(QToolButton::InstantPopup);
140 if (!popupMenu) {
141 popupMenu = new QMenu(extension);
142 }
143 extension->setMenu(popupMenu);
144 }
145}
146
147void QToolBarLayout::checkUsePopupMenu()
148{
149 QToolBar *tb = static_cast<QToolBar *>(parent());
150 QMainWindow *mw = qobject_cast<QMainWindow *>(tb->parent());
151 Qt::Orientation o = tb->orientation();
152 setUsePopupMenu(!mw || tb->isFloating() || perp(o, expandedSize(mw->size())) >= perp(o, mw->size()));
153}
154
155void QToolBarLayout::addItem(QLayoutItem*)
156{
157 qWarning() << "QToolBarLayout::addItem(): please use addAction() instead";
158 return;
159}
160
161QLayoutItem *QToolBarLayout::itemAt(int index) const
162{
163 if (index < 0 || index >= items.count())
164 return 0;
165 return items.at(index);
166}
167
168QLayoutItem *QToolBarLayout::takeAt(int index)
169{
170 if (index < 0 || index >= items.count())
171 return 0;
172 QToolBarItem *item = items.takeAt(index);
173
174 if (popupMenu)
175 popupMenu->removeAction(item->action);
176
177 QWidgetAction *widgetAction = qobject_cast<QWidgetAction*>(item->action);
178 if (widgetAction != 0 && item->customWidget) {
179 widgetAction->releaseWidget(item->widget());
180 } else {
181 // destroy the QToolButton/QToolBarSeparator
182 item->widget()->hide();
183 item->widget()->deleteLater();
184 }
185
186 invalidate();
187 return item;
188}
189
190void QToolBarLayout::insertAction(int index, QAction *action)
191{
192 index = qMax(0, index);
193 index = qMin(items.count(), index);
194
195 QToolBarItem *item = createItem(action);
196 if (item) {
197 items.insert(index, item);
198 invalidate();
199 }
200}
201
202int QToolBarLayout::indexOf(QAction *action) const
203{
204 for (int i = 0; i < items.count(); ++i) {
205 if (items.at(i)->action == action)
206 return i;
207 }
208 return -1;
209}
210
211int QToolBarLayout::count() const
212{
213 return items.count();
214}
215
216bool QToolBarLayout::isEmpty() const
217{
218 if (dirty)
219 updateGeomArray();
220 return empty;
221}
222
223void QToolBarLayout::invalidate()
224{
225 dirty = true;
226 QLayout::invalidate();
227}
228
229Qt::Orientations QToolBarLayout::expandingDirections() const
230{
231 if (dirty)
232 updateGeomArray();
233 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
234 if (!tb)
235 return Qt::Orientations(0);
236 Qt::Orientation o = tb->orientation();
237 return expanding ? Qt::Orientations(o) : Qt::Orientations(0);
238}
239
240bool QToolBarLayout::movable() const
241{
242 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
243 if (!tb)
244 return false;
245 QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget());
246 return tb->isMovable() && win != 0;
247}
248
249void QToolBarLayout::updateGeomArray() const
250{
251 if (!dirty)
252 return;
253
254 QToolBarLayout *that = const_cast<QToolBarLayout*>(this);
255
256 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
257 if (!tb)
258 return;
259 QStyle *style = tb->style();
260 QStyleOptionToolBar opt;
261 tb->initStyleOption(&opt);
262 const int handleExtent = movable()
263 ? style->pixelMetric(QStyle::PM_ToolBarHandleExtent, &opt, tb) : 0;
264 const int margin = this->margin();
265 const int spacing = this->spacing();
266 const int extensionExtent = style->pixelMetric(QStyle::PM_ToolBarExtensionExtent, &opt, tb);
267 Qt::Orientation o = tb->orientation();
268
269 that->minSize = QSize(0, 0);
270 that->hint = QSize(0, 0);
271 rperp(o, that->minSize) = style->pixelMetric(QStyle::PM_ToolBarHandleExtent, &opt, tb);
272 rperp(o, that->hint) = style->pixelMetric(QStyle::PM_ToolBarHandleExtent, &opt, tb);
273
274 that->expanding = false;
275 that->empty = false;
276
277 QVector<QLayoutStruct> a(items.count() + 1); // + 1 for the stretch
278
279 int count = 0;
280 for (int i = 0; i < items.count(); ++i) {
281 QToolBarItem *item = items.at(i);
282
283 QSize max = item->maximumSize();
284 QSize min = item->minimumSize();
285 QSize hint = item->sizeHint();
286 Qt::Orientations exp = item->expandingDirections();
287 bool empty = item->isEmpty();
288
289 that->expanding = expanding || exp & o;
290
291
292 if (item->widget()) {
293 if ((item->widget()->sizePolicy().horizontalPolicy() & QSizePolicy::ExpandFlag)) {
294 that->expandFlag = true;
295 }
296 }
297
298 if (!empty) {
299 if (count == 0) // the minimum size only displays one widget
300 rpick(o, that->minSize) += pick(o, min);
301 int s = perp(o, minSize);
302 rperp(o, that->minSize) = qMax(s, perp(o, min));
303
304 //we only add spacing before item (ie never before the first one)
305 rpick(o, that->hint) += (count == 0 ? 0 : spacing) + pick(o, hint);
306 s = perp(o, that->hint);
307 rperp(o, that->hint) = qMax(s, perp(o, hint));
308 ++count;
309 }
310
311 a[i].sizeHint = pick(o, hint);
312 a[i].maximumSize = pick(o, max);
313 a[i].minimumSize = pick(o, min);
314 a[i].expansive = exp & o;
315 if (o == Qt::Horizontal)
316 a[i].stretch = item->widget()->sizePolicy().horizontalStretch();
317 else
318 a[i].stretch = item->widget()->sizePolicy().verticalStretch();
319 a[i].empty = empty;
320 }
321
322 that->geomArray = a;
323 that->empty = count == 0;
324
325 rpick(o, that->minSize) += handleExtent;
326 that->minSize += QSize(2*margin, 2*margin);
327 if (items.count() > 1)
328 rpick(o, that->minSize) += spacing + extensionExtent;
329
330 rpick(o, that->hint) += handleExtent;
331 that->hint += QSize(2*margin, 2*margin);
332 that->dirty = false;
333#ifdef Q_WS_MAC
334 if (QMainWindow *mw = qobject_cast<QMainWindow *>(parentWidget()->parentWidget())) {
335 if (mw->unifiedTitleAndToolBarOnMac()
336 && mw->toolBarArea(static_cast<QToolBar *>(parentWidget())) == Qt::TopToolBarArea) {
337 if (expandFlag) {
338 tb->setMaximumSize(0xFFFFFF, 0xFFFFFF);
339 } else {
340 tb->setMaximumSize(hint);
341 }
342 }
343 }
344#endif
345
346 that->dirty = false;
347}
348
349static bool defaultWidgetAction(QToolBarItem *item)
350{
351 QWidgetAction *a = qobject_cast<QWidgetAction*>(item->action);
352 return a != 0 && a->defaultWidget() == item->widget();
353}
354
355void QToolBarLayout::setGeometry(const QRect &rect)
356{
357 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
358 if (!tb)
359 return;
360 QStyle *style = tb->style();
361 QStyleOptionToolBar opt;
362 tb->initStyleOption(&opt);
363 const int margin = this->margin();
364 const int extensionExtent = style->pixelMetric(QStyle::PM_ToolBarExtensionExtent, &opt, tb);
365 Qt::Orientation o = tb->orientation();
366
367 QLayout::setGeometry(rect);
368
369 bool ranOutOfSpace = false;
370 if (!animating)
371 ranOutOfSpace = layoutActions(rect.size());
372
373 if (expanded || animating || ranOutOfSpace) {
374 Qt::ToolBarArea area = Qt::TopToolBarArea;
375 if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget()))
376 area = win->toolBarArea(tb);
377 QSize hint = sizeHint();
378
379 QPoint pos;
380 rpick(o, pos) = pick(o, rect.bottomRight()) - margin - extensionExtent + 2;
381 if (area == Qt::LeftToolBarArea || area == Qt::TopToolBarArea)
382 rperp(o, pos) = perp(o, rect.topLeft()) + margin;
383 else
384 rperp(o, pos) = perp(o, rect.bottomRight()) - margin - (perp(o, hint) - 2*margin) + 1;
385 QSize size;
386 rpick(o, size) = extensionExtent;
387 rperp(o, size) = perp(o, hint) - 2*margin;
388 QRect r(pos, size);
389
390 if (o == Qt::Horizontal)
391 r = QStyle::visualRect(parentWidget()->layoutDirection(), rect, r);
392
393 extension->setGeometry(r);
394
395 if (extension->isHidden())
396 extension->show();
397 } else {
398 if (!extension->isHidden())
399 extension->hide();
400 }
401#ifdef Q_WS_MAC
402 // Nothing to do for Carbon... probably
403# ifdef QT_MAC_USE_COCOA
404 if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget())) {
405 Qt::ToolBarArea area = win->toolBarArea(tb);
406 if (win->unifiedTitleAndToolBarOnMac() && area == Qt::TopToolBarArea) {
407 static_cast<QMainWindowLayout *>(win->layout())->fixSizeInUnifiedToolbar(tb);
408 }
409 }
410# endif
411#endif
412
413}
414
415bool QToolBarLayout::layoutActions(const QSize &size)
416{
417 if (dirty)
418 updateGeomArray();
419
420 QRect rect(0, 0, size.width(), size.height());
421
422 QList<QWidget*> showWidgets, hideWidgets;
423
424 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
425 if (!tb)
426 return false;
427 QStyle *style = tb->style();
428 QStyleOptionToolBar opt;
429 tb->initStyleOption(&opt);
430 const int handleExtent = movable()
431 ? style->pixelMetric(QStyle::PM_ToolBarHandleExtent, &opt, tb) : 0;
432 const int margin = this->margin();
433 const int spacing = this->spacing();
434 const int extensionExtent = style->pixelMetric(QStyle::PM_ToolBarExtensionExtent, &opt, tb);
435 Qt::Orientation o = tb->orientation();
436 bool extensionMenuContainsOnlyWidgetActions = true;
437
438 int space = pick(o, rect.size()) - 2*margin - handleExtent;
439 if (space <= 0)
440 return false; // nothing to do.
441
442 if(popupMenu)
443 popupMenu->clear();
444
445 bool ranOutOfSpace = false;
446 int rows = 0;
447 int rowPos = perp(o, rect.topLeft()) + margin;
448 int i = 0;
449 while (i < items.count()) {
450 QVector<QLayoutStruct> a = geomArray;
451
452 int start = i;
453 int size = 0;
454 int prev = -1;
455 int rowHeight = 0;
456 int count = 0;
457 int maximumSize = 0;
458 bool expansiveRow = false;
459 for (; i < items.count(); ++i) {
460 if (a[i].empty)
461 continue;
462
463 int newSize = size + (count == 0 ? 0 : spacing) + a[i].minimumSize;
464 if (prev != -1 && newSize > space) {
465 if (rows == 0)
466 ranOutOfSpace = true;
467 // do we have to move the previous item to the next line to make space for
468 // the extension button?
469 if (count > 1 && size + spacing + extensionExtent > space)
470 i = prev;
471 break;
472 }
473
474 if (expanded)
475 rowHeight = qMax(rowHeight, perp(o, items.at(i)->sizeHint()));
476 expansiveRow = expansiveRow || a[i].expansive;
477 size = newSize;
478 maximumSize += spacing + (a[i].expansive ? a[i].maximumSize : a[i].smartSizeHint());
479 prev = i;
480 ++count;
481 }
482
483 // stretch at the end
484 a[i].sizeHint = 0;
485 a[i].maximumSize = QWIDGETSIZE_MAX;
486 a[i].minimumSize = 0;
487 a[i].expansive = true;
488 a[i].stretch = 0;
489 a[i].empty = true;
490
491 if (expansiveRow && maximumSize < space) {
492 expansiveRow = false;
493 a[i].maximumSize = space - maximumSize;
494 }
495
496 qGeomCalc(a, start, i - start + (expansiveRow ? 0 : 1), 0,
497 space - (ranOutOfSpace ? (extensionExtent + spacing) : 0),
498 spacing);
499
500 for (int j = start; j < i; ++j) {
501 QToolBarItem *item = items.at(j);
502
503 if (a[j].empty) {
504 if (!item->widget()->isHidden())
505 hideWidgets << item->widget();
506 continue;
507 }
508
509 QPoint pos;
510 rpick(o, pos) = margin + handleExtent + a[j].pos;
511 rperp(o, pos) = rowPos;
512 QSize size;
513 rpick(o, size) = a[j].size;
514 if (expanded)
515 rperp(o, size) = rowHeight;
516 else
517 rperp(o, size) = perp(o, rect.size()) - 2*margin;
518 QRect r(pos, size);
519
520 if (o == Qt::Horizontal)
521 r = QStyle::visualRect(parentWidget()->layoutDirection(), rect, r);
522
523 item->setGeometry(r);
524
525 if (item->widget()->isHidden())
526 showWidgets << item->widget();
527 }
528
529 if (!expanded) {
530 for (int j = i; j < items.count(); ++j) {
531 QToolBarItem *item = items.at(j);
532 if (!item->widget()->isHidden())
533 hideWidgets << item->widget();
534 if (popupMenu) {
535 if (!defaultWidgetAction(item)) {
536 popupMenu->addAction(item->action);
537 extensionMenuContainsOnlyWidgetActions = false;
538 }
539 }
540 }
541 break;
542 }
543
544 rowPos += rowHeight + spacing;
545 ++rows;
546 }
547
548 // if we are using a popup menu, not the expadning toolbar effect, we cannot move custom
549 // widgets into the menu. If only custom widget actions are chopped off, the popup menu
550 // is empty. So we show the little extension button to show something is chopped off,
551 // but we make it disabled.
552 extension->setEnabled(popupMenu == 0 || !extensionMenuContainsOnlyWidgetActions);
553
554 // we have to do the show/hide here, because it triggers more calls to setGeometry :(
555 for (int i = 0; i < showWidgets.count(); ++i)
556 showWidgets.at(i)->show();
557 for (int i = 0; i < hideWidgets.count(); ++i)
558 hideWidgets.at(i)->hide();
559
560 return ranOutOfSpace;
561}
562
563QSize QToolBarLayout::expandedSize(const QSize &size) const
564{
565 if (dirty)
566 updateGeomArray();
567
568 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
569 if (!tb)
570 return QSize(0, 0);
571 QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget());
572 Qt::Orientation o = tb->orientation();
573 QStyle *style = tb->style();
574 QStyleOptionToolBar opt;
575 tb->initStyleOption(&opt);
576 const int handleExtent = movable()
577 ? style->pixelMetric(QStyle::PM_ToolBarHandleExtent, &opt, tb) : 0;
578 const int margin = this->margin();
579 const int spacing = this->spacing();
580 const int extensionExtent = style->pixelMetric(QStyle::PM_ToolBarExtensionExtent, &opt, tb);
581
582 int total_w = 0;
583 int count = 0;
584 for (int x = 0; x < items.count(); ++x) {
585 if (!geomArray[x].empty) {
586 total_w += (count == 0 ? 0 : spacing) + geomArray[x].minimumSize;
587 ++count;
588 }
589 }
590 if (count == 0)
591 return QSize(0, 0);
592
593 int min_w = pick(o, size);
594 int rows = (int)qSqrt(qreal(count));
595 if (rows == 1)
596 ++rows; // we want to expand to at least two rows
597 int space = total_w/rows + spacing + extensionExtent;
598 space = qMax(space, min_w - 2*margin - handleExtent);
599 if (win != 0)
600 space = qMin(space, pick(o, win->size()) - 2*margin - handleExtent);
601
602 int w = 0;
603 int h = 0;
604 int i = 0;
605 while (i < items.count()) {
606 int count = 0;
607 int size = 0;
608 int prev = -1;
609 int rowHeight = 0;
610 for (; i < items.count(); ++i) {
611 if (geomArray[i].empty)
612 continue;
613
614 int newSize = size + (count == 0 ? 0 : spacing) + geomArray[i].minimumSize;
615 rowHeight = qMax(rowHeight, perp(o, items.at(i)->sizeHint()));
616 if (prev != -1 && newSize > space) {
617 if (count > 1 && size + spacing + extensionExtent > space) {
618 size -= spacing + geomArray[prev].minimumSize;
619 i = prev;
620 }
621 break;
622 }
623
624 size = newSize;
625 prev = i;
626 ++count;
627 }
628
629 w = qMax(size, w);
630 h += rowHeight + spacing;
631 }
632
633 w += 2*margin + handleExtent + spacing + extensionExtent;
634 w = qMax(w, min_w);
635 if (win != 0)
636 w = qMin(w, pick(o, win->size()));
637 h += 2*margin - spacing; //there is no spacing before the first row
638
639 QSize result;
640 rpick(o, result) = w;
641 rperp(o, result) = h;
642 return result;
643}
644
645void QToolBarLayout::setExpanded(bool exp)
646{
647 if (exp == expanded)
648 return;
649
650 expanded = exp;
651 extension->setChecked(expanded);
652
653 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
654 if (!tb)
655 return;
656 if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget())) {
657 animating = !tb->isWindow() && win->isAnimated();
658 QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());
659 if (expanded) {
660 tb->raise();
661 } else {
662 QList<int> path = layout->layoutState.indexOf(tb);
663 if (!path.isEmpty()) {
664 QRect rect = layout->layoutState.itemRect(path);
665 layoutActions(rect.size());
666 }
667 }
668 layout->layoutState.toolBarAreaLayout.apply(animating);
669 }
670}
671
672QSize QToolBarLayout::minimumSize() const
673{
674 if (dirty)
675 updateGeomArray();
676 return minSize;
677}
678
679QSize QToolBarLayout::sizeHint() const
680{
681 if (dirty)
682 updateGeomArray();
683 return hint;
684}
685
686QToolBarItem *QToolBarLayout::createItem(QAction *action)
687{
688 bool customWidget = false;
689 bool standardButtonWidget = false;
690 QWidget *widget = 0;
691 QToolBar *tb = qobject_cast<QToolBar*>(parentWidget());
692 if (!tb)
693 return (QToolBarItem *)0;
694
695 if (QWidgetAction *widgetAction = qobject_cast<QWidgetAction *>(action)) {
696 widget = widgetAction->requestWidget(tb);
697 if (widget != 0) {
698 widget->setAttribute(Qt::WA_LayoutUsesWidgetRect);
699 customWidget = true;
700 }
701 } else if (action->isSeparator()) {
702 QToolBarSeparator *sep = new QToolBarSeparator(tb);
703 connect(tb, SIGNAL(orientationChanged(Qt::Orientation)),
704 sep, SLOT(setOrientation(Qt::Orientation)));
705 widget = sep;
706 }
707
708 if (!widget) {
709 QToolButton *button = new QToolButton(tb);
710 button->setAutoRaise(true);
711 button->setFocusPolicy(Qt::NoFocus);
712 button->setIconSize(tb->iconSize());
713 button->setToolButtonStyle(tb->toolButtonStyle());
714 QObject::connect(tb, SIGNAL(iconSizeChanged(QSize)),
715 button, SLOT(setIconSize(QSize)));
716 QObject::connect(tb, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)),
717 button, SLOT(setToolButtonStyle(Qt::ToolButtonStyle)));
718 button->setDefaultAction(action);
719 QObject::connect(button, SIGNAL(triggered(QAction*)), tb, SIGNAL(actionTriggered(QAction*)));
720 widget = button;
721 standardButtonWidget = true;
722 }
723
724 widget->hide();
725 QToolBarItem *result = new QToolBarItem(widget);
726 if (standardButtonWidget)
727 result->setAlignment(Qt::AlignJustify);
728 result->customWidget = customWidget;
729 result->action = action;
730 return result;
731}
732
733QT_END_NAMESPACE
734
735#endif // QT_NO_TOOLBAR
Note: See TracBrowser for help on using the repository browser.