Qt Reference Documentation

- Qt 4.8
- ALL VERSIONS

- A
- A
- A
- Print

# toolbar.cpp Example File

demos/mainwindow/toolbar.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2015 The Qt Company Ltd.
     ** Contact: http://www.qt.io/licensing/
     **
     ** This file is part of the demonstration applications of the Qt Toolkit.
     **
     ** $QT_BEGIN_LICENSE:LGPL$
     ** Commercial License Usage
     ** Licensees holding valid commercial Qt licenses may use this file in
     ** accordance with the commercial license agreement provided with the
     ** Software or, alternatively, in accordance with the terms contained in
     ** a written agreement between you and The Qt Company. For licensing terms
     ** and conditions see http://www.qt.io/terms-conditions. For further
     ** information use the contact form at http://www.qt.io/contact-us.
     **
     ** 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 or version 3 as published by the Free
     ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
     ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
     ** following information to ensure the GNU Lesser General Public License
     ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
     ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
     **
     ** As a special exception, The Qt Company gives you certain additional
     ** rights. These rights are described in The Qt Company LGPL Exception
     ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
     **
     ** GNU General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License version 3.0 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.GPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU General Public License version 3.0 requirements will be
     ** met: http://www.gnu.org/copyleft/gpl.html.
     **
     ** $QT_END_LICENSE$
     **
     ****************************************************************************/

     #include "toolbar.h"

     #include <QMainWindow>
     #include <QMenu>
     #include <QPainter>
     #include <QPainterPath>
     #include <QSpinBox>
     #include <QLabel>
     #include <QToolTip>

     #include <stdlib.h>

     static QPixmap genIcon(const QSize &iconSize, const QString &, const QColor &color)
     {
         int w = iconSize.width();
         int h = iconSize.height();

         QImage image(w, h, QImage::Format_ARGB32_Premultiplied);
         image.fill(0);

         QPainter p(&image);

         extern void render_qt_text(QPainter *, int, int, const QColor &);
         render_qt_text(&p, w, h, color);

         return QPixmap::fromImage(image, Qt::DiffuseDither | Qt::DiffuseAlphaDither);
     }

     static QPixmap genIcon(const QSize &iconSize, int number, const QColor &color)
     { return genIcon(iconSize, QString::number(number), color); }

     ToolBar::ToolBar(const QString &title, QWidget *parent)
         : QToolBar(parent), spinbox(0), spinboxAction(0)
     {
         tip = 0;
         setWindowTitle(title);
         setObjectName(title);

         setIconSize(QSize(32, 32));

         QColor bg(palette().background().color());
         menu = new QMenu("One", this);
         menu->setIcon(genIcon(iconSize(), 1, Qt::black));
         menu->addAction(genIcon(iconSize(), "A", Qt::blue), "A");
         menu->addAction(genIcon(iconSize(), "B", Qt::blue), "B");
         menu->addAction(genIcon(iconSize(), "C", Qt::blue), "C");
         addAction(menu->menuAction());

         QAction *two = addAction(genIcon(iconSize(), 2, Qt::white), "Two");
         QFont boldFont;
         boldFont.setBold(true);
         two->setFont(boldFont);

         addAction(genIcon(iconSize(), 3, Qt::red), "Three");
         addAction(genIcon(iconSize(), 4, Qt::green), "Four");
         addAction(genIcon(iconSize(), 5, Qt::blue), "Five");
         addAction(genIcon(iconSize(), 6, Qt::yellow), "Six");
         orderAction = new QAction(this);
         orderAction->setText(tr("Order Items in Tool Bar"));
         connect(orderAction, SIGNAL(triggered()), SLOT(order()));

         randomizeAction = new QAction(this);
         randomizeAction->setText(tr("Randomize Items in Tool Bar"));
         connect(randomizeAction, SIGNAL(triggered()), SLOT(randomize()));

         addSpinBoxAction = new QAction(this);
         addSpinBoxAction->setText(tr("Add Spin Box"));
         connect(addSpinBoxAction, SIGNAL(triggered()), SLOT(addSpinBox()));

         removeSpinBoxAction = new QAction(this);
         removeSpinBoxAction->setText(tr("Remove Spin Box"));
         removeSpinBoxAction->setEnabled(false);
         connect(removeSpinBoxAction, SIGNAL(triggered()), SLOT(removeSpinBox()));

         movableAction = new QAction(tr("Movable"), this);
         movableAction->setCheckable(true);
         connect(movableAction, SIGNAL(triggered(bool)), SLOT(changeMovable(bool)));

         allowedAreasActions = new QActionGroup(this);
         allowedAreasActions->setExclusive(false);

         allowLeftAction = new QAction(tr("Allow on Left"), this);
         allowLeftAction->setCheckable(true);
         connect(allowLeftAction, SIGNAL(triggered(bool)), SLOT(allowLeft(bool)));

         allowRightAction = new QAction(tr("Allow on Right"), this);
         allowRightAction->setCheckable(true);
         connect(allowRightAction, SIGNAL(triggered(bool)), SLOT(allowRight(bool)));

         allowTopAction = new QAction(tr("Allow on Top"), this);
         allowTopAction->setCheckable(true);
         connect(allowTopAction, SIGNAL(triggered(bool)), SLOT(allowTop(bool)));

         allowBottomAction = new QAction(tr("Allow on Bottom"), this);
         allowBottomAction->setCheckable(true);
         connect(allowBottomAction, SIGNAL(triggered(bool)), SLOT(allowBottom(bool)));

         allowedAreasActions->addAction(allowLeftAction);
         allowedAreasActions->addAction(allowRightAction);
         allowedAreasActions->addAction(allowTopAction);
         allowedAreasActions->addAction(allowBottomAction);

         areaActions = new QActionGroup(this);
         areaActions->setExclusive(true);

         leftAction = new QAction(tr("Place on Left") , this);
         leftAction->setCheckable(true);
         connect(leftAction, SIGNAL(triggered(bool)), SLOT(placeLeft(bool)));

         rightAction = new QAction(tr("Place on Right") , this);
         rightAction->setCheckable(true);
         connect(rightAction, SIGNAL(triggered(bool)), SLOT(placeRight(bool)));

         topAction = new QAction(tr("Place on Top") , this);
         topAction->setCheckable(true);
         connect(topAction, SIGNAL(triggered(bool)), SLOT(placeTop(bool)));

         bottomAction = new QAction(tr("Place on Bottom") , this);
         bottomAction->setCheckable(true);
         connect(bottomAction, SIGNAL(triggered(bool)), SLOT(placeBottom(bool)));

         areaActions->addAction(leftAction);
         areaActions->addAction(rightAction);
         areaActions->addAction(topAction);
         areaActions->addAction(bottomAction);

         toolBarBreakAction = new QAction(tr("Insert break"), this);
         connect(toolBarBreakAction, SIGNAL(triggered(bool)), this, SLOT(insertToolBarBreak()));

         connect(movableAction, SIGNAL(triggered(bool)), areaActions, SLOT(setEnabled(bool)));

         connect(movableAction, SIGNAL(triggered(bool)), allowedAreasActions, SLOT(setEnabled(bool)));

         menu = new QMenu(title, this);
         menu->addAction(toggleViewAction());
         menu->addSeparator();
         menu->addAction(orderAction);
         menu->addAction(randomizeAction);
         menu->addSeparator();
         menu->addAction(addSpinBoxAction);
         menu->addAction(removeSpinBoxAction);
         menu->addSeparator();
         menu->addAction(movableAction);
         menu->addSeparator();
         menu->addActions(allowedAreasActions->actions());
         menu->addSeparator();
         menu->addActions(areaActions->actions());
         menu->addSeparator();
         menu->addAction(toolBarBreakAction);

         connect(menu, SIGNAL(aboutToShow()), this, SLOT(updateMenu()));

         randomize();
     }

     void ToolBar::updateMenu()
     {
         QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
         Q_ASSERT(mainWindow != 0);

         const Qt::ToolBarArea area = mainWindow->toolBarArea(this);
         const Qt::ToolBarAreas areas = allowedAreas();

         movableAction->setChecked(isMovable());

         allowLeftAction->setChecked(isAreaAllowed(Qt::LeftToolBarArea));
         allowRightAction->setChecked(isAreaAllowed(Qt::RightToolBarArea));
         allowTopAction->setChecked(isAreaAllowed(Qt::TopToolBarArea));
         allowBottomAction->setChecked(isAreaAllowed(Qt::BottomToolBarArea));

         if (allowedAreasActions->isEnabled()) {
             allowLeftAction->setEnabled(area != Qt::LeftToolBarArea);
             allowRightAction->setEnabled(area != Qt::RightToolBarArea);
             allowTopAction->setEnabled(area != Qt::TopToolBarArea);
             allowBottomAction->setEnabled(area != Qt::BottomToolBarArea);
         }

         leftAction->setChecked(area == Qt::LeftToolBarArea);
         rightAction->setChecked(area == Qt::RightToolBarArea);
         topAction->setChecked(area == Qt::TopToolBarArea);
         bottomAction->setChecked(area == Qt::BottomToolBarArea);

         if (areaActions->isEnabled()) {
             leftAction->setEnabled(areas & Qt::LeftToolBarArea);
             rightAction->setEnabled(areas & Qt::RightToolBarArea);
             topAction->setEnabled(areas & Qt::TopToolBarArea);
             bottomAction->setEnabled(areas & Qt::BottomToolBarArea);
         }
     }

     void ToolBar::order()
     {
         QList<QAction *> ordered, actions1 = actions(),
                                   actions2 = findChildren<QAction *>();
         while (!actions2.isEmpty()) {
             QAction *action = actions2.takeFirst();
             if (!actions1.contains(action))
                 continue;
             actions1.removeAll(action);
             ordered.append(action);
         }

         clear();
         addActions(ordered);

         orderAction->setEnabled(false);
     }

     void ToolBar::randomize()
     {
         QList<QAction *> randomized, actions = this->actions();
         while (!actions.isEmpty()) {
             QAction *action = actions.takeAt(rand() % actions.size());
             randomized.append(action);
         }
         clear();
         addActions(randomized);

         orderAction->setEnabled(true);
     }

     void ToolBar::addSpinBox()
     {
         if (!spinbox) {
             spinbox = new QSpinBox(this);
         }
         if (!spinboxAction)
             spinboxAction = addWidget(spinbox);
         else
             addAction(spinboxAction);

         addSpinBoxAction->setEnabled(false);
         removeSpinBoxAction->setEnabled(true);
     }

     void ToolBar::removeSpinBox()
     {
         if (spinboxAction)
             removeAction(spinboxAction);

         addSpinBoxAction->setEnabled(true);
         removeSpinBoxAction->setEnabled(false);
     }

     void ToolBar::allow(Qt::ToolBarArea area, bool a)
     {
         Qt::ToolBarAreas areas = allowedAreas();
         areas = a ? areas | area : areas & ~area;
         setAllowedAreas(areas);

         if (areaActions->isEnabled()) {
             leftAction->setEnabled(areas & Qt::LeftToolBarArea);
             rightAction->setEnabled(areas & Qt::RightToolBarArea);
             topAction->setEnabled(areas & Qt::TopToolBarArea);
             bottomAction->setEnabled(areas & Qt::BottomToolBarArea);
         }
     }

     void ToolBar::place(Qt::ToolBarArea area, bool p)
     {
         if (!p)
             return;

         QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
         Q_ASSERT(mainWindow != 0);

         mainWindow->addToolBar(area, this);

         if (allowedAreasActions->isEnabled()) {
             allowLeftAction->setEnabled(area != Qt::LeftToolBarArea);
             allowRightAction->setEnabled(area != Qt::RightToolBarArea);
             allowTopAction->setEnabled(area != Qt::TopToolBarArea);
             allowBottomAction->setEnabled(area != Qt::BottomToolBarArea);
         }
     }

     void ToolBar::changeMovable(bool movable)
     { setMovable(movable); }

     void ToolBar::allowLeft(bool a)
     { allow(Qt::LeftToolBarArea, a); }

     void ToolBar::allowRight(bool a)
     { allow(Qt::RightToolBarArea, a); }

     void ToolBar::allowTop(bool a)
     { allow(Qt::TopToolBarArea, a); }

     void ToolBar::allowBottom(bool a)
     { allow(Qt::BottomToolBarArea, a); }

     void ToolBar::placeLeft(bool p)
     { place(Qt::LeftToolBarArea, p); }

     void ToolBar::placeRight(bool p)
     { place(Qt::RightToolBarArea, p); }

     void ToolBar::placeTop(bool p)
     { place(Qt::TopToolBarArea, p); }

     void ToolBar::placeBottom(bool p)
     { place(Qt::BottomToolBarArea, p); }

     void ToolBar::insertToolBarBreak()
     {
         QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
         Q_ASSERT(mainWindow != 0);

         mainWindow->insertToolBarBreak(this);
     }

     void ToolBar::enterEvent(QEvent*)
     {
     /*
         These labels on top of toolbars look darn ugly

         if (tip == 0) {
             tip = new QLabel(windowTitle(), this);
             QPalette pal = tip->palette();
             QColor c = Qt::black;
             c.setAlpha(100);
             pal.setColor(QPalette::Window, c);
             pal.setColor(QPalette::Foreground, Qt::white);
             tip->setPalette(pal);
             tip->setAutoFillBackground(true);
             tip->setMargin(3);
             tip->setText(windowTitle());
         }
         QPoint c = rect().center();
         QSize hint = tip->sizeHint();
         tip->setGeometry(c.x() - hint.width()/2, c.y() - hint.height()/2,
                             hint.width(), hint.height());

         tip->show();
     */
     }

     void ToolBar::leaveEvent(QEvent*)
     {
         if (tip != 0)
             tip->hide();
     }