/****************************************************************************
 **
 ** Copyright (C) 2004-2007 Trolltech ASA. All rights reserved.
 **
 ** This file is part of the demonstration applications of the Qt Toolkit.
 **
 ** This file may be used under the terms of the GNU General Public
 ** License version 2.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 GNU
 ** General Public Licensing requirements will be met:
 ** http://trolltech.com/products/qt/licenses/licensing/opensource/
 **
 ** If you are unsure which license is appropriate for your use, please
 ** review the following information:
 ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
 ** or contact the sales department at sales@trolltech.com.
 **
 ** In addition, as a special exception, Trolltech gives you certain
 ** additional rights. These rights are described in the Trolltech GPL
 ** Exception version 1.0, which can be found at
 ** http://www.trolltech.com/products/qt/gplexception/ and in the file
 ** GPL_EXCEPTION.txt in this package.
 **
 ** In addition, as a special exception, Trolltech, as the sole copyright
 ** holder for Qt Designer, grants users of the Qt/Eclipse Integration
 ** plug-in the right for the Qt/Eclipse Integration to link to
 ** functionality provided by Qt Designer and its related libraries.
 **
 ** Trolltech reserves all rights not expressly granted herein.
 **
 ** Trolltech ASA (c) 2007
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ****************************************************************************/
 
 #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();
 }