Main Window | Qt Widgets 5.13.0

Qt 5.13 | Qt Widgets | Main Window

Qt 5.13.0 Reference Documentation

# Main Window

      /****************************************************************************
      **
      ** Copyright (C) 2016 The Qt Company Ltd.
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the demonstration applications of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** 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 https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/

      #include "toolbar.h"

      #include <QRandomGenerator>

      #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, qreal pixelRatio)
      {
          int w = qRound(iconSize.width() * pixelRatio);
          int h = qRound(iconSize.height() * pixelRatio);

          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);

          QPixmap pm = QPixmap::fromImage(image, Qt::DiffuseDither | Qt::DiffuseAlphaDither);
          pm.setDevicePixelRatio(pixelRatio);
          return pm;
      }

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

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

          setIconSize(QSize(32, 32));

          qreal dpr = devicePixelRatioF();
          menu = new QMenu("One", this);
          menu->setIcon(genIcon(iconSize(), 1, Qt::black, dpr));
          menu->addAction(genIcon(iconSize(), "A", Qt::blue, dpr), "A");
          menu->addAction(genIcon(iconSize(), "B", Qt::blue, dpr), "B");
          menu->addAction(genIcon(iconSize(), "C", Qt::blue, dpr), "C");
          addAction(menu->menuAction());

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

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

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

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

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

          movableAction = new QAction(tr("Movable"), this);
          movableAction->setCheckable(true);
          connect(movableAction, &QAction::triggered, this, &ToolBar::changeMovable);

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

          allowLeftAction = new QAction(tr("Allow on Left"), this);
          allowLeftAction->setCheckable(true);
          connect(allowLeftAction, &QAction::triggered, this, &ToolBar::allowLeft);

          allowRightAction = new QAction(tr("Allow on Right"), this);
          allowRightAction->setCheckable(true);
          connect(allowRightAction, &QAction::triggered, this, &ToolBar::allowRight);

          allowTopAction = new QAction(tr("Allow on Top"), this);
          allowTopAction->setCheckable(true);
          connect(allowTopAction, &QAction::triggered, this, &ToolBar::allowTop);

          allowBottomAction = new QAction(tr("Allow on Bottom"), this);
          allowBottomAction->setCheckable(true);
          connect(allowBottomAction, &QAction::triggered, this, &ToolBar::allowBottom);

          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, &QAction::triggered, this, &ToolBar::placeLeft);

          rightAction = new QAction(tr("Place on Right") , this);
          rightAction->setCheckable(true);
          connect(rightAction, &QAction::triggered, this, &ToolBar::placeRight);

          topAction = new QAction(tr("Place on Top") , this);
          topAction->setCheckable(true);
          connect(topAction, &QAction::triggered, this, &ToolBar::placeTop);

          bottomAction = new QAction(tr("Place on Bottom") , this);
          bottomAction->setCheckable(true);
          connect(bottomAction, &QAction::triggered, this, &ToolBar::placeBottom);

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

          connect(movableAction, &QAction::triggered, areaActions, &QActionGroup::setEnabled);

          connect(movableAction, &QAction::triggered, allowedAreasActions, &QActionGroup::setEnabled);

          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(tr("Insert break"), this, &ToolBar::insertToolBarBreak);

          connect(menu, &QMenu::aboutToShow, this, &ToolBar::updateMenu);

          randomize();
      }

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

          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;
          QList<QAction *> actions1 = actions();
          const QList<QAction *> childActions = findChildren<QAction *>();
          for (QAction *action : childActions) {
              if (!actions1.contains(action))
                  continue;
              actions1.removeAll(action);
              ordered.append(action);
          }

          clear();
          addActions(ordered);

          orderAction->setEnabled(false);
      }

      void ToolBar::randomize()
      {
          QList<QAction *> randomized;
          QList<QAction *> actions = this->actions();
          while (!actions.isEmpty()) {
              QAction *action = actions.takeAt(QRandomGenerator::global()->bounded(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);

          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);

          mainWindow->insertToolBarBreak(this);
      }