/****************************************************************************

**

** 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 demonstration applications 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 "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 = qFindChildren<QAction *>(this);

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

}