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 module 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 "qwindowscestyle.h"

    43 

    44 #if !defined(QT_NO_STYLE_WINDOWSCE) || defined(QT_PLUGIN)

    45 

    46 #include "qpainterpath.h"

    47 #include "qapplication.h"

    48 #include "qdockwidget.h"

    49 #include "qtoolbar.h"

    50 #include "qpaintengine.h"

    51 #include "qpainter.h"

    52 #include "qstyleoption.h"

    53 #include "qwindowscestyle_p.h"

    54 #include "qdebug.h"

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 static const int windowsItemFrame        =  2; // menu item frame width

    59 static const int windowsItemHMargin      =  3; // menu item hor text margin

    60 static const int windowsItemVMargin      =  2; // menu item ver text margin

    61 static const int windowsArrowHMargin	 =  6; // arrow horizontal margin

    62 static const int windowsRightBorder      = 15; // right border on windows

    63 static const int windowsCheckMarkWidth   = 14; // checkmarks width on windows

    64 

    65 static const int windowsCEitemViewCheckBoxSize   = 14;

    66 static const int windowsCEFrameGroupBoxOffset    = 9;

    67 static const int windowsCEIndicatorSize          = 14;

    68 static const int windowsCEExclusiveIndicatorSize = 14;

    69 static const int windowsCESliderThickness        = 24;

    70 static const int windowsCEIconSize               = 16;

    71 

    72 static const QColor windowsCECheckBoxGradientColorBegin = QColor(222, 224, 214);

    73 static const QColor windowsCECheckBoxGradientColorEnd   =  QColor(255, 255, 255);

    74 

    75 enum QSliderDirection { SlUp, SlDown, SlLeft, SlRight };

    76 

    77 QWindowsCEStyle::QWindowsCEStyle() : QWindowsStyle() {

    78     qApp->setEffectEnabled(Qt::UI_FadeMenu, false);

    79     qApp->setEffectEnabled(Qt::UI_AnimateMenu, false);

    80 }

    81 

    82 void QWindowsCEStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,

    83                                     QPainter *painter, const QWidget *widget) const {

    84 

    85     bool doRestore = false;

    86     QRect rect = option->rect;

    87 

    88     switch (element) {

    89     case PE_PanelButtonTool: {

    90         if (

    91 #ifndef QT_NO_TOOLBAR

    92              (widget && qobject_cast<QToolBar*>(widget->parentWidget())) ||

    93 #endif

    94 #ifndef QT_NO_DOCKWIDGET

    95              (widget && widget->inherits("QDockWidgetTitleButton")) ||

    96 #endif

    97             (option->state & (State_Sunken | State_On)))

    98                QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect.adjusted(0, 0, 0, 0),

    99                   option->palette, option->state & (State_Sunken | State_On),

   100                   &option->palette.button());

   101         if (option->state & (State_On)){

   102             QBrush fill = QBrush(option->palette.midlight().color(), Qt::Dense4Pattern);

   103             painter->fillRect(option->rect.adjusted(windowsItemFrame , windowsItemFrame ,

   104                               -windowsItemFrame , -windowsItemFrame ), fill);

   105         }

   106         break; }

   107     case PE_IndicatorButtonDropDown:

   108         QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect, option->palette,

   109             option->state & (State_Sunken | State_On),

   110             &option->palette.brush(QPalette::Button));

   111         break;

   112 #ifndef QT_NO_TABBAR

   113         case PE_IndicatorTabTear:

   114         if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {

   115             bool rtl = tab->direction == Qt::RightToLeft;

   116             QRect rect = tab->rect;

   117             QPainterPath path;

   118             rect.setTop(rect.top() + ((tab->state & State_Selected) ? 1 : 3));

   119             rect.setBottom(rect.bottom() - ((tab->state & State_Selected) ? 0 : 2));

   120             path.moveTo(QPoint(rtl ? rect.right() : rect.left(), rect.top()));

   121             int count = 3;

   122             for(int jags = 1; jags <= count; ++jags, rtl = !rtl)

   123                 path.lineTo(QPoint(rtl ? rect.left() : rect.right(), rect.top() + jags * rect.height()/count));

   124 

   125             painter->setPen(QPen(tab->palette.light(), qreal(.8)));

   126             painter->setBrush(tab->palette.background());

   127             painter->setRenderHint(QPainter::Antialiasing);

   128             painter->drawPath(path);

   129         }

   130         break;

   131 #endif //QT_NO_TABBAR

   132 #ifndef QT_NO_TOOLBAR

   133         case PE_IndicatorToolBarSeparator:

   134             //nothing to draw on WindowsCE

   135             break;

   136         case PE_IndicatorToolBarHandle:

   137             painter->save();

   138             painter->translate(option->rect.x(), option->rect.y());

   139             if (option->state & State_Horizontal) {

   140                 int x = option->rect.width() / 2 - 4;

   141                 if (QApplication::layoutDirection() == Qt::RightToLeft)

   142                     x -= 2;

   143                 if (option->rect.height() > 4) {

   144                     QWindowsCEStylePrivate::drawWinCEButton(painter,x - 1, 0, 7, option->rect.height(),

   145                         option->palette, false,  0);

   146                     QWindowsCEStylePrivate::drawWinCEPanel(painter, x, 1, 3, option->rect.height() - 1,

   147                         option->palette, false, 0);

   148                     QWindowsCEStylePrivate::drawWinCEPanel(painter, x + 3, 1, 3, option->rect.height() - 1,

   149                         option->palette, false, 0);

   150                     painter->setPen(option->palette.button().color());

   151                     painter->drawLine(x + 4, 2, x + 4,option->rect.height() - 2);

   152                 }

   153             } else {

   154                 if (option->rect.width() > 4) {

   155                     int y = option->rect.height() / 2 - 4;

   156                     QWindowsCEStylePrivate::drawWinCEPanel(painter, 2, y, option->rect.width() - 2, 3,

   157                         option->palette, false,  0);

   158                     QWindowsCEStylePrivate::drawWinCEPanel(painter, 2, y + 3, option->rect.width() - 2, 3,

   159                         option->palette, false,  0);

   160                 }

   161             }

   162             painter->restore();

   163             break;

   164 

   165 #endif // QT_NO_TOOLBAR

   166         case PE_FrameButtonTool: {

   167 #ifndef QT_NO_DOCKWIDGET

   168             if (widget && widget->inherits("QDockWidgetTitleButton")) {

   169                 if (const QDockWidget *dw = qobject_cast<const QDockWidget *>(widget->parent()))

   170                     if (dw->isFloating()){

   171                         QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect.adjusted(1, 1, 0, 0),

   172                                                                 option->palette, option->state & (State_Sunken | State_On),

   173                             &option->palette.button());

   174                         return;

   175                     }

   176             }

   177 #endif // QT_NO_DOCKWIDGET

   178         QBrush fill;

   179         bool stippled;

   180         bool panel = (element == PE_PanelButtonTool);

   181         if ((!(option->state & State_Sunken ))

   182             && (!(option->state & State_Enabled)

   183             || ((option->state & State_Enabled ) && !(option->state & State_MouseOver)))

   184             && (option->state & State_On)) {

   185                 fill = QBrush(option->palette.light().color(), Qt::Dense4Pattern);

   186                 stippled = true;

   187         } else {

   188             fill = option->palette.brush(QPalette::Button);

   189             stippled = false;

   190         }

   191         if (option->state & (State_Raised | State_Sunken | State_On)) {

   192             if (option->state & State_AutoRaise) {

   193                 if(option->state & (State_Enabled | State_Sunken | State_On)){

   194                     if (panel)

   195                         QWindowsCEStylePrivate::drawWinCEPanel(painter, option->rect, option->palette,

   196                         option->state & (State_Sunken | State_On), &fill);

   197                     else

   198                         qDrawShadeRect(painter, option->rect, option->palette,

   199                         option->state & (State_Sunken | State_On), 1);

   200                 }

   201                 if (stippled) {

   202                     painter->setPen(option->palette.button().color());

   203                     painter->drawRect(option->rect.adjusted(1, 1, -2, -2));

   204                 }

   205             } else {

   206                 QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect, option->palette,

   207                     option->state & (State_Sunken | State_On), panel ? &fill : 0);

   208             }

   209         } else {

   210             painter->fillRect(option->rect, fill);

   211         }

   212         break; }

   213 

   214     case PE_PanelButtonBevel: {

   215         QBrush fill;

   216         bool panel = element != PE_FrameButtonBevel;

   217         painter->setBrushOrigin(option->rect.topLeft());

   218         if (!(option->state & State_Sunken) && (option->state & State_On))

   219             fill = QBrush(option->palette.light().color(), Qt::Dense4Pattern);

   220         else

   221             fill = option->palette.brush(QPalette::Button);

   222 

   223         if (option->state & (State_Raised | State_On | State_Sunken)) {

   224             QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect, option->palette,

   225                                                     option->state & (State_Sunken | State_On),

   226                 panel ? &fill : 0); ;

   227         } else {

   228             if (panel)

   229                 painter->fillRect(option->rect, fill);

   230             else

   231                 painter->drawRect(option->rect);

   232         }

   233         break; }

   234 

   235     case PE_FrameGroupBox:

   236         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(option)) {

   237             QRect fr = frame->rect;

   238             painter->setPen(frame->palette.shadow().color());

   239             painter->drawRect(fr.x(), fr.y(), fr.x() + fr.width() - 1,

   240                               fr.y() + fr.height() - windowsCEFrameGroupBoxOffset);

   241         }

   242         break;

   243 

   244    case PE_IndicatorCheckBox: {

   245         QBrush fill;

   246         if (option->state & State_NoChange)

   247             fill = QBrush(option->palette.base().color(), Qt::Dense4Pattern);

   248         else if (option->state & State_Sunken)

   249             fill = option->palette.button();

   250         else if (option->state & State_Enabled)

   251             fill = option->palette.base();

   252         else

   253             fill = option->palette.background();

   254         painter->save();

   255         doRestore = true;

   256         painter->fillRect(option->rect,fill);

   257         painter->setPen(option->palette.dark().color());

   258         painter->drawRect(option->rect);

   259         painter->setPen(option->palette.shadow().color());

   260         painter->drawLine(option->rect.x() + 1,option->rect.y() + 1,

   261                           option->rect.x() + option->rect.width() - 1, option->rect.y() + 1);

   262         painter->drawLine(option->rect.x() + 1,option->rect.y() + 1,

   263                           option->rect.x() + 1, option->rect.y() + option->rect.height() - 1);

   264         //fall through...

   265     }

   266     case PE_IndicatorViewItemCheck:

   267     case PE_Q3CheckListIndicator: {

   268         if (!doRestore) {

   269             painter->save();

   270             doRestore = true;

   271         }

   272         int arrowSize= 2;

   273         if (element == PE_Q3CheckListIndicator || element == PE_IndicatorViewItemCheck) {

   274             QLinearGradient linearGradient(QPoint(option->rect.x(),option->rect.y()), QPoint(option->rect.x()+option->rect.width(),

   275                                            option->rect.y()+option->rect.height()));

   276             linearGradient.setColorAt(0, windowsCECheckBoxGradientColorBegin);

   277             linearGradient.setColorAt(1, windowsCECheckBoxGradientColorEnd);

   278             painter->setBrush(linearGradient);

   279             painter->setPen(Qt::NoPen);

   280             if (option->state & State_NoChange)

   281                 painter->setBrush(option->palette.brush(QPalette::Button));

   282             painter->setPen(option->palette.link().color());

   283             painter->drawRect(option->rect.x(), option->rect.y(), windowsCEitemViewCheckBoxSize, windowsCEitemViewCheckBoxSize);

   284             painter->setPen(option->palette.brightText().color());

   285             arrowSize= 3;

   286         }

   287         if (!(option->state & State_Off)) {

   288             QLineF lines[9];

   289             int i, xx, yy;

   290             xx = option->rect.x() + 4;

   291             yy = option->rect.y() + 6;

   292             for (i = 0; i < 4; ++i) {

   293                 lines[i] = QLineF(xx, yy, xx, yy + arrowSize);

   294                 ++xx;

   295                 ++yy;

   296             }

   297             yy -= 2;

   298             for (i = 4; i < 9; ++i) {

   299                 lines[i] = QLineF(xx, yy, xx, yy + arrowSize);

   300                 ++xx;

   301                 --yy;

   302             }

   303             painter->drawLines(lines, 9);

   304         }

   305         if (doRestore)

   306             painter->restore();

   307 

   308         break; }

   309     case PE_IndicatorRadioButton: {

   310         QRect ir = option->rect;

   311         painter->save();

   312         painter->setPen(Qt::NoPen);

   313         painter->setBrush(option->palette.light());

   314         painter->drawEllipse(option->rect);

   315         painter->setPen(option->palette.shadow().color());

   316         painter->setBrush(option->palette.shadow().color());

   317         painter->drawArc(option->rect, 0, 360 * 16);

   318         painter->drawArc(option->rect.x() + 1, option->rect.y() + 1, option->rect.width() - 2,

   319                          option->rect.height() - 2, 40 * 16, 180 * 16);

   320         painter->setPen(option->palette.light().color());

   321         painter->drawPoint(option->rect.x() + 11, option->rect.y() + 3);

   322         painter->drawPoint(option->rect.x() + 3,option->rect.y() + 3);

   323         painter->setPen(option->palette.shadow().color());

   324         painter->drawPoint(option->rect.x() +3,option->rect.y() + 12);

   325         if (option->state & (State_Sunken | State_On)) {

   326             painter->setPen(Qt::NoPen);

   327             painter->setBrush(option->palette.text());

   328             painter->drawEllipse(option->rect.x() +3,option->rect.y()+ 2,9,10);

   329         }

   330         painter->restore();

   331         break; }

   332    case PE_PanelMenuBar:

   333        painter->save();

   334        painter->setPen(option->palette.shadow().color());

   335        painter->drawRect(option->rect);

   336        painter->restore();

   337        break;

   338    case PE_PanelButtonCommand:

   339        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {

   340            QBrush fill;

   341            State flags = option->state;

   342            QPalette pal = option->palette;

   343            QRect r = option->rect;

   344            if (! (flags & State_Sunken) && (flags & State_On))

   345                fill = QBrush(pal.light().color(), Qt::Dense4Pattern);

   346            else

   347                fill = pal.brush(QPalette::Button);

   348            if (btn->features & QStyleOptionButton::DefaultButton && flags & State_Sunken) {

   349                painter->setPen(pal.dark().color());

   350                painter->setBrush(fill);

   351                painter->drawRect(r.adjusted(0, 0, -1, -1));

   352            } else if (flags & (State_Raised | State_Sunken | State_On | State_Sunken)) {

   353                QWindowsCEStylePrivate::drawWinCEButton(painter, r, pal, flags & (State_Sunken | State_On),

   354                    &fill);

   355            } else {

   356                painter->fillRect(r, fill);

   357            }

   358 

   359        }

   360        break;

   361    case PE_FrameDefaultButton: {

   362        painter->setPen(option->palette.shadow().color());

   363        QRect rect = option->rect;

   364        rect.adjust(0, 0, -1, -1);

   365        painter->drawRect(rect);

   366        break; }

   367    case PE_IndicatorSpinPlus:

   368    case PE_IndicatorSpinMinus: {

   369        QRect r = option->rect;

   370        int fw = pixelMetric(PM_DefaultFrameWidth, option, widget)+2;

   371        QRect br = r.adjusted(fw, fw, -fw, -fw);

   372        int offset = (option->state & State_Sunken) ? 1 : 0;

   373        int step = (br.width() + 4) / 5;

   374        painter->fillRect(br.x() + offset, br.y() + offset +br.height() / 2 - step / 2,

   375            br.width(), step,

   376            option->palette.buttonText());

   377        if (element == PE_IndicatorSpinPlus)

   378            painter->fillRect(br.x() + br.width() / 2 - step / 2 + offset, br.y() + offset+4,

   379            step, br.height()-7,

   380            option->palette.buttonText());

   381        break; }

   382     case PE_IndicatorSpinUp:

   383     case PE_IndicatorSpinDown: {

   384         painter->save();

   385             QPoint points[7];

   386             switch (element) {

   387                 case PE_IndicatorSpinUp:

   388                     points[0] = QPoint(-2, -4);

   389                     points[1] = QPoint(-2, 2);

   390                     points[2] = QPoint(-1, -3);

   391                     points[3] = QPoint(-1, 1);

   392                     points[4] = QPoint(0, -2);

   393                     points[5] = QPoint(0, 0);

   394                     points[6] = QPoint(1, -1);

   395                 break;

   396                 case PE_IndicatorSpinDown:

   397                     points[0] = QPoint(0, -4);

   398                     points[1] = QPoint(0, 2);

   399                     points[2] = QPoint(-1, -3);

   400                     points[3] = QPoint(-1, 1);

   401                     points[4] = QPoint(-2, -2);

   402                     points[5] = QPoint(-2, 0);

   403                     points[6] = QPoint(-3, -1);

   404                 break;

   405                 default:

   406                 break;

   407             }

   408             if (option->state & State_Sunken)

   409                 painter->translate(pixelMetric(PM_ButtonShiftHorizontal),

   410                 pixelMetric(PM_ButtonShiftVertical));

   411             if (option->state & State_Enabled) {

   412                 painter->translate(option->rect.x() + option->rect.width() / 2,

   413                                    option->rect.y() + option->rect.height() / 2);

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

   415                 painter->drawLine(points[0], points[1]);

   416                 painter->drawLine(points[2], points[3]);

   417                 painter->drawLine(points[4], points[5]);

   418                 painter->drawPoint(points[6]);

   419             } else {

   420                 painter->translate(option->rect.x() + option->rect.width() / 2 + 1,

   421                                    option->rect.y() + option->rect.height() / 2 + 1);

   422                 painter->setPen(option->palette.light().color());

   423                 painter->drawLine(points[0], points[1]);

   424                 painter->drawLine(points[2], points[3]);

   425                 painter->drawLine(points[4], points[5]);

   426                 painter->drawPoint(points[6]);

   427                 painter->translate(-1, -1);

   428                 painter->setPen(option->palette.mid().color());

   429                 painter->drawLine(points[0], points[1]);

   430                 painter->drawLine(points[2], points[3]);

   431                 painter->drawLine(points[4], points[5]);

   432                 painter->drawPoint(points[6]);

   433             }

   434 

   435         painter->restore();

   436         break; }

   437     case PE_IndicatorArrowUp:

   438     case PE_IndicatorArrowDown:

   439     case PE_IndicatorArrowRight:

   440     case PE_IndicatorArrowLeft: {

   441             painter->save();

   442             QPoint points[9];

   443             switch (element) {

   444                 case PE_IndicatorArrowUp:

   445 

   446                     points[0] = QPoint(-4, 2);

   447                     points[1] = QPoint(4, 2);

   448                     points[2] = QPoint(-3, 1);

   449                     points[3] = QPoint(3, 1);

   450                     points[4] = QPoint(-2, 0);

   451                     points[5] = QPoint(2, 0);

   452                     points[6] = QPoint(-1, -1);

   453                     points[7] = QPoint(1, -1);

   454                     points[8] = QPoint(0, -2);

   455                 break;

   456                 case PE_IndicatorArrowDown:

   457 

   458                     points[0] = QPoint(-4, -2);

   459                     points[1] = QPoint(4, -2);

   460                     points[2] = QPoint(-3, -1);

   461                     points[3] = QPoint(3, -1);

   462                     points[4] = QPoint(-2, 0);

   463                     points[5] = QPoint(2, 0);

   464                     points[6] = QPoint(-1, 1);

   465                     points[7] = QPoint(1, 1);

   466                     points[8] = QPoint(0, 2);

   467                 break;

   468                 case PE_IndicatorArrowRight:

   469                     points[0] = QPoint(-3, -4);

   470                     points[1] = QPoint(-3, 4);

   471                     points[2] = QPoint(-2, -3);

   472                     points[3] = QPoint(-2, 3);

   473                     points[4] = QPoint(-1, -2);

   474                     points[5] = QPoint(-1, 2);

   475                     points[6] = QPoint(0, -1);

   476                     points[7] = QPoint(0, 1);

   477                     points[8] = QPoint(1, 0);

   478                 break;

   479                 case PE_IndicatorArrowLeft:

   480                     points[0] = QPoint(1, -4);

   481                     points[1] = QPoint(1, 4);

   482                     points[2] = QPoint(0, -3);

   483                     points[3] = QPoint(0, 3);

   484                     points[4] = QPoint(-1, -2);

   485                     points[5] = QPoint(-1, 2);

   486                     points[6] = QPoint(-2, -1);

   487                     points[7] = QPoint(-2, 1);

   488                     points[8] = QPoint(-3, 0);

   489                 break;

   490                 default:

   491                 break;

   492             }

   493             if (option->state & State_Sunken)

   494                 painter->translate(pixelMetric(PM_ButtonShiftHorizontal),

   495                 pixelMetric(PM_ButtonShiftVertical));

   496             if (option->state & State_Enabled) {

   497                 painter->translate(option->rect.x() + option->rect.width() / 2,

   498                     option->rect.y() + option->rect.height() / 2);

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

   500                 painter->drawLine(points[0], points[1]);

   501                 painter->drawLine(points[2], points[3]);

   502                 painter->drawLine(points[4], points[5]);

   503                 painter->drawLine(points[6], points[7]);

   504                 painter->drawPoint(points[8]);

   505             } else {

   506                 painter->translate(option->rect.x() + option->rect.width() / 2 + 1,

   507                     option->rect.y() + option->rect.height() / 2 + 1);

   508                 painter->setPen(option->palette.light().color());

   509                 painter->drawLine(points[0], points[1]);

   510                 painter->drawLine(points[2], points[3]);

   511                 painter->drawLine(points[4], points[5]);

   512                 painter->drawLine(points[6], points[7]);

   513                 painter->drawPoint(points[8]);

   514                 painter->translate(-1, -1);

   515                 painter->setPen(option->palette.mid().color());

   516                 painter->drawLine(points[0], points[1]);

   517                 painter->drawLine(points[2], points[3]);

   518                 painter->drawLine(points[4], points[5]);

   519                 painter->drawLine(points[6], points[7]);

   520                 painter->drawPoint(points[8]);

   521             }

   522         painter->restore();

   523         break; }

   524 

   525     case PE_FrameWindow: {

   526         QPalette popupPal = option->palette;

   527         popupPal.setColor(QPalette::Light, option->palette.background().color());

   528         popupPal.setColor(QPalette::Midlight, option->palette.light().color());

   529         QWindowsCEStylePrivate::drawWinCEPanel(painter, option->rect, popupPal, option->state & State_Sunken);

   530         break; }

   531 

   532     case PE_Frame:

   533     case PE_FrameMenu:

   534         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(option)) {

   535             QPalette popupPal = frame->palette;

   536             QRect r = frame->rect;

   537             qDrawPlainRect(painter, r, frame->palette.shadow().color(),1);

   538         }

   539         break;

   540     case PE_FrameStatusBar:

   541         QWindowsCEStylePrivate::drawWinCEPanel(painter, option->rect, option->palette, true, 0);

   542         break;

   543 

   544     case PE_FrameTabWidget: {

   545         QRect rect = option->rect;

   546         QPalette pal = option->palette;

   547         QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect, option->palette, false, 0);

   548         break; }

   549     default:

   550         QWindowsStyle::drawPrimitive(element, option, painter, widget);

   551         break;

   552     }

   553 }

   554 

   555 void QWindowsCEStyle::drawControl(ControlElement element, const QStyleOption *option,

   556                                   QPainter *painter, const QWidget *widget) const {

   557    switch (element) {

   558    #ifndef QT_NO_MENU

   559    case CE_MenuTearoff: {

   560         if(option->state & State_Selected) {

   561             if(pixelMetric(PM_MenuPanelWidth, option, widget) > 1)

   562                 qDrawShadePanel(painter, option->rect.x(), option->rect.y(), option->rect.width(),

   563                                 option->rect.height(), option->palette, false, 2,

   564                                 &option->palette.brush(QPalette::Button));

   565             else

   566                 qDrawShadePanel(painter, option->rect.x() + 1, option->rect.y() + 1, option->rect.width() - 2,

   567                                 option->rect.height() - 2, option->palette, true, 1, &option->palette.brush(QPalette::Button));

   568         } else {

   569             painter->fillRect(option->rect, option->palette.brush(QPalette::Button));

   570         }

   571         painter->setPen(QPen(option->palette.dark().color(), 1, Qt::DashLine));

   572         painter->drawLine(option->rect.x()+2, option->rect.y()+option->rect.height()/2-1, option->rect.x()+option->rect.width()-4,

   573                     option->rect.y()+option->rect.height()/2-1);

   574         painter->setPen(QPen(option->palette.light().color(), 1, Qt::DashLine));

   575         painter->drawLine(option->rect.x()+2, option->rect.y()+option->rect.height()/2, option->rect.x()+option->rect.width()-4,

   576                     option->rect.y()+option->rect.height()/2);

   577         break; }

   578 

   579 

   580    case CE_MenuBarItem:

   581         if (const QStyleOptionMenuItem *mbi = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {

   582             bool active = mbi->state & State_Selected;

   583             bool hasFocus = mbi->state & State_HasFocus;

   584             bool down = mbi->state & State_Sunken;

   585             QStyleOptionMenuItem newMbi = *mbi;

   586             if (active || hasFocus) {

   587                 QBrush b = mbi->palette.brush(QPalette::Highlight);

   588                 if (active && down) {

   589                     painter->fillRect(mbi->rect.adjusted(0, 1, 0, -1), b);

   590                 }

   591             }

   592             uint alignment = Qt::AlignCenter | Qt::TextShowMnemonic | Qt::TextDontClip

   593                             | Qt::TextSingleLine;

   594             if (!styleHint(SH_UnderlineShortcut, mbi, widget))

   595                 alignment |= Qt::TextHideMnemonic;

   596 

   597             painter->save();

   598             QFont f = painter->font();

   599             f.setBold(true);

   600             painter->setFont(f);

   601             QPixmap pix = mbi->icon.pixmap(pixelMetric(PM_SmallIconSize),

   602                                           (mbi->state & State_Enabled) ? QIcon::Normal : QIcon::Disabled);

   603             if (!pix.isNull())

   604                 drawItemPixmap(painter,mbi->rect, alignment, pix);

   605             else

   606                 if (active && down)

   607                   drawItemText(painter, mbi->rect, alignment, mbi->palette, mbi->state & State_Enabled,

   608                              mbi->text, QPalette::Light);

   609                 else

   610                   drawItemText(painter, mbi->rect, alignment, mbi->palette, mbi->state & State_Enabled,

   611                              mbi->text, QPalette::ButtonText);

   612             painter->restore();

   613         }

   614         break;

   615 

   616    case CE_MenuBarEmptyArea:

   617         painter->save();

   618         painter->setPen(option->palette.shadow().color());

   619         if (widget && !widget->testAttribute(Qt::WA_NoSystemBackground)) {

   620             painter->eraseRect(option->rect);

   621             QRect r = option->rect;

   622             painter->drawLine(r.x() + 1, r.y() + 1, r.x()+ 1, r.y()+ r.height() - 2);

   623             painter->drawLine(r.x() - 2 + r.width(), r.y()  + 1, r.x() - 2 + r.width(), r.y() + r.height() - 2);

   624             painter->drawLine(r.x() + 1, r.y() +1, r.x() - 1 + r.width(), r.y() + 1);

   625             painter->drawLine(r.x() + 1, r.y() + r.height()-2 , r.x() - 2 + r.width(), r.y() + r.height() - 2);

   626         }

   627         painter->restore();

   628         break;

   629 

   630     case CE_MenuItem:

   631           if (const QStyleOptionMenuItem *menuitem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {

   632             int x, y, w, h;

   633             menuitem->rect.getRect(&x, &y, &w, &h);

   634             int tab = menuitem->tabWidth;

   635             bool dis = !(menuitem->state & State_Enabled);

   636             bool checked = menuitem->checkType != QStyleOptionMenuItem::NotCheckable

   637                             ? menuitem->checked : false;

   638             bool act = menuitem->state & State_Selected;

   639 

   640             // windows always has a check column, regardless whether we have an icon or not

   641             int checkcol = qMax(menuitem->maxIconWidth, windowsCheckMarkWidth);

   642             QBrush fill = menuitem->palette.brush(act ? QPalette::Highlight : QPalette::Button);

   643             painter->fillRect(menuitem->rect.adjusted(1, 1, 0, 0), fill);

   644 

   645             if (menuitem->menuItemType == QStyleOptionMenuItem::Separator) {

   646                 int yoff = y-1 + h / 2;

   647                 painter->setPen(menuitem->palette.shadow().color());

   648                 painter->drawLine(x + 4, yoff + 1, x + w - 8, yoff + 1);

   649                 return;

   650             }

   651 

   652             QRect vCheckRect = visualRect(option->direction, menuitem->rect, QRect(menuitem->rect.x(),

   653                                           menuitem->rect.y(), checkcol, menuitem->rect.height()));

   654             if (checked) {

   655                 if (act && !dis) {

   656                     qDrawPlainRect(painter, vCheckRect,

   657                         menuitem->palette.button().color(), 1,

   658                                     &menuitem->palette.brush(QPalette::Button));

   659                 } else {

   660                     QBrush fill(menuitem->palette.button().color(), Qt::Dense4Pattern);

   661                     qDrawPlainRect(painter, vCheckRect,menuitem->palette.button().color(), 1, &fill);

   662                 }

   663             } else if (!act) {

   664                 painter->fillRect(vCheckRect, menuitem->palette.brush(QPalette::Button));

   665             }

   666             // On Windows Style, if we have a checkable item and an icon we

   667             // draw the icon recessed to indicate an item is checked. If we

   668             // have no icon, we draw a checkmark instead.

   669             if (!menuitem->icon.isNull()) {

   670                 QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal;

   671                 if (act && !dis)

   672                     mode = QIcon::Active;

   673                 QPixmap pixmap;

   674                 if (checked)

   675                     pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode, QIcon::On);

   676                 else

   677                     pixmap = menuitem->icon.pixmap(pixelMetric(PM_SmallIconSize), mode);

   678                 int pixw = pixmap.width();

   679                 int pixh = pixmap.height();

   680                 if (act && !dis && !checked)

   681                     qDrawPlainRect(painter, vCheckRect,  menuitem->palette.button().color(), 1,

   682                                     &menuitem->palette.brush(QPalette::Button));

   683                 QRect pmr(0, 0, pixw, pixh);

   684                 pmr.moveCenter(vCheckRect.center());

   685                 painter->setPen(menuitem->palette.text().color());

   686                 painter->drawPixmap(pmr.topLeft(), pixmap);

   687             } else if (checked) {

   688                 QStyleOptionMenuItem newMi = *menuitem;

   689                 newMi.state = State_None;

   690                 if (!dis)

   691                     newMi.state |= State_Enabled;

   692                 if (act)

   693                     newMi.state |= State_On;

   694                 newMi.rect = visualRect(option->direction, menuitem->rect, QRect(menuitem->rect.x()

   695                            + windowsItemFrame, menuitem->rect.y() + windowsItemFrame,

   696                              checkcol - 2 * windowsItemFrame, menuitem->rect.height() - 2*windowsItemFrame));

   697                 drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, painter, widget);

   698             }

   699             painter->setPen(act ? menuitem->palette.highlightedText().color() : menuitem->palette.buttonText().color());

   700 

   701             QColor discol;

   702             if (dis) {

   703                 discol = menuitem->palette.text().color();

   704                 painter->setPen(discol);

   705             }

   706             int xm = windowsItemFrame + checkcol + windowsItemHMargin;

   707             int xpos = menuitem->rect.x() + xm;

   708             QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);

   709             QRect vTextRect = visualRect(option->direction, menuitem->rect, textRect);

   710             QString s = menuitem->text;

   711             if (!s.isEmpty()) {                     // draw text

   712                 painter->save();

   713                 int t = s.indexOf(QLatin1Char('\t'));

   714                 int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine;

   715                 if (!styleHint(SH_UnderlineShortcut, menuitem, widget))

   716                     text_flags |= Qt::TextHideMnemonic;

   717                 text_flags |= Qt::AlignLeft;

   718                 if (t >= 0) {

   719                     QRect vShortcutRect = visualRect(option->direction, menuitem->rect,

   720                         QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom())));

   721                     if (dis && !act)

   722                         painter->setPen(discol);

   723                     painter->drawText(vShortcutRect, text_flags, s.mid(t + 1));

   724                     s = s.left(t);

   725                 }

   726                 QFont font = menuitem->font;

   727                 if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem)

   728                     font.setBold(true);

   729                 painter->setFont(font);

   730                 if (dis && !act)

   731                     painter->setPen(discol);

   732                 painter->drawText(vTextRect, text_flags, s.left(t));

   733                 painter->restore();

   734             }

   735             if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow

   736                 int dim = (h - 2 * windowsItemFrame) / 2;

   737                 PrimitiveElement arrow;

   738                 arrow = (option->direction == Qt::RightToLeft) ? PE_IndicatorSpinDown : PE_IndicatorSpinUp;

   739                 xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;

   740                 QRect  vSubMenuRect = visualRect(option->direction, menuitem->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));

   741                 QStyleOptionMenuItem newMI = *menuitem;

   742                 newMI.rect = vSubMenuRect;

   743                 newMI.state = dis ? State_None : State_Enabled;

   744                 if (act)

   745                     newMI.palette.setColor(QPalette::ButtonText,

   746                                            newMI.palette.highlightedText().color());

   747                 drawPrimitive(arrow, &newMI, painter, widget);

   748             }

   749         }

   750         break;

   751 #endif // QT_NO_MENU

   752     case CE_MenuVMargin:

   753         painter->fillRect(option->rect, Qt::white);

   754         break;

   755     case CE_MenuEmptyArea:

   756         QWindowsStyle::drawControl(element,option, painter, widget);

   757         break;

   758 

   759 #ifndef QT_NO_TABBAR

   760         case CE_TabBarTab:

   761             if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {

   762                 drawControl(CE_TabBarTabShape, tab, painter, widget);

   763                 drawControl(CE_TabBarTabLabel, tab, painter, widget);

   764             }

   765             break;

   766     case CE_TabBarTabShape:

   767         if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {

   768             bool rtlHorTabs = (tab->direction == Qt::RightToLeft

   769                                && (tab->shape == QTabBar::RoundedNorth

   770                                    || tab->shape == QTabBar::RoundedSouth));

   771             bool selected = tab->state & State_Selected;

   772             bool lastTab = ((!rtlHorTabs && tab->position == QStyleOptionTab::End)

   773                             || (rtlHorTabs

   774                                 && tab->position == QStyleOptionTab::Beginning));

   775             bool firstTab = ((!rtlHorTabs

   776                                && tab->position == QStyleOptionTab::Beginning)

   777                              || (rtlHorTabs

   778                                  && tab->position == QStyleOptionTab::End));

   779             bool onlyOne = tab->position == QStyleOptionTab::OnlyOneTab;

   780             bool previousSelected =

   781                 ((!rtlHorTabs

   782                   && tab->selectedPosition == QStyleOptionTab::PreviousIsSelected)

   783                 || (rtlHorTabs

   784                     && tab->selectedPosition == QStyleOptionTab::NextIsSelected));

   785             bool nextSelected =

   786                 ((!rtlHorTabs

   787                   && tab->selectedPosition == QStyleOptionTab::NextIsSelected)

   788                  || (rtlHorTabs

   789                      && tab->selectedPosition

   790                             == QStyleOptionTab::PreviousIsSelected));

   791             int tabBarAlignment = styleHint(SH_TabBar_Alignment, tab, widget);

   792             bool leftAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignLeft)

   793                                 || (rtlHorTabs

   794                                     && tabBarAlignment == Qt::AlignRight);

   795 

   796             bool rightAligned = (!rtlHorTabs && tabBarAlignment == Qt::AlignRight)

   797                                  || (rtlHorTabs

   798                                          && tabBarAlignment == Qt::AlignLeft);

   799             QColor light = tab->palette.light().color();

   800             QColor midlight = tab->palette.midlight().color();

   801             QColor dark = tab->palette.dark().color();

   802             QColor shadow = tab->palette.shadow().color();

   803             QColor background = tab->palette.background().color();

   804             int borderThinkness = pixelMetric(PM_TabBarBaseOverlap, tab, widget);

   805             if (selected)

   806                 borderThinkness /= 2;

   807             QRect r2(option->rect);

   808             int x1 = r2.left();

   809             int x2 = r2.right();

   810             int y1 = r2.top();

   811             int y2 = r2.bottom();

   812             switch (tab->shape) {

   813             default:

   814                 QCommonStyle::drawControl(element, tab, painter, widget);

   815                 break;

   816             case QTabBar::RoundedNorth: {

   817                 if (!selected) {

   818                     y1 += 2;

   819                     x1 += firstTab ? borderThinkness : 0;

   820                     x2 -= lastTab ? borderThinkness : 0;

   821                 }

   822 

   823                 painter->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 2), tab->palette.background());

   824 

   825                 // Delete border

   826                 if (selected) {

   827                     painter->setPen(background);

   828                     painter->drawLine(x1, y2 - 1, x2, y2 - 1);

   829                     painter->drawLine(x1, y2 + 1, x2, y2 + 1);

   830                     painter->drawLine(x1, y2, x2, y2);

   831                 }

   832                 // Left

   833                 if (firstTab || selected || onlyOne || !previousSelected) {

   834                     painter->setPen(dark);

   835                     painter->drawLine(x1, y1 + 2, x1, y2 - ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));

   836                     painter->drawPoint(x1 + 1, y1 + 1);

   837                         painter->setPen(midlight);

   838                         painter->drawLine(x1 + 1, y1 + 2, x1 + 1, y2 -

   839                                          ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));

   840 

   841                 }

   842                 // Top

   843                 {

   844                     int beg = x1 + (previousSelected ? 0 : 2);

   845                     int end = x2 - (nextSelected ? 0 : 2);

   846                     painter->setPen(dark);

   847                     painter->drawLine(beg, y1, end, y1);

   848 

   849                     painter->setPen(midlight);

   850                     painter->drawLine(beg, y1 + 1, end, y1 + 1);

   851 

   852                 }

   853                 // Right

   854                 if (lastTab || selected || onlyOne || !nextSelected) {

   855                     painter->setPen(shadow);

   856                     painter->drawLine(x2, y1 + 2, x2, y2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));

   857                     painter->drawPoint(x2 - 1, y1 + 1);

   858                     painter->setPen(dark);

   859                     painter->drawLine(x2 - 1, y1 + 2, x2 - 1, y2 - ((onlyOne || lastTab) && selected && rightAligned ? 0 : borderThinkness));

   860                 }

   861                 break; }

   862             case QTabBar::RoundedSouth: {

   863                 if (!selected) {

   864                     y2 -= 2;

   865                     x1 += firstTab ? borderThinkness : 0;

   866                     x2 -= lastTab ? borderThinkness : 0;

   867                 }

   868 

   869                 painter->fillRect(QRect(x1 + 1, y1 + 2, (x2 - x1) - 1, (y2 - y1) - 1), tab->palette.background());

   870 

   871                 // Delete border

   872                 if (selected) {

   873                     painter->setPen(background);

   874                     painter->drawLine(x1, y1 + 1, x2 - 1, y1 + 1);

   875                     painter->drawLine(x1, y1 - 1, x2 - 1, y1 - 1);

   876                     painter->drawLine(x1, y1, x2 - 1, y1);

   877                 }

   878                 // Left

   879                 if (firstTab || selected || onlyOne || !previousSelected) {

   880                     painter->setPen(dark);

   881                     painter->drawLine(x1, y2 - 2, x1, y1 + ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));

   882                     painter->drawPoint(x1 + 1, y2 - 1);

   883                     painter->setPen(midlight);

   884                     painter->drawLine(x1 + 1, y2 - 2, x1 + 1, y1 + ((onlyOne || firstTab) && selected && leftAligned ? 0 : borderThinkness));

   885                 }

   886                 // Bottom

   887                 {

   888                     int beg = x1 + (previousSelected ? 0 : 2);

   889                     int end = x2 - (nextSelected ? 0 : 2);

   890                     painter->setPen(shadow);

   891                     painter->drawLine(beg, y2, end, y2);

   892                     painter->setPen(dark);

   893                     painter->drawLine(beg, y2 - 1, end, y2 - 1);

   894                 }

   895                 // Right

   896                 if (lastTab || selected || onlyOne || !nextSelected) {

   897                     painter->setPen(shadow);

   898                     painter->drawLine(x2, y2 - 2, x2, y1 + ((onlyOne || lastTab) && selected &&

   899                                       rightAligned ? 0 : borderThinkness));

   900                     painter->drawPoint(x2 - 1, y2 - 1);

   901                     painter->setPen(dark);

   902                     painter->drawLine(x2 - 1, y2 - 2, x2 - 1, y1 + ((onlyOne || lastTab) && selected &&

   903                                       rightAligned ? 0 : borderThinkness));

   904                 }

   905                 break; }

   906             case QTabBar::RoundedWest: {

   907                 if (!selected) {

   908                     x1 += 2;

   909                     y1 += firstTab ? borderThinkness : 0;

   910                     y2 -= lastTab ? borderThinkness : 0;

   911                 }

   912 

   913                 painter->fillRect(QRect(x1 + 1, y1 + 1, (x2 - x1) - 2, (y2 - y1) - 1), tab->palette.background());

   914 

   915                 // Delete border

   916                 if (selected) {

   917                     painter->setPen(background);

   918                     painter->drawLine(x2 - 1, y1, x2 - 1, y2);

   919                     painter->drawLine(x2, y1, x2, y2);

   920                 }

   921                 // Top

   922                 if (firstTab || selected || onlyOne || !previousSelected) {

   923                     painter->setPen(dark);

   924                     painter->drawLine(x1 + 2, y1, x2 - ((onlyOne || firstTab) && selected &&

   925                                       leftAligned ? 0 : borderThinkness), y1);

   926                     painter->drawPoint(x1 + 1, y1 + 1);

   927                     painter->setPen(midlight);

   928                     painter->drawLine(x1 + 2, y1 + 1, x2 - ((onlyOne || firstTab) && selected &&

   929                                       leftAligned ? 0 : borderThinkness), y1 + 1);

   930                 }

   931                 // Left

   932                 {

   933                     int beg = y1 + (previousSelected ? 0 : 2);

   934                     int end = y2 - (nextSelected ? 0 : 2);

   935                     painter->setPen(dark);

   936                     painter->drawLine(x1, beg, x1, end);

   937                     painter->setPen(midlight);

   938                     painter->drawLine(x1 + 1, beg, x1 + 1, end);

   939                 }

   940                 // Bottom

   941                 if (lastTab || selected || onlyOne || !nextSelected) {

   942                     painter->setPen(shadow);

   943                     painter->drawLine(x1 + 3, y2, x2 - ((onlyOne || lastTab) && selected &&

   944                                       rightAligned ? 0 : borderThinkness), y2);

   945                     painter->drawPoint(x1 + 2, y2 - 1);

   946                     painter->setPen(dark);

   947                     painter->drawLine(x1 + 3, y2 - 1, x2 - ((onlyOne || lastTab) && selected &&

   948                                       rightAligned ? 0 : borderThinkness), y2 - 1);

   949                     painter->drawPoint(x1 + 1, y2 - 1);

   950                     painter->drawPoint(x1 + 2, y2);

   951                 }

   952                 break; }

   953             case QTabBar::RoundedEast: {

   954                 if (!selected) {

   955                     x2 -= 2;

   956                     y1 += firstTab ? borderThinkness : 0;

   957                     y2 -= lastTab ? borderThinkness : 0;

   958                 }

   959 

   960                 painter->fillRect(QRect(x1 + 2, y1 + 1, (x2 - x1) - 1, (y2 - y1) - 1), tab->palette.background());

   961 

   962                 // Delete border

   963                 if (selected) {

   964                     painter->setPen(background);

   965                     painter->drawLine(x1 + 1, y1, x1 + 1, y2 - 1);

   966                     painter->drawLine(x1, y1, x1, y2 - 1);

   967                 }

   968                 // Top

   969                 if (firstTab || selected || onlyOne || !previousSelected) {

   970                     painter->setPen(dark);

   971                     painter->drawLine(x2 - 2, y1, x1 + ((onlyOne || firstTab) && selected &&

   972                                       leftAligned ? 0 : borderThinkness), y1);

   973                     painter->drawPoint(x2 - 1, y1 + 1);

   974                     painter->setPen(midlight);

   975                     painter->drawLine(x2 - 3, y1 + 1, x1 + ((onlyOne || firstTab) &&

   976                                       selected && leftAligned ? 0 : borderThinkness), y1 + 1);

   977                     painter->drawPoint(x2 - 1, y1);

   978 

   979                 }

   980                 // Right

   981                 {

   982                     int beg = y1 + (previousSelected ? 0 : 2);

   983                     int end = y2 - (nextSelected ? 0 : 2);

   984                     painter->setPen(shadow);

   985                     painter->drawLine(x2, beg, x2, end);

   986                     painter->setPen(dark);

   987                     painter->drawLine(x2 - 1, beg, x2 - 1, end);

   988                 }

   989                 // Bottom

   990                 if (lastTab || selected || onlyOne || !nextSelected) {

   991                     painter->setPen(shadow);

   992                     painter->drawLine(x2 - 2, y2, x1 + ((onlyOne || lastTab) &&

   993                                       selected && rightAligned ? 0 : borderThinkness), y2);

   994                     painter->drawPoint(x2 - 1, y2 - 1);

   995                     painter->setPen(dark);

   996                     painter->drawLine(x2 - 2, y2 - 1, x1 + ((onlyOne || lastTab) &&

   997                                       selected && rightAligned ? 0 : borderThinkness), y2 - 1);

   998                 }

   999                 break; }

  1000             }

  1001         }

  1002         break;

  1003 #endif // QT_NO_TABBAR

  1004 

  1005     case CE_ToolBar: {

  1006         QRect rect = option->rect;

  1007         painter->setPen(QPen(option->palette.dark().color()));

  1008         painter->drawLine(rect.topRight().x()-1,

  1009             rect.topRight().y(),

  1010             rect.bottomRight().x()-1,

  1011             rect.bottomRight().y());

  1012         painter->drawLine(rect.bottomLeft().x(),

  1013             rect.bottomLeft().y(),

  1014             rect.bottomRight().x(),

  1015             rect.bottomRight().y());

  1016         painter->setPen(QPen(option->palette.light().color()));

  1017         painter->drawLine(rect.topRight().x(),

  1018             rect.topRight().y(),

  1019             rect.bottomRight().x(),

  1020             rect.bottomRight().y());

  1021         painter->drawLine(rect.topLeft().x(),

  1022             rect.topLeft().y(),

  1023             rect.topRight().x(),

  1024             rect.topRight().y());

  1025 

  1026         break; }

  1027 #ifndef QT_NO_SCROLLBAR

  1028     case CE_ScrollBarSubLine:

  1029     case CE_ScrollBarAddLine: {

  1030         if (option->state & State_Sunken) {

  1031             QStyleOption buttonOpt = *option;

  1032 

  1033             drawPrimitive(PE_PanelButtonBevel, &buttonOpt, painter, widget);

  1034         } else {

  1035             QStyleOption buttonOpt = *option;

  1036             if (!(buttonOpt.state & State_Sunken))

  1037                 buttonOpt.state |= State_Raised;

  1038             drawPrimitive(PE_PanelButtonBevel, &buttonOpt, painter, widget);

  1039         }

  1040         PrimitiveElement arrow;

  1041         if (option->state & State_Horizontal) {

  1042             if (element == CE_ScrollBarAddLine)

  1043                 arrow = option->direction == Qt::LeftToRight ? PE_IndicatorArrowRight : PE_IndicatorArrowLeft;

  1044             else

  1045                 arrow = option->direction == Qt::LeftToRight ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;

  1046         } else {

  1047             if (element == CE_ScrollBarAddLine)

  1048                 arrow = PE_IndicatorArrowDown;

  1049             else

  1050                 arrow = PE_IndicatorArrowUp;

  1051         }

  1052         drawPrimitive(arrow, option, painter, widget);

  1053         break; }

  1054     case CE_ScrollBarAddPage:

  1055     case CE_ScrollBarSubPage: {

  1056             QBrush br;

  1057             QBrush bg = painter->background();

  1058             Qt::BGMode bg_mode = painter->backgroundMode();

  1059             painter->setPen(Qt::NoPen);

  1060             painter->setBackgroundMode(Qt::OpaqueMode);

  1061 

  1062             if (option->state & State_Sunken) {

  1063                 br = QBrush(option->palette.shadow().color(), Qt::Dense4Pattern);

  1064                 painter->setBackground(option->palette.dark().color());

  1065                 painter->setBrush(br);

  1066             } else {

  1067                 QPixmap pm = option->palette.brush(QPalette::Light).texture();

  1068                 if (option->state & State_Enabled)

  1069                     br = !pm.isNull() ? QBrush(pm) : QBrush(option->palette.button().color(), Qt::Dense4Pattern);

  1070                 else

  1071                     br = !pm.isNull() ? QBrush(pm) : QBrush(option->palette.light().color(), Qt::Dense4Pattern);

  1072                 painter->setBackground(option->palette.base().color());

  1073                 painter->setBrush(br);

  1074             }

  1075             painter->drawRect(option->rect);

  1076             painter->setBackground(bg);

  1077             painter->setBackgroundMode(bg_mode);

  1078             break; }

  1079     case CE_ScrollBarSlider:

  1080         if (!(option->state & State_Enabled)) {

  1081             QStyleOptionButton buttonOpt;

  1082             buttonOpt.QStyleOption::operator=(*option);

  1083             buttonOpt.state = State_Enabled | State_Raised;

  1084             drawPrimitive(PE_PanelButtonBevel, &buttonOpt, painter, widget);

  1085             QPixmap pm = option->palette.brush(QPalette::Light).texture();

  1086             QBrush br = !pm.isNull() ? QBrush(pm) : QBrush(option->palette.light().color(), Qt::Dense4Pattern);

  1087             painter->setPen(Qt::NoPen);

  1088             painter->setBrush(br);

  1089             painter->setBackgroundMode(Qt::OpaqueMode);

  1090             painter->drawRect(option->rect.adjusted(2, 2, -2, -2));

  1091         } else {

  1092             QStyleOptionButton buttonOpt;

  1093             buttonOpt.QStyleOption::operator=(*option);

  1094             buttonOpt.state = State_Enabled | State_Raised;

  1095             drawPrimitive(PE_PanelButtonBevel, &buttonOpt, painter, widget);

  1096         }

  1097         break;

  1098 #endif // QT_NO_SCROLLBAR

  1099     case CE_HeaderSection: {

  1100         QBrush fill;

  1101         if (option->state & State_On)

  1102             fill = QBrush(option->palette.light().color(), Qt::Dense4Pattern);

  1103         else

  1104             fill = option->palette.brush(QPalette::Button);

  1105 

  1106         if (option->state & (State_Raised | State_Sunken)) {

  1107             QWindowsCEStylePrivate::drawWinCEButton(painter, option->rect, option->palette,

  1108                                                     option->state & State_Sunken, &fill);

  1109         } else {

  1110             painter->fillRect(option->rect, fill);

  1111         }

  1112         break; }

  1113 

  1114     case CE_DockWidgetTitle:

  1115         QWindowsStyle::drawControl(element,option, painter, widget);

  1116         break;

  1117 

  1118         case CE_PushButtonLabel:

  1119         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {

  1120             painter->save();

  1121             QFont f = painter->font();

  1122             f.setBold(true);

  1123             painter->setFont(f);

  1124             QRect ir = btn->rect;

  1125             uint tf = Qt::AlignVCenter | Qt::TextShowMnemonic;

  1126             if (!styleHint(SH_UnderlineShortcut, btn, widget))

  1127                 tf |= Qt::TextHideMnemonic;

  1128 

  1129             if (btn->state & (State_On | State_Sunken))

  1130                 ir.translate(pixelMetric(PM_ButtonShiftHorizontal, option, widget),

  1131                              pixelMetric(PM_ButtonShiftVertical, option, widget));

  1132             if (!btn->icon.isNull()) {

  1133                 QIcon::Mode mode = btn->state & State_Enabled ? QIcon::Normal

  1134                                                               : QIcon::Disabled;