|  | Home · All Namespaces · All Classes · Main Classes · Grouped Classes · Modules · Functions |

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

     /****************************************************************************
     **
     ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Qt Software Information (qt-info@nokia.com)
     **
     ** This file is part of the example classes of the Qt Toolkit.
     **
     ** Commercial Usage
     ** Licensees holding valid Qt Commercial licenses may use this file in
     ** accordance with the Qt Commercial License Agreement provided with the
     ** Software or, alternatively, in accordance with the terms contained in
     ** a written agreement between you and Nokia.
     **
     **
     ** GNU General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License versions 2.0 or 3.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.fsf.org/licensing/licenses/info/GPLv2.html and
     ** http://www.gnu.org/copyleft/gpl.html.  In addition, as a special
     ** exception, Nokia gives you certain additional rights. These rights
     ** are described in the Nokia Qt GPL Exception version 1.3, included in
     ** the file GPL_EXCEPTION.txt in this package.
     **
     ** Qt for Windows(R) Licensees
     ** As a special exception, Nokia, 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.
     **
     ** If you are unsure which license is appropriate for your use, please
     ** contact the sales department at qt-sales@nokia.com.
     **
     ****************************************************************************/

     #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::Window, backgroundImage);

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

         palette.setBrush(QPalette::Disabled, QPalette::WindowText, 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;
     }