/****************************************************************************+
−
**+
−
** 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+
−