- Qt 5.5
- Qt Widgets
- Main Window
- colorswatch.cpp Example File
- Qt 5.5.1 Reference Documentation

# colorswatch.cpp Example File

mainwindows/mainwindow/colorswatch.cpp

    /****************************************************************************
    **
    ** Copyright (C) 2015 The Qt Company Ltd.
    ** Contact: http://www.qt.io/licensing/
    **
    ** This file is part of the demonstration applications of the Qt Toolkit.
    **
    ** $QT_BEGIN_LICENSE:LGPL21$
    ** 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 http://www.qt.io/terms-conditions. For further
    ** information use the contact form at http://www.qt.io/contact-us.
    **
    ** 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 or version 3 as published by the Free
    ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
    ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
    ** following information to ensure the GNU Lesser General Public License
    ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
    ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    **
    ** As a special exception, The Qt Company gives you certain additional
    ** rights. These rights are described in The Qt Company LGPL Exception
    ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    **
    ** $QT_END_LICENSE$
    **
    ****************************************************************************/

    #include "colorswatch.h"

    #include <QAction>
    #include <QtEvents>
    #include <QFrame>
    #include <QMainWindow>
    #include <QMenu>
    #include <QPainter>
    #include <QImage>
    #include <QColor>
    #include <QDialog>
    #include <QGridLayout>
    #include <QSpinBox>
    #include <QLabel>
    #include <QPainterPath>
    #include <QPushButton>
    #include <QHBoxLayout>
    #include <QBitmap>
    #include <QtDebug>

    #undef DEBUG_SIZEHINTS

    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(name).light(110);
    }

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

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

        virtual QSize sizeHint() const Q_DECL_OVERRIDE;
        virtual QSize minimumSizeHint() const Q_DECL_OVERRIDE;

        void setCustomSizeHint(const QSize &size);

    public slots:
        void changeSizeHints();

    protected:
        void paintEvent(QPaintEvent *) Q_DECL_OVERRIDE;
        QString color;
        QSize szHint, minSzHint;
    };

    ColorDock::ColorDock(const QString &c, QWidget *parent)
        : QFrame(parent) , color(c)
    {
        QFont font = this->font();
        font.setPointSize(8);
        setFont(font);
        szHint = QSize(-1, -1);
        minSzHint = QSize(125, 75);
    }

    QSize ColorDock::sizeHint() const
    {
        return szHint;
    }

    QSize ColorDock::minimumSizeHint() const
    {
        return minSzHint;
    }

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

        p.save();

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

        p.restore();

    #ifdef DEBUG_SIZEHINTS
        p.setRenderHint(QPainter::Antialiasing, false);

        QSize sz = size();
        QSize szHint = sizeHint();
        QSize minSzHint = minimumSizeHint();
        QSize maxSz = maximumSize();
        QString text = QString::fromLatin1("sz: %1x%2\nszHint: %3x%4\nminSzHint: %5x%6\n"
                                            "maxSz: %8x%9")
                        .arg(sz.width()).arg(sz.height())
                        .arg(szHint.width()).arg(szHint.height())
                        .arg(minSzHint.width()).arg(minSzHint.height())
                        .arg(maxSz.width()).arg(maxSz.height());

        QRect r = fontMetrics().boundingRect(rect(), Qt::AlignLeft|Qt::AlignTop, text);
        r.adjust(-2, -2, 1, 1);
        p.translate(4, 4);
        QColor bg = Qt::yellow;
        bg.setAlpha(120);
        p.setBrush(bg);
        p.setPen(Qt::black);
        p.drawRect(r);
        p.drawText(rect(), Qt::AlignLeft|Qt::AlignTop, text);
    #endif // DEBUG_SIZEHINTS
    }

    static QSpinBox *createSpinBox(int value, QWidget *parent, int max = 1000)
    {
        QSpinBox *result = new QSpinBox(parent);
        result->setMinimum(-1);
        result->setMaximum(max);
        result->setValue(value);
        return result;
    }

    void ColorDock::changeSizeHints()
    {
        QDialog dialog(this);
        dialog.setWindowTitle(color);

        QVBoxLayout *topLayout = new QVBoxLayout(&dialog);

        QGridLayout *inputLayout = new QGridLayout();
        topLayout->addLayout(inputLayout);

        inputLayout->addWidget(new QLabel(tr("Size Hint:"), &dialog), 0, 0);
        inputLayout->addWidget(new QLabel(tr("Min Size Hint:"), &dialog), 1, 0);
        inputLayout->addWidget(new QLabel(tr("Max Size:"), &dialog), 2, 0);
        inputLayout->addWidget(new QLabel(tr("Dockwgt Max Size:"), &dialog), 3, 0);

        QSpinBox *szHintW = createSpinBox(szHint.width(), &dialog);
        inputLayout->addWidget(szHintW, 0, 1);
        QSpinBox *szHintH = createSpinBox(szHint.height(), &dialog);
        inputLayout->addWidget(szHintH, 0, 2);

        QSpinBox *minSzHintW = createSpinBox(minSzHint.width(), &dialog);
        inputLayout->addWidget(minSzHintW, 1, 1);
        QSpinBox *minSzHintH = createSpinBox(minSzHint.height(), &dialog);
        inputLayout->addWidget(minSzHintH, 1, 2);

        QSize maxSz = maximumSize();
        QSpinBox *maxSzW = createSpinBox(maxSz.width(), &dialog, QWIDGETSIZE_MAX);
        inputLayout->addWidget(maxSzW, 2, 1);
        QSpinBox *maxSzH = createSpinBox(maxSz.height(), &dialog, QWIDGETSIZE_MAX);
        inputLayout->addWidget(maxSzH, 2, 2);

        QSize dwMaxSz = parentWidget()->maximumSize();
        QSpinBox *dwMaxSzW = createSpinBox(dwMaxSz.width(), &dialog, QWIDGETSIZE_MAX);
        inputLayout->addWidget(dwMaxSzW, 3, 1);
        QSpinBox *dwMaxSzH = createSpinBox(dwMaxSz.height(), &dialog, QWIDGETSIZE_MAX);
        inputLayout->addWidget(dwMaxSzH, 3, 2);

        inputLayout->setColumnStretch(1, 1);
        inputLayout->setColumnStretch(2, 1);

        topLayout->addStretch();

        QHBoxLayout *buttonBox = new QHBoxLayout();
        topLayout->addLayout(buttonBox);

        QPushButton *okButton = new QPushButton(tr("Ok"), &dialog);
        QPushButton *cancelButton = new QPushButton(tr("Cancel"), &dialog);
        connect(okButton, SIGNAL(clicked()), &dialog, SLOT(accept()));
        connect(cancelButton, SIGNAL(clicked()), &dialog, SLOT(reject()));
        buttonBox->addStretch();
        buttonBox->addWidget(cancelButton);
        buttonBox->addWidget(okButton);

        if (!dialog.exec())
            return;

        szHint = QSize(szHintW->value(), szHintH->value());
        minSzHint = QSize(minSzHintW->value(), minSzHintH->value());
        maxSz = QSize(maxSzW->value(), maxSzH->value());
        setMaximumSize(maxSz);
        dwMaxSz = QSize(dwMaxSzW->value(), dwMaxSzH->value());
        parentWidget()->setMaximumSize(dwMaxSz);
        updateGeometry();
        update();
    }

    void ColorDock::setCustomSizeHint(const QSize &size)
    {
        szHint = size;
        updateGeometry();
    }

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

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

        setWidget(swatch);

        changeSizeHintsAction = new QAction(tr("Change Size Hints"), this);
        connect(changeSizeHintsAction, SIGNAL(triggered()), swatch, SLOT(changeSizeHints()));

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

        verticalTitleBarAction = new QAction(tr("Vertical title bar"), this);
        verticalTitleBarAction->setCheckable(true);
        connect(verticalTitleBarAction, SIGNAL(triggered(bool)),
                SLOT(changeVerticalTitleBar(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)));

        tabMenu = new QMenu(this);
        tabMenu->setTitle(tr("Tab into"));
        connect(tabMenu, SIGNAL(triggered(QAction*)), this, SLOT(tabInto(QAction*)));

        splitHMenu = new QMenu(this);
        splitHMenu->setTitle(tr("Split horizontally into"));
        connect(splitHMenu, SIGNAL(triggered(QAction*)), this, SLOT(splitInto(QAction*)));

        splitVMenu = new QMenu(this);
        splitVMenu->setTitle(tr("Split vertically into"));
        connect(splitVMenu, SIGNAL(triggered(QAction*)), this, SLOT(splitInto(QAction*)));

        windowModifiedAction = new QAction(tr("Modified"), this);
        windowModifiedAction->setCheckable(true);
        windowModifiedAction->setChecked(false);
        connect(windowModifiedAction, SIGNAL(toggled(bool)), this, SLOT(setWindowModified(bool)));

        menu = new QMenu(colorName, this);
        menu->addAction(toggleViewAction());
        QAction *action = menu->addAction(tr("Raise"));
        connect(action, SIGNAL(triggered()), this, SLOT(raise()));
        menu->addAction(changeSizeHintsAction);
        menu->addSeparator();
        menu->addAction(closableAction);
        menu->addAction(movableAction);
        menu->addAction(floatableAction);
        menu->addAction(floatingAction);
        menu->addAction(verticalTitleBarAction);
        menu->addSeparator();
        menu->addActions(allowedAreasActions->actions());
        menu->addSeparator();
        menu->addActions(areaActions->actions());
        menu->addSeparator();
        menu->addMenu(splitHMenu);
        menu->addMenu(splitVMenu);
        menu->addMenu(tabMenu);
        menu->addSeparator();
        menu->addAction(windowModifiedAction);

        connect(menu, SIGNAL(aboutToShow()), this, SLOT(updateContextMenu()));

        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::updateContextMenu()
    {
        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);
            verticalTitleBarAction->setChecked(false);
        } else {
            floatableAction->setChecked(features() & QDockWidget::DockWidgetFloatable);
            floatingAction->setChecked(isWindow());
            // done after floating, to get 'floatable' correctly initialized
            movableAction->setChecked(features() & QDockWidget::DockWidgetMovable);
            verticalTitleBarAction
                ->setChecked(features() & QDockWidget::DockWidgetVerticalTitleBar);
        }

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

        tabMenu->clear();
        splitHMenu->clear();
        splitVMenu->clear();
        QList<ColorSwatch*> dock_list = mainWindow->findChildren<ColorSwatch*>();
        foreach (ColorSwatch *dock, dock_list) {
    //        if (!dock->isVisible() || dock->isFloating())
    //            continue;
            tabMenu->addAction(dock->objectName());
            splitHMenu->addAction(dock->objectName());
            splitVMenu->addAction(dock->objectName());
        }
    }

    void ColorSwatch::splitInto(QAction *action)
    {
        QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
        QList<ColorSwatch*> dock_list = mainWindow->findChildren<ColorSwatch*>();
        ColorSwatch *target = 0;
        foreach (ColorSwatch *dock, dock_list) {
            if (action->text() == dock->objectName()) {
                target = dock;
                break;
            }
        }
        if (target == 0)
            return;

        Qt::Orientation o = action->parent() == splitHMenu
                            ? Qt::Horizontal : Qt::Vertical;
        mainWindow->splitDockWidget(target, this, o);
    }

    void ColorSwatch::tabInto(QAction *action)
    {
        QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parentWidget());
        QList<ColorSwatch*> dock_list = mainWindow->findChildren<ColorSwatch*>();
        ColorSwatch *target = 0;
        foreach (ColorSwatch *dock, dock_list) {
            if (action->text() == dock->objectName()) {
                target = dock;
                break;
            }
        }
        if (target == 0)
            return;

        mainWindow->tabifyDockWidget(target, this);
    }

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

    void ColorSwatch::resizeEvent(QResizeEvent *e)
    {
        if (BlueTitleBar *btb = qobject_cast<BlueTitleBar*>(titleBarWidget()))
            btb->updateMask();

        QDockWidget::resizeEvent(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::setCustomSizeHint(const QSize &size)
    {
        if (ColorDock *dock = qobject_cast<ColorDock*>(widget()))
            dock->setCustomSizeHint(size);
    }

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

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

    QSize BlueTitleBar::minimumSizeHint() const
    {
        QDockWidget *dw = qobject_cast<QDockWidget*>(parentWidget());
        Q_ASSERT(dw != 0);
        QSize result(leftPm.width() + rightPm.width(), centerPm.height());
        if (dw->features() & QDockWidget::DockWidgetVerticalTitleBar)
            result.transpose();
        return result;
    }

    BlueTitleBar::BlueTitleBar(QWidget *parent)
        : QWidget(parent)
    {
        leftPm = QPixmap(":/res/titlebarLeft.png");
        centerPm = QPixmap(":/res/titlebarCenter.png");
        rightPm = QPixmap(":/res/titlebarRight.png");
    }

    void BlueTitleBar::paintEvent(QPaintEvent*)
    {
        QPainter painter(this);
        QRect rect = this->rect();

        QDockWidget *dw = qobject_cast<QDockWidget*>(parentWidget());
        Q_ASSERT(dw != 0);

        if (dw->features() & QDockWidget::DockWidgetVerticalTitleBar) {
            QSize s = rect.size();
            s.transpose();
            rect.setSize(s);

            painter.translate(rect.left(), rect.top() + rect.width());
            painter.rotate(-90);
            painter.translate(-rect.left(), -rect.top());
        }

        painter.drawPixmap(rect.topLeft(), leftPm);
        painter.drawPixmap(rect.topRight() - QPoint(rightPm.width() - 1, 0), rightPm);
        QBrush brush(centerPm);
        painter.fillRect(rect.left() + leftPm.width(), rect.top(),
                            rect.width() - leftPm.width() - rightPm.width(),
                            centerPm.height(), centerPm);
    }

    void BlueTitleBar::mouseReleaseEvent(QMouseEvent *event)
    {
        QPoint pos = event->pos();

        QRect rect = this->rect();

        QDockWidget *dw = qobject_cast<QDockWidget*>(parentWidget());
        Q_ASSERT(dw != 0);

        if (dw->features() & QDockWidget::DockWidgetVerticalTitleBar) {
            QPoint p = pos;
            pos.setX(rect.left() + rect.bottom() - p.y());
            pos.setY(rect.top() + p.x() - rect.left());

            QSize s = rect.size();
            s.transpose();
            rect.setSize(s);
        }

        const int buttonRight = 7;
        const int buttonWidth = 20;
        int right = rect.right() - pos.x();
        int button = (right - buttonRight)/buttonWidth;
        switch (button) {
            case 0:
                event->accept();
                dw->close();
                break;
            case 1:
                event->accept();
                dw->setFloating(!dw->isFloating());
                break;
            case 2: {
                event->accept();
                QDockWidget::DockWidgetFeatures features = dw->features();
                if (features & QDockWidget::DockWidgetVerticalTitleBar)
                    features &= ~QDockWidget::DockWidgetVerticalTitleBar;
                else
                    features |= QDockWidget::DockWidgetVerticalTitleBar;
                dw->setFeatures(features);
                break;
            }
            default:
                event->ignore();
                break;
        }
    }

    void BlueTitleBar::updateMask()
    {
        QDockWidget *dw = qobject_cast<QDockWidget*>(parent());
        Q_ASSERT(dw != 0);

        QRect rect = dw->rect();
        QPixmap bitmap(dw->size());

        {
            QPainter painter(&bitmap);

            ///initialize to transparent
            painter.fillRect(rect, Qt::color0);

            QRect contents = rect;
            contents.setTopLeft(geometry().bottomLeft());
            contents.setRight(geometry().right());
            contents.setBottom(contents.bottom()-y());
            painter.fillRect(contents, Qt::color1);

            //let's pait the titlebar

            QRect titleRect = this->geometry();

            if (dw->features() & QDockWidget::DockWidgetVerticalTitleBar) {
                QSize s = rect.size();
                s.transpose();
                rect.setSize(s);

                QSize s2 = size();
                s2.transpose();
                titleRect.setSize(s2);

                painter.translate(rect.left(), rect.top() + rect.width());
                painter.rotate(-90);
                painter.translate(-rect.left(), -rect.top());
            }

            contents.setTopLeft(titleRect.bottomLeft());
            contents.setRight(titleRect.right());
            contents.setBottom(rect.bottom()-y());

            QRect rect = titleRect;

            painter.drawPixmap(rect.topLeft(), leftPm.mask());
            painter.fillRect(rect.left() + leftPm.width(), rect.top(),
                rect.width() - leftPm.width() - rightPm.width(),
                centerPm.height(), Qt::color1);
            painter.drawPixmap(rect.topRight() - QPoint(rightPm.width() - 1, 0), rightPm.mask());

            painter.fillRect(contents, Qt::color1);
        }

        dw->setMask(bitmap);
    }

    #include "colorswatch.moc"