colorswatch.cpp Example File
^{demos/mainwindow/colorswatch.cpp}

    /****************************************************************************
    **
    ** Copyright (C) 2004-2006 Trolltech ASA. All rights reserved.
    **
    ** This file is part of the documentation 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://www.trolltech.com/products/qt/opensource.html
    **
    ** If you are unsure which license is appropriate for your use, please
    ** review the following information:
    ** http://www.trolltech.com/products/qt/licensing.html or contact the
    ** sales department at sales@trolltech.com.
    **
    ** 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 "colorswatch.h"

    #include <QAction>
    #include <QtEvents>
    #include <QFrame>
    #include <QMainWindow>
    #include <QMenu>
    #include <QPainter>
    #include <QImage>
    #include <QColor>
    #include <QPainterPath>
    #include <QtDebug>

    QColor bgColorForName(const QString &name)
    {
        if (name == "Black")
            return QColor("#D8D8D8");
        else if (name == "White")
            return QColor("#F1F1F1");
        else if (name == "Red")
            return QColor("#F1D8D8");
        else if (name == "Green")
            return QColor("#D8E4D8");
        else if (name == "Blue")
            return QColor("#D8D8F1");
        else if (name == "Yellow")
            return QColor("#F1F0D8");
        return QColor();
    }

    QColor fgColorForName(const QString &name)
    {
        if (name == "Black")
            return QColor("#6C6C6C");
        else if (name == "White")
            return QColor("#F8F8F8");
        else if (name == "Red")
            return QColor("#F86C6C");
        else if (name == "Green")
            return QColor("#6CB26C");
        else if (name == "Blue")
            return QColor("#6C6CF8");
        else if (name == "Yellow")
            return QColor("#F8F76C");
        return QColor();
    }

    class ColorDock : public QFrame
    {
    public:
        ColorDock(const QString &c, QWidget *parent)
            : QFrame(parent)
            , color(c)
        {
        }

    protected:
        void paintEvent(QPaintEvent *) {
            QPainter p(this);
            p.setRenderHint(QPainter::Antialiasing);
            p.fillRect(rect(), bgColorForName(color));

            extern void render_qt_text(QPainter *, int, int, const QColor &);
            render_qt_text(&p, width(), height(), fgColorForName(color));
        }

        QString color;
    };

    ColorSwatch::ColorSwatch(const QString &colorName, QWidget *parent, Qt::WFlags flags)
        : QDockWidget(parent, flags)
    {
        setObjectName(colorName + QLatin1String(" Dock Widget"));
        setWindowTitle(objectName());

        QFrame *swatch = new ColorDock(colorName, this);
        swatch->setFrameStyle(QFrame::Box | QFrame::Sunken);
        swatch->setMinimumSize(125, 75);

        setWidget(swatch);

        closableAction = new QAction(tr("Closable"), this);
        closableAction->setCheckable(true);
        connect(closableAction, SIGNAL(triggered(bool)), SLOT(changeClosable(bool)));

        movableAction = new QAction(tr("Movable"), this);
        movableAction->setCheckable(true);
        connect(movableAction, SIGNAL(triggered(bool)), SLOT(changeMovable(bool)));

        floatableAction = new QAction(tr("Floatable"), this);
        floatableAction->setCheckable(true);
        connect(floatableAction, SIGNAL(triggered(bool)), SLOT(changeFloatable(bool)));

        floatingAction = new QAction(tr("Floating"), this);
        floatingAction->setCheckable(true);
        connect(floatingAction, SIGNAL(triggered(bool)), SLOT(changeFloating(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);

        connect(movableAction, SIGNAL(triggered(bool)), areaActions, SLOT(setEnabled(bool)));

        connect(movableAction, SIGNAL(triggered(bool)), allowedAreasActions, SLOT(setEnabled(bool)));

        connect(floatableAction, SIGNAL(triggered(bool)), floatingAction, SLOT(setEnabled(bool)));

        connect(floatingAction, SIGNAL(triggered(bool)), floatableAction, SLOT(setDisabled(bool)));
        connect(movableAction, SIGNAL(triggered(bool)), floatableAction, SLOT(setEnabled(bool)));

        menu = new QMenu(colorName, this);
        menu->addAction(toggleViewAction());
        menu->addSeparator();
        menu->addAction(closableAction);
        menu->addAction(movableAction);
        menu->addAction(floatableAction);
        menu->addAction(floatingAction);
        menu->addSeparator();
        menu->addActions(allowedAreasActions->actions());
        menu->addSeparator();
        menu->addActions(areaActions->actions());

        if(colorName == "Black") {
            leftAction->setShortcut(Qt::CTRL|Qt::Key_W);
            rightAction->setShortcut(Qt::CTRL|Qt::Key_E);
            toggleViewAction()->setShortcut(Qt::CTRL|Qt::Key_R);
        }
    }

    void ColorSwatch::contextMenuEvent(QContextMenuEvent *event)
    {
        event->accept();
        menu->exec(event->globalPos());
    }

    bool ColorSwatch::event(QEvent *e)
    {
        if (e->type() != QEvent::Polish)
            return QDockWidget::event(e);

        QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
        const Qt::DockWidgetArea area = mainWindow->dockWidgetArea(this);
        const Qt::DockWidgetAreas areas = allowedAreas();

        closableAction->setChecked(features() & QDockWidget::DockWidgetClosable);
        if (windowType() == Qt::Drawer) {
            floatableAction->setEnabled(false);
            floatingAction->setEnabled(false);
            movableAction->setEnabled(false);
        } else {
            floatableAction->setChecked(features() & QDockWidget::DockWidgetFloatable);
            floatingAction->setChecked(isWindow());
            // done after floating, to get 'floatable' correctly initialized
            movableAction->setChecked(features() & QDockWidget::DockWidgetMovable);
        }

        allowLeftAction->setChecked(isAreaAllowed(Qt::LeftDockWidgetArea));
        allowRightAction->setChecked(isAreaAllowed(Qt::RightDockWidgetArea));
        allowTopAction->setChecked(isAreaAllowed(Qt::TopDockWidgetArea));
        allowBottomAction->setChecked(isAreaAllowed(Qt::BottomDockWidgetArea));

        if (allowedAreasActions->isEnabled()) {
            allowLeftAction->setEnabled(area != Qt::LeftDockWidgetArea);
            allowRightAction->setEnabled(area != Qt::RightDockWidgetArea);
            allowTopAction->setEnabled(area != Qt::TopDockWidgetArea);
            allowBottomAction->setEnabled(area != Qt::BottomDockWidgetArea);
        }

        leftAction->blockSignals(true);
        rightAction->blockSignals(true);
        topAction->blockSignals(true);
        bottomAction->blockSignals(true);

        leftAction->setChecked(area == Qt::LeftDockWidgetArea);
        rightAction->setChecked(area == Qt::RightDockWidgetArea);
        topAction->setChecked(area == Qt::TopDockWidgetArea);
        bottomAction->setChecked(area == Qt::BottomDockWidgetArea);

        leftAction->blockSignals(false);
        rightAction->blockSignals(false);
        topAction->blockSignals(false);
        bottomAction->blockSignals(false);

        if (areaActions->isEnabled()) {
            leftAction->setEnabled(areas & Qt::LeftDockWidgetArea);
            rightAction->setEnabled(areas & Qt::RightDockWidgetArea);
            topAction->setEnabled(areas & Qt::TopDockWidgetArea);
            bottomAction->setEnabled(areas & Qt::BottomDockWidgetArea);
        }
        return QDockWidget::event(e);
    }

    void ColorSwatch::allow(Qt::DockWidgetArea area, bool a)
    {
        Qt::DockWidgetAreas areas = allowedAreas();
        areas = a ? areas | area : areas & ~area;
        setAllowedAreas(areas);

        if (areaActions->isEnabled()) {
            leftAction->setEnabled(areas & Qt::LeftDockWidgetArea);
            rightAction->setEnabled(areas & Qt::RightDockWidgetArea);
            topAction->setEnabled(areas & Qt::TopDockWidgetArea);
            bottomAction->setEnabled(areas & Qt::BottomDockWidgetArea);
        }
    }

    void ColorSwatch::place(Qt::DockWidgetArea area, bool p)
    {
        if (!p) return;

        QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
        mainWindow->addDockWidget(area, this);

        if (allowedAreasActions->isEnabled()) {
            allowLeftAction->setEnabled(area != Qt::LeftDockWidgetArea);
            allowRightAction->setEnabled(area != Qt::RightDockWidgetArea);
            allowTopAction->setEnabled(area != Qt::TopDockWidgetArea);
            allowBottomAction->setEnabled(area != Qt::BottomDockWidgetArea);
        }
    }

    void ColorSwatch::changeClosable(bool on)
    { setFeatures(on ? features() | DockWidgetClosable : features() & ~DockWidgetClosable); }

    void ColorSwatch::changeMovable(bool on)
    { setFeatures(on ? features() | DockWidgetMovable : features() & ~DockWidgetMovable); }

    void ColorSwatch::changeFloatable(bool on)
    { setFeatures(on ? features() | DockWidgetFloatable : features() & ~DockWidgetFloatable); }

    void ColorSwatch::changeFloating(bool floating)
    { setFloating(floating); }

    void ColorSwatch::allowLeft(bool a)
    { allow(Qt::LeftDockWidgetArea, a); }

    void ColorSwatch::allowRight(bool a)
    { allow(Qt::RightDockWidgetArea, a); }

    void ColorSwatch::allowTop(bool a)
    { allow(Qt::TopDockWidgetArea, a); }

    void ColorSwatch::allowBottom(bool a)
    { allow(Qt::BottomDockWidgetArea, a); }

    void ColorSwatch::placeLeft(bool p)
    { place(Qt::LeftDockWidgetArea, p); }

    void ColorSwatch::placeRight(bool p)
    { place(Qt::RightDockWidgetArea, p); }

    void ColorSwatch::placeTop(bool p)
    { place(Qt::TopDockWidgetArea, p); }

    void ColorSwatch::placeBottom(bool p)
    { place(Qt::BottomDockWidgetArea, p); }