f9f395c28b
Updated version of LGPL and FDL licenseheaders. Apply release phase licenseheaders for all source files. Reviewed-by: Trust Me
384 lines
12 KiB
C++
384 lines
12 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
** All rights reserved.
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
|
**
|
|
** This file is part of the demonstration applications of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** GNU Lesser General Public License Usage
|
|
** 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.
|
|
**
|
|
** 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.
|
|
**
|
|
** Other Usage
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
**
|
|
**
|
|
**
|
|
**
|
|
**
|
|
** $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();
|
|
}
|