qt-everywhere-src-5.14.1/qtbase/examples/widgets/mainwindows/mainwindow/toolbar.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** 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);
 }
	/****************************************************************************
	**
	** 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);
	}