/****************************************************************************+ −
**+ −
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+ −
** All rights reserved.+ −
** Contact: Nokia Corporation (qt-info@nokia.com)+ −
**+ −
** This file is part of the QtGui module of the Qt Toolkit.+ −
**+ −
** $QT_BEGIN_LICENSE:LGPL$+ −
** No Commercial Usage+ −
** This file contains pre-release code and may not be distributed.+ −
** You may use this file in accordance with the terms and conditions+ −
** contained in the Technology Preview License Agreement accompanying+ −
** this package.+ −
**+ −
** GNU Lesser General Public License Usage+ −
** Alternatively, this file may be used under the terms of the GNU Lesser+ −
** General Public License version 2.1 as published by the Free Software+ −
** Foundation and appearing in the file LICENSE.LGPL included in the+ −
** packaging of this file. Please review the following information to+ −
** ensure the GNU Lesser General Public License version 2.1 requirements+ −
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+ −
**+ −
** In addition, as a special exception, Nokia gives you certain additional+ −
** rights. These rights are described in the Nokia Qt LGPL Exception+ −
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+ −
**+ −
** If you have questions regarding the use of this file, please contact+ −
** Nokia at qt-info@nokia.com.+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
**+ −
** $QT_END_LICENSE$+ −
**+ −
****************************************************************************/+ −
+ −
#include "qtoolbar.h"+ −
+ −
#ifndef QT_NO_TOOLBAR+ −
+ −
#include <qapplication.h>+ −
#include <qcombobox.h>+ −
#include <qevent.h>+ −
#include <qlayout.h>+ −
#include <qmainwindow.h>+ −
#include <qmenu.h>+ −
#include <qmenubar.h>+ −
#include <qrubberband.h>+ −
#include <qsignalmapper.h>+ −
#include <qstylepainter.h>+ −
#include <qtoolbutton.h>+ −
#include <qwidgetaction.h>+ −
#include <qtimer.h>+ −
#include <private/qwidgetaction_p.h>+ −
#ifdef Q_WS_MAC+ −
#include <private/qt_mac_p.h>+ −
#include <private/qt_cocoa_helpers_mac_p.h>+ −
#endif+ −
+ −
#include <private/qmainwindowlayout_p.h>+ −
+ −
#include "qtoolbar_p.h"+ −
#include "qtoolbarseparator_p.h"+ −
#include "qtoolbarlayout_p.h"+ −
+ −
#include "qdebug.h"+ −
+ −
#define POPUP_TIMER_INTERVAL 500+ −
+ −
QT_BEGIN_NAMESPACE+ −
+ −
#ifdef Q_WS_MAC+ −
static void qt_mac_updateToolBarButtonHint(QWidget *parentWidget)+ −
{+ −
if (!(parentWidget->windowFlags() & Qt::CustomizeWindowHint))+ −
parentWidget->setWindowFlags(parentWidget->windowFlags() | Qt::MacWindowToolBarButtonHint);+ −
}+ −
#endif+ −
+ −
/******************************************************************************+ −
** QToolBarPrivate+ −
*/+ −
+ −
void QToolBarPrivate::init()+ −
{+ −
Q_Q(QToolBar);+ −
q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));+ −
q->setBackgroundRole(QPalette::Button);+ −
q->setAttribute(Qt::WA_Hover);+ −
q->setAttribute(Qt::WA_X11NetWmWindowTypeToolBar);+ −
+ −
QStyle *style = q->style();+ −
int e = style->pixelMetric(QStyle::PM_ToolBarIconSize, 0, q);+ −
iconSize = QSize(e, e);+ −
+ −
layout = new QToolBarLayout(q);+ −
layout->updateMarginAndSpacing();+ −
+ −
#ifdef Q_WS_MAC+ −
if (q->parentWidget() && q->parentWidget()->isWindow()) {+ −
// Make sure that the window has the "toolbar" button.+ −
QWidget *parentWidget = q->parentWidget();+ −
qt_mac_updateToolBarButtonHint(parentWidget);+ −
reinterpret_cast<QToolBar *>(parentWidget)->d_func()->createWinId(); // Please let me create your winId...+ −
extern OSWindowRef qt_mac_window_for(const QWidget *); // qwidget_mac.cpp+ −
macWindowToolbarShow(q->parentWidget(), true);+ −
}+ −
#endif+ −
+ −
toggleViewAction = new QAction(q);+ −
toggleViewAction->setCheckable(true);+ −
q->setMovable(q->style()->styleHint(QStyle::SH_ToolBar_Movable, 0, q ));+ −
QObject::connect(toggleViewAction, SIGNAL(triggered(bool)), q, SLOT(_q_toggleView(bool)));+ −
}+ −
+ −
void QToolBarPrivate::_q_toggleView(bool b)+ −
{+ −
Q_Q(QToolBar);+ −
if (b == q->isHidden()) {+ −
if (b)+ −
q->show();+ −
else+ −
q->close();+ −
}+ −
}+ −
+ −
void QToolBarPrivate::_q_updateIconSize(const QSize &sz)+ −
{+ −
Q_Q(QToolBar);+ −
if (!explicitIconSize) {+ −
// iconSize not explicitly set+ −
q->setIconSize(sz);+ −
explicitIconSize = false;+ −
}+ −
}+ −
+ −
void QToolBarPrivate::_q_updateToolButtonStyle(Qt::ToolButtonStyle style)+ −
{+ −
Q_Q(QToolBar);+ −
if (!explicitToolButtonStyle) {+ −
q->setToolButtonStyle(style);+ −
explicitToolButtonStyle = false;+ −
}+ −
}+ −
+ −
void QToolBarPrivate::updateWindowFlags(bool floating, bool unplug)+ −
{+ −
Q_Q(QToolBar);+ −
Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;+ −
+ −
flags |= Qt::FramelessWindowHint;+ −
+ −
if (unplug) {+ −
flags |= Qt::X11BypassWindowManagerHint;+ −
#ifdef Q_WS_MAC+ −
flags |= Qt::WindowStaysOnTopHint;+ −
#endif+ −
}+ −
+ −
q->setWindowFlags(flags);+ −
}+ −
+ −
void QToolBarPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)+ −
{+ −
Q_Q(QToolBar);+ −
bool visible = !q->isHidden();+ −
bool wasFloating = q->isFloating(); // ...is also currently using popup menus+ −
+ −
q->hide();+ −
+ −
updateWindowFlags(floating, unplug);+ −
+ −
if (floating != wasFloating)+ −
layout->checkUsePopupMenu();+ −
+ −
if (!rect.isNull())+ −
q->setGeometry(rect);+ −
+ −
if (visible)+ −
q->show();+ −
+ −
if (floating != wasFloating)+ −
emit q->topLevelChanged(floating);+ −
}+ −
+ −
void QToolBarPrivate::initDrag(const QPoint &pos)+ −
{+ −
Q_Q(QToolBar);+ −
+ −
if (state != 0)+ −
return;+ −
+ −
QMainWindow *win = qobject_cast<QMainWindow*>(parent);+ −
Q_ASSERT(win != 0);+ −
QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());+ −
Q_ASSERT(layout != 0);+ −
if (layout->pluggingWidget != 0) // the main window is animating a docking operation+ −
return;+ −
+ −
state = new DragState;+ −
state->pressPos = pos;+ −
state->dragging = false;+ −
state->moving = false;+ −
state->widgetItem = 0;+ −
+ −
if (q->isRightToLeft())+ −
state->pressPos = QPoint(q->width() - state->pressPos.x(), state->pressPos.y());+ −
}+ −
+ −
void QToolBarPrivate::startDrag(bool moving)+ −
{+ −
Q_Q(QToolBar);+ −
+ −
Q_ASSERT(state != 0);+ −
+ −
if ((moving && state->moving) || state->dragging)+ −
return;+ −
+ −
QMainWindow *win = qobject_cast<QMainWindow*>(parent);+ −
Q_ASSERT(win != 0);+ −
QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());+ −
Q_ASSERT(layout != 0);+ −
+ −
if (!moving) {+ −
state->widgetItem = layout->unplug(q);+ −
#if defined(Q_WS_MAC) && !defined(QT_MAC_USE_COCOA)+ −
if (q->isWindow()) {+ −
setWindowState(true, true); //set it to floating+ −
}+ −
#endif+ −
Q_ASSERT(state->widgetItem != 0);+ −
}+ −
state->dragging = !moving;+ −
state->moving = moving;+ −
}+ −
+ −
void QToolBarPrivate::endDrag()+ −
{+ −
Q_Q(QToolBar);+ −
Q_ASSERT(state != 0);+ −
+ −
q->releaseMouse();+ −
+ −
if (state->dragging) {+ −
QMainWindowLayout *layout =+ −
qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());+ −
Q_ASSERT(layout != 0);+ −
+ −
if (!layout->plug(state->widgetItem)) {+ −
if (q->isFloatable()) {+ −
layout->restore();+ −
#if defined(Q_WS_X11) || defined(Q_WS_MAC)+ −
setWindowState(true); // gets rid of the X11BypassWindowManager window flag+ −
// and activates the resizer+ −
#endif+ −
q->activateWindow();+ −
} else {+ −
layout->revert(state->widgetItem);+ −
}+ −
}+ −
}+ −
+ −
delete state;+ −
state = 0;+ −
}+ −
+ −
bool QToolBarPrivate::mousePressEvent(QMouseEvent *event)+ −
{+ −
Q_Q(QToolBar);+ −
QStyleOptionToolBar opt;+ −
q->initStyleOption(&opt);+ −
if (q->style()->subElementRect(QStyle::SE_ToolBarHandle, &opt, q).contains(event->pos()) == false) {+ −
#ifdef Q_WS_MAC+ −
// When using the unified toolbar on Mac OS X the user can can click and+ −
// drag between toolbar contents to move the window. Make this work by+ −
// implementing the standard mouse-dragging code and then call+ −
// window->move() in mouseMoveEvent below.+ −
if (QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parent)) {+ −
if (mainWindow->toolBarArea(q) == Qt::TopToolBarArea+ −
&& mainWindow->unifiedTitleAndToolBarOnMac()+ −
&& q->childAt(event->pos()) == 0) {+ −
macWindowDragging = true;+ −
macWindowDragPressPosition = event->pos();+ −
return true;+ −
}+ −
}+ −
#endif+ −
return false;+ −
}+ −
+ −
if (event->button() != Qt::LeftButton)+ −
return true;+ −
+ −
if (!layout->movable())+ −
return true;+ −
+ −
initDrag(event->pos());+ −
return true;+ −
}+ −
+ −
bool QToolBarPrivate::mouseReleaseEvent(QMouseEvent*)+ −
{+ −
if (state != 0) {+ −
endDrag();+ −
return true;+ −
} else {+ −
#ifdef Q_WS_MAC+ −
if (!macWindowDragging)+ −
return false;+ −
macWindowDragging = false;+ −
macWindowDragPressPosition = QPoint();+ −
return true;+ −
#endif+ −
return false;+ −
}+ −
}+ −
+ −
bool QToolBarPrivate::mouseMoveEvent(QMouseEvent *event)+ −
{+ −
Q_Q(QToolBar);+ −
+ −
if (!state) {+ −
#ifdef Q_WS_MAC+ −
if (!macWindowDragging)+ −
return false;+ −
QWidget *w = q->window();+ −
const QPoint delta = event->pos() - macWindowDragPressPosition;+ −
w->move(w->pos() + delta);+ −
return true;+ −
#endif+ −
return false;+ −
}+ −
+ −
QMainWindow *win = qobject_cast<QMainWindow*>(parent);+ −
if (win == 0)+ −
return true;+ −
+ −
QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());+ −
Q_ASSERT(layout != 0);+ −
+ −
if (layout->pluggingWidget == 0+ −
&& (event->pos() - state->pressPos).manhattanLength() > QApplication::startDragDistance()) {+ −
const bool wasDragging = state->dragging;+ −
const bool moving = !q->isWindow() && (orientation == Qt::Vertical ?+ −
event->x() >= 0 && event->x() < q->width() :+ −
event->y() >= 0 && event->y() < q->height());+ −
+ −
startDrag(moving);+ −
if (!moving && !wasDragging) {+ −
#ifdef Q_OS_WIN+ −
grabMouseWhileInWindow();+ −
#else+ −
q->grabMouse();+ −
#endif+ −
}+ −
}+ −
+ −
if (state->dragging) {+ −
QPoint pos = event->globalPos();+ −
// if we are right-to-left, we move so as to keep the right edge the same distance+ −
// from the mouse+ −
if (q->isLeftToRight())+ −
pos -= state->pressPos;+ −
else+ −
pos += QPoint(state->pressPos.x() - q->width(), -state->pressPos.y());+ −
+ −
q->move(pos);+ −
layout->hover(state->widgetItem, event->globalPos());+ −
} else if (state->moving) {+ −
+ −
const QPoint rtl(q->width() - state->pressPos.x(), state->pressPos.y()); //for RTL+ −
const QPoint globalPressPos = q->mapToGlobal(q->isRightToLeft() ? rtl : state->pressPos);+ −
int pos = 0;+ −
+ −
QPoint delta = event->globalPos() - globalPressPos;+ −
if (orientation == Qt::Vertical) {+ −
pos = q->y() + delta.y();+ −
} else {+ −
if (q->isRightToLeft()) {+ −
pos = win->width() - q->width() - q->x() - delta.x();+ −
} else {+ −
pos = q->x() + delta.x();+ −
}+ −
}+ −
+ −
layout->moveToolBar(q, pos);+ −
}+ −
return true;+ −
}+ −
+ −
void QToolBarPrivate::unplug(const QRect &_r)+ −
{+ −
Q_Q(QToolBar);+ −
QRect r = _r;+ −
r.moveTopLeft(q->mapToGlobal(QPoint(0, 0)));+ −
setWindowState(true, true, r);+ −
layout->setExpanded(false);+ −
}+ −
+ −
void QToolBarPrivate::plug(const QRect &r)+ −
{+ −
setWindowState(false, false, r);+ −
}+ −
+ −
/******************************************************************************+ −
** QToolBar+ −
*/+ −
+ −
/*!+ −
\class QToolBar+ −
+ −
\brief The QToolBar class provides a movable panel that contains a+ −
set of controls.+ −
+ −
\ingroup mainwindow-classes+ −
+ −
+ −
Toolbar buttons are added by adding \e actions, using addAction()+ −
or insertAction(). Groups of buttons can be separated using+ −
addSeparator() or insertSeparator(). If a toolbar button is not+ −
appropriate, a widget can be inserted instead using addWidget() or+ −
insertWidget(); examples of suitable widgets are QSpinBox,+ −
QDoubleSpinBox, and QComboBox. When a toolbar button is pressed it+ −
emits the actionTriggered() signal.+ −
+ −
A toolbar can be fixed in place in a particular area (e.g. at the+ −
top of the window), or it can be movable (isMovable()) between+ −
toolbar areas; see allowedAreas() and isAreaAllowed().+ −
+ −
When a toolbar is resized in such a way that it is too small to+ −
show all the items it contains, an extension button will appear as+ −
the last item in the toolbar. Pressing the extension button will+ −
pop up a menu containing the items that does not currently fit in+ −
the toolbar.+ −
+ −
When a QToolBar is not a child of a QMainWindow, it looses the ability+ −
to populate the extension pop up with widgets added to the toolbar using+ −
addWidget(). Please use widget actions created by inheriting QWidgetAction+ −
and implementing QWidgetAction::createWidget() instead.+ −
+ −
\sa QToolButton, QMenu, QAction, {Application Example}+ −
*/+ −
+ −
/*!+ −
\fn bool QToolBar::isAreaAllowed(Qt::ToolBarArea area) const+ −
+ −
Returns true if this toolbar is dockable in the given \a area;+ −
otherwise returns false.+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::addAction(QAction *action)+ −
\overload+ −
+ −
Appends the action \a action to the toolbar's list of actions.+ −
+ −
\sa QMenu::addAction(), QWidget::addAction()+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::actionTriggered(QAction *action)+ −
+ −
This signal is emitted when an action in this toolbar is triggered.+ −
This happens when the action's tool button is pressed, or when the+ −
action is triggered in some other way outside the tool bar. The parameter+ −
holds the triggered \a action.+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::allowedAreasChanged(Qt::ToolBarAreas allowedAreas)+ −
+ −
This signal is emitted when the collection of allowed areas for the+ −
toolbar is changed. The new areas in which the toolbar can be positioned+ −
are specified by \a allowedAreas.+ −
+ −
\sa allowedAreas+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::iconSizeChanged(const QSize &iconSize)+ −
+ −
This signal is emitted when the icon size is changed. The \a+ −
iconSize parameter holds the toolbar's new icon size.+ −
+ −
\sa iconSize QMainWindow::iconSize+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::movableChanged(bool movable)+ −
+ −
This signal is emitted when the toolbar becomes movable or fixed.+ −
If the toolbar can be moved, \a movable is true; otherwise it is+ −
false.+ −
+ −
\sa movable+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::orientationChanged(Qt::Orientation orientation)+ −
+ −
This signal is emitted when the orientation of the toolbar changes.+ −
The new orientation is specified by the \a orientation given.+ −
+ −
\sa orientation+ −
*/+ −
+ −
/*!+ −
\fn void QToolBar::toolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle)+ −
+ −
This signal is emitted when the tool button style is changed. The+ −
\a toolButtonStyle parameter holds the toolbar's new tool button+ −
style.+ −
+ −
\sa toolButtonStyle QMainWindow::toolButtonStyle+ −
*/+ −
+ −
/*!+ −
\since 4.6+ −
+ −
\fn void QToolBar::topLevelChanged(bool topLevel)+ −
+ −
This signal is emitted when the \l floating property changes.+ −
The \a topLevel parameter is true if the toolbar is now floating;+ −
otherwise it is false.+ −
+ −
\sa isWindow()+ −
*/+ −
+ −
+ −
/*!+ −
Constructs a QToolBar with the given \a parent.+ −
*/+ −
QToolBar::QToolBar(QWidget *parent)+ −
: QWidget(*new QToolBarPrivate, parent, 0)+ −
{+ −
Q_D(QToolBar);+ −
d->init();+ −
}+ −
+ −
/*!+ −
Constructs a QToolBar with the given \a parent.+ −
+ −
The given window \a title identifies the toolbar and is shown in+ −
the context menu provided by QMainWindow.+ −
+ −
\sa setWindowTitle()+ −
*/+ −
QToolBar::QToolBar(const QString &title, QWidget *parent)+ −
: QWidget(*new QToolBarPrivate, parent, 0)+ −
{+ −
Q_D(QToolBar);+ −
d->init();+ −
setWindowTitle(title);+ −
}+ −
+ −
#ifdef QT3_SUPPORT+ −
/*! \obsolete+ −
Constructs a QToolBar with the given \a parent and \a name.+ −
*/+ −
QToolBar::QToolBar(QWidget *parent, const char *name)+ −
: QWidget(*new QToolBarPrivate, parent, 0)+ −
{+ −
Q_D(QToolBar);+ −
d->init();+ −
setObjectName(QString::fromAscii(name));+ −
}+ −
#endif+ −
+ −
/*!+ −
Destroys the toolbar.+ −
*/+ −
QToolBar::~QToolBar()+ −
{+ −
// Remove the toolbar button if there is nothing left.+ −
QMainWindow *mainwindow = qobject_cast<QMainWindow *>(parentWidget());+ −
if (mainwindow) {+ −
#ifdef Q_WS_MAC+ −
QMainWindowLayout *mainwin_layout = qobject_cast<QMainWindowLayout *>(mainwindow->layout());+ −
if (mainwin_layout && mainwin_layout->layoutState.toolBarAreaLayout.isEmpty()+ −
&& mainwindow->testAttribute(Qt::WA_WState_Created))+ −
macWindowToolbarShow(mainwindow, false);+ −
#endif+ −
}+ −
}+ −
+ −
/*! \property QToolBar::movable+ −
\brief whether the user can move the toolbar within the toolbar area,+ −
or between toolbar areas+ −
+ −
By default, this property is true.+ −
+ −
This property only makes sense if the toolbar is in a+ −
QMainWindow.+ −
+ −
\sa allowedAreas+ −
*/+ −
+ −
void QToolBar::setMovable(bool movable)+ −
{+ −
Q_D(QToolBar);+ −
if (!movable == !d->movable)+ −
return;+ −
d->movable = movable;+ −
d->layout->invalidate();+ −
emit movableChanged(d->movable);+ −
}+ −
+ −
bool QToolBar::isMovable() const+ −
{+ −
Q_D(const QToolBar);+ −
return d->movable;+ −
}+ −
+ −
/*!+ −
\property QToolBar::floatable+ −
\brief whether the toolbar can be dragged and dropped as an independent window.+ −
+ −
The default is true.+ −
*/+ −
bool QToolBar::isFloatable() const+ −
{+ −
Q_D(const QToolBar);+ −
return d->floatable;+ −
}+ −
+ −
void QToolBar::setFloatable(bool floatable)+ −
{+ −
Q_D(QToolBar);+ −
d->floatable = floatable;+ −
}+ −
+ −
/*!+ −
\property QToolBar::floating+ −
\brief whether the toolbar is an independent window.+ −
+ −
By default, this property is true.+ −
+ −
\sa QWidget::isWindow()+ −
*/+ −
bool QToolBar::isFloating() const+ −
{+ −
return isWindow();+ −
}+ −
+ −
/*!+ −
\property QToolBar::allowedAreas+ −
\brief areas where the toolbar may be placed+ −
+ −
The default is Qt::AllToolBarAreas.+ −
+ −
This property only makes sense if the toolbar is in a+ −
QMainWindow.+ −
+ −
\sa movable+ −
*/+ −
+ −
void QToolBar::setAllowedAreas(Qt::ToolBarAreas areas)+ −
{+ −
Q_D(QToolBar);+ −
areas &= Qt::ToolBarArea_Mask;+ −
if (areas == d->allowedAreas)+ −
return;+ −
d->allowedAreas = areas;+ −
emit allowedAreasChanged(d->allowedAreas);+ −
}+ −
+ −
Qt::ToolBarAreas QToolBar::allowedAreas() const+ −
{+ −
Q_D(const QToolBar);+ −
#ifdef Q_WS_MAC+ −
if (QMainWindow *window = qobject_cast<QMainWindow *>(parentWidget())) {+ −
if (window->unifiedTitleAndToolBarOnMac()) // Don't allow drags to the top (for now).+ −
return (d->allowedAreas & ~Qt::TopToolBarArea);+ −
}+ −
#endif+ −
return d->allowedAreas;+ −
}+ −
+ −
/*! \property QToolBar::orientation+ −
\brief orientation of the toolbar+ −
+ −
The default is Qt::Horizontal.+ −
+ −
This function should not be used when the toolbar is managed+ −
by QMainWindow. You can use QMainWindow::addToolBar() or+ −
QMainWindow::insertToolBar() if you wish to move a toolbar (that+ −
is already added to a main window) to another Qt::ToolBarArea.+ −
*/+ −
+ −
void QToolBar::setOrientation(Qt::Orientation orientation)+ −
{+ −
Q_D(QToolBar);+ −
if (orientation == d->orientation)+ −
return;+ −
+ −
d->orientation = orientation;+ −
+ −
if (orientation == Qt::Vertical)+ −
setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred));+ −
else+ −
setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));+ −
+ −
d->layout->invalidate();+ −
d->layout->activate();+ −
+ −
emit orientationChanged(d->orientation);+ −
}+ −
+ −
Qt::Orientation QToolBar::orientation() const+ −
{ Q_D(const QToolBar); return d->orientation; }+ −
+ −
/*!+ −
\property QToolBar::iconSize+ −
\brief size of icons in the toolbar.+ −
+ −
The default size is determined by the application's style and is+ −
derived from the QStyle::PM_ToolBarIconSize pixel metric. It is+ −
the maximum size an icon can have. Icons of smaller size will not+ −
be scaled up.+ −
*/+ −
+ −
QSize QToolBar::iconSize() const+ −
{ Q_D(const QToolBar); return d->iconSize; }+ −
+ −
void QToolBar::setIconSize(const QSize &iconSize)+ −
{+ −
Q_D(QToolBar);+ −
QSize sz = iconSize;+ −
if (!sz.isValid()) {+ −
QMainWindow *mw = qobject_cast<QMainWindow *>(parentWidget());+ −
if (mw && mw->layout()) {+ −
QLayout *layout = mw->layout();+ −
int i = 0;+ −
QLayoutItem *item = 0;+ −
do {+ −
item = layout->itemAt(i++);+ −
if (item && (item->widget() == this))+ −
sz = mw->iconSize();+ −
} while (!sz.isValid() && item != 0);+ −
}+ −
}+ −
if (!sz.isValid()) {+ −
const int metric = style()->pixelMetric(QStyle::PM_ToolBarIconSize, 0, this);+ −
sz = QSize(metric, metric);+ −
}+ −
if (d->iconSize != sz) {+ −
d->iconSize = sz;+ −
setMinimumSize(0, 0);+ −
emit iconSizeChanged(d->iconSize);+ −
}+ −
d->explicitIconSize = iconSize.isValid();+ −
+ −
d->layout->invalidate();+ −
}+ −
+ −
/*!+ −
\property QToolBar::toolButtonStyle+ −
\brief the style of toolbar buttons+ −
+ −
This property defines the style of all tool buttons that are added+ −
as \l{QAction}s. Note that if you add a QToolButton with the+ −
addWidget() method, it will not get this button style.+ −
+ −
The default is Qt::ToolButtonIconOnly.+ −
*/+ −
+ −
Qt::ToolButtonStyle QToolBar::toolButtonStyle() const+ −
{ Q_D(const QToolBar); return d->toolButtonStyle; }+ −
+ −
void QToolBar::setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle)+ −
{+ −
Q_D(QToolBar);+ −
d->explicitToolButtonStyle = true;+ −
if (d->toolButtonStyle == toolButtonStyle)+ −
return;+ −
d->toolButtonStyle = toolButtonStyle;+ −
setMinimumSize(0, 0);+ −
emit toolButtonStyleChanged(d->toolButtonStyle);+ −
}+ −
+ −
/*!+ −
Removes all actions from the toolbar.+ −
+ −
\sa removeAction()+ −
*/+ −
void QToolBar::clear()+ −
{+ −
QList<QAction *> actions = this->actions();+ −
for(int i = 0; i < actions.size(); i++)+ −
removeAction(actions.at(i));+ −
}+ −
+ −
/*!+ −
\overload+ −
+ −
Creates a new action with the given \a text. This action is added to+ −
the end of the toolbar.+ −
*/+ −
QAction *QToolBar::addAction(const QString &text)+ −
{+ −
QAction *action = new QAction(text, this);+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
\overload+ −
+ −
Creates a new action with the given \a icon and \a text. This+ −
action is added to the end of the toolbar.+ −
*/+ −
QAction *QToolBar::addAction(const QIcon &icon, const QString &text)+ −
{+ −
QAction *action = new QAction(icon, text, this);+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
\overload+ −
+ −
Creates a new action with the given \a text. This action is added to+ −
the end of the toolbar. The action's \link QAction::triggered()+ −
triggered()\endlink signal is connected to \a member in \a+ −
receiver.+ −
*/+ −
QAction *QToolBar::addAction(const QString &text,+ −
const QObject *receiver, const char* member)+ −
{+ −
QAction *action = new QAction(text, this);+ −
QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
\overload+ −
+ −
Creates a new action with the icon \a icon and text \a text. This+ −
action is added to the end of the toolbar. The action's \link+ −
QAction::triggered() triggered()\endlink signal is connected to \a+ −
member in \a receiver.+ −
*/+ −
QAction *QToolBar::addAction(const QIcon &icon, const QString &text,+ −
const QObject *receiver, const char* member)+ −
{+ −
QAction *action = new QAction(icon, text, this);+ −
QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
Adds a separator to the end of the toolbar.+ −
+ −
\sa insertSeparator()+ −
*/+ −
QAction *QToolBar::addSeparator()+ −
{+ −
QAction *action = new QAction(this);+ −
action->setSeparator(true);+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
Inserts a separator into the toolbar in front of the toolbar+ −
item associated with the \a before action.+ −
+ −
\sa addSeparator()+ −
*/+ −
QAction *QToolBar::insertSeparator(QAction *before)+ −
{+ −
QAction *action = new QAction(this);+ −
action->setSeparator(true);+ −
insertAction(before, action);+ −
return action;+ −
}+ −
+ −
/*!+ −
Adds the given \a widget to the toolbar as the toolbar's last+ −
item.+ −
+ −
The toolbar takes ownership of \a widget.+ −
+ −
If you add a QToolButton with this method, the tools bar's+ −
Qt::ToolButtonStyle will not be respected.+ −
+ −
\note You should use QAction::setVisible() to change the+ −
visibility of the widget. Using QWidget::setVisible(),+ −
QWidget::show() and QWidget::hide() does not work.+ −
+ −
\sa insertWidget()+ −
*/+ −
QAction *QToolBar::addWidget(QWidget *widget)+ −
{+ −
QWidgetAction *action = new QWidgetAction(this);+ −
action->setDefaultWidget(widget);+ −
action->d_func()->autoCreated = true;+ −
addAction(action);+ −
return action;+ −
}+ −
+ −
/*!+ −
Inserts the given \a widget in front of the toolbar item+ −
associated with the \a before action.+ −
+ −
Note: You should use QAction::setVisible() to change the+ −
visibility of the widget. Using QWidget::setVisible(),+ −
QWidget::show() and QWidget::hide() does not work.+ −
+ −
\sa addWidget()+ −
*/+ −
QAction *QToolBar::insertWidget(QAction *before, QWidget *widget)+ −
{+ −
QWidgetAction *action = new QWidgetAction(this);+ −
action->setDefaultWidget(widget);+ −
action->d_func()->autoCreated = true;+ −
insertAction(before, action);+ −
return action;+ −
}+ −
+ −
/*!+ −
\internal+ −
+ −
Returns the geometry of the toolbar item associated with the given+ −
\a action, or an invalid QRect if no matching item is found.+ −
*/+ −
QRect QToolBar::actionGeometry(QAction *action) const+ −
{+ −
Q_D(const QToolBar);+ −
+ −
int index = d->layout->indexOf(action);+ −
if (index == -1)+ −
return QRect();+ −
return d->layout->itemAt(index)->widget()->geometry();+ −
}+ −
+ −
/*!+ −
Returns the action at point \a p. This function returns zero if no+ −
action was found.+ −
+ −
\sa QWidget::childAt()+ −
*/+ −
QAction *QToolBar::actionAt(const QPoint &p) const+ −
{+ −
Q_D(const QToolBar);+ −
QWidget *widget = childAt(p);+ −
int index = d->layout->indexOf(widget);+ −
if (index == -1)+ −
return 0;+ −
QLayoutItem *item = d->layout->itemAt(index);+ −
return static_cast<QToolBarItem*>(item)->action;+ −
}+ −
+ −
/*! \fn QAction *QToolBar::actionAt(int x, int y) const+ −
\overload+ −
+ −
Returns the action at the point \a x, \a y. This function returns+ −
zero if no action was found.+ −
*/+ −
+ −
/*! \reimp */+ −
void QToolBar::actionEvent(QActionEvent *event)+ −
{+ −
Q_D(QToolBar);+ −
QAction *action = event->action();+ −
QWidgetAction *widgetAction = qobject_cast<QWidgetAction *>(action);+ −
+ −
switch (event->type()) {+ −
case QEvent::ActionAdded: {+ −
Q_ASSERT_X(widgetAction == 0 || d->layout->indexOf(widgetAction) == -1,+ −
"QToolBar", "widgets cannot be inserted multiple times");+ −
+ −
// reparent the action to this toolbar if it has been created+ −
// using the addAction(text) etc. convenience functions, to+ −
// preserve Qt 4.1.x behavior. The widget is already+ −
// reparented to us due to the createWidget call inside+ −
// createItem()+ −
if (widgetAction != 0 && widgetAction->d_func()->autoCreated)+ −
widgetAction->setParent(this);+ −
+ −
int index = d->layout->count();+ −
if (event->before()) {+ −
index = d->layout->indexOf(event->before());+ −
Q_ASSERT_X(index != -1, "QToolBar::insertAction", "internal error");+ −
}+ −
d->layout->insertAction(index, action);+ −
break;+ −
}+ −
+ −
case QEvent::ActionChanged:+ −
d->layout->invalidate();+ −
break;+ −
+ −
case QEvent::ActionRemoved: {+ −
int index = d->layout->indexOf(action);+ −
if (index != -1) {+ −
delete d->layout->takeAt(index);+ −
}+ −
break;+ −
}+ −
+ −
default:+ −
Q_ASSERT_X(false, "QToolBar::actionEvent", "internal error");+ −
}+ −
}+ −
+ −
/*! \reimp */+ −
void QToolBar::changeEvent(QEvent *event)+ −
{+ −
Q_D(QToolBar);+ −
switch (event->type()) {+ −
case QEvent::WindowTitleChange:+ −
d->toggleViewAction->setText(windowTitle());+ −
break;+ −
case QEvent::StyleChange:+ −
d->layout->invalidate();+ −
if (!d->explicitIconSize)+ −
setIconSize(QSize());+ −
d->layout->updateMarginAndSpacing();+ −
break;+ −
case QEvent::LayoutDirectionChange:+ −
d->layout->invalidate();+ −
break;+ −
default:+ −
break;+ −
}+ −
QWidget::changeEvent(event);+ −
}+ −
+ −
/*! \reimp */+ −
void QToolBar::paintEvent(QPaintEvent *)+ −
{+ −
Q_D(QToolBar);+ −
+ −
QPainter p(this);+ −
QStyle *style = this->style();+ −
QStyleOptionToolBar opt;+ −
initStyleOption(&opt);+ −
+ −
if (d->layout->expanded || d->layout->animating || isWindow()) {+ −
//if the toolbar is expended, we need to fill the background with the window color+ −
//because some styles may expects that.+ −
p.fillRect(opt.rect, palette().background());+ −
style->drawControl(QStyle::CE_ToolBar, &opt, &p, this);+ −
style->drawPrimitive(QStyle::PE_FrameMenu, &opt, &p, this);+ −
} else {+ −
style->drawControl(QStyle::CE_ToolBar, &opt, &p, this);+ −
}+ −
+ −
opt.rect = style->subElementRect(QStyle::SE_ToolBarHandle, &opt, this);+ −
if (opt.rect.isValid())+ −
style->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this);+ −
}+ −
+ −
/*+ −
Checks if an expanded toolbar has to wait for this popup to close before+ −
the toolbar collapses. This is true if+ −
1) the popup has the toolbar in its parent chain,+ −
2) the popup is a menu whose menuAction is somewhere in the toolbar.+ −
*/+ −
static bool waitForPopup(QToolBar *tb, QWidget *popup)+ −
{+ −
if (popup == 0 || popup->isHidden())+ −
return false;+ −
+ −
QWidget *w = popup;+ −
while (w != 0) {+ −
if (w == tb)+ −
return true;+ −
w = w->parentWidget();+ −
}+ −
+ −
QMenu *menu = qobject_cast<QMenu*>(popup);+ −
if (menu == 0)+ −
return false;+ −
+ −
QAction *action = menu->menuAction();+ −
QList<QWidget*> widgets = action->associatedWidgets();+ −
for (int i = 0; i < widgets.count(); ++i) {+ −
if (waitForPopup(tb, widgets.at(i)))+ −
return true;+ −
}+ −
+ −
return false;+ −
}+ −
+ −
#if defined(Q_WS_MAC)+ −
static bool toolbarInUnifiedToolBar(QToolBar *toolbar)+ −
{+ −
const QMainWindow *mainWindow = qobject_cast<const QMainWindow *>(toolbar->parentWidget());+ −
return mainWindow && mainWindow->unifiedTitleAndToolBarOnMac()+ −
&& mainWindow->toolBarArea(toolbar) == Qt::TopToolBarArea;+ −
}+ −
#endif+ −
+ −
/*! \reimp */+ −
bool QToolBar::event(QEvent *event)+ −
{+ −
Q_D(QToolBar);+ −
+ −
switch (event->type()) {+ −
case QEvent::Timer:+ −
if (d->waitForPopupTimer.timerId() == static_cast<QTimerEvent*>(event)->timerId()) {+ −
QWidget *w = QApplication::activePopupWidget();+ −
if (!waitForPopup(this, w)) {+ −
d->waitForPopupTimer.stop();+ −
if (!this->underMouse())+ −
d->layout->setExpanded(false);+ −
}+ −
}+ −
break;+ −
case QEvent::Hide:+ −
if (!isHidden())+ −
break;+ −
// fallthrough intended+ −
case QEvent::Show:+ −
d->toggleViewAction->setChecked(event->type() == QEvent::Show);+ −
#if defined(Q_WS_MAC)+ −
if (toolbarInUnifiedToolBar(this)) {+ −
// I can static_cast because I did the qobject_cast in the if above, therefore+ −
// we must have a QMainWindowLayout here.+ −
QMainWindowLayout *mwLayout = static_cast<QMainWindowLayout *>(parentWidget()->layout());+ −
mwLayout->fixSizeInUnifiedToolbar(this);+ −
mwLayout->syncUnifiedToolbarVisibility();+ −
}+ −
# if !defined(QT_MAC_USE_COCOA)+ −
// Fall through+ −
case QEvent::LayoutRequest: {+ −
// There's currently no way to invalidate the size and let+ −
// HIToolbar know about it. This forces a re-check.+ −
int earlyResult = -1;+ −
if (QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget())) {+ −
bool needUpdate = true;+ −
if (event->type() == QEvent::LayoutRequest) {+ −
QSize oldSizeHint = sizeHint();+ −
earlyResult = QWidget::event(event) ? 1 : 0;+ −
needUpdate = oldSizeHint != sizeHint();+ −
}+ −
+ −
if (needUpdate) {+ −
OSWindowRef windowRef = qt_mac_window_for(mainWindow);+ −
if (toolbarInUnifiedToolBar(this)+ −
&& macWindowToolbarIsVisible(windowRef)) {+ −
DisableScreenUpdates();+ −
macWindowToolbarShow(this, false);+ −
macWindowToolbarShow(this, true);+ −
EnableScreenUpdates();+ −
}+ −
}+ −
+ −
if (earlyResult != -1)+ −
return earlyResult;+ −
}+ −
}+ −
# endif // !QT_MAC_USE_COCOA+ −
#endif // Q_WS_MAC+ −
break;+ −
case QEvent::ParentChange:+ −
d->layout->checkUsePopupMenu();+ −
#if defined(Q_WS_MAC)+ −
if (parentWidget() && parentWidget()->isWindow())+ −
qt_mac_updateToolBarButtonHint(parentWidget());+ −
#endif+ −
break;+ −
+ −
case QEvent::MouseButtonPress: {+ −
if (d->mousePressEvent(static_cast<QMouseEvent*>(event)))+ −
return true;+ −
break;+ −
}+ −
case QEvent::MouseButtonRelease:+ −
if (d->mouseReleaseEvent(static_cast<QMouseEvent*>(event)))+ −
return true;+ −
break;+ −
case QEvent::HoverEnter:+ −
case QEvent::HoverLeave:+ −
// there's nothing special to do here and we don't want to update the whole widget+ −
return true;+ −
case QEvent::HoverMove: {+ −
#ifndef QT_NO_CURSOR+ −
QHoverEvent *e = static_cast<QHoverEvent*>(event);+ −
QStyleOptionToolBar opt;+ −
initStyleOption(&opt);+ −
if (style()->subElementRect(QStyle::SE_ToolBarHandle, &opt, this).contains(e->pos()))+ −
setCursor(Qt::SizeAllCursor);+ −
else+ −
unsetCursor();+ −
#endif+ −
break;+ −
}+ −
case QEvent::MouseMove:+ −
if (d->mouseMoveEvent(static_cast<QMouseEvent*>(event)))+ −
return true;+ −
break;+ −
#ifdef Q_WS_WINCE+ −
case QEvent::ContextMenu:+ −
{+ −
QContextMenuEvent* contextMenuEvent = static_cast<QContextMenuEvent*>(event);+ −
QWidget* child = childAt(contextMenuEvent->pos());+ −
QAbstractButton* button = qobject_cast<QAbstractButton*>(child);+ −
if (button)+ −
button->setDown(false);+ −
}+ −
break;+ −
#endif+ −
case QEvent::Leave:+ −
if (d->state != 0 && d->state->dragging) {+ −
#ifdef Q_OS_WIN+ −
// This is a workaround for loosing the mouse on Vista.+ −
QPoint pos = QCursor::pos();+ −
QMouseEvent fake(QEvent::MouseMove, mapFromGlobal(pos), pos, Qt::NoButton,+ −
QApplication::mouseButtons(), QApplication::keyboardModifiers());+ −
d->mouseMoveEvent(&fake);+ −
#endif+ −
} else {+ −
if (!d->layout->expanded)+ −
break;+ −
+ −
QWidget *w = QApplication::activePopupWidget();+ −
if (waitForPopup(this, w)) {+ −
d->waitForPopupTimer.start(POPUP_TIMER_INTERVAL, this);+ −
break;+ −
}+ −
+ −
d->waitForPopupTimer.stop();+ −
d->layout->setExpanded(false);+ −
break;+ −
}+ −
default:+ −
break;+ −
}+ −
return QWidget::event(event);+ −
}+ −
+ −
/*!+ −
Returns a checkable action that can be used to show or hide this+ −
toolbar.+ −
+ −
The action's text is set to the toolbar's window title.+ −
+ −
\sa QAction::text QWidget::windowTitle+ −
*/+ −
QAction *QToolBar::toggleViewAction() const+ −
{ Q_D(const QToolBar); return d->toggleViewAction; }+ −
+ −
/*!+ −
\fn void QToolBar::setLabel(const QString &label)+ −
+ −
Use setWindowTitle() instead.+ −
*/+ −
+ −
/*!+ −
\fn QString QToolBar::label() const+ −
+ −
Use windowTitle() instead.+ −
*/+ −
+ −
/*!+ −
\since 4.2+ −
+ −
Returns the widget associated with the specified \a action.+ −
+ −
\sa addWidget()+ −
*/+ −
QWidget *QToolBar::widgetForAction(QAction *action) const+ −
{+ −
Q_D(const QToolBar);+ −
+ −
int index = d->layout->indexOf(action);+ −
if (index == -1)+ −
return 0;+ −
+ −
return d->layout->itemAt(index)->widget();+ −
}+ −
+ −
/*!+ −
\internal+ −
*/+ −
void QToolBar::initStyleOption(QStyleOptionToolBar *option) const+ −
{+ −
Q_D(const QToolBar);+ −
+ −
if (!option)+ −
return;+ −
+ −
option->initFrom(this);+ −
if (orientation() == Qt::Horizontal)+ −
option->state |= QStyle::State_Horizontal;+ −
option->lineWidth = style()->pixelMetric(QStyle::PM_ToolBarFrameWidth, 0, this);+ −
option->features = d->layout->movable()+ −
? QStyleOptionToolBar::Movable+ −
: QStyleOptionToolBar::None;+ −
// if the tool bar is not in a QMainWindow, this will make the painting right+ −
option->toolBarArea = Qt::NoToolBarArea;+ −
+ −
// Add more styleoptions if the toolbar has been added to a mainwindow.+ −
QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());+ −
+ −
if (!mainWindow)+ −
return;+ −
+ −
QMainWindowLayout *layout = qobject_cast<QMainWindowLayout *>(mainWindow->layout());+ −
Q_ASSERT_X(layout != 0, "QToolBar::initStyleOption()",+ −
"QMainWindow->layout() != QMainWindowLayout");+ −
+ −
layout->getStyleOptionInfo(option, const_cast<QToolBar *>(this));+ −
}+ −
+ −
/*!+ −
\reimp+ −
*/+ −
void QToolBar::childEvent(QChildEvent *event) // ### remove me in 5.0+ −
{+ −
QWidget::childEvent(event);+ −
}+ −
+ −
/*!+ −
\reimp+ −
*/+ −
void QToolBar::resizeEvent(QResizeEvent *event) // ### remove me in 5.0+ −
{+ −
QWidget::resizeEvent(event);+ −
}+ −
+ −
QT_END_NAMESPACE+ −
+ −
#include "moc_qtoolbar.cpp"+ −
+ −
#endif // QT_NO_TOOLBAR+ −