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 documentation 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 <QtGui>

    43 

    44 #include "javastyle.h"

    45 #include <math.h>

    46 

    47 static const int windowsItemFrame        =  2;

    48 static const int windowsSepHeight        =  2;

    49 static const int windowsItemHMargin      =  3;

    50 static const int windowsItemVMargin      =  2;

    51 static const int windowsArrowHMargin     =  6;

    52 static const int windowsTabSpacing       = 12;

    53 static const int windowsCheckMarkHMargin =  2;

    54 static const int windowsRightBorder      = 15;

    55 static const int windowsCheckMarkWidth   = 12;

    56 

    57 JavaStyle::JavaStyle()

    58 {

    59     qApp->setPalette(standardPalette());

    60 }

    61 

    62 

    63 inline QPoint JavaStyle::adjustScrollPoint(const QPoint &point,

    64                     Qt::Orientation orientation,

    65                     bool add) const

    66 {

    67     int adder = add ? -1 : 1;

    68     QPoint retPoint;

    69 

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

    71         retPoint = QPoint(point.y() * adder, point.x());

    72     } else {

    73         retPoint = QPoint(point.x(), point.y() * adder);

    74     }

    75 

    76     return retPoint;

    77 }

    78 

    79 QPalette JavaStyle::standardPalette() const

    80 {

    81     QPalette palette = QWindowsStyle::standardPalette();

    82 

    83     palette.setBrush(QPalette::Active, QPalette::Button,

    84                      QColor(184, 207, 229));

    85     palette.setBrush(QPalette::Active, QPalette::WindowText,

    86                      Qt::black);

    87     palette.setBrush(QPalette::Active, QPalette::Background,

    88                      QColor(238, 238, 238));

    89     palette.setBrush(QPalette::Active, QPalette::Window,

    90                      QColor(238 ,238, 238));

    91     palette.setBrush(QPalette::Active, QPalette::Base, Qt::white);

    92     palette.setBrush(QPalette::Active, QPalette::AlternateBase, QColor(238, 238, 238));

    93     palette.setBrush(QPalette::Active, QPalette::Text, Qt::black);

    94     palette.setBrush(QPalette::Active, QPalette::BrightText, Qt::white);

    95 

    96     palette.setBrush(QPalette::Active, QPalette::Light, QColor(163, 184, 204)); // focusFrameColor

    97     palette.setBrush(QPalette::Active, QPalette::Midlight, QColor(99, 130, 191)); // tabBarBorderColor

    98     palette.setBrush(QPalette::Active, QPalette::Dark, QColor(106, 104, 100));

    99     palette.setBrush(QPalette::Active, QPalette::Mid, QColor(122, 138, 153)); //defaultFrameColor

   100     palette.setBrush(QPalette::Active, QPalette::Shadow, QColor(122, 138, 153)); // defaultFrame

   101 

   102     palette.setBrush(QPalette::Active, QPalette::Highlight, QColor(184, 207, 229));

   103     palette.setBrush(QPalette::Active, QPalette::HighlightedText, Qt::black);

   104 

   105     palette.setBrush(QPalette::Inactive, QPalette::Highlight, QColor(184, 207, 229));

   106     palette.setBrush(QPalette::Inactive, QPalette::HighlightedText, Qt::black);

   107     

   108     palette.setBrush(QPalette::Disabled, QPalette::Button,

   109                      QColor(238, 238, 238));

   110     palette.setBrush(QPalette::Disabled, QPalette::WindowText,

   111                      QColor(153, 153, 153));

   112     palette.setBrush(QPalette::Disabled, QPalette::Background, QColor(238, 238, 238));

   113 

   114     palette.setBrush(QPalette::Inactive, QPalette::Button,

   115                      QColor(184, 207, 229));

   116     palette.setBrush(QPalette::Inactive, QPalette::Background,

   117                      QColor(238, 238, 238));

   118     palette.setBrush(QPalette::Inactive, QPalette::Window,

   119                      QColor(238 ,238, 238));

   120     palette.setBrush(QPalette::Inactive, QPalette::Light, QColor(163, 184, 204)); // focusFrameColor

   121     palette.setBrush(QPalette::Inactive, QPalette::Midlight, QColor(99, 130, 191)); // tabBarBorderColor

   122     palette.setBrush(QPalette::Inactive, QPalette::Dark,QColor(106, 104, 100));

   123     palette.setBrush(QPalette::Inactive, QPalette::Mid, QColor(122, 138, 153)); //defaultFrame

   124     palette.setBrush(QPalette::Inactive, QPalette::Shadow, QColor(122, 138, 153)); // defaultFrame

   125 

   126     return palette;

   127 }

   128 

   129 inline void JavaStyle::drawScrollBarArrow(const QRect &rect, QPainter *painter,

   130                       const QStyleOptionSlider *option,

   131                       bool add) const

   132 {

   133 

   134     painter->save();

   135 

   136     Qt::Orientation orient = option->orientation;

   137     QPoint offset;

   138 

   139     if (add) {

   140         if (orient == Qt::Vertical) {

   141             offset = rect.bottomLeft();

   142         } else {

   143             offset = rect.topRight();

   144         }

   145     } else {

   146         offset = rect.topLeft();

   147     }

   148 

   149     QPainterPath arrow;

   150     arrow.moveTo(offset + adjustScrollPoint(QPoint(4, 8), orient, add));

   151     arrow.lineTo(offset + adjustScrollPoint(QPoint(7, 5), orient, add));

   152     arrow.lineTo(offset + adjustScrollPoint(QPoint(8, 5), orient, add));

   153     arrow.lineTo(offset + adjustScrollPoint(QPoint(11, 8), orient, add));

   154     arrow.lineTo(offset + adjustScrollPoint(QPoint(4, 8), orient, add));

   155 

   156     QColor fillColor;

   157     if (option->state & State_Sunken)

   158         fillColor = QColor(option->palette.color(QPalette::Button));

   159     else

   160         fillColor = option->palette.color(QPalette::Background);

   161 

   162     painter->fillRect(rect, fillColor);

   163 

   164     painter->setPen(option->palette.color(QPalette::Base));

   165     int adjust = option->state & State_Sunken ? 0 : 1;

   166     painter->drawRect(rect.adjusted(adjust, adjust, -1, -1));

   167     painter->setPen(option->palette.color(QPalette::Mid));

   168     painter->drawRect(rect.adjusted(0, 0, -1, -1));

   169 

   170     painter->setPen(option->palette.color(QPalette::WindowText));

   171     painter->setBrush(option->palette.color(QPalette::WindowText));

   172     painter->drawPath(arrow);

   173 

   174     painter->restore();

   175 }

   176 

   177 inline QPoint JavaStyle::adjustScrollHandlePoint(Qt::Orientation orig,

   178                          const QPoint &point) const

   179 {

   180     QPoint retPoint;

   181 

   182     if (orig == Qt::Vertical)

   183         retPoint = point;

   184     else

   185         retPoint = QPoint(point.y(), point.x());

   186 

   187     return retPoint;

   188 }

   189 

   190 void JavaStyle::drawControl(ControlElement control, const QStyleOption *option,

   191                             QPainter *painter, const QWidget *widget) const

   192 {

   193 

   194     painter->save();

   195 

   196     switch (control) {

   197         case CE_ToolBoxTabShape: {

   198             const QStyleOptionToolBox *box =

   199             qstyleoption_cast<const QStyleOptionToolBox *>(option);

   200 

   201             painter->save();

   202 

   203             if (box->direction == Qt::RightToLeft) {

   204                 painter->rotate(1);

   205                 painter->translate(box->rect.width(), -box->rect.height());

   206             }

   207 

   208             int textWidth = box->fontMetrics.width(box->text) + 20;

   209 

   210             QPolygon innerLine;

   211             innerLine << (box->rect.topLeft() + QPoint(0, 1)) <<

   212                 (box->rect.topLeft() + QPoint(textWidth, 1)) <<

   213                 (box->rect.bottomLeft() + QPoint(textWidth + 15, -3)) <<

   214                 (box->rect.bottomRight() + QPoint(0, -3)) <<

   215                 box->rect.bottomRight() <<

   216                 box->rect.bottomLeft() <<

   217                 box->rect.topLeft();

   218 

   219             painter->setPen(box->palette.color(QPalette::Base));

   220             painter->setBrush(QColor(200, 221, 242));

   221             painter->drawPolygon(innerLine);

   222 

   223             QPolygon outerLine;

   224             outerLine << (box->rect.bottomRight() + QPoint(0, -3)) <<

   225                box->rect.bottomRight() <<

   226                box->rect.bottomLeft() <<

   227                box->rect.topLeft() <<

   228                (box->rect.topLeft() + QPoint(textWidth, 0)) <<

   229                (box->rect.bottomLeft() + QPoint(textWidth + 15, -4)) <<

   230                (box->rect.bottomRight() + QPoint(0, -4));

   231 

   232             painter->setPen(box->palette.color(QPalette::Midlight));

   233             painter->setBrush(Qt::NoBrush);

   234             painter->drawPolyline(outerLine);

   235 

   236             painter->restore();

   237             break;

   238         }

   239         case CE_DockWidgetTitle: {

   240             const QStyleOptionDockWidgetV2 *docker =

   241                 new QStyleOptionDockWidgetV2(

   242                 *qstyleoption_cast<const QStyleOptionDockWidget *>(option));

   243 

   244             QRect rect = docker->rect;

   245             QRect titleRect = rect;

   246             if (docker->verticalTitleBar) {

   247                 QRect r = rect;

   248                 QSize s = r.size();

   249                 s.transpose();

   250                 r.setSize(s);

   251 

   252                 titleRect = QRect(r.left() + rect.bottom()

   253                                 - titleRect.bottom(),

   254                                 r.top() + titleRect.left() - rect.left(),

   255                                 titleRect.height(), titleRect.width());

   256 

   257                 painter->translate(r.left(), r.top() + r.width());

   258                 painter->rotate(-90);

   259                 painter->translate(-r.left(), -r.top());

   260 

   261                 rect = r;

   262             }

   263 

   264             QLinearGradient gradient(rect.topLeft(),

   265                                      rect.bottomLeft());

   266             gradient.setColorAt(1.0, QColor(191, 212, 231));

   267             gradient.setColorAt(0.3, Qt::white);

   268             gradient.setColorAt(0.0, QColor(221, 232, 243));

   269 

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

   271             painter->setBrush(gradient);

   272             painter->drawRect(rect.adjusted(0, 0, -1, -1));

   273 

   274             if (!docker->title.isEmpty()) {

   275                 QRect textRect = docker->fontMetrics.boundingRect(docker->title);

   276                 textRect.moveCenter(rect.center());

   277 

   278                 QFont font = painter->font();

   279                 font.setPointSize(font.pointSize() - 1);

   280                 painter->setFont(font);

   281                 painter->setPen(docker->palette.text().color());

   282                 painter->drawText(textRect, docker->title,

   283                                   QTextOption(Qt::AlignHCenter |

   284                                   Qt::AlignVCenter));

   285             }

   286             break;

   287         }

   288         case CE_RubberBand: {

   289             painter->setPen(option->palette.color(QPalette::Active,

   290                             QPalette::WindowText));

   291             painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

   292             break;

   293         }

   294         case CE_SizeGrip: {

   295             break;

   296         }

   297         case CE_HeaderSection: {

   298             const QStyleOptionHeader *header =

   299                 qstyleoption_cast<const QStyleOptionHeader *>(option);

   300 

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

   302             painter->setBrush(option->palette.color(QPalette::Active,

   303                               QPalette::Background));

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

   305 

   306             painter->setPen(header->palette.color(QPalette::Mid));

   307             if (header->orientation == Qt::Horizontal) {

   308                 if (header->position == QStyleOptionHeader::Beginning ||

   309                     header->position == QStyleOptionHeader::OnlyOneSection) {

   310                     painter->drawRect(header->rect.adjusted(0, 0, -1, -1));

   311                     painter->setPen(header->palette.color(QPalette::Base));

   312                     painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

   313                                       header->rect.topLeft() + QPoint(1, 1));

   314                     painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

   315                                       header->rect.topRight() + QPoint(-1, 1));

   316                 } else {

   317                     painter->drawLine(header->rect.bottomRight(),

   318                                       header->rect.topRight());

   319                     painter->drawLine(header->rect.topLeft(),

   320                                       header->rect.topRight());

   321                     painter->drawLine(header->rect.bottomLeft(),

   322                                       header->rect.bottomRight());

   323                     painter->setPen(option->palette.color(QPalette::Base));

   324                     painter->drawLine(header->rect.bottomLeft() + QPoint(0, -1),

   325                                       header->rect.topLeft() + QPoint(0, 1));

   326                     painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

   327                                       header->rect.topRight() + QPoint(-1, 1));

   328                 }

   329             } else { // Vertical

   330                 if (header->position == QStyleOptionHeader::Beginning ||

   331                     header->position == QStyleOptionHeader::OnlyOneSection) {

   332                     painter->drawRect(header->rect.adjusted(0, 0, -1, -1));

   333                     painter->setPen(header->palette.color(QPalette::Base));

   334                     painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

   335                                   header->rect.topLeft() + QPoint(1, 1));

   336                     painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

   337                                   header->rect.topRight() + QPoint(-1, 1));

   338                 } else {

   339                     painter->drawLine(header->rect.bottomLeft(),

   340                                       header->rect.bottomRight());

   341                     painter->drawLine(header->rect.topLeft(),

   342                                       header->rect.bottomLeft());

   343                     painter->drawLine(header->rect.topRight(),

   344                                       header->rect.bottomRight());

   345                     painter->setPen(header->palette.color(QPalette::Base));

   346                     painter->drawLine(header->rect.topLeft(),

   347                                       header->rect.topRight() + QPoint(-1, 0));

   348                     painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

   349                                       header->rect.topLeft() + QPoint(1, 0));

   350                 }

   351             }

   352             break;

   353         }

   354         case CE_ToolBar: {

   355             QRect rect = option->rect;

   356 

   357             QLinearGradient gradient(rect.topLeft(), rect.bottomLeft());

   358             gradient.setColorAt(1.0, QColor(221, 221, 221));

   359             gradient.setColorAt(0.0, QColor(241, 241, 241));

   360 

   361             if (option->state & State_Horizontal) {

   362                 painter->setPen(QColor(204, 204, 204));

   363                 painter->setBrush(gradient);

   364             } else {

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

   366                 painter->setBrush(option->palette.color(QPalette::Background));

   367             }

   368             painter->drawRect(rect.adjusted(0, 0, -1, -1));

   369             break;

   370         }

   371         case CE_ProgressBar: {

   372             const QStyleOptionProgressBar *bar1 =

   373                 qstyleoption_cast<const QStyleOptionProgressBar *>(option);

   374 

   375             QStyleOptionProgressBarV2 *bar = new QStyleOptionProgressBarV2(*bar1);

   376 

   377             QRect rect = bar->rect;

   378             if (bar->orientation == Qt::Vertical) {

   379                 rect = QRect(rect.left(), rect.top(), rect.height(), rect.width());

   380                 QMatrix m;

   381                 m.translate(rect.height()-1, 0);

   382                 m.rotate(90.0);

   383                 painter->setMatrix(m);

   384             }

   385 

   386             painter->setPen(bar->palette.color(QPalette::Mid));

   387             painter->drawRect(rect.adjusted(0, 0, -1, -1));

   388 

   389             QRect grooveRect = subElementRect(SE_ProgressBarGroove, bar,

   390                                               widget);

   391             if (bar->orientation == Qt::Vertical) {

   392                 grooveRect = QRect(grooveRect.left(), grooveRect.top(),

   393                                    grooveRect.height(), grooveRect.width());

   394             }

   395 

   396             QStyleOptionProgressBar grooveBar = *bar;

   397             grooveBar.rect = grooveRect;

   398 

   399             drawControl(CE_ProgressBarGroove, &grooveBar, painter, widget);

   400 

   401             QRect progressRect = subElementRect(SE_ProgressBarContents, bar,

   402                                                 widget);

   403             if (bar->orientation == Qt::Vertical) {

   404                 progressRect = QRect(progressRect.left(), progressRect.top(),

   405                 progressRect.height(), progressRect.width());

   406                 progressRect.adjust(0, 0, 0, -1);

   407             }

   408             QStyleOptionProgressBar progressOpt = *bar;

   409             progressOpt.rect = progressRect;

   410             drawControl(CE_ProgressBarContents, &progressOpt, painter, widget);

   411 

   412             QRect labelRect = subElementRect(SE_ProgressBarLabel, bar, widget);

   413             if (bar->orientation == Qt::Vertical) {

   414                 labelRect = QRect(labelRect.left(), labelRect.top(),

   415                 labelRect.height(), labelRect.width());

   416             }

   417             QStyleOptionProgressBar subBar = *bar;

   418             subBar.rect = labelRect;

   419             if (bar->textVisible)

   420                 drawControl(CE_ProgressBarLabel, &subBar, painter, widget);

   421 

   422             delete bar;

   423             break;

   424         }

   425         case CE_ProgressBarGroove: {

   426             painter->setBrush(option->palette.color(QPalette::Background));

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

   428             painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

   429 

   430             painter->setPen(option->palette.color(QPalette::Button));

   431             painter->drawLine(option->rect.topLeft() + QPoint(0, 0),

   432                               option->rect.topRight() + QPoint(0, 0));

   433             break;

   434         }

   435         case CE_ProgressBarContents: {

   436             const QStyleOptionProgressBar *bar =

   437                 qstyleoption_cast<const QStyleOptionProgressBar *>(option);

   438             int progress = int((double(bar->progress) /

   439                                 double(bar->maximum - bar->minimum)) *

   440                                 bar->rect.width());

   441 

   442             painter->setBrush(bar->palette.color(QPalette::Light));

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

   444             QRect progressRect = QRect(bar->rect.topLeft(), QPoint(progress,

   445             bar->rect.bottom()));

   446             painter->drawRect(progressRect);

   447 

   448             painter->setPen(bar->palette.color(QPalette::Midlight));

   449             painter->setBrush(Qt::NoBrush);

   450 

   451             painter->drawLine(bar->rect.bottomLeft(), bar->rect.topLeft());

   452             painter->drawLine(bar->rect.topLeft(), QPoint(progress,

   453                               bar->rect.top()));

   454             break;

   455         }

   456         case CE_ProgressBarLabel: {

   457             painter->save();

   458             const QStyleOptionProgressBar *bar =

   459                 qstyleoption_cast<const QStyleOptionProgressBar *>(option);

   460 

   461             QRect rect = bar->rect;

   462                 QRect leftRect;

   463 

   464             int progressIndicatorPos = int((double(bar->progress) /

   465                     double(bar->maximum - bar->minimum)) *

   466                     bar->rect.width());

   467 

   468             QFont font;

   469             font.setBold(true);

   470             painter->setFont(font);

   471             painter->setPen(bar->palette.color(QPalette::Midlight));

   472 

   473             if (progressIndicatorPos >= 0 &&

   474                 progressIndicatorPos <= rect.width()) {

   475                 leftRect = QRect(bar->rect.topLeft(),

   476                                  QPoint(progressIndicatorPos,

   477                 bar->rect.bottom()));

   478             } else if (progressIndicatorPos > rect.width()) {

   479                 painter->setPen(bar->palette.color(QPalette::Base));

   480             } else {

   481                 painter->setPen(bar->palette.color(QPalette::Midlight));

   482             }

   483 

   484             QRect textRect = QFontMetrics(font).boundingRect(bar->text);

   485             textRect.moveCenter(option->rect.center());

   486             painter->drawText(textRect, bar->text,

   487                               QTextOption(Qt::AlignCenter));

   488             if (!leftRect.isNull()) {

   489                 painter->setPen(bar->palette.color(QPalette::Base));

   490                 painter->setClipRect(leftRect, Qt::IntersectClip);

   491                 painter->drawText(textRect, bar->text,

   492                                   QTextOption(Qt::AlignCenter));

   493             }

   494 

   495             painter->restore();

   496             break;

   497         }

   498         case CE_MenuBarEmptyArea: {

   499             QRect emptyArea = option->rect.adjusted(0, 0, -1, -1);

   500             QLinearGradient gradient(emptyArea.topLeft(), emptyArea.bottomLeft()

   501                                      - QPoint(0, 1));

   502             gradient.setColorAt(0.0, option->palette.color(QPalette::Base));

   503             gradient.setColorAt(1.0, QColor(223, 223, 223));

   504 

   505             painter->setPen(QColor(238, 238, 238));

   506             painter->setBrush(gradient);

   507             painter->drawRect(emptyArea.adjusted(0, 0, 0, -1));

   508             break;

   509         }

   510         case CE_MenuBarItem: {

   511             if (!(option->state & State_Sunken)) {

   512                 QLinearGradient gradient(option->rect.topLeft(),

   513                                          option->rect.bottomLeft());

   514                 gradient.setColorAt(0.0, Qt::white);

   515                 gradient.setColorAt(1.0, QColor(223, 223, 223));

   516 

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

   518                 painter->setBrush(gradient);

   519             } else {

   520                 painter->setBrush(option->palette.color(QPalette::Light));

   521             }

   522 

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

   524             if (option->state & State_Sunken) {

   525                 painter->setPen(option->palette.color(QPalette::Mid));

   526                 painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

   527                 painter->setPen(option->palette.color(QPalette::Base));

   528                 painter->setBrush(Qt::NoBrush);

   529                 painter->drawLine(option->rect.bottomRight() + QPoint(0, -1),

   530                                   option->rect.topRight() + QPoint(0, -1));

   531             }

   532             QCommonStyle::drawControl(control, option, painter, widget);

   533             break;

   534         }

   535         case CE_MenuItem: {

   536             const QStyleOptionMenuItem *menuItem =

   537                 qstyleoption_cast<const QStyleOptionMenuItem *>(option);

   538 

   539             bool selected = menuItem->state & State_Selected;

   540             bool checkable = menuItem->checkType !=

   541                              QStyleOptionMenuItem::NotCheckable;

   542             bool checked = menuItem->checked;

   543 

   544             if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {

   545                 QPoint center = menuItem->rect.center();

   546 

   547                 painter->setPen(menuItem->palette.color(QPalette::Midlight));

   548                 painter->drawLine(QPoint(menuItem->rect.left() - 2, center.y()),

   549                                   QPoint(menuItem->rect.right(), center.y()));

   550                 painter->setPen(menuItem->palette.color(QPalette::Base));

   551                 painter->drawLine(QPoint(menuItem->rect.left() - 2,

   552                                   center.y() + 1),

   553                 QPoint(menuItem->rect.right(),

   554                       center.y() + 1));

   555 

   556                 break;

   557             }

   558 

   559             if (selected) {

   560                 painter->setBrush(menuItem->palette.color(QPalette::Light));

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

   562                 painter->drawRect(menuItem->rect);

   563                 painter->setPen(menuItem->palette.color(QPalette::Midlight));

   564                 painter->drawLine(menuItem->rect.topLeft(),

   565                                   menuItem->rect.topRight());

   566                 painter->setPen(menuItem->palette.color(QPalette::Base));

   567                 painter->drawLine(menuItem->rect.bottomLeft(),

   568                                   menuItem->rect.bottomRight());

   569             }

   570 

   571             if (checkable) {

   572                 QRect checkRect(option->rect.left() + 5,

   573                                 option->rect.center().y() - 5, 10, 10);

   574                 if (menuItem->checkType & QStyleOptionMenuItem::Exclusive) {

   575                     QStyleOptionButton button;

   576                     button.rect = checkRect;

   577                     button.state = menuItem->state;

   578                     if (button.state & State_Sunken)

   579                         button.state ^= State_Sunken;

   580                     if (checked)

   581                         button.state |= State_On;

   582                     button.palette = menuItem->palette;

   583                     drawPrimitive(PE_IndicatorRadioButton, &button, painter,

   584                               widget);

   585                 } else {

   586                     QBrush buttonBrush = gradientBrush(option->rect);

   587                     painter->setBrush(buttonBrush);

   588                     painter->setPen(option->palette.color(QPalette::Mid));

   589 

   590                     painter->drawRect(checkRect);

   591 

   592                     if (checked) {

   593                         QImage image(":/images/checkboxchecked.png");

   594                         painter->drawImage(QPoint(option->rect.left() + 5,

   595                                            option->rect.center().y() - 8), image);

   596                     }

   597                 }

   598             }

   599 

   600             bool dis = !(menuItem->state & State_Enabled);

   601             bool act = menuItem->state & State_Selected;

   602             const QStyleOption *opt = option;

   603             const QStyleOptionMenuItem *menuitem = menuItem;

   604             int checkcol = qMax(menuitem->maxIconWidth, 20);

   605             if (menuItem->icon.isNull())

   606                 checkcol = 0;

   607 

   608             QPainter *p = painter;

   609             QRect vCheckRect = visualRect(opt->direction, menuitem->rect,

   610                                           QRect(menuitem->rect.x(),

   611                                           menuitem->rect.y(),

   612                                           checkcol, menuitem->rect.height()));

   613             if (!menuItem->icon.isNull()) {

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

   615                 if (act && !dis)

   616                     mode = QIcon::Active;

   617                 QPixmap pixmap;

   618                 if (checked)

   619                     pixmap = menuItem->icon.pixmap(

   620                     pixelMetric(PM_SmallIconSize), mode, QIcon::On);

   621                 else

   622                     pixmap = menuItem->icon.pixmap(

   623                         pixelMetric(PM_SmallIconSize), mode);

   624                 int pixw = pixmap.width();

   625                 int pixh = pixmap.height();

   626 

   627                 int adjustedIcon = checkable ? 15 : 0;

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

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

   630                 painter->setPen(menuItem->palette.text().color());

   631                 if (checkable && checked)

   632                     painter->drawPixmap(QPoint(pmr.left() +

   633                     adjustedIcon, pmr.top() + 1), pixmap);

   634                 else

   635                     painter->drawPixmap(pmr.topLeft() +

   636                     QPoint(adjustedIcon, 0), pixmap);

   637             }

   638 

   639             if (selected) {

   640                 painter->setPen(menuItem->palette.highlightedText().color());

   641             } else {

   642                 painter->setPen(menuItem->palette.text().color());

   643             }

   644             int x, y, w, h;

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

   646             int tab =  menuitem->tabWidth;

   647             QColor discol;

   648             if (dis) {

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

   650                 p->setPen(discol);

   651             }

   652             int xm = windowsItemFrame + checkcol + windowsItemHMargin;

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

   654         QRect textRect;

   655         if (!menuItem->icon.isNull())

   656         textRect.setRect(xpos, y + windowsItemVMargin, w - xm -

   657             windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);

   658         else

   659         textRect.setRect(menuItem->rect.left() + 9,

   660                  y + windowsItemVMargin,

   661                  w - xm - windowsRightBorder - tab,

   662                  h - 2 * windowsItemVMargin);

   663 

   664         if (checkable)

   665         textRect.adjust(10, 0, 10, 0);

   666 

   667             QRect vTextRect = visualRect(opt->direction, menuitem->rect,

   668                      textRect);

   669             QString s = menuitem->text;

   670             if (!s.isEmpty()) {

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

   672                 int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic |

   673                  Qt::TextDontClip | Qt::TextSingleLine;

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

   675                     text_flags |= Qt::TextHideMnemonic;

   676                 text_flags |= Qt::AlignLeft;

   677                 if (t >= 0) {

   678                     QRect vShortcutRect = visualRect(opt->direction,

   679                              menuitem->rect,

   680                         QRect(textRect.topRight(),

   681             QPoint(menuitem->rect.right(), textRect.bottom())));

   682                     if (dis && !act) {

   683                         p->setPen(menuitem->palette.light().color());

   684                         p->drawText(vShortcutRect.adjusted(1, 1, 1, 1),

   685                     text_flags,

   686                     s.mid(t + 1));

   687                         p->setPen(discol);

   688                     }

   689                     p->drawText(vShortcutRect, text_flags, s.mid(t + 1));

   690                     s = s.left(t);

   691                 }

   692                 QFont font = menuitem->font;

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

   694                     font.setBold(true);

   695                 p->setFont(font);

   696                 if (dis && !act) {

   697                     p->setPen(menuitem->palette.light().color());

   698                     p->drawText(vTextRect.adjusted(1,1,1,1), text_flags,

   699                 s.left(t));

   700                     p->setPen(discol);

   701                 }

   702                 p->drawText(vTextRect, text_flags, s.left(t));

   703             }

   704 

   705             if (menuItem->menuItemType & QStyleOptionMenuItem::SubMenu) {

   706                 QPoint center = menuItem->rect.center();

   707                 QPoint drawStart(menuItem->rect.right() - 6, center.y() + 4);

   708 

   709                 QPainterPath arrow;

   710                 arrow.moveTo(drawStart);

   711                 arrow.lineTo(drawStart + QPoint(0, -8));

   712                 arrow.lineTo(drawStart + QPoint(4, -5));

   713                 arrow.lineTo(drawStart + QPoint(4, -4));

   714                 arrow.lineTo(drawStart + QPoint(0, 0));

   715 

   716                 painter->save();

   717                 painter->setBrush(menuItem->palette.color(QPalette::Text));

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

   719                 painter->drawPath(arrow);

   720                 painter->restore();

   721             }

   722 

   723             break;

   724         }

   725         case CE_MenuVMargin: {

   726             break;

   727         }

   728         case CE_MenuHMargin: {

   729             break;

   730         }

   731         case CE_Splitter: {

   732             drawSplitter(option, painter, option->state & State_Horizontal);

   733             break;

   734         }

   735         case CE_ScrollBarAddPage: {

   736         case CE_ScrollBarSubPage:

   737             const QStyleOptionSlider *scrollBar =

   738                 qstyleoption_cast<const QStyleOptionSlider *>(option);

   739             QRect myRect;

   740             if (scrollBar->orientation == Qt::Horizontal) {

   741                 myRect = QRect(option->rect.topLeft(),

   742                 option->rect.bottomRight()).adjusted(0, 0, 1, -1);

   743             } else {

   744                 myRect = option->rect;

   745             }

   746 

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

   748             painter->setBrush(option->palette.color(QPalette::Background));

   749             painter->drawRect(myRect);

   750 

   751             painter->setBrush(Qt::NoBrush);

   752             painter->setPen(scrollBar->palette.color(QPalette::Mid));

   753             painter->drawRect(myRect.adjusted(0, 0, -1, 0));

   754             painter->setPen(scrollBar->palette.color(QPalette::Button));

   755             painter->drawLine(myRect.bottomLeft() + QPoint(1, 0),

   756                               myRect.topLeft() + QPoint(1, 1));

   757             painter->drawLine(myRect.topLeft() + QPoint(1, 1),

   758                               myRect.topRight() + QPoint(-1, 1));

   759             break;

   760         }

   761         case CE_ScrollBarSubLine: {

   762             const QStyleOptionSlider *scrollBar =

   763                 qstyleoption_cast<const QStyleOptionSlider *>(option);

   764             int scrollBarExtent = pixelMetric(PM_ScrollBarExtent);

   765             QRect scrollBarSubLine = option->rect;

   766 

   767             QRect button1;

   768             QRect button2;

   769 

   770             if (scrollBar->orientation == Qt::Horizontal) {

   771                 button1.setRect(scrollBarSubLine.left(), scrollBarSubLine.top(),

   772                 16, scrollBarExtent);

   773                 button2.setRect(scrollBarSubLine.right() - 15,

   774                 scrollBarSubLine.top(), 16, scrollBarExtent);

   775             } else {

   776                 button1.setRect(scrollBarSubLine.left(), scrollBarSubLine.top(),

   777                 scrollBarExtent, 16);

   778                 button2.setRect(scrollBarSubLine.left(),

   779                 scrollBarSubLine.bottom() - 15, scrollBarExtent, 16);

   780             }

   781 

   782             painter->fillRect(button2, Qt::blue);

   783 

   784             drawScrollBarArrow(button1, painter, scrollBar);

   785             drawScrollBarArrow(button2, painter, scrollBar);

   786             break;

   787         }

   788         case CE_ScrollBarAddLine: {

   789             const QStyleOptionSlider *scrollBar =

   790                 qstyleoption_cast<const QStyleOptionSlider *>(option);

   791             QRect button(option->rect.left(), option->rect.top(), 16, 16);

   792             drawScrollBarArrow(button, painter, scrollBar, true);

   793             break;

   794         }

   795         case CE_ScrollBarSlider: {

   796             const QStyleOptionSlider *scrollBar =

   797                 qstyleoption_cast<const QStyleOptionSlider *>(option);

   798 

   799             painter->setPen(scrollBar->palette.color(QPalette::Midlight));

   800             painter->drawRect(scrollBar->rect.adjusted(-1, 0, -3, -1));

   801 

   802             QPoint g1, g2;

   803             if (scrollBar->orientation == Qt::Horizontal) {

   804                 g1 = option->rect.topLeft();

   805                 g2 = option->rect.bottomLeft();

   806             } else {

   807                 g1 = option->rect.topLeft();

   808                 g2 = option->rect.topRight();

   809             }

   810 

   811             if (scrollBar->state & State_Enabled) {

   812                 QLinearGradient gradient(g1, g2);

   813                 gradient.setColorAt(1.0, QColor(188, 210, 230));

   814                 gradient.setColorAt(0.3, Qt::white);

   815                 gradient.setColorAt(0.0, QColor(223, 233, 243));

   816                 painter->setBrush(gradient);

   817             } else {

   818                 painter->setPen(scrollBar->palette.buttonText().color());

   819                 painter->setBrush(scrollBar->palette.button());

   820             }

   821             painter->drawRect(scrollBar->rect.adjusted(0, 0, -1, -1));

   822 

   823             int sliderLength = option->rect.height();

   824             int drawPos = scrollBar->orientation == Qt::Vertical ?

   825                 (sliderLength / 2) + 1 : 1 - ((option->rect.width() / 2));

   826 

   827             QPoint origin;

   828             if (scrollBar->orientation == Qt::Vertical)

   829                 origin = option->rect.bottomLeft();

   830             else

   831                 origin = option->rect.topLeft();

   832 

   833             painter->setPen(scrollBar->palette.color(QPalette::Base));

   834             painter->drawLine(origin + adjustScrollHandlePoint(

   835                              scrollBar->orientation,

   836                     QPoint(4, -drawPos)),

   837                     origin + adjustScrollHandlePoint(

   838                     scrollBar->orientation,

   839                     QPoint(13, -drawPos)));

   840             painter->drawLine(origin + adjustScrollHandlePoint(

   841                         scrollBar->orientation,

   842                       QPoint(4,  2 - drawPos)),

   843                       origin + adjustScrollHandlePoint(

   844                       scrollBar->orientation,

   845                       QPoint(13, 2 - drawPos)));

   846             painter->drawLine(origin + adjustScrollHandlePoint(

   847                     scrollBar->orientation,

   848                     QPoint(4,  4 - drawPos)),

   849                     origin + adjustScrollHandlePoint(

   850                     scrollBar->orientation,

   851                     QPoint(13, 4 - drawPos)));

   852 

   853             painter->setPen(option->palette.color(QPalette::Midlight));

   854             painter->drawLine(origin + adjustScrollHandlePoint(

   855                     scrollBar->orientation,

   856                     QPoint(3, -(drawPos + 1))),

   857                     origin + adjustScrollHandlePoint(

   858                     scrollBar->orientation,

   859                     QPoint(12, -(drawPos + 1))));

   860             painter->drawLine(origin + adjustScrollHandlePoint(

   861                     scrollBar->orientation,

   862                     QPoint(3, 1 - drawPos)),

   863                     origin + adjustScrollHandlePoint(

   864                     scrollBar->orientation,

   865                     QPoint(12, 1 - drawPos)));

   866             painter->drawLine(origin + adjustScrollHandlePoint(

   867                     scrollBar->orientation,

   868                     QPoint(3, 3 - drawPos)),

   869                     origin + adjustScrollHandlePoint(

   870                     scrollBar->orientation,

   871                     QPoint(12, 3 - drawPos)));

   872 

   873             break;

   874         }

   875         case CE_TabBarTabLabel: {

   876             QStyleOptionTab copy =

   877                 *qstyleoption_cast<const QStyleOptionTab *>(option);

   878             if (copy.state & State_HasFocus)

   879                 copy.state ^= State_HasFocus;

   880                 painter->setBrush(Qt::NoBrush);

   881                 QWindowsStyle::drawControl(CE_TabBarTabLabel, &copy, painter,

   882                                            widget);

   883             break;

   884         }

   885         case CE_TabBarTabShape: {

   886             const QStyleOptionTab *tab =

   887                 qstyleoption_cast<const QStyleOptionTab *>(option);

   888             QRect myRect = option->rect;

   889             QPoint bottomLeft, bottomRight, topLeft, topRight;

   890 

   891             if ((tab->position == QStyleOptionTab::Beginning) ||

   892                 (tab->position == QStyleOptionTab::OnlyOneTab)) {

   893                 if (tab->shape == QTabBar::RoundedSouth ||

   894                     tab->shape == QTabBar::RoundedNorth) {

   895                     myRect = myRect.adjusted(2, 0, 0, 0);

   896                 } else {

   897                     myRect = myRect.adjusted(0, 2, 0, 0);

   898                 }

   899             }

   900 

   901             switch (tab->shape) {

   902                 case QTabBar::RoundedNorth:

   903                     topLeft = myRect.topLeft();

   904                     topRight = myRect.topRight();

   905                     bottomLeft = myRect.bottomLeft();

   906                     bottomRight = myRect.bottomRight();

   907                     break;

   908                 case QTabBar::RoundedSouth:

   909                     topLeft = myRect.bottomLeft();

   910                     topRight = myRect.bottomRight();

   911                     bottomLeft = myRect.topLeft();

   912                     bottomRight = myRect.topRight();

   913                     break;

   914                 case QTabBar::RoundedWest:

   915                     topLeft = myRect.topLeft();

   916                     topRight = myRect.bottomLeft();

   917                     bottomLeft = myRect.topRight();

   918                     bottomRight = myRect.bottomRight();

   919                     break;

   920                 case QTabBar::RoundedEast:

   921                     topLeft = myRect.topRight();

   922                     topRight = myRect.bottomRight();

   923                     bottomLeft = myRect.topLeft();

   924                     bottomRight = myRect.bottomLeft();

   925                     break;

   926                 default:

   927                     ;

   928             }

   929 

   930             QPainterPath outerPath;

   931             outerPath.moveTo(bottomLeft + adjustTabPoint(QPoint(0, -2),

   932                              tab->shape));

   933             outerPath.lineTo(bottomLeft + adjustTabPoint(QPoint(0, -14),

   934                              tab->shape));

   935             outerPath.lineTo(topLeft + adjustTabPoint(QPoint(6 , 0),

   936                              tab->shape));

   937             outerPath.lineTo(topRight + adjustTabPoint(QPoint(0, 0),

   938                              tab->shape));

   939             outerPath.lineTo(bottomRight + adjustTabPoint(QPoint(0, -2),

   940                              tab->shape));

   941 

   942             if (tab->state & State_Selected ||

   943                 tab->position == QStyleOptionTab::OnlyOneTab) {

   944                 QPainterPath innerPath;

   945                 innerPath.moveTo(topLeft + adjustTabPoint(QPoint(6, 2),

   946                                  tab->shape));

   947                 innerPath.lineTo(topRight + adjustTabPoint(QPoint(-1, 2),

   948                                  tab->shape));

   949                 innerPath.lineTo(bottomRight + adjustTabPoint(QPoint(-1 , -2),

   950                                  tab->shape));

   951                 innerPath.lineTo(bottomLeft + adjustTabPoint(QPoint(2 , -2),

   952                                  tab->shape));

   953                 innerPath.lineTo(bottomLeft + adjustTabPoint(QPoint(2 , -14),

   954                                  tab->shape));

   955                 innerPath.lineTo(topLeft + adjustTabPoint(QPoint(6, 2),

   956                                  tab->shape));

   957 

   958                 QPainterPath whitePath;

   959                 whitePath.moveTo(bottomLeft + adjustTabPoint(QPoint(1, -2),

   960                                  tab->shape));

   961                 whitePath.lineTo(bottomLeft + adjustTabPoint(QPoint(1, -14),

   962                                  tab->shape));

   963                 whitePath.lineTo(topLeft + adjustTabPoint(QPoint(6, 1),

   964                                  tab->shape));

   965                 whitePath.lineTo(topRight + adjustTabPoint(QPoint(-1, 1),

   966                                  tab->shape));

   967 

   968                 painter->setPen(tab->palette.color(QPalette::Midlight));

   969                 painter->setBrush(QColor(200, 221, 242));

   970                 painter->drawPath(outerPath);

   971                 painter->setPen(QColor(200, 221, 242));

   972                 painter->drawRect(QRect(bottomLeft + adjustTabPoint( 

   973                                         QPoint(2, -3), tab->shape),

   974                                         bottomRight + adjustTabPoint(

   975                                         QPoint(-2, 0), tab->shape)));

   976                 painter->setPen(tab->palette.color(QPalette::Base));

   977                 painter->setBrush(Qt::NoBrush);

   978                 painter->drawPath(whitePath);

   979 

   980                 if (option->state & State_HasFocus) { 

   981                     painter->setPen(option->palette.color(QPalette::Mid));

   982                     painter->drawPath(innerPath);

   983                 }

   984             } else {

   985                 painter->setPen(tab->palette.color(QPalette::Mid));

   986                 painter->drawPath(outerPath);

   987             }

   988             break;

   989         }

   990         case CE_PushButtonLabel:

   991             painter->save();

   992 

   993             if (const QStyleOptionButton *button =

   994                 qstyleoption_cast<const QStyleOptionButton *>(option)) {

   995                 QRect ir = button->rect;

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

   997                 if (!styleHint(SH_UnderlineShortcut, button, widget))

   998                     tf |= Qt::TextHideMnemonic;

   999 

  1000                 if (!button->icon.isNull()) {

  1001                     QPoint point;

  1002 

  1003                     QIcon::Mode mode = button->state & State_Enabled ? QIcon::Normal

  1004                                                                   : QIcon::Disabled;

  1005                     if (mode == QIcon::Normal && button->state & State_HasFocus)

  1006                         mode = QIcon::Active;

  1007                     QIcon::State state = QIcon::Off;

  1008                     if (button->state & State_On)

  1009                         state = QIcon::On;

  1010 

  1011                     QPixmap pixmap = button->icon.pixmap(button->iconSize, mode,

  1012                              state);

  1013                     int w = pixmap.width();

  1014                     int h = pixmap.height();

  1015 

  1016                     if (!button->text.isEmpty())

  1017                         w += button->fontMetrics.width(button->text) + 2;

  1018 

  1019                     point = QPoint(ir.x() + ir.width() / 2 - w / 2,

  1020                                    ir.y() + ir.height() / 2 - h / 2);

  1021 

  1022                     if (button->direction == Qt::RightToLeft)

  1023                         point.rx() += pixmap.width();

  1024 

  1025                     painter->drawPixmap(visualPos(button->direction, button->rect,

  1026                               point), pixmap);

  1027 

  1028                     if (button->direction == Qt::RightToLeft)

  1029                         ir.translate(-point.x() - 2, 0);

  1030                     else

  1031                         ir.translate(point.x() + pixmap.width(), 0);

  1032 

  1033                     if (!button->text.isEmpty())

  1034                         tf |= Qt::AlignLeft;

  1035 

  1036                 } else {

  1037                     tf |= Qt::AlignHCenter;

  1038                 }

  1039 

  1040                 if (button->fontMetrics.height() > 14)

  1041                     ir.translate(0, 1);

  1042 

  1043                 drawItemText(painter, ir, tf, button->palette, (button->state &

  1044                                  State_Enabled),

  1045                              button->text, QPalette::ButtonText);

  1046             }

  1047 

  1048             painter->restore();

  1049             break;

  1050 

  1051         default:

  1052             QWindowsStyle::drawControl(control, option, painter, widget);

  1053     }

  1054     painter->restore();

  1055 }

  1056 

  1057 inline QPoint JavaStyle::adjustTabPoint(const QPoint &point,

  1058                                         QTabBar::Shape shape) const

  1059 {

  1060     QPoint rPoint;

  1061 

  1062     switch (shape) {

  1063         case QTabBar::RoundedWest:

  1064             rPoint = QPoint(point.y(), point.x());

  1065             break;

  1066         case QTabBar::RoundedSouth:

  1067             rPoint = QPoint(point.x(), point.y() * -1);

  1068             break;

  1069         case QTabBar::RoundedEast:

  1070             rPoint = QPoint(point.y() * -1, point.x());

  1071             break;

  1072         default:

  1073             rPoint = point;

  1074     }

  1075     return rPoint;

  1076 }

  1077 

  1078 QRect JavaStyle::subControlRect(ComplexControl control,

  1079                                 const QStyleOptionComplex *option,

  1080                                 SubControl subControl,

  1081                                 const QWidget *widget) const

  1082 {

  1083     QRect rect = QWindowsStyle::subControlRect(control, option, subControl,

  1084                                                widget);

  1085 

  1086     switch (control) {

  1087         case CC_TitleBar: {

  1088             const QStyleOptionTitleBar *bar =

  1089             qstyleoption_cast<const QStyleOptionTitleBar *>(option);

  1090 

  1091             switch (subControl) {

  1092                 case SC_TitleBarMinButton: {

  1093                     rect = QRect(bar->rect.topRight() + QPoint(-68, 2),

  1094                     QSize(15, 15));

  1095                     break;

  1096                 }

  1097                 case SC_TitleBarMaxButton: {

  1098                     rect = QRect(bar->rect.topRight() + QPoint(-43, 3),

  1099                                  QSize(15, 15));

  1100                     break;

  1101                 }

  1102                 case SC_TitleBarCloseButton: {

  1103                     rect = QRect(bar->rect.topRight() + QPoint(-18, 3),

  1104                                  QSize(15, 15));

  1105                     break;

  1106                 }

  1107                 case SC_TitleBarLabel: {

  1108                     QRect labelRect = bar->fontMetrics.boundingRect(bar->text);

  1109                     rect = labelRect;

  1110                     rect.translate(bar->rect.left() + 30, 0);

  1111                     rect.moveTop(bar->rect.top());

  1112                     rect.adjust(0, 2, 2, 2);

  1113                     break;

  1114                 }

  1115                 case SC_TitleBarSysMenu: {

  1116                     rect = QRect(bar->rect.topLeft() + QPoint(6, 3),

  1117                                  QSize(16, 16));

  1118                     break;

  1119                 }

  1120                 default:

  1121                     ;

  1122             }

  1123             break;

  1124         }

  1125         case CC_GroupBox: {

  1126             const QStyleOptionGroupBox *box =

  1127                 qstyleoption_cast<const QStyleOptionGroupBox *>(option);

  1128             bool hasCheckbox = box->subControls & SC_GroupBoxCheckBox;

  1129             int checkAdjust = 13;

  1130 

  1131             QRect textRect = box->fontMetrics.boundingRect(box->text);

  1132 

  1133             switch (subControl) {

  1134                 case SC_GroupBoxFrame: {

  1135                     rect = box->rect;