1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qs60style_p.h"

    43 

    44 #include "qapplication.h"

    45 #include "qpainter.h"

    46 #include "qstyleoption.h"

    47 #include "qevent.h"

    48 #include "qpixmapcache.h"

    49 

    50 #include "qcalendarwidget.h"

    51 #include "qdial.h"

    52 #include "qdialog.h"

    53 #include "qgroupbox.h"

    54 #include "qheaderview.h"

    55 #include "qlist.h"

    56 #include "qlistwidget.h"

    57 #include "qlistview.h"

    58 #include "qmenu.h"

    59 #include "qmenubar.h"

    60 #include "qpushbutton.h"

    61 #include "qscrollarea.h"

    62 #include "qscrollbar.h"

    63 #include "qtabbar.h"

    64 #include "qtablewidget.h"

    65 #include "qtableview.h"

    66 #include "qtextedit.h"

    67 #include "qtoolbar.h"

    68 #include "qtoolbutton.h"

    69 #include "qtreeview.h"

    70 #include "qfocusframe.h"

    71 

    72 #include "private/qtoolbarextension_p.h"

    73 #include "private/qcombobox_p.h"

    74 #include "private/qwidget_p.h"

    75 #include "private/qapplication_p.h"

    76 

    77 #if !defined(QT_NO_STYLE_S60) || defined(QT_PLUGIN)

    78 

    79 QT_BEGIN_NAMESPACE

    80 

    81 // from text/qfont.cpp

    82 extern Q_GUI_EXPORT int qt_defaultDpiY();

    83 

    84 const QS60StylePrivate::SkinElementFlags QS60StylePrivate::KDefaultSkinElementFlags =

    85     SkinElementFlags(SF_PointNorth | SF_StateEnabled);

    86 

    87 static const QByteArray propertyKeyLayouts = "layouts";

    88 static const QByteArray propertyKeyCurrentlayout = "currentlayout";

    89 

    90 static const qreal goldenRatio = 1.618;

    91 

    92 const layoutHeader QS60StylePrivate::m_layoutHeaders[] = {

    93 // *** generated layout data ***

    94 {240,320,1,14,true,"QVGA Landscape Mirrored"},

    95 {240,320,1,14,false,"QVGA Landscape"},

    96 {320,240,1,14,true,"QVGA Portrait Mirrored"},

    97 {320,240,1,14,false,"QVGA Portrait"},

    98 {360,640,1,14,true,"NHD Landscape Mirrored"},

    99 {360,640,1,14,false,"NHD Landscape"},

   100 {640,360,1,14,true,"NHD Portrait Mirrored"},

   101 {640,360,1,14,false,"NHD Portrait"},

   102 {352,800,1,12,true,"E90 Landscape Mirrored"},

   103 {352,800,1,12,false,"E90 Landscape"}

   104 // *** End of generated data ***

   105 };

   106 const int QS60StylePrivate::m_numberOfLayouts =

   107     (int)sizeof(QS60StylePrivate::m_layoutHeaders)/sizeof(QS60StylePrivate::m_layoutHeaders[0]);

   108 

   109 const short QS60StylePrivate::data[][MAX_PIXELMETRICS] = {

   110 // *** generated pixel metrics ***

   111 {5,0,-909,0,0,1,0,0,-1,8,15,22,15,15,7,198,-909,-909,-909,19,15,2,0,0,21,-909,21,-909,4,4,1,-909,-909,0,2,0,0,13,23,17,17,21,21,2,115,21,0,-909,-909,-909,-909,0,0,15,1,-909,0,0,-909,15,-909,-909,-909,-909,32,21,51,27,51,4,4,5,10,15,-909,5,58,12,5,0,7,4,4,9,4,4,-909,1,-909,-909,-909,-909,4,4,3,1},

   112 {5,0,-909,0,0,1,0,0,-1,8,15,22,15,15,7,198,-909,-909,-909,19,15,2,0,0,21,-909,21,-909,4,4,1,-909,-909,0,2,0,0,13,23,17,17,21,21,2,115,21,0,-909,-909,-909,-909,0,0,15,1,-909,0,0,-909,15,-909,-909,-909,-909,32,21,51,27,51,4,4,5,10,15,-909,5,58,12,5,0,4,4,7,9,4,4,-909,1,-909,-909,-909,-909,4,4,3,1},

   113 {5,0,-909,0,0,1,0,0,-1,8,14,22,15,15,7,164,-909,-909,-909,19,15,2,0,0,21,-909,27,-909,4,4,1,-909,-909,0,7,6,0,13,23,17,17,21,21,7,115,21,0,-909,-909,-909,-909,0,0,15,1,-909,0,0,-909,15,-909,-909,-909,-909,32,21,65,27,65,4,4,5,10,15,-909,5,58,13,5,0,7,4,4,9,4,4,-909,1,-909,-909,-909,-909,4,4,3,1},

   114 {5,0,-909,0,0,1,0,0,-1,8,14,22,15,15,7,164,-909,-909,-909,19,15,2,0,0,21,-909,27,-909,4,4,1,-909,-909,0,7,6,0,13,23,17,17,21,21,7,115,21,0,-909,-909,-909,-909,0,0,15,1,-909,0,0,-909,15,-909,-909,-909,-909,32,21,65,27,65,4,4,5,10,15,-909,5,58,13,5,0,4,4,7,9,4,4,-909,1,-909,-909,-909,-909,4,4,3,1},

   115 {7,0,-909,0,0,2,0,0,-1,20,53,28,19,19,9,258,-909,-909,-909,29,19,26,0,0,32,-909,72,-909,5,5,2,-909,-909,0,7,21,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,25,2,-909,0,0,-909,25,-909,-909,-909,-909,87,27,77,35,77,5,5,6,8,19,-909,7,74,19,7,0,8,5,5,12,5,5,-909,2,-909,-909,-909,-909,7,7,3,1},

   116 {7,0,-909,0,0,2,0,0,-1,20,53,28,19,19,9,258,-909,-909,-909,29,19,26,0,0,32,-909,72,-909,5,5,2,-909,-909,0,7,21,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,25,2,-909,0,0,-909,25,-909,-909,-909,-909,87,27,77,35,77,5,5,6,8,19,-909,7,74,19,7,0,5,5,8,12,5,5,-909,2,-909,-909,-909,-909,7,7,3,1},

   117 {7,0,-909,0,0,2,0,0,-1,20,52,28,19,19,9,258,-909,-909,-909,29,19,6,0,0,32,-909,60,-909,5,5,2,-909,-909,0,7,32,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,26,2,-909,0,0,-909,26,-909,-909,-909,-909,87,27,98,35,98,5,5,6,8,19,-909,7,74,22,7,0,8,5,5,12,5,5,-909,2,-909,-909,-909,-909,7,7,3,1},

   118 {7,0,-909,0,0,2,0,0,-1,20,52,28,19,19,9,258,-909,-909,-909,29,19,6,0,0,32,-909,60,-909,5,5,2,-909,-909,0,7,32,0,17,29,22,22,27,27,7,173,29,0,-909,-909,-909,-909,0,0,26,2,-909,0,0,-909,26,-909,-909,-909,-909,87,27,98,35,98,5,5,6,8,19,-909,7,74,22,7,0,5,5,8,12,5,5,-909,2,-909,-909,-909,-909,7,7,3,1},

   119 {7,0,-909,0,0,2,0,0,-1,10,20,27,18,18,9,301,-909,-909,-909,29,18,5,0,0,35,-909,32,-909,5,5,2,-909,-909,0,2,8,0,16,28,21,21,26,26,2,170,26,0,-909,-909,-909,-909,0,0,21,5,-909,0,0,-909,-909,-909,-909,-909,-909,54,26,265,34,265,5,5,6,3,18,-909,7,72,19,7,0,8,6,5,11,6,5,-909,2,-909,-909,-909,-909,5,5,3,1},

   120 {7,0,-909,0,0,2,0,0,-1,10,20,27,18,18,9,301,-909,-909,-909,29,18,5,0,0,35,-909,32,-909,5,5,2,-909,-909,0,2,8,0,16,28,21,21,26,26,2,170,26,0,-909,-909,-909,-909,0,0,21,6,-909,0,0,-909,-909,-909,-909,-909,-909,54,26,265,34,265,5,5,6,3,18,-909,7,72,19,7,0,5,6,8,11,6,5,-909,2,-909,-909,-909,-909,5,5,3,1}

   121 // *** End of generated data ***

   122 };

   123 

   124 const short *QS60StylePrivate::m_pmPointer = QS60StylePrivate::data[0];

   125 

   126 // theme background texture

   127 QPixmap *QS60StylePrivate::m_background = 0;

   128 

   129 // theme palette

   130 QPalette *QS60StylePrivate::m_themePalette = 0;

   131 

   132 const struct QS60StylePrivate::frameElementCenter QS60StylePrivate::m_frameElementsData[] = {

   133     {SE_ButtonNormal,           QS60StyleEnums::SP_QsnFrButtonTbCenter},

   134     {SE_ButtonPressed,          QS60StyleEnums::SP_QsnFrButtonTbCenterPressed},

   135     {SE_FrameLineEdit,          QS60StyleEnums::SP_QsnFrInputCenter},

   136     {SE_ListHighlight,          QS60StyleEnums::SP_QsnFrListCenter},

   137     {SE_OptionsMenu,            QS60StyleEnums::SP_QsnFrPopupCenter},

   138     {SE_SettingsList,           QS60StyleEnums::SP_QsnFrSetOptCenter},

   139     {SE_TableItem,              QS60StyleEnums::SP_QsnFrCaleCenter},

   140     {SE_TableHeaderItem,        QS60StyleEnums::SP_QsnFrCaleHeadingCenter},

   141     {SE_ToolTip,                QS60StyleEnums::SP_QsnFrPopupPreviewCenter},

   142     {SE_ToolBar,                QS60StyleEnums::SP_QsnFrPopupSubCenter},

   143     {SE_ToolBarButton,          QS60StyleEnums::SP_QsnFrSctrlButtonCenter},

   144     {SE_ToolBarButtonPressed,   QS60StyleEnums::SP_QsnFrSctrlButtonCenterPressed},

   145     {SE_PanelBackground,        QS60StyleEnums::SP_QsnFrSetOptCenter},

   146     {SE_ButtonInactive,         QS60StyleEnums::SP_QsnFrButtonCenterInactive},

   147     {SE_Editor,                 QS60StyleEnums::SP_QsnFrNotepadCenter},

   148 };

   149 

   150 static const int frameElementsCount =

   151     int(sizeof(QS60StylePrivate::m_frameElementsData)/sizeof(QS60StylePrivate::m_frameElementsData[0]));

   152 

   153 const int KNotFound = -909;

   154 const double KTabFontMul = 0.72;

   155 

   156 QS60StylePrivate::~QS60StylePrivate()

   157 {

   158     clearCaches(); //deletes also background image

   159     deleteThemePalette();

   160 }

   161 

   162 void QS60StylePrivate::drawSkinElement(SkinElements element, QPainter *painter,

   163     const QRect &rect, SkinElementFlags flags)

   164 {

   165     switch (element) {

   166     case SE_ButtonNormal:

   167         drawFrame(SF_ButtonNormal, painter, rect, flags | SF_PointNorth);

   168         break;

   169     case SE_ButtonPressed:

   170         drawFrame(SF_ButtonPressed, painter, rect, flags | SF_PointNorth);

   171         break;

   172     case SE_FrameLineEdit:

   173         drawFrame(SF_FrameLineEdit, painter, rect, flags | SF_PointNorth);

   174         break;

   175     case SE_ProgressBarGrooveHorizontal:

   176         drawRow(QS60StyleEnums::SP_QgnGrafBarFrameSideL, QS60StyleEnums::SP_QgnGrafBarFrameCenter,

   177             QS60StyleEnums::SP_QgnGrafBarFrameSideR, Qt::Horizontal, painter, rect, flags | SF_PointNorth);

   178         break;

   179     case SE_ProgressBarGrooveVertical:

   180         drawRow(QS60StyleEnums::SP_QgnGrafBarFrameSideL, QS60StyleEnums::SP_QgnGrafBarFrameCenter,

   181             QS60StyleEnums::SP_QgnGrafBarFrameSideR, Qt::Vertical, painter, rect, flags | SF_PointEast);

   182         break;

   183     case SE_ProgressBarIndicatorHorizontal:

   184         drawPart(QS60StyleEnums::SP_QgnGrafBarProgress, painter, rect, flags | SF_PointNorth);

   185         break;

   186     case SE_ProgressBarIndicatorVertical:

   187         drawPart(QS60StyleEnums::SP_QgnGrafBarProgress, painter, rect, flags | SF_PointWest);

   188         break;

   189     case SE_ScrollBarGrooveHorizontal:

   190         drawRow(QS60StyleEnums::SP_QsnCpScrollBgBottom, QS60StyleEnums::SP_QsnCpScrollBgMiddle,

   191             QS60StyleEnums::SP_QsnCpScrollBgTop, Qt::Horizontal, painter, rect, flags | SF_PointEast);

   192         break;

   193     case SE_ScrollBarGrooveVertical:

   194         drawRow(QS60StyleEnums::SP_QsnCpScrollBgTop, QS60StyleEnums::SP_QsnCpScrollBgMiddle,

   195             QS60StyleEnums::SP_QsnCpScrollBgBottom, Qt::Vertical, painter, rect, flags | SF_PointNorth);

   196         break;

   197     case SE_ScrollBarHandleHorizontal:

   198         drawRow(QS60StyleEnums::SP_QsnCpScrollHandleBottom, QS60StyleEnums::SP_QsnCpScrollHandleMiddle,

   199             QS60StyleEnums::SP_QsnCpScrollHandleTop, Qt::Horizontal, painter, rect, flags | SF_PointEast);

   200         break;

   201     case SE_ScrollBarHandleVertical:

   202         drawRow(QS60StyleEnums::SP_QsnCpScrollHandleTop, QS60StyleEnums::SP_QsnCpScrollHandleMiddle,

   203             QS60StyleEnums::SP_QsnCpScrollHandleBottom, Qt::Vertical, painter, rect, flags | SF_PointNorth);

   204         break;

   205     case SE_SliderHandleHorizontal:

   206         drawPart(QS60StyleEnums::SP_QgnIndiSliderEdit, painter, rect, flags | SF_PointNorth);

   207         break;

   208     case SE_SliderHandleVertical:

   209         drawPart(QS60StyleEnums::SP_QgnIndiSliderEdit, painter, rect, flags | SF_PointEast);

   210         break;

   211     case SE_TabBarTabEastActive:

   212         drawRow(QS60StyleEnums::SP_QgnGrafTabActiveL, QS60StyleEnums::SP_QgnGrafTabActiveM,

   213             QS60StyleEnums::SP_QgnGrafTabActiveR, Qt::Vertical, painter, rect, flags | SF_PointEast);

   214         break;

   215     case SE_TabBarTabEastInactive:

   216         drawRow(QS60StyleEnums::SP_QgnGrafTabPassiveL, QS60StyleEnums::SP_QgnGrafTabPassiveM,

   217             QS60StyleEnums::SP_QgnGrafTabPassiveR, Qt::Vertical, painter, rect, flags | SF_PointEast);

   218         break;

   219     case SE_TabBarTabNorthActive:

   220         drawRow(QS60StyleEnums::SP_QgnGrafTabActiveL, QS60StyleEnums::SP_QgnGrafTabActiveM,

   221             QS60StyleEnums::SP_QgnGrafTabActiveR, Qt::Horizontal, painter, rect, flags | SF_PointNorth);

   222         break;

   223     case SE_TabBarTabNorthInactive:

   224         drawRow(QS60StyleEnums::SP_QgnGrafTabPassiveL, QS60StyleEnums::SP_QgnGrafTabPassiveM,

   225             QS60StyleEnums::SP_QgnGrafTabPassiveR, Qt::Horizontal, painter, rect, flags | SF_PointNorth);

   226         break;

   227     case SE_TabBarTabSouthActive:

   228         drawRow(QS60StyleEnums::SP_QgnGrafTabActiveR, QS60StyleEnums::SP_QgnGrafTabActiveM,

   229             QS60StyleEnums::SP_QgnGrafTabActiveL, Qt::Horizontal, painter, rect, flags | SF_PointSouth);

   230         break;

   231     case SE_TabBarTabSouthInactive:

   232         drawRow(QS60StyleEnums::SP_QgnGrafTabPassiveR, QS60StyleEnums::SP_QgnGrafTabPassiveM,

   233             QS60StyleEnums::SP_QgnGrafTabPassiveL, Qt::Horizontal, painter, rect, flags | SF_PointSouth);

   234         break;

   235     case SE_TabBarTabWestActive:

   236         drawRow(QS60StyleEnums::SP_QgnGrafTabActiveR, QS60StyleEnums::SP_QgnGrafTabActiveM,

   237             QS60StyleEnums::SP_QgnGrafTabActiveL, Qt::Vertical, painter, rect, flags | SF_PointWest);

   238         break;

   239     case SE_TabBarTabWestInactive:

   240         drawRow(QS60StyleEnums::SP_QgnGrafTabPassiveR, QS60StyleEnums::SP_QgnGrafTabPassiveM,

   241             QS60StyleEnums::SP_QgnGrafTabPassiveL, Qt::Vertical, painter, rect, flags | SF_PointWest);

   242         break;

   243     case SE_ListHighlight:

   244         drawFrame(SF_ListHighlight, painter, rect, flags | SF_PointNorth);

   245         break;

   246     case SE_OptionsMenu:

   247         drawFrame(SF_OptionsMenu, painter, rect, flags | SF_PointNorth);

   248         break;

   249     case SE_SettingsList:

   250         drawFrame(SF_SettingsList, painter, rect, flags | SF_PointNorth);

   251         break;

   252     case SE_TableItem:

   253         drawFrame(SF_TableItem, painter, rect, flags | SF_PointNorth);

   254         break;

   255     case SE_TableHeaderItem:

   256         drawFrame(SF_TableHeaderItem, painter, rect, flags | SF_PointNorth);

   257         break;

   258     case SE_ToolTip:

   259         drawFrame(SF_ToolTip, painter, rect, flags | SF_PointNorth);

   260         break;

   261     case SE_ToolBar:

   262         drawFrame(SF_ToolBar, painter, rect, flags | SF_PointNorth);

   263         break;

   264     case SE_ToolBarButton:

   265         drawFrame(SF_ToolBarButton, painter, rect, flags | SF_PointNorth);

   266         break;

   267     case SE_ToolBarButtonPressed:

   268         drawFrame(SF_ToolBarButtonPressed, painter, rect, flags | SF_PointNorth);

   269         break;

   270     case SE_PanelBackground:

   271         drawFrame(SF_PanelBackground, painter, rect, flags | SF_PointNorth);

   272         break;

   273     case SE_ScrollBarHandlePressedHorizontal:

   274         drawRow(QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed, QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed,

   275             QS60StyleEnums::SP_QsnCpScrollHandleTopPressed, Qt::Horizontal, painter, rect, flags | SF_PointEast);

   276         break;

   277     case SE_ScrollBarHandlePressedVertical:

   278         drawRow(QS60StyleEnums::SP_QsnCpScrollHandleTopPressed, QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed,

   279             QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed, Qt::Vertical, painter, rect, flags | SF_PointNorth);

   280         break;

   281     case SE_ButtonInactive:

   282         drawFrame(SF_ButtonInactive, painter, rect, flags | SF_PointNorth);

   283         break;

   284     case SE_Editor:

   285         drawFrame(SF_Editor, painter, rect, flags | SF_PointNorth);

   286         break;

   287     default:

   288         break;

   289     }

   290 }

   291 

   292 void QS60StylePrivate::drawSkinPart(QS60StyleEnums::SkinParts part,

   293     QPainter *painter, const QRect &rect, SkinElementFlags flags)

   294 {

   295     drawPart(part, painter, rect, flags);

   296 }

   297 

   298 short QS60StylePrivate::pixelMetric(int metric)

   299 {

   300     Q_ASSERT(metric < MAX_PIXELMETRICS);

   301     const short returnValue = m_pmPointer[metric];

   302     return returnValue;

   303 }

   304 

   305 void QS60StylePrivate::setStyleProperty(const char *name, const QVariant &value)

   306 {

   307     if (name == propertyKeyCurrentlayout) {

   308         static const QStringList layouts = styleProperty(propertyKeyLayouts).toStringList();

   309         const QString layout = value.toString();

   310         Q_ASSERT(layouts.contains(layout));

   311         const int layoutIndex = layouts.indexOf(layout);

   312         setCurrentLayout(layoutIndex);

   313         QApplication::setLayoutDirection(m_layoutHeaders[layoutIndex].mirroring ? Qt::RightToLeft : Qt::LeftToRight);

   314         clearCaches();

   315         refreshUI();

   316     }

   317 }

   318 

   319 QVariant QS60StylePrivate::styleProperty(const char *name) const

   320 {

   321     if (name == propertyKeyLayouts) {

   322         static QStringList layouts;

   323         if (layouts.isEmpty())

   324             for (int i = 0; i < m_numberOfLayouts; i++)

   325                 layouts.append(QLatin1String(m_layoutHeaders[i].layoutName));

   326         return layouts;

   327     }

   328     return QVariant();

   329 }

   330 

   331 QColor QS60StylePrivate::stateColor(const QColor &color, const QStyleOption *option)

   332 {

   333     QColor retColor (color);

   334     if (option && !(option->state & QStyle::State_Enabled)) {

   335         QColor hsvColor = retColor.toHsv();

   336         int colorSat = hsvColor.saturation();

   337         int colorVal = hsvColor.value();

   338         colorSat = (colorSat!=0) ? (colorSat>>1) : 128;

   339         colorVal = (colorVal!=0) ? (colorVal>>1) : 128;

   340         hsvColor.setHsv(hsvColor.hue(), colorSat, colorVal);

   341         retColor = hsvColor.toRgb();

   342     }

   343     return retColor;

   344 }

   345 

   346 QColor QS60StylePrivate::lighterColor(const QColor &baseColor)

   347 {

   348     QColor result(baseColor);

   349     bool modifyColor = false;

   350     if (result.saturation() == 0) {

   351         result.setHsv(result.hue(), 128, result.value());

   352         modifyColor = true;

   353     }

   354     if (result.value() == 0) {

   355         result.setHsv(result.hue(), result.saturation(), 128);

   356         modifyColor = true;

   357     }

   358     if (modifyColor)

   359         result = result.lighter(175);

   360     else

   361         result = result.lighter(225);

   362     return result;

   363 }

   364 

   365 bool QS60StylePrivate::drawsOwnThemeBackground(const QWidget *widget)

   366 {

   367     return qobject_cast<const QDialog *> (widget);

   368 }

   369 

   370 QFont QS60StylePrivate::s60Font(

   371     QS60StyleEnums::FontCategories fontCategory, int pointSize) const

   372 {

   373     QFont result;

   374     int actualPointSize = pointSize;

   375     if (actualPointSize <= 0) {

   376         const QFont appFont = QApplication::font();

   377         actualPointSize = appFont.pointSize();

   378         if (actualPointSize <= 0)

   379             actualPointSize = appFont.pixelSize() * 72 / qt_defaultDpiY();

   380     }

   381     Q_ASSERT(actualPointSize > 0);

   382     const QPair<QS60StyleEnums::FontCategories, int> key(fontCategory, actualPointSize);

   383     if (!m_mappedFontsCache.contains(key)) {

   384         result = s60Font_specific(fontCategory, actualPointSize);

   385         m_mappedFontsCache.insert(key, result);

   386     } else {

   387         result = m_mappedFontsCache.value(key);

   388         if (result.pointSize() != actualPointSize)

   389             result.setPointSize(actualPointSize);

   390     }

   391     return result;

   392 }

   393 

   394 void QS60StylePrivate::clearCaches(CacheClearReason reason)

   395 {

   396     switch(reason){

   397     case CC_LayoutChange:

   398         // when layout changes, the colors remain in cache, but graphics and fonts can change

   399         m_mappedFontsCache.clear();

   400         deleteBackground();

   401         QPixmapCache::clear();

   402         break;

   403     case CC_ThemeChange:

   404         m_colorCache.clear();

   405         QPixmapCache::clear();

   406         deleteBackground();

   407         break;

   408     case CC_UndefinedChange:

   409     default:

   410         m_colorCache.clear();

   411         m_mappedFontsCache.clear();

   412         QPixmapCache::clear();

   413         deleteBackground();

   414         break;

   415     }

   416 }

   417 

   418 // Since S60Style has 'button' and 'tooltip' as a graphic, we don't have any native color which to use

   419 // for QPalette::Button and QPalette::ToolTipBase. Therefore S60Style needs to guesstimate

   420 // palette colors by calculating average rgb values for button pixels.

   421 // Returns Qt::black if there is an issue with the graphics (image is NULL, or no bits() found).

   422 QColor QS60StylePrivate::colorFromFrameGraphics(SkinFrameElements frame) const

   423 {

   424     const bool cachedColorExists = m_colorCache.contains(frame);

   425     if (!cachedColorExists) {

   426         const int frameCornerWidth = pixelMetric(PM_Custom_FrameCornerWidth);

   427         const int frameCornerHeight = pixelMetric(PM_Custom_FrameCornerHeight);

   428         Q_ASSERT(2*frameCornerWidth<32);

   429         Q_ASSERT(2*frameCornerHeight<32);

   430 

   431         const QImage frameImage = QS60StylePrivate::frame(frame, QSize(32,32)).toImage();

   432         Q_ASSERT(frameImage.bytesPerLine() > 0);

   433         if (frameImage.isNull())

   434             return Qt::black;

   435 

   436         const QRgb *pixelRgb = (const QRgb*)frameImage.bits();

   437         const int pixels = frameImage.numBytes()/sizeof(QRgb);

   438 

   439         int estimatedRed = 0;

   440         int estimatedGreen = 0;

   441         int estimatedBlue = 0;

   442 

   443         int skips = 0;

   444         int estimations = 0;

   445 

   446         const int topBorderLastPixel = frameCornerHeight*frameImage.width()-1;

   447         const int bottomBorderFirstPixel = frameImage.width()*frameImage.height()-frameCornerHeight*frameImage.width()-1;

   448         const int rightBorderFirstPixel = frameImage.width()-frameCornerWidth;

   449         const int leftBorderLastPixel = frameCornerWidth;

   450 

   451         while ((skips + estimations) < pixels) {

   452             if ((skips+estimations) > topBorderLastPixel &&

   453                 (skips+estimations) < bottomBorderFirstPixel) {

   454                 for (int rowIndex = 0; rowIndex < frameImage.width(); rowIndex++) {

   455                     if (rowIndex > leftBorderLastPixel &&

   456                         rowIndex < rightBorderFirstPixel) {

   457                         estimatedRed += qRed(*pixelRgb);

   458                         estimatedGreen += qGreen(*pixelRgb);

   459                         estimatedBlue += qBlue(*pixelRgb);

   460                     }

   461                     pixelRgb++;

   462                     estimations++;

   463                 }

   464             } else {

   465                 pixelRgb++;

   466                 skips++;

   467             }

   468         }

   469         QColor frameColor(estimatedRed/estimations, estimatedGreen/estimations, estimatedBlue/estimations);

   470         m_colorCache.insert(frame, frameColor);

   471         return !estimations ? Qt::black : frameColor;

   472     } else {

   473         return m_colorCache.value(frame);

   474     }

   475 

   476 }

   477 

   478 void QS60StylePrivate::setThemePalette(QApplication *app) const

   479 {

   480     Q_UNUSED(app)

   481     QPalette widgetPalette = QPalette(Qt::white);

   482     setThemePalette(&widgetPalette);

   483     QApplication::setPalette(widgetPalette); //calling QApplication::setPalette clears palette hash

   484     setThemePaletteHash(&widgetPalette);

   485     storeThemePalette(&widgetPalette);

   486 }

   487 

   488 void QS60StylePrivate::setThemePalette(QStyleOption *option) const

   489 {

   490     setThemePalette(&option->palette);

   491 }

   492 

   493 QPalette* QS60StylePrivate::themePalette()

   494 {

   495     return m_themePalette;

   496 }

   497 

   498 void QS60StylePrivate::setBackgroundTexture(QApplication *app) const

   499 {

   500     Q_UNUSED(app)

   501     QPalette applicationPalette = QApplication::palette();

   502     applicationPalette.setBrush(QPalette::Window, backgroundTexture());

   503     QApplication::setPalette(applicationPalette);

   504 }

   505 

   506 void QS60StylePrivate::deleteBackground()

   507 {

   508     if (m_background) {

   509         delete m_background;

   510         m_background = 0;

   511     }

   512 }

   513 

   514 void QS60StylePrivate::setCurrentLayout(int index)

   515 {

   516     m_pmPointer = data[index];

   517 }

   518 

   519 void QS60StylePrivate::drawPart(QS60StyleEnums::SkinParts skinPart,

   520     QPainter *painter, const QRect &rect, SkinElementFlags flags)

   521 {

   522     static const bool doCache =

   523 #if defined(Q_WS_S60)

   524         // Freezes on 3.1. Anyways, caching is only really needed on touch UI

   525         !(QSysInfo::s60Version() == QSysInfo::SV_S60_3_1 || QSysInfo::s60Version() == QSysInfo::SV_S60_3_2);

   526 #else

   527         true;

   528 #endif

   529     const QPixmap skinPartPixMap((doCache ? cachedPart : part)(skinPart, rect.size(), flags));

   530     if (!skinPartPixMap.isNull())

   531         painter->drawPixmap(rect.topLeft(), skinPartPixMap);

   532 }

   533 

   534 void QS60StylePrivate::drawFrame(SkinFrameElements frameElement, QPainter *painter, const QRect &rect, SkinElementFlags flags)

   535 {

   536     static const bool doCache =

   537 #if defined(Q_WS_S60)

   538         // Freezes on 3.1. Anyways, caching is only really needed on touch UI

   539         !(QSysInfo::s60Version() == QSysInfo::SV_S60_3_1 || QSysInfo::s60Version() == QSysInfo::SV_S60_3_2);

   540 #else

   541         true;

   542 #endif

   543     const QPixmap frameElementPixMap((doCache ? cachedFrame : frame)(frameElement, rect.size(), flags));

   544     if (!frameElementPixMap.isNull())

   545         painter->drawPixmap(rect.topLeft(), frameElementPixMap);

   546 }

   547 

   548 void QS60StylePrivate::drawRow(QS60StyleEnums::SkinParts start,

   549     QS60StyleEnums::SkinParts middle, QS60StyleEnums::SkinParts end,

   550     Qt::Orientation orientation, QPainter *painter, const QRect &rect,

   551     SkinElementFlags flags)

   552 {

   553     QSize startEndSize(partSize(start, flags));

   554     startEndSize.scale(rect.size(), Qt::KeepAspectRatio);

   555 

   556     QRect startRect = QRect(rect.topLeft(), startEndSize);

   557     QRect middleRect = rect;

   558     QRect endRect;

   559 

   560     if (orientation == Qt::Horizontal) {

   561         startRect.setWidth(qMin((rect.width() >> 1) - 1, startRect.width()));

   562         endRect = startRect.translated(rect.width() - startRect.width(), 0);

   563         middleRect.adjust(startRect.width(), 0, -startRect.width(), 0);

   564         if (startRect.bottomRight().x() > endRect.topLeft().x()) {

   565             const int overlap = (startRect.bottomRight().x() -  endRect.topLeft().x())>>1;

   566             startRect.setWidth(startRect.width()-overlap);

   567             endRect.adjust(overlap,0,0,0);

   568         }

   569     } else {

   570         startRect.setHeight(qMin((rect.height() >> 1) - 1, startRect.height()));

   571         endRect = startRect.translated(0, rect.height() - startRect.height());

   572         middleRect.adjust(0, startRect.height(), 0, -startRect.height());

   573         if (startRect.topRight().y() > endRect.bottomLeft().y()) {

   574             const int overlap = (startRect.topRight().y() - endRect.bottomLeft().y())>>1;

   575             startRect.setHeight(startRect.height()-overlap);

   576             endRect.adjust(0,overlap,0,0);

   577         }

   578     }

   579 

   580 #if 0

   581     painter->save();

   582     painter->setOpacity(.3);

   583     painter->fillRect(startRect, Qt::red);

   584     painter->fillRect(middleRect, Qt::green);

   585     painter->fillRect(endRect, Qt::blue);

   586     painter->restore();

   587 #else

   588     drawPart(start, painter, startRect, flags);

   589     if (middleRect.isValid())

   590         drawPart(middle, painter, middleRect, flags);

   591     drawPart(end, painter, endRect, flags);

   592 #endif

   593 }

   594 

   595 QPixmap QS60StylePrivate::cachedPart(QS60StyleEnums::SkinParts part,

   596     const QSize &size, SkinElementFlags flags)

   597 {

   598     QPixmap result;

   599     const QString cacheKey =

   600         QString::fromLatin1("S60Style: SkinParts=%1 QSize=%2|%3 SkinPartFlags=%4")

   601             .arg((int)part).arg(size.width()).arg(size.height()).arg((int)flags);

   602     if (!QPixmapCache::find(cacheKey, result)) {

   603         result = QS60StylePrivate::part(part, size, flags);

   604         QPixmapCache::insert(cacheKey, result);

   605     }

   606     return result;

   607 }

   608 

   609 QPixmap QS60StylePrivate::cachedFrame(SkinFrameElements frame, const QSize &size, SkinElementFlags flags)

   610 {

   611     QPixmap result;

   612     const QString cacheKey =

   613         QString::fromLatin1("S60Style: SkinFrameElements=%1 QSize=%2|%3 SkinElementFlags=%4")

   614             .arg((int)frame).arg(size.width()).arg(size.height()).arg((int)flags);

   615     if (!QPixmapCache::find(cacheKey, result)) {

   616         result = QS60StylePrivate::frame(frame, size, flags);

   617         QPixmapCache::insert(cacheKey, result);

   618     }

   619     return result;

   620 }

   621 

   622 void QS60StylePrivate::refreshUI()

   623 {

   624     QList<QWidget *> widgets = QApplication::allWidgets();

   625 

   626     for (int i = 0; i < widgets.size(); ++i) {

   627         QWidget *widget = widgets.at(i);

   628         if (widget == 0)

   629             continue;

   630 

   631         if (widget->style()) {

   632             widget->style()->polish(widget);

   633             QEvent event(QEvent::StyleChange);

   634             qApp->sendEvent(widget, &event);

   635         }

   636         widget->update();

   637         widget->updateGeometry();

   638     }

   639 }

   640 

   641 void QS60StylePrivate::setFont(QWidget *widget) const

   642 {

   643     QS60StyleEnums::FontCategories fontCategory = QS60StyleEnums::FC_Undefined;

   644     if (!widget)

   645         return;

   646     if (qobject_cast<QPushButton *>(widget)){

   647         fontCategory = QS60StyleEnums::FC_Primary;

   648     } else if (qobject_cast<QToolButton *>(widget)){

   649         fontCategory = QS60StyleEnums::FC_Primary;

   650     } else if (qobject_cast<QHeaderView *>(widget)){

   651         fontCategory = QS60StyleEnums::FC_Secondary;

   652     } else if (qobject_cast<QGroupBox *>(widget)){

   653         fontCategory = QS60StyleEnums::FC_Title;

   654     }

   655     if (fontCategory != QS60StyleEnums::FC_Undefined) {

   656         const QFont suggestedFont =

   657             s60Font(fontCategory, widget->font().pointSizeF());

   658         widget->setFont(suggestedFont);

   659     }

   660 }

   661 

   662 void QS60StylePrivate::setThemePalette(QWidget *widget) const

   663 {

   664     if(!widget)

   665         return;

   666     QPalette widgetPalette = QApplication::palette(widget);

   667 

   668     //header view and its viewport need to be set 100% transparent button color, since drawing code will

   669     //draw transparent theme graphics to table column and row headers.

   670     if (qobject_cast<QHeaderView *>(widget)){

   671         widgetPalette.setColor(QPalette::Active, QPalette::ButtonText,

   672             s60Color(QS60StyleEnums::CL_QsnTextColors, 23, 0));

   673         QHeaderView* header = qobject_cast<QHeaderView *>(widget);

   674         widgetPalette.setColor(QPalette::Button, Qt::transparent );

   675         if ( header->viewport() )

   676             header->viewport()->setPalette(widgetPalette);

   677         QApplication::setPalette(widgetPalette, "QHeaderView");

   678     }

   679 }

   680 

   681 void QS60StylePrivate::setThemePalette(QPalette *palette) const

   682 {

   683     if (!palette)

   684         return;

   685 

   686     // basic colors

   687     palette->setColor(QPalette::WindowText,

   688         s60Color(QS60StyleEnums::CL_QsnTextColors, 6, 0));

   689     palette->setColor(QPalette::ButtonText,

   690         s60Color(QS60StyleEnums::CL_QsnTextColors, 6, 0));

   691     palette->setColor(QPalette::Text,

   692         s60Color(QS60StyleEnums::CL_QsnTextColors, 6, 0));

   693     palette->setColor(QPalette::ToolTipText,

   694         s60Color(QS60StyleEnums::CL_QsnTextColors, 55, 0));

   695     palette->setColor(QPalette::BrightText, palette->color(QPalette::WindowText).lighter());

   696     palette->setColor(QPalette::HighlightedText,

   697         s60Color(QS60StyleEnums::CL_QsnTextColors, 10, 0));

   698     palette->setColor(QPalette::Link,

   699         s60Color(QS60StyleEnums::CL_QsnHighlightColors, 3, 0));

   700     palette->setColor(QPalette::LinkVisited, palette->color(QPalette::Link).darker());

   701     palette->setColor(QPalette::Highlight,

   702         s60Color(QS60StyleEnums::CL_QsnHighlightColors, 2, 0));

   703     // set background image as a texture brush

   704     palette->setBrush(QPalette::Window, backgroundTexture());

   705     // set these as transparent so that styled full screen theme background is visible

   706     palette->setColor(QPalette::AlternateBase, Qt::transparent);

   707     palette->setBrush(QPalette::Base, Qt::transparent);

   708     // set button and tooltipbase based on pixel colors

   709     const QColor buttonColor = colorFromFrameGraphics(SF_ButtonNormal);

   710     palette->setColor(QPalette::Button, buttonColor);

   711     const QColor toolTipColor = colorFromFrameGraphics(SF_ToolTip);

   712     palette->setColor(QPalette::ToolTipBase, toolTipColor);

   713     palette->setColor(QPalette::Light, palette->color(QPalette::Button).lighter());

   714     palette->setColor(QPalette::Dark, palette->color(QPalette::Button).darker());

   715     palette->setColor(QPalette::Midlight, palette->color(QPalette::Button).lighter(125));

   716     palette->setColor(QPalette::Mid, palette->color(QPalette::Button).darker(150));

   717     palette->setColor(QPalette::Shadow, Qt::black);

   718 }

   719 

   720 void QS60StylePrivate::deleteThemePalette()

   721 {

   722     if (m_themePalette) {

   723         delete m_themePalette;

   724         m_themePalette = 0;

   725     }

   726 }

   727 

   728 void QS60StylePrivate::storeThemePalette(QPalette *palette)

   729 {

   730     deleteThemePalette();

   731     //store specified palette for latter use.

   732     m_themePalette = new QPalette(*palette);

   733 }

   734 

   735 // set widget specific palettes

   736 void QS60StylePrivate::setThemePaletteHash(QPalette *palette) const

   737 {

   738     if (!palette)

   739         return;

   740 

   741     //store the original palette

   742     QPalette widgetPalette = *palette;

   743     const QColor mainAreaTextColor =

   744         s60Color(QS60StyleEnums::CL_QsnTextColors, 6, 0);

   745 

   746     widgetPalette.setColor(QPalette::All, QPalette::WindowText,

   747         s60Color(QS60StyleEnums::CL_QsnLineColors, 8, 0));

   748     QApplication::setPalette(widgetPalette, "QSlider");

   749     // return to original palette after each widget

   750     widgetPalette = *palette;

   751 

   752     widgetPalette.setColor(QPalette::Active, QPalette::ButtonText, mainAreaTextColor);

   753     widgetPalette.setColor(QPalette::Inactive, QPalette::ButtonText, mainAreaTextColor);

   754     const QStyleOption opt;

   755     widgetPalette.setColor(QPalette::Disabled, QPalette::ButtonText,

   756         s60Color(QS60StyleEnums::CL_QsnTextColors, 6, &opt));

   757     QApplication::setPalette(widgetPalette, "QPushButton");

   758     widgetPalette = *palette;

   759 

   760     widgetPalette.setColor(QPalette::Active, QPalette::ButtonText, mainAreaTextColor);

   761     widgetPalette.setColor(QPalette::Inactive, QPalette::ButtonText, mainAreaTextColor);

   762     QApplication::setPalette(widgetPalette, "QToolButton");

   763     widgetPalette = *palette;

   764 

   765     widgetPalette.setColor(QPalette::Active, QPalette::ButtonText,

   766         s60Color(QS60StyleEnums::CL_QsnTextColors, 23, 0));

   767     QApplication::setPalette(widgetPalette, "QHeaderView");

   768     widgetPalette = *palette;

   769 

   770     widgetPalette.setColor(QPalette::All, QPalette::ButtonText,

   771         s60Color(QS60StyleEnums::CL_QsnTextColors, 8, 0));

   772     QApplication::setPalette(widgetPalette, "QMenuBar");

   773     widgetPalette = *palette;

   774 

   775     widgetPalette.setColor(QPalette::Active, QPalette::WindowText,

   776         s60Color(QS60StyleEnums::CL_QsnTextColors, 4, 0));

   777     QApplication::setPalette(widgetPalette, "QTabBar");

   778     widgetPalette = *palette;

   779 

   780     widgetPalette.setColor(QPalette::All, QPalette::Text,

   781         s60Color(QS60StyleEnums::CL_QsnTextColors, 22, 0));

   782     QApplication::setPalette(widgetPalette, "QTableView");

   783     widgetPalette = *palette;

   784 

   785     widgetPalette.setColor(QPalette::All, QPalette::HighlightedText,

   786         s60Color(QS60StyleEnums::CL_QsnTextColors, 24, 0));

   787     QApplication::setPalette(widgetPalette, "QLineEdit");

   788     widgetPalette = *palette;

   789 

   790     widgetPalette.setColor(QPalette::All, QPalette::Text,

   791         s60Color(QS60StyleEnums::CL_QsnTextColors, 34, 0));

   792     widgetPalette.setColor(QPalette::All, QPalette::HighlightedText,

   793         s60Color(QS60StyleEnums::CL_QsnTextColors, 24, 0));

   794     QApplication::setPalette(widgetPalette, "QTextEdit");

   795     widgetPalette = *palette;

   796 

   797     widgetPalette.setColor(QPalette::All, QPalette::HighlightedText,

   798         s60Color(QS60StyleEnums::CL_QsnTextColors, 24, 0));

   799     QApplication::setPalette(widgetPalette, "QComboBox");

   800     widgetPalette = *palette;

   801 

   802     widgetPalette.setColor(QPalette::WindowText, mainAreaTextColor);

   803     widgetPalette.setColor(QPalette::Button, QApplication::palette().color(QPalette::Button));

   804     widgetPalette.setColor(QPalette::Dark, mainAreaTextColor.darker());

   805     widgetPalette.setColor(QPalette::Light, mainAreaTextColor.lighter());

   806     QApplication::setPalette(widgetPalette, "QDial");

   807     widgetPalette = *palette;

   808 

   809     widgetPalette.setBrush(QPalette::Window, QBrush());

   810     QApplication::setPalette(widgetPalette, "QScrollArea");

   811     widgetPalette = *palette;

   812 }

   813 

   814 QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlags flags)

   815 {

   816     QSize result(20, 20);

   817     switch (part)

   818         {

   819         case QS60StyleEnums::SP_QgnGrafBarProgress:

   820             result.setWidth(pixelMetric(QStyle::PM_ProgressBarChunkWidth));

   821             break;

   822         case QS60StyleEnums::SP_QgnGrafTabActiveM:

   823         case QS60StyleEnums::SP_QgnGrafTabPassiveM:

   824         case QS60StyleEnums::SP_QgnGrafTabActiveR:

   825         case QS60StyleEnums::SP_QgnGrafTabPassiveR:

   826         case QS60StyleEnums::SP_QgnGrafTabPassiveL:

   827         case QS60StyleEnums::SP_QgnGrafTabActiveL:

   828             break;

   829         case QS60StyleEnums::SP_QgnIndiSliderEdit:

   830             result.scale(pixelMetric(QStyle::PM_SliderLength),

   831                 pixelMetric(QStyle::PM_SliderControlThickness), Qt::IgnoreAspectRatio);

   832             break;

   833 

   834         case QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed:

   835         case QS60StyleEnums::SP_QsnCpScrollHandleTopPressed:

   836         case QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed:

   837         case QS60StyleEnums::SP_QsnCpScrollBgBottom:

   838         case QS60StyleEnums::SP_QsnCpScrollBgMiddle:

   839         case QS60StyleEnums::SP_QsnCpScrollBgTop:

   840         case QS60StyleEnums::SP_QsnCpScrollHandleBottom:

   841         case QS60StyleEnums::SP_QsnCpScrollHandleMiddle:

   842         case QS60StyleEnums::SP_QsnCpScrollHandleTop:

   843             result.setHeight(pixelMetric(QStyle::PM_ScrollBarExtent));

   844             result.setWidth(pixelMetric(QStyle::PM_ScrollBarSliderMin));

   845             break;

   846         default:

   847             // Generic frame part size gathering.

   848             for (int i = 0; i < frameElementsCount; ++i)

   849             {

   850                 switch (m_frameElementsData[i].center - part) {

   851                     case 8: /* CornerTl */

   852                     case 7: /* CornerTr */

   853                     case 6: /* CornerBl */

   854                     case 5: /* CornerBr */

   855                         result.setWidth(pixelMetric(PM_Custom_FrameCornerWidth));

   856                         // Falltrough intended...

   857                     case 4: /* SideT */

   858                     case 3: /* SideB */

   859                         result.setHeight(pixelMetric(PM_Custom_FrameCornerHeight));

   860                         break;

   861                     case 2: /* SideL */

   862                     case 1: /* SideR */

   863                         result.setWidth(pixelMetric(PM_Custom_FrameCornerWidth));

   864                         break;

   865                     case 0: /* center */

   866                     default:

   867                         break;

   868                 }

   869             }

   870             break;

   871     }

   872     if (flags & (SF_PointEast | SF_PointWest)) {

   873         const int temp = result.width();

   874         result.setWidth(result.height());

   875         result.setHeight(temp);

   876     }

   877     return result;

   878 }

   879 

   880 /*!

   881   \class QS60Style

   882   \brief The QS60Style class provides a look and feel suitable for applications on S60.

   883   \since 4.6

   884   \ingroup appearance

   885 

   886   \sa QMacStyle, QWindowsStyle, QWindowsXPStyle, QWindowsVistaStyle, QPlastiqueStyle, QCleanlooksStyle, QMotifStyle

   887 */

   888 

   889 

   890 /*!

   891     Destroys the style.

   892 */

   893 QS60Style::~QS60Style()

   894 {

   895 }

   896 

   897 /*!

   898   \reimp

   899 */

   900 void QS60Style::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget) const

   901 {

   902     const QS60StylePrivate::SkinElementFlags flags = (option->state & State_Enabled) ?  QS60StylePrivate::SF_StateEnabled : QS60StylePrivate::SF_StateDisabled;

   903     SubControls sub = option->subControls;

   904 

   905     switch (control) {

   906 #ifndef QT_NO_SCROLLBAR

   907     case CC_ScrollBar:

   908         if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {

   909             const bool horizontal = optionSlider->orientation == Qt::Horizontal;

   910 

   911             const QRect scrollBarSlider = subControlRect(control, optionSlider, SC_ScrollBarSlider, widget);

   912             const QRect grooveRect = subControlRect(control, optionSlider, SC_ScrollBarGroove, widget);

   913 

   914             const QS60StylePrivate::SkinElements grooveElement =

   915                 horizontal ? QS60StylePrivate::SE_ScrollBarGrooveHorizontal : QS60StylePrivate::SE_ScrollBarGrooveVertical;

   916             QS60StylePrivate::drawSkinElement(grooveElement, painter, grooveRect, flags);

   917 

   918             const QStyle::SubControls subControls = optionSlider->subControls;

   919 

   920             // select correct slider (horizontal/vertical/pressed)

   921             const bool sliderPressed = ((optionSlider->state & QStyle::State_Sunken) && (subControls & SC_ScrollBarSlider));

   922             const QS60StylePrivate::SkinElements handleElement =

   923                 horizontal ?

   924                     ( sliderPressed ?

   925                         QS60StylePrivate::SE_ScrollBarHandlePressedHorizontal :

   926                         QS60StylePrivate::SE_ScrollBarHandleHorizontal ) :

   927                     ( sliderPressed ?

   928                         QS60StylePrivate::SE_ScrollBarHandlePressedVertical :

   929                         QS60StylePrivate::SE_ScrollBarHandleVertical);

   930             QS60StylePrivate::drawSkinElement(handleElement, painter, scrollBarSlider, flags);

   931         }

   932         break;

   933 #endif // QT_NO_SCROLLBAR

   934 #ifndef QT_NO_SLIDER

   935     case CC_Slider:

   936         if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {

   937 

   938             // The groove is just a centered line. Maybe a qgn_graf_line_* at some point

   939             const QRect sliderGroove = subControlRect(control, optionSlider, SC_SliderGroove, widget);

   940             const QPoint sliderGrooveCenter = sliderGroove.center();

   941             const bool horizontal = optionSlider->orientation == Qt::Horizontal;

   942             painter->save();

   943             if (widget)

   944                 painter->setPen(widget->palette().windowText().color());

   945             if (horizontal)

   946                 painter->drawLine(0, sliderGrooveCenter.y(), sliderGroove.right(), sliderGrooveCenter.y());

   947             else

   948                 painter->drawLine(sliderGrooveCenter.x(), 0, sliderGrooveCenter.x(), sliderGroove.bottom());

   949             painter->restore();

   950 

   951             const QRect sliderHandle = subControlRect(control, optionSlider, SC_SliderHandle, widget);

   952             const QS60StylePrivate::SkinElements handleElement =

   953                 horizontal ? QS60StylePrivate::SE_SliderHandleHorizontal : QS60StylePrivate::SE_SliderHandleVertical;

   954             QS60StylePrivate::drawSkinElement(handleElement, painter, sliderHandle, flags);

   955         }

   956         break;

   957 #endif // QT_NO_SLIDER

   958 #ifndef QT_NO_COMBOBOX

   959     case CC_ComboBox:

   960         if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {

   961             const QRect cmbxEditField = subControlRect(CC_ComboBox, option, SC_ComboBoxEditField, widget);

   962             const QRect cmbxFrame = subControlRect(CC_ComboBox, option, SC_ComboBoxFrame, widget);

   963             const bool direction = cmb->direction == Qt::LeftToRight;

   964 

   965             // Button frame

   966             QStyleOptionFrame  buttonOption;

   967             buttonOption.QStyleOption::operator=(*cmb);

   968             const int maxHeight = cmbxFrame.height();

   969             const int maxWidth = cmbxFrame.width() - cmbxEditField.width();

   970             const int topLeftPoint = direction ? cmbxEditField.right()+1 : cmbxEditField.left()+1-maxWidth;

   971             const QRect buttonRect(topLeftPoint, cmbxEditField.top(), maxWidth, maxHeight);

   972             buttonOption.rect = buttonRect;

   973             buttonOption.state = cmb->state & (State_Enabled | State_MouseOver);

   974             drawPrimitive(PE_PanelButtonCommand, &buttonOption, painter, widget);

   975 

   976             // draw label background - label itself is drawn separately

   977             const QS60StylePrivate::SkinElements skinElement = QS60StylePrivate::SE_FrameLineEdit;

   978             QS60StylePrivate::drawSkinElement(skinElement, painter, cmbxEditField, flags);

   979 

   980             // Draw the combobox arrow

   981             if (sub & SC_ComboBoxArrow) {

   982                 // Make rect slightly smaller

   983                 buttonOption.rect.adjust(1, 1, -1, -1);

   984                 painter->save();

   985                 painter->setPen(option->palette.buttonText().color());

   986                 drawPrimitive(PE_IndicatorSpinDown, &buttonOption, painter, widget);

   987                 painter->restore();

   988             }

   989         }

   990         break;

   991 #endif // QT_NO_COMBOBOX

   992 #ifndef QT_NO_TOOLBUTTON

   993     case CC_ToolButton:

   994         if (const QStyleOptionToolButton *toolBtn = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {

   995             const State bflags = toolBtn->state;

   996             const QRect button(subControlRect(control, toolBtn, SC_ToolButton, widget));

   997             QStyleOptionToolButton toolButton = *toolBtn;

   998 

   999             if (sub&SC_ToolButton) {

  1000                 QStyleOption tool(0);

  1001                 tool.palette = toolBtn->palette;

  1002 

  1003                 // Check if toolbutton is in toolbar.

  1004                 QToolBar *toolBar = 0;

  1005                 if (widget)

  1006                     toolBar = qobject_cast<QToolBar *>(widget->parentWidget());

  1007 

  1008                 if (bflags & (State_Sunken | State_On | State_Raised)) {

  1009                     tool.rect = button;

  1010                     tool.state = bflags;

  1011 

  1012                     // todo: I'd like to move extension button next to where last button is

  1013                     // however, the painter seems to want to clip the button rect even if I turn of the clipping.

  1014                     if (toolBar && (qobject_cast<const QToolBarExtension *>(widget))){

  1015                         /*QList<QAction *> actionList = toolBar->actions();

  1016                         const int actionCount = actionList.count();

  1017                         const int toolbarWidth = toolBar->width();

  1018                         const int extButtonWidth = pixelMetric(PM_ToolBarExtensionExtent, option, widget);

  1019                         const int toolBarButtonWidth = pixelMetric(PM_ToolBarIconSize, option, widget);

  1020                         const int frame = pixelMetric(PM_ToolBarFrameWidth, option, widget);

  1021                         const int margin = pixelMetric(PM_ToolBarItemMargin, option, widget);

  1022                         const int border = frame + margin;

  1023                         const int spacing = pixelMetric(PM_ToolBarItemSpacing, option, widget);

  1024                         const int toolBarButtonArea = toolbarWidth - extButtonWidth - spacing - 2*border;

  1025                         const int numberOfVisibleButtons = toolBarButtonArea / toolBarButtonWidth;

  1026                         // new extension button place is after border and all the other visible buttons (with spacings)

  1027                         const int newXForExtensionButton = numberOfVisibleButtons * toolBarButtonWidth + (numberOfVisibleButtons-1)*spacing + border;

  1028                         painter->save();

  1029                         painter->setClipping(false);

  1030                         tool.rect.translate(-newXForExtensionButton,0);

  1031                         painter->restore();*/

  1032                     }

  1033 

  1034                     if (toolBar){

  1035                         /*if (toolBar->orientation() == Qt::Vertical){

  1036                             // todo: I'd like to make all vertical buttons the same size, but again the painter

  1037                             // prefers to use clipping for button rects, even though clipping has been set off.

  1038                             painter->save();

  1039                             painter->setClipping(false);

  1040 

  1041                             const int origWidth = tool.rect.width();

  1042                             const int newWidth = toolBar->width()-2*pixelMetric(PM_ToolBarFrameWidth, option, widget);

  1043                             painter->translate(origWidth-newWidth,0);

  1044                             tool.rect.translate(origWidth-tool.rect.width(),0);

  1045                             tool.rect.setWidth(newWidth);

  1046 

  1047                             if (option->state & QStyle::State_Sunken)

  1048                                 QS60StylePrivate::drawSkinElement(QS60StylePrivate::SE_ToolBarButtonPressed, painter, tool.rect, flags);

  1049                             else

  1050                                 QS60StylePrivate::drawSkinElement(QS60StylePrivate::SE_ToolBarButton, painter, tool.rect, flags);

  1051 

  1052                         }*/

  1053                         if (option->state & QStyle::State_Sunken)

  1054                             QS60StylePrivate::drawSkinElement(QS60StylePrivate::SE_ToolBarButtonPressed, painter, tool.rect, flags);

  1055                         else

  1056                             QS60StylePrivate::drawSkinElement(QS60StylePrivate::SE_ToolBarButton, painter, tool.rect, flags);

  1057                         /*

  1058                         if (toolBar->orientation() == Qt::Vertical)

  1059                             painter->restore();

  1060                             */

  1061                     } else {

  1062                         drawPrimitive(PE_PanelButtonTool, &tool, painter, widget);

  1063                     }

  1064                 }

  1065             }

  1066 

  1067             if (toolBtn->features & QStyleOptionToolButton::Arrow) {

  1068                 QStyle::PrimitiveElement pe;

  1069                 switch (toolBtn->arrowType) {

  1070                     case Qt::LeftArrow:

  1071                         pe = QStyle::PE_IndicatorArrowLeft;

  1072                         break;

  1073                     case Qt::RightArrow:

  1074                         pe = QStyle::PE_IndicatorArrowRight;

  1075                         break;

  1076                     case Qt::UpArrow:

  1077                         pe = QStyle::PE_IndicatorArrowUp;

  1078                         break;

  1079                     case Qt::DownArrow:

  1080                         pe = QStyle::PE_IndicatorArrowDown;

  1081                         break;

  1082                     default:

  1083                         break; }

  1084                 toolButton.rect = button;

  1085                 drawPrimitive(pe, &toolButton, painter, widget);

  1086             }

  1087 

  1088             if (toolBtn->text.length()>0 ||

  1089                 !toolBtn->icon.isNull()) {

  1090                 const int frameWidth = pixelMetric(PM_DefaultFrameWidth, option, widget);

  1091                 toolButton.rect = button.adjusted(frameWidth, frameWidth, -frameWidth, -frameWidth);

  1092                 drawControl(CE_ToolButtonLabel, &toolButton, painter, widget);

  1093                 }

  1094             }

  1095         break;

  1096 #endif //QT_NO_TOOLBUTTON

  1097 #ifndef QT_NO_SPINBOX

  1098     case CC_SpinBox:

  1099         if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {

  1100             QStyleOptionSpinBox copy = *spinBox;

  1101             PrimitiveElement pe;

  1102 

  1103             if (spinBox->subControls & SC_SpinBoxUp) {

  1104                 copy.subControls = SC_SpinBoxUp;

  1105                 QPalette spinBoxPal = spinBox->palette;

  1106                 if (!(spinBox->stepEnabled & QAbstractSpinBox::StepUpEnabled)) {

  1107                     spinBoxPal.setCurrentColorGroup(QPalette::Disabled);

  1108                     copy.state &= ~State_Enabled;

  1109                     copy.palette = spinBoxPal;

  1110                 }

  1111 

  1112                 if (spinBox->activeSubControls == SC_SpinBoxUp && (spinBox->state & State_Sunken)) {

  1113                     copy.state |= State_On;

  1114                     copy.state |= State_Sunken;

  1115                 } else {

  1116                     copy.state |= State_Raised;

  1117                     copy.state &= ~State_Sunken;

  1118                 }

  1119                 pe = (spinBox->buttonSymbols == QAbstractSpinBox::PlusMinus) ?

  1120                       PE_IndicatorSpinPlus :

  1121                       PE_IndicatorSpinUp;

  1122 

  1123                 copy.rect = subControlRect(CC_SpinBox, spinBox, SC_SpinBoxUp, widget);

  1124                 drawPrimitive(PE_PanelButtonBevel, &copy, painter, widget);

  1125                 copy.rect.adjust(1, 1, -1, -1);

  1126                 drawPrimitive(pe, &copy, painter, widget);

  1127             }

  1128 

  1129             if (spinBox->subControls & SC_SpinBoxDown) {

  1130                 copy.subControls = SC_SpinBoxDown;

  1131                 copy.state = spinBox->state;

  1132                 QPalette spinBoxPal = spinBox->palette;

  1133                 if (!(spinBox->stepEnabled & QAbstractSpinBox::StepDownEnabled)) {

  1134                     spinBoxPal.setCurrentColorGroup(QPalette::Disabled);