|  | Home · All Classes · Main Classes · Annotated · Grouped Classes · Functions |

# norwegianwoodstyle.cpp Example File
widgets/styles/norwegianwoodstyle.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2005-2005 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be distributed under the terms of the Q Public License
    ** as defined by Trolltech AS of Norway and appearing in the file
    ** LICENSE.QPL included in the packaging of this file.
    **
    ** This file may be distributed and/or modified under the terms of the
    ** GNU General Public License version 2 as published by the Free Software
    ** Foundation and appearing in the file LICENSE.GPL included in the
    ** packaging of this file.
    **
    ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
    **   information about Qt Commercial License Agreements.
    ** See http://www.trolltech.com/qpl/ for QPL licensing information.
    ** See http://www.trolltech.com/gpl/ for GPL licensing information.
    **
    ** Contact info@trolltech.com if any conditions of this licensing are
    ** not clear to you.
        **
        ** 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 <QtGui>

        #include "norwegianwoodstyle.h"

        void NorwegianWoodStyle::polish(QPalette &palette)
        {
            QColor brown(212, 140, 95);
            QColor beige(236, 182, 120);
            QColor slightlyOpaqueBlack(0, 0, 0, 63);

            QPixmap backgroundImage(":/images/woodbackground.png");
            QPixmap buttonImage(":/images/woodbutton.png");
            QPixmap midImage = buttonImage;

            QPainter painter;
            painter.begin(&midImage);
            painter.setPen(Qt::NoPen);
            painter.fillRect(midImage.rect(), slightlyOpaqueBlack);
            painter.end();

            palette = QPalette(brown);

            palette.setBrush(QPalette::BrightText, Qt::white);
            palette.setBrush(QPalette::Base, beige);
            palette.setBrush(QPalette::Highlight, Qt::darkGreen);
            setTexture(palette, QPalette::Button, buttonImage);
            setTexture(palette, QPalette::Mid, midImage);
            setTexture(palette, QPalette::Background, backgroundImage);

            QBrush brush = palette.background();
            brush.setColor(brush.color().dark());

            palette.setBrush(QPalette::Disabled, QPalette::Foreground, brush);
            palette.setBrush(QPalette::Disabled, QPalette::Text, brush);
            palette.setBrush(QPalette::Disabled, QPalette::ButtonText, brush);
            palette.setBrush(QPalette::Disabled, QPalette::Base, brush);
            palette.setBrush(QPalette::Disabled, QPalette::Button, brush);
            palette.setBrush(QPalette::Disabled, QPalette::Mid, brush);
        }

        void NorwegianWoodStyle::polish(QWidget *widget)
        {
            if (qobject_cast<QPushButton *>(widget)
                    || qobject_cast<QComboBox *>(widget))
                widget->setAttribute(Qt::WA_Hover, true);
        }

        void NorwegianWoodStyle::unpolish(QWidget *widget)
        {
            if (qobject_cast<QPushButton *>(widget)
                    || qobject_cast<QComboBox *>(widget))
                widget->setAttribute(Qt::WA_Hover, false);
        }

        int NorwegianWoodStyle::pixelMetric(PixelMetric metric,
                                            const QStyleOption *option,
                                            const QWidget *widget) const
        {
            switch (metric) {
            case PM_ComboBoxFrameWidth:
                return 8;
            case PM_ScrollBarExtent:
                return QMotifStyle::pixelMetric(metric, option, widget) + 4;
            default:
                return QMotifStyle::pixelMetric(metric, option, widget);
            }
        }

        int NorwegianWoodStyle::styleHint(StyleHint hint, const QStyleOption *option,
                                          const QWidget *widget,
                                          QStyleHintReturn *returnData) const
        {
            switch (hint) {
            case SH_DitherDisabledText:
                return int(false);
            case SH_EtchDisabledText:
                return int(true);
            default:
                return QMotifStyle::styleHint(hint, option, widget, returnData);
            }
        }

        void NorwegianWoodStyle::drawPrimitive(PrimitiveElement element,
                                               const QStyleOption *option,
                                               QPainter *painter,
                                               const QWidget *widget) const
        {
            switch (element) {
            case PE_PanelButtonCommand:
                {
                    int delta = (option->state & State_MouseOver) ? 64 : 0;
                    QColor slightlyOpaqueBlack(0, 0, 0, 63);
                    QColor semiTransparentWhite(255, 255, 255, 127 + delta);
                    QColor semiTransparentBlack(0, 0, 0, 127 - delta);

                    int x, y, width, height;
                    option->rect.getRect(&x, &y, &width, &height);

                    QPainterPath roundRect = roundRectPath(option->rect);
                    int radius = qMin(width, height) / 2;

                    QBrush brush;
                    bool darker;

                    const QStyleOptionButton *buttonOption =
                            qstyleoption_cast<const QStyleOptionButton *>(option);
                    if (buttonOption
                            && (buttonOption->features & QStyleOptionButton::Flat)) {
                        brush = option->palette.background();
                        darker = (option->state & (State_Sunken | State_On));
                    } else {
                        if (option->state & (State_Sunken | State_On)) {
                            brush = option->palette.mid();
                            darker = !(option->state & State_Sunken);
                        } else {
                            brush = option->palette.button();
                            darker = false;
                        }
                    }

                    painter->save();
                    painter->setRenderHint(QPainter::Antialiasing, true);
                    painter->fillPath(roundRect, brush);
                    if (darker)
                        painter->fillPath(roundRect, slightlyOpaqueBlack);

                    int penWidth;
                    if (radius < 10)
                        penWidth = 3;
                    else if (radius < 20)
                        penWidth = 5;
                    else
                        penWidth = 7;

                    QPen topPen(semiTransparentWhite, penWidth);
                    QPen bottomPen(semiTransparentBlack, penWidth);

                    if (option->state & (State_Sunken | State_On))
                        qSwap(topPen, bottomPen);

                    int x1 = x;
                    int x2 = x + radius;
                    int x3 = x + width - radius;
                    int x4 = x + width;

                    if (option->direction == Qt::RightToLeft) {
                        qSwap(x1, x4);
                        qSwap(x2, x3);
                    }

                    QPolygon topHalf;
                    topHalf << QPoint(x1, y)
                            << QPoint(x4, y)
                            << QPoint(x3, y + radius)
                            << QPoint(x2, y + height - radius)
                            << QPoint(x1, y + height);

                    painter->setClipPath(roundRect);
                    painter->setClipRegion(topHalf, Qt::IntersectClip);
                    painter->setPen(topPen);
                    painter->drawPath(roundRect);

                    QPolygon bottomHalf = topHalf;
                    bottomHalf[0] = QPoint(x4, y + height);

                    painter->setClipPath(roundRect);
                    painter->setClipRegion(bottomHalf, Qt::IntersectClip);
                    painter->setPen(bottomPen);
                    painter->drawPath(roundRect);

                    painter->setPen(option->palette.foreground().color());
                    painter->setClipping(false);
                    painter->drawPath(roundRect);

                    painter->restore();
                }
                break;
            default:
                QMotifStyle::drawPrimitive(element, option, painter, widget);
            }
        }

        void NorwegianWoodStyle::drawControl(ControlElement element,
                                             const QStyleOption *option,
                                             QPainter *painter,
                                             const QWidget *widget) const
        {
            switch (element) {
            case CE_PushButtonLabel:
                {
                    QStyleOptionButton myButtonOption;
                    const QStyleOptionButton *buttonOption =
                            qstyleoption_cast<const QStyleOptionButton *>(option);
                    if (buttonOption) {
                        myButtonOption = *buttonOption;
                        if (myButtonOption.palette.currentColorGroup()
                                != QPalette::Disabled) {
                            if (myButtonOption.state & (State_Sunken | State_On)) {
                                myButtonOption.palette.setBrush(QPalette::ButtonText,
                                        myButtonOption.palette.brightText());
                            }
                        }
                    }
                    QMotifStyle::drawControl(element, &myButtonOption, painter, widget);
                }
                break;
            default:
                QMotifStyle::drawControl(element, option, painter, widget);
            }
        }

        void NorwegianWoodStyle::setTexture(QPalette &palette, QPalette::ColorRole role,
                                            const QPixmap &pixmap)
        {
            for (int i = 0; i < QPalette::NColorGroups; ++i) {
                QColor color = palette.brush(QPalette::ColorGroup(i), role).color();
                palette.setBrush(QPalette::ColorGroup(i), role, QBrush(color, pixmap));
            }
        }

        QPainterPath NorwegianWoodStyle::roundRectPath(const QRect &rect)
        {
            int radius = qMin(rect.width(), rect.height()) / 2;
            int diam = 2 * radius;

            int x1, y1, x2, y2;
            rect.getCoords(&x1, &y1, &x2, &y2);

            QPainterPath path;
            path.moveTo(x2, y1 + radius);
            path.arcTo(QRect(x2 - diam, y1, diam, diam), 0.0, +90.0);
            path.lineTo(x1 + radius, y1);
            path.arcTo(QRect(x1, y1, diam, diam), 90.0, +90.0);
            path.lineTo(x1, y2 - radius);
            path.arcTo(QRect(x1, y2 - diam, diam, diam), 180.0, +90.0);
            path.lineTo(x1 + radius, y2);
            path.arcTo(QRect(x2 - diam, y2 - diam, diam, diam), 270.0, +90.0);
            path.closeSubpath();
            return path;
        }