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

     2 **

     3 ** Copyright (C) 2010 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 "qcommonstyle.h"

    43 #include "qcommonstyle_p.h"

    44 

    45 #include <qfile.h>

    46 #include <qapplication.h>

    47 #include <qbitmap.h>

    48 #include <qcache.h>

    49 #include <qdockwidget.h>

    50 #include <qdrawutil.h>

    51 #include <qdialogbuttonbox.h>

    52 #include <qformlayout.h>

    53 #include <qgroupbox.h>

    54 #include <qmath.h>

    55 #include <qmenu.h>

    56 #include <qpainter.h>

    57 #include <qpaintengine.h>

    58 #include <qpainterpath.h>

    59 #include <qslider.h>

    60 #include <qstyleoption.h>

    61 #include <qtabbar.h>

    62 #include <qtabwidget.h>

    63 #include <qtoolbar.h>

    64 #include <qtoolbutton.h>

    65 #include <qrubberband.h>

    66 #include <private/qcommonstylepixmaps_p.h>

    67 #include <private/qmath_p.h>

    68 #include <private/qstylehelper_p.h>

    69 #include <qdebug.h>

    70 #include <qtextformat.h>

    71 #include <qwizard.h>

    72 #include <qtabbar.h>

    73 #include <qfileinfo.h>

    74 #include <qdir.h>

    75 #include <qsettings.h>

    76 #include <qpixmapcache.h>

    77 #include <private/qguiplatformplugin_p.h>

    78 

    79 #include <limits.h>

    80 

    81 #ifndef QT_NO_ITEMVIEWS

    82 #   include "private/qtextengine_p.h"

    83 #endif

    84 

    85 #ifdef Q_WS_X11

    86 #   include <private/qt_x11_p.h>

    87 #elif defined(Q_WS_MAC)

    88 #   include <private/qt_cocoa_helpers_mac_p.h>

    89 #endif

    90 

    91 QT_BEGIN_NAMESPACE

    92 

    93 /*!

    94     \class QCommonStyle

    95     \brief The QCommonStyle class encapsulates the common Look and Feel of a GUI.

    96 

    97     \ingroup appearance

    98 

    99     This abstract class implements some of the widget's look and feel

   100     that is common to all GUI styles provided and shipped as part of

   101     Qt.

   102 

   103     Since QCommonStyle inherits QStyle, all of its functions are fully documented

   104     in the QStyle documentation.

   105     \omit

   106     , although the

   107     extra functions that QCommonStyle provides, e.g.

   108     drawComplexControl(), drawControl(), drawPrimitive(),

   109     hitTestComplexControl(), subControlRect(), sizeFromContents(), and

   110     subElementRect() are documented here.

   111     \endomit

   112 

   113     \sa QStyle, QMotifStyle, QWindowsStyle

   114 */

   115 

   116 /*!

   117     Constructs a QCommonStyle.

   118 */

   119 QCommonStyle::QCommonStyle()

   120     : QStyle(*new QCommonStylePrivate)

   121 { }

   122 

   123 /*! \internal

   124 */

   125 QCommonStyle::QCommonStyle(QCommonStylePrivate &dd)

   126     : QStyle(dd)

   127 { }

   128 

   129 /*!

   130     Destroys the style.

   131 */

   132 QCommonStyle::~QCommonStyle()

   133 { }

   134 

   135 

   136 /*!

   137     \reimp

   138 */

   139 void QCommonStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p,

   140                                  const QWidget *widget) const

   141 {

   142     Q_D(const QCommonStyle);

   143     switch (pe) {

   144     case PE_FrameButtonBevel:

   145     case PE_FrameButtonTool:

   146         qDrawShadeRect(p, opt->rect, opt->palette,

   147                        opt->state & (State_Sunken | State_On), 1, 0);

   148         break;

   149     case PE_PanelButtonCommand:

   150     case PE_PanelButtonBevel:

   151     case PE_PanelButtonTool:

   152     case PE_IndicatorButtonDropDown:

   153         qDrawShadePanel(p, opt->rect, opt->palette,

   154                         opt->state & (State_Sunken | State_On), 1,

   155                         &opt->palette.brush(QPalette::Button));

   156         break;

   157     case PE_IndicatorViewItemCheck:

   158         proxy()->drawPrimitive(PE_IndicatorCheckBox, opt, p, widget);

   159         break;

   160     case PE_IndicatorCheckBox:

   161         if (opt->state & State_NoChange) {

   162             p->setPen(opt->palette.foreground().color());

   163             p->fillRect(opt->rect, opt->palette.brush(QPalette::Button));

   164             p->drawRect(opt->rect);

   165             p->drawLine(opt->rect.topLeft(), opt->rect.bottomRight());

   166         } else {

   167             qDrawShadePanel(p, opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height(),

   168                             opt->palette, opt->state & (State_Sunken | State_On), 1,

   169                             &opt->palette.brush(QPalette::Button));

   170         }

   171         break;

   172     case PE_IndicatorRadioButton: {

   173         QRect ir = opt->rect;

   174         p->setPen(opt->palette.dark().color());

   175         p->drawArc(opt->rect, 0, 5760);

   176         if (opt->state & (State_Sunken | State_On)) {

   177             ir.adjust(2, 2, -2, -2);

   178             p->setBrush(opt->palette.foreground());

   179             p->drawEllipse(ir);

   180         }

   181         break; }

   182     case PE_FrameFocusRect:

   183         if (const QStyleOptionFocusRect *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(opt)) {

   184             QColor bg = fropt->backgroundColor;

   185             QPen oldPen = p->pen();

   186             if (bg.isValid()) {

   187                 int h, s, v;

   188                 bg.getHsv(&h, &s, &v);

   189                 if (v >= 128)

   190                     p->setPen(Qt::black);

   191                 else

   192                     p->setPen(Qt::white);

   193             } else {

   194                 p->setPen(opt->palette.foreground().color());

   195             }

   196             QRect focusRect = opt->rect.adjusted(1, 1, -1, -1);

   197             p->drawRect(focusRect.adjusted(0, 0, -1, -1)); //draw pen inclusive

   198             p->setPen(oldPen);

   199         }

   200         break;

   201     case PE_IndicatorMenuCheckMark: {

   202         const int markW = opt->rect.width() > 7 ? 7 : opt->rect.width();

   203         const int markH = markW;

   204         int posX = opt->rect.x() + (opt->rect.width() - markW)/2 + 1;

   205         int posY = opt->rect.y() + (opt->rect.height() - markH)/2;

   206 

   207         QVector<QLineF> a;

   208         a.reserve(markH);

   209 

   210         int i, xx, yy;

   211         xx = posX;

   212         yy = 3 + posY;

   213         for (i = 0; i < markW/2; ++i) {

   214             a << QLineF(xx, yy, xx, yy + 2);

   215             ++xx;

   216             ++yy;

   217         }

   218         yy -= 2;

   219         for (; i < markH; ++i) {

   220             a << QLineF(xx, yy, xx, yy + 2);

   221             ++xx;

   222             --yy;

   223         }

   224         if (!(opt->state & State_Enabled) && !(opt->state & State_On)) {

   225             int pnt;

   226             p->setPen(opt->palette.highlightedText().color());

   227             QPoint offset(1, 1);

   228             for (pnt = 0; pnt < a.size(); ++pnt)

   229                 a[pnt].translate(offset.x(), offset.y());

   230             p->drawLines(a);

   231             for (pnt = 0; pnt < a.size(); ++pnt)

   232                 a[pnt].translate(offset.x(), offset.y());

   233         }

   234         p->setPen(opt->palette.text().color());

   235         p->drawLines(a);

   236         break; }

   237     case PE_Frame:

   238     case PE_FrameMenu:

   239         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {

   240             if (pe == PE_FrameMenu || (frame->state & State_Sunken) || (frame->state & State_Raised)) {

   241                 qDrawShadePanel(p, frame->rect, frame->palette, frame->state & State_Sunken,

   242                                 frame->lineWidth);

   243             } else {

   244                 qDrawPlainRect(p, frame->rect, frame->palette.foreground().color(), frame->lineWidth);

   245             }

   246         }

   247         break;

   248 #ifndef QT_NO_TOOLBAR

   249     case PE_PanelMenuBar:

   250         if (widget && qobject_cast<QToolBar *>(widget->parentWidget()))

   251             break;

   252         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)){

   253             qDrawShadePanel(p, frame->rect, frame->palette, false, frame->lineWidth,

   254                             &frame->palette.brush(QPalette::Button));

   255 

   256         }

   257         else if (const QStyleOptionToolBar *frame = qstyleoption_cast<const QStyleOptionToolBar *>(opt)){

   258             qDrawShadePanel(p, frame->rect, frame->palette, false, frame->lineWidth,

   259                             &frame->palette.brush(QPalette::Button));

   260         }

   261 

   262         break;

   263    case PE_PanelMenu:

   264         break;

   265     case PE_PanelToolBar:

   266        break;

   267 #endif // QT_NO_TOOLBAR

   268 #ifndef QT_NO_PROGRESSBAR

   269     case PE_IndicatorProgressChunk:

   270         {

   271             bool vertical = false;

   272             if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(opt))

   273                 vertical = (pb2->orientation == Qt::Vertical);

   274             if (!vertical) {

   275                 p->fillRect(opt->rect.x(), opt->rect.y() + 3, opt->rect.width() -2, opt->rect.height() - 6,

   276                             opt->palette.brush(QPalette::Highlight));

   277             } else {

   278                 p->fillRect(opt->rect.x() + 2, opt->rect.y(), opt->rect.width() -6, opt->rect.height() - 2,

   279                             opt->palette.brush(QPalette::Highlight));

   280             }

   281         }

   282         break;

   283 #endif // QT_NO_PROGRESSBAR

   284 #ifdef QT3_SUPPORT

   285     case PE_Q3CheckListController:

   286 #ifndef QT_NO_IMAGEFORMAT_XPM

   287         p->drawPixmap(opt->rect.topLeft(), QPixmap(check_list_controller_xpm));

   288 #endif

   289         break;

   290     case PE_Q3CheckListExclusiveIndicator:

   291         if (const QStyleOptionQ3ListView *lv = qstyleoption_cast<const QStyleOptionQ3ListView *>(opt)) {

   292             if (lv->items.isEmpty())

   293                 return;

   294             int x = lv->rect.x(),

   295                 y = lv->rect.y();

   296 #define INTARRLEN(x) sizeof(x)/(sizeof(int)*2)

   297             static const int pts1[] = {                // dark lines

   298                 1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };

   299             static const int pts2[] = {                // black lines

   300                 2,8, 1,7, 1,4, 2,3, 2,2, 3,2, 4,1, 7,1, 8,2, 9,2 };

   301             static const int pts3[] = {                // background lines

   302                 2,9, 3,9, 4,10, 7,10, 8,9, 9,9, 9,8, 10,7, 10,4, 9,3 };

   303             static const int pts4[] = {                // white lines

   304                 2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,

   305                 11,4, 10,3, 10,2 };

   306             // static const int pts5[] = {                // inner fill

   307             //    4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };

   308             //QPolygon a;

   309 

   310             if (lv->state & State_Enabled)

   311                 p->setPen(lv->palette.text().color());

   312             else

   313                 p->setPen(QPen(lv->viewportPalette.color(QPalette::Disabled, QPalette::Text)));

   314             QPolygon a(INTARRLEN(pts1), pts1);

   315             a.translate(x, y);

   316             //p->setPen(pal.dark());

   317             p->drawPolyline(a);

   318             a.setPoints(INTARRLEN(pts2), pts2);

   319             a.translate(x, y);

   320             p->drawPolyline(a);

   321             a.setPoints(INTARRLEN(pts3), pts3);

   322             a.translate(x, y);

   323             //                p->setPen(black);

   324             p->drawPolyline(a);

   325             a.setPoints(INTARRLEN(pts4), pts4);

   326             a.translate(x, y);

   327             //                        p->setPen(blue);

   328             p->drawPolyline(a);

   329             //                a.setPoints(INTARRLEN(pts5), pts5);

   330             //                a.translate(x, y);

   331             //        QColor fillColor = isDown() ? g.background() : g.base();

   332             //        p->setPen(fillColor);

   333             //        p->setBrush(fillColor);

   334             //        p->drawPolygon(a);

   335             if (opt->state & State_On) {

   336                 p->setPen(Qt::NoPen);

   337                 p->setBrush(opt->palette.text());

   338                 p->drawRect(x + 5, y + 4, 2, 4);

   339                 p->drawRect(x + 4, y + 5, 4, 2);

   340             }

   341 #undef INTARRLEN

   342         }

   343         break;

   344     case PE_Q3CheckListIndicator:

   345         if (const QStyleOptionQ3ListView *lv = qstyleoption_cast<const QStyleOptionQ3ListView *>(opt)) {

   346             if(lv->items.isEmpty())

   347                 break;

   348             QStyleOptionQ3ListViewItem item = lv->items.at(0);

   349             int x = lv->rect.x(),

   350                 y = lv->rect.y(),

   351                 w = lv->rect.width(),

   352                 h = lv->rect.width(),

   353              marg = lv->itemMargin;

   354 

   355             if (lv->state & State_Enabled)

   356                 p->setPen(QPen(lv->palette.text().color(), 2));

   357             else

   358                 p->setPen(QPen(lv->viewportPalette.color(QPalette::Disabled, QPalette::Text), 2));

   359             if (opt->state & State_Selected && !lv->rootIsDecorated

   360                 && !(item.features & QStyleOptionQ3ListViewItem::ParentControl)) {

   361                 p->fillRect(0, 0, x + marg + w + 4, item.height,

   362                             lv->palette.brush(QPalette::Highlight));

   363                 if (item.state & State_Enabled)

   364                     p->setPen(QPen(lv->palette.highlightedText().color(), 2));

   365             }

   366 

   367             if (lv->state & State_NoChange)

   368                 p->setBrush(lv->palette.brush(QPalette::Button));

   369             p->drawRect(x + marg, y + 2, w - 4, h - 4);

   370             /////////////////////

   371                 ++x;

   372                 ++y;

   373                 if (lv->state & State_On || lv->state & State_NoChange) {

   374                     QLineF lines[7];

   375                     int i,

   376                         xx = x + 1 + marg,

   377                         yy = y + 5;

   378                     for (i = 0; i < 3; ++i) {

   379                         lines[i] = QLineF(xx, yy, xx, yy + 2);

   380                         ++xx;

   381                         ++yy;

   382                     }

   383                     yy -= 2;

   384                     for (i = 3; i < 7; ++i) {

   385                         lines[i] = QLineF(xx, yy, xx, yy + 2);

   386                         ++xx;

   387                         --yy;

   388                     }

   389                     p->drawLines(lines, 7);

   390                 }

   391         }

   392         break;

   393 #endif // QT3_SUPPORT

   394     case PE_IndicatorBranch: {

   395         int mid_h = opt->rect.x() + opt->rect.width() / 2;

   396         int mid_v = opt->rect.y() + opt->rect.height() / 2;

   397         int bef_h = mid_h;

   398         int bef_v = mid_v;

   399         int aft_h = mid_h;

   400         int aft_v = mid_v;

   401 #ifndef QT_NO_IMAGEFORMAT_XPM

   402         static const int decoration_size = 9;

   403         static QPixmap open(tree_branch_open_xpm);

   404         static QPixmap closed(tree_branch_closed_xpm);

   405         if (opt->state & State_Children) {

   406             int delta = decoration_size / 2;

   407             bef_h -= delta;

   408             bef_v -= delta;

   409             aft_h += delta;

   410             aft_v += delta;

   411             p->drawPixmap(bef_h, bef_v, opt->state & State_Open ? open : closed);

   412         }

   413 #endif // QT_NO_IMAGEFORMAT_XPM

   414         if (opt->state & State_Item) {

   415             if (opt->direction == Qt::RightToLeft)

   416                 p->drawLine(opt->rect.left(), mid_v, bef_h, mid_v);

   417             else

   418                 p->drawLine(aft_h, mid_v, opt->rect.right(), mid_v);

   419         }

   420         if (opt->state & State_Sibling)

   421             p->drawLine(mid_h, aft_v, mid_h, opt->rect.bottom());

   422         if (opt->state & (State_Open | State_Children | State_Item | State_Sibling))

   423             p->drawLine(mid_h, opt->rect.y(), mid_h, bef_v);

   424         break; }

   425 #ifdef QT3_SUPPORT

   426     case PE_Q3Separator:

   427         qDrawShadeLine(p, opt->rect.left(), opt->rect.top(), opt->rect.right(), opt->rect.bottom(),

   428                        opt->palette, opt->state & State_Sunken, 1, 0);

   429         break;

   430 #endif // QT3_SUPPORT

   431     case PE_FrameStatusBarItem:

   432         qDrawShadeRect(p, opt->rect, opt->palette, true, 1, 0, 0);

   433         break;

   434     case PE_IndicatorHeaderArrow:

   435         if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(opt)) {

   436             QPen oldPen = p->pen();

   437             if (header->sortIndicator & QStyleOptionHeader::SortUp) {

   438                 QPolygon pa(3);

   439                 p->setPen(QPen(opt->palette.light(), 0));

   440                 p->drawLine(opt->rect.x() + opt->rect.width(), opt->rect.y(),

   441                             opt->rect.x() + opt->rect.width() / 2, opt->rect.y() + opt->rect.height());

   442                 p->setPen(QPen(opt->palette.dark(), 0));

   443                 pa.setPoint(0, opt->rect.x() + opt->rect.width() / 2, opt->rect.y() + opt->rect.height());

   444                 pa.setPoint(1, opt->rect.x(), opt->rect.y());

   445                 pa.setPoint(2, opt->rect.x() + opt->rect.width(), opt->rect.y());

   446                 p->drawPolyline(pa);

   447             } else if (header->sortIndicator & QStyleOptionHeader::SortDown) {

   448                 QPolygon pa(3);

   449                 p->setPen(QPen(opt->palette.light(), 0));

   450                 pa.setPoint(0, opt->rect.x(), opt->rect.y() + opt->rect.height());

   451                 pa.setPoint(1, opt->rect.x() + opt->rect.width(), opt->rect.y() + opt->rect.height());

   452                 pa.setPoint(2, opt->rect.x() + opt->rect.width() / 2, opt->rect.y());

   453                 p->drawPolyline(pa);

   454                 p->setPen(QPen(opt->palette.dark(), 0));

   455                 p->drawLine(opt->rect.x(), opt->rect.y() + opt->rect.height(),

   456                             opt->rect.x() + opt->rect.width() / 2, opt->rect.y());

   457             }

   458             p->setPen(oldPen);

   459         }

   460         break;

   461 #ifndef QT_NO_TABBAR

   462     case PE_FrameTabBarBase:

   463         if (const QStyleOptionTabBarBase *tbb

   464                 = qstyleoption_cast<const QStyleOptionTabBarBase *>(opt)) {

   465             p->save();

   466             switch (tbb->shape) {

   467             case QTabBar::RoundedNorth:

   468             case QTabBar::TriangularNorth:

   469                 p->setPen(QPen(tbb->palette.light(), 0));

   470                 p->drawLine(tbb->rect.topLeft(), tbb->rect.topRight());

   471                 break;

   472             case QTabBar::RoundedWest:

   473             case QTabBar::TriangularWest:

   474                 p->setPen(QPen(tbb->palette.light(), 0));

   475                 p->drawLine(tbb->rect.topLeft(), tbb->rect.bottomLeft());

   476                 break;

   477             case QTabBar::RoundedSouth:

   478             case QTabBar::TriangularSouth:

   479                 p->setPen(QPen(tbb->palette.shadow(), 0));

   480                 p->drawLine(tbb->rect.left(), tbb->rect.bottom(),

   481                             tbb->rect.right(), tbb->rect.bottom());

   482                 p->setPen(QPen(tbb->palette.dark(), 0));

   483                 p->drawLine(tbb->rect.left(), tbb->rect.bottom() - 1,

   484                             tbb->rect.right() - 1, tbb->rect.bottom() - 1);

   485                 break;

   486             case QTabBar::RoundedEast:

   487             case QTabBar::TriangularEast:

   488                 p->setPen(QPen(tbb->palette.dark(), 0));

   489                 p->drawLine(tbb->rect.topRight(), tbb->rect.bottomRight());

   490                 break;

   491             }

   492             p->restore();

   493         }

   494         break;

   495     case PE_IndicatorTabClose: {

   496         if (d->tabBarcloseButtonIcon.isNull()) {

   497             d->tabBarcloseButtonIcon.addPixmap(QPixmap(

   498                         QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-16.png")),

   499                         QIcon::Normal, QIcon::Off);

   500             d->tabBarcloseButtonIcon.addPixmap(QPixmap(

   501                         QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-down-16.png")),

   502                         QIcon::Normal, QIcon::On);

   503             d->tabBarcloseButtonIcon.addPixmap(QPixmap(

   504                         QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-hover-16.png")),

   505                         QIcon::Active, QIcon::Off);

   506         }

   507 

   508         int size = proxy()->pixelMetric(QStyle::PM_SmallIconSize);

   509         QIcon::Mode mode = opt->state & State_Enabled ?

   510                             (opt->state & State_Raised ? QIcon::Active : QIcon::Normal)

   511                             : QIcon::Disabled;

   512         if (!(opt->state & State_Raised)

   513             && !(opt->state & State_Sunken)

   514             && !(opt->state & QStyle::State_Selected))

   515             mode = QIcon::Disabled;

   516 

   517         QIcon::State state = opt->state & State_Sunken ? QIcon::On : QIcon::Off;

   518         QPixmap pixmap = d->tabBarcloseButtonIcon.pixmap(size, mode, state);

   519         proxy()->drawItemPixmap(p, opt->rect, Qt::AlignCenter, pixmap);

   520         break;

   521     }

   522 #endif // QT_NO_TABBAR

   523     case PE_FrameTabWidget:

   524     case PE_FrameWindow:

   525         qDrawWinPanel(p, opt->rect, opt->palette, false, 0);

   526         break;

   527     case PE_FrameLineEdit:

   528         proxy()->drawPrimitive(PE_Frame, opt, p, widget);

   529         break;

   530 #ifndef QT_NO_GROUPBOX

   531     case PE_FrameGroupBox:

   532         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {

   533             const QStyleOptionFrameV2 *frame2 = qstyleoption_cast<const QStyleOptionFrameV2 *>(opt);

   534             if (frame2 && (frame2->features & QStyleOptionFrameV2::Flat)) {

   535                 QRect fr = frame->rect;

   536                 QPoint p1(fr.x(), fr.y() + 1);

   537                 QPoint p2(fr.x() + fr.width(), p1.y());

   538                 qDrawShadeLine(p, p1, p2, frame->palette, true,

   539                                frame->lineWidth, frame->midLineWidth);

   540             } else {

   541                 qDrawShadeRect(p, frame->rect.x(), frame->rect.y(), frame->rect.width(),

   542                                frame->rect.height(), frame->palette, true,

   543                                frame->lineWidth, frame->midLineWidth);

   544             }

   545         }

   546         break;

   547 #endif // QT_NO_GROUPBOX

   548 #ifndef QT_NO_DOCKWIDGET

   549     case PE_FrameDockWidget:

   550         if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {

   551             int lw = frame->lineWidth;

   552             if (lw <= 0)

   553                 lw = proxy()->pixelMetric(PM_DockWidgetFrameWidth);

   554 

   555             qDrawShadePanel(p, frame->rect, frame->palette, false, lw);

   556         }

   557         break;

   558 #endif // QT_NO_DOCKWIDGET

   559 #ifndef QT_NO_TOOLBAR

   560     case PE_IndicatorToolBarHandle:

   561         p->save();

   562         p->translate(opt->rect.x(), opt->rect.y());

   563         if (opt->state & State_Horizontal) {

   564             int x = opt->rect.width() / 3;

   565             if (opt->direction == Qt::RightToLeft)

   566                 x -= 2;

   567             if (opt->rect.height() > 4) {

   568                 qDrawShadePanel(p, x, 2, 3, opt->rect.height() - 4,

   569                                 opt->palette, false, 1, 0);

   570                 qDrawShadePanel(p, x+3, 2, 3, opt->rect.height() - 4,

   571                                 opt->palette, false, 1, 0);

   572             }

   573         } else {

   574             if (opt->rect.width() > 4) {

   575                 int y = opt->rect.height() / 3;

   576                 qDrawShadePanel(p, 2, y, opt->rect.width() - 4, 3,

   577                                 opt->palette, false, 1, 0);

   578                 qDrawShadePanel(p, 2, y+3, opt->rect.width() - 4, 3,

   579                                 opt->palette, false, 1, 0);

   580             }

   581         }

   582         p->restore();

   583         break;

   584     case PE_Q3DockWindowSeparator:

   585         proxy()->drawPrimitive(PE_IndicatorToolBarSeparator, opt, p, widget);

   586         break;

   587     case PE_IndicatorToolBarSeparator:

   588         {

   589             QPoint p1, p2;

   590             if (opt->state & State_Horizontal) {

   591                 p1 = QPoint(opt->rect.width()/2, 0);

   592                 p2 = QPoint(p1.x(), opt->rect.height());

   593             } else {

   594                 p1 = QPoint(0, opt->rect.height()/2);

   595                 p2 = QPoint(opt->rect.width(), p1.y());

   596             }

   597             qDrawShadeLine(p, p1, p2, opt->palette, 1, 1, 0);

   598             break;

   599         }

   600 #endif // QT_NO_TOOLBAR

   601 #ifndef QT_NO_SPINBOX

   602     case PE_IndicatorSpinPlus:

   603     case PE_IndicatorSpinMinus: {

   604         QRect r = opt->rect;

   605         int fw = proxy()->pixelMetric(PM_DefaultFrameWidth, opt, widget);

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

   607 

   608         int offset = (opt->state & State_Sunken) ? 1 : 0;

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

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

   611                     br.width(), step,

   612                     opt->palette.buttonText());

   613         if (pe == PE_IndicatorSpinPlus)

   614             p->fillRect(br.x() + br.width() / 2 - step / 2 + offset, br.y() + offset,

   615                         step, br.height(),

   616                         opt->palette.buttonText());

   617 

   618         break; }

   619     case PE_IndicatorSpinUp:

   620     case PE_IndicatorSpinDown: {

   621         QRect r = opt->rect;

   622         int fw = proxy()->pixelMetric(PM_DefaultFrameWidth, opt, widget);

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

   624         int x = r.x(), y = r.y(), w = r.width(), h = r.height();

   625         int sw = w-4;

   626         if (sw < 3)

   627             break;

   628         else if (!(sw & 1))

   629             sw--;

   630         sw -= (sw / 7) * 2;        // Empty border

   631         int sh = sw/2 + 2;      // Must have empty row at foot of arrow

   632 

   633         int sx = x + w / 2 - sw / 2;

   634         int sy = y + h / 2 - sh / 2;

   635 

   636         if (pe == PE_IndicatorSpinUp && fw)

   637             --sy;

   638 

   639         QPolygon a;

   640         if (pe == PE_IndicatorSpinDown)

   641             a.setPoints(3, 0, 1,  sw-1, 1,  sh-2, sh-1);

   642         else

   643             a.setPoints(3, 0, sh-1,  sw-1, sh-1,  sh-2, 1);

   644         int bsx = 0;

   645         int bsy = 0;

   646         if (opt->state & State_Sunken) {

   647             bsx = proxy()->pixelMetric(PM_ButtonShiftHorizontal);

   648             bsy = proxy()->pixelMetric(PM_ButtonShiftVertical);

   649         }

   650         p->save();

   651         p->translate(sx + bsx, sy + bsy);

   652         p->setPen(opt->palette.buttonText().color());

   653         p->setBrush(opt->palette.buttonText());

   654         p->drawPolygon(a);

   655         p->restore();

   656         break; }

   657 #endif // QT_NO_SPINBOX

   658     case PE_PanelTipLabel: {

   659         QBrush oldBrush = p->brush();

   660         QPen oldPen = p->pen();

   661         p->setPen(QPen(opt->palette.toolTipText(), 0));

   662         p->setBrush(opt->palette.toolTipBase());

   663         p->drawRect(opt->rect.adjusted(0, 0, -1, -1));

   664         p->setPen(oldPen);

   665         p->setBrush(oldBrush);

   666         break;

   667     }

   668 #ifndef QT_NO_TABBAR

   669     case PE_IndicatorTabTear:

   670         if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(opt)) {

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

   672             QRect rect = tab->rect;

   673             QPainterPath path;

   674 

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

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

   677 

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

   679             int count = 4;

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

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

   682 

   683             p->setPen(QPen(tab->palette.light(), qreal(.8)));

   684             p->setBrush(tab->palette.background());

   685             p->setRenderHint(QPainter::Antialiasing);

   686             p->drawPath(path);

   687         }

   688         break;

   689 #endif // QT_NO_TABBAR

   690 #ifndef QT_NO_LINEEDIT

   691     case PE_PanelLineEdit:

   692         if (const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {

   693             p->fillRect(panel->rect.adjusted(panel->lineWidth, panel->lineWidth, -panel->lineWidth, -panel->lineWidth),

   694                         panel->palette.brush(QPalette::Base));

   695 

   696             if (panel->lineWidth > 0)

   697                 proxy()->drawPrimitive(PE_FrameLineEdit, panel, p, widget);

   698         }

   699         break;

   700 #endif // QT_NO_LINEEDIT

   701 #ifndef QT_NO_COLUMNVIEW

   702     case PE_IndicatorColumnViewArrow: {

   703     if (const QStyleOptionViewItem *viewOpt = qstyleoption_cast<const QStyleOptionViewItem *>(opt)) {

   704         bool reverse = (viewOpt->direction == Qt::RightToLeft);

   705         p->save();

   706         QPainterPath path;

   707         int x = viewOpt->rect.x() + 1;

   708         int offset = (viewOpt->rect.height() / 3);

   709         int height = (viewOpt->rect.height()) - offset * 2;

   710         if (height % 2 == 1)

   711             --height;

   712         int x2 = x + height - 1;

   713         if (reverse) {

   714             x = viewOpt->rect.x() + viewOpt->rect.width() - 1;

   715             x2 = x - height + 1;

   716         }

   717         path.moveTo(x, viewOpt->rect.y() + offset);

   718         path.lineTo(x, viewOpt->rect.y() + offset + height);

   719         path.lineTo(x2, viewOpt->rect.y() + offset+height/2);

   720         path.closeSubpath();

   721         if (viewOpt->state & QStyle::State_Selected ) {

   722             if (viewOpt->showDecorationSelected) {

   723                 QColor color = viewOpt->palette.color(QPalette::Active, QPalette::HighlightedText);

   724                 p->setPen(color);

   725                 p->setBrush(color);

   726             } else {

   727                 QColor color = viewOpt->palette.color(QPalette::Active, QPalette::WindowText);

   728                 p->setPen(color);

   729                 p->setBrush(color);

   730             }

   731 

   732         } else {

   733             QColor color = viewOpt->palette.color(QPalette::Active, QPalette::Mid);

   734             p->setPen(color);

   735             p->setBrush(color);

   736         }

   737         p->drawPath(path);

   738 

   739         // draw the vertical and top triangle line

   740         if (!(viewOpt->state & QStyle::State_Selected)) {

   741             QPainterPath lines;

   742             lines.moveTo(x, viewOpt->rect.y() + offset);

   743             lines.lineTo(x, viewOpt->rect.y() + offset + height);

   744             lines.moveTo(x, viewOpt->rect.y() + offset);

   745             lines.lineTo(x2, viewOpt->rect.y() + offset+height/2);

   746             QColor color = viewOpt->palette.color(QPalette::Active, QPalette::Dark);

   747             p->setPen(color);

   748             p->drawPath(lines);

   749         }

   750         p->restore();

   751     }

   752     break; }

   753 #endif //QT_NO_COLUMNVIEW

   754     case PE_IndicatorItemViewItemDrop: {

   755         QRect rect = opt->rect;

   756         if (opt->rect.height() == 0)

   757             p->drawLine(rect.topLeft(), rect.topRight());

   758         else

   759             p->drawRect(rect);

   760         break; }

   761 #ifndef QT_NO_ITEMVIEWS

   762     case PE_PanelItemViewRow:

   763         if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(opt)) {

   764             QPalette::ColorGroup cg = vopt->state & QStyle::State_Enabled

   765                                       ? QPalette::Normal : QPalette::Disabled;

   766             if (cg == QPalette::Normal && !(vopt->state & QStyle::State_Active))

   767                 cg = QPalette::Inactive;

   768 

   769             if ((vopt->state & QStyle::State_Selected) &&  proxy()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected, opt, widget))

   770                 p->fillRect(vopt->rect, vopt->palette.brush(cg, QPalette::Highlight));

   771             else if (vopt->features & QStyleOptionViewItemV2::Alternate)

   772                 p->fillRect(vopt->rect, vopt->palette.brush(cg, QPalette::AlternateBase));

   773         }

   774         break;

   775     case PE_PanelItemViewItem:

   776         if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(opt)) {

   777             QPalette::ColorGroup cg = vopt->state & QStyle::State_Enabled

   778                                       ? QPalette::Normal : QPalette::Disabled;

   779             if (cg == QPalette::Normal && !(vopt->state & QStyle::State_Active))

   780                 cg = QPalette::Inactive;

   781 

   782             if (vopt->showDecorationSelected && (vopt->state & QStyle::State_Selected)) {

   783                 p->fillRect(vopt->rect, vopt->palette.brush(cg, QPalette::Highlight));

   784             } else {

   785                 if (vopt->backgroundBrush.style() != Qt::NoBrush) {

   786                     QPointF oldBO = p->brushOrigin();

   787                     p->setBrushOrigin(vopt->rect.topLeft());

   788                     p->fillRect(vopt->rect, vopt->backgroundBrush);

   789                     p->setBrushOrigin(oldBO);

   790                 }

   791 

   792                 if (vopt->state & QStyle::State_Selected) {

   793                     QRect textRect = subElementRect(QStyle::SE_ItemViewItemText,  opt, widget);

   794                     p->fillRect(textRect, vopt->palette.brush(cg, QPalette::Highlight));

   795                 }

   796             }

   797         }

   798         break;

   799 #endif //QT_NO_ITEMVIEWS

   800     case PE_PanelScrollAreaCorner: {

   801         const QBrush brush(opt->palette.brush(QPalette::Window));

   802         p->fillRect(opt->rect, brush);

   803         } break;

   804     default:

   805         break;

   806     }

   807 }

   808 

   809 #ifndef QT_NO_TOOLBUTTON

   810 static void drawArrow(const QStyle *style, const QStyleOptionToolButton *toolbutton,

   811                       const QRect &rect, QPainter *painter, const QWidget *widget = 0)

   812 {

   813     QStyle::PrimitiveElement pe;

   814     switch (toolbutton->arrowType) {

   815     case Qt::LeftArrow:

   816         pe = QStyle::PE_IndicatorArrowLeft;

   817         break;

   818     case Qt::RightArrow:

   819         pe = QStyle::PE_IndicatorArrowRight;

   820         break;

   821     case Qt::UpArrow:

   822         pe = QStyle::PE_IndicatorArrowUp;

   823         break;

   824     case Qt::DownArrow:

   825         pe = QStyle::PE_IndicatorArrowDown;

   826         break;

   827     default:

   828         return;

   829     }

   830     QStyleOption arrowOpt;

   831     arrowOpt.rect = rect;

   832     arrowOpt.palette = toolbutton->palette;

   833     arrowOpt.state = toolbutton->state;

   834     style->drawPrimitive(pe, &arrowOpt, painter, widget);

   835 }

   836 #endif // QT_NO_TOOLBUTTON

   837 

   838 #ifndef QT_NO_ITEMVIEWS

   839 

   840 QSize QCommonStylePrivate::viewItemSize(const QStyleOptionViewItemV4 *option, int role) const

   841 {

   842     Q_Q(const QCommonStyle);

   843 

   844     const QWidget *widget = option->widget;

   845     switch (role) {

   846     case Qt::CheckStateRole:

   847         if (option->features & QStyleOptionViewItemV2::HasCheckIndicator)

   848             return QSize(q->pixelMetric(QStyle::PM_IndicatorWidth, option, widget),

   849                          q->pixelMetric(QStyle::PM_IndicatorHeight, option, widget));

   850         break;

   851     case Qt::DisplayRole:

   852         if (option->features & QStyleOptionViewItemV2::HasDisplay) {

   853             QTextOption textOption;

   854             textOption.setWrapMode(QTextOption::WordWrap);

   855             QTextLayout textLayout;

   856             textLayout.setTextOption(textOption);

   857             textLayout.setFont(option->font);

   858             textLayout.setText(option->text);

   859             const bool wrapText = option->features & QStyleOptionViewItemV2::WrapText;

   860             const int textMargin = q->pixelMetric(QStyle::PM_FocusFrameHMargin, option, widget) + 1;

   861             QRect bounds = option->rect;

   862             switch (option->decorationPosition) {

   863             case QStyleOptionViewItem::Left:

   864             case QStyleOptionViewItem::Right:

   865                 bounds.setWidth(wrapText && bounds.isValid() ? bounds.width() - 2 * textMargin : QFIXED_MAX);

   866                 break;

   867             case QStyleOptionViewItem::Top:

   868             case QStyleOptionViewItem::Bottom:

   869                 bounds.setWidth(wrapText ? option->decorationSize.width() : QFIXED_MAX);

   870                 break;

   871             default:

   872                 break;

   873             }

   874 

   875             qreal height = 0, widthUsed = 0;

   876             textLayout.beginLayout();

   877             while (true) {

   878                 QTextLine line = textLayout.createLine();

   879                 if (!line.isValid())

   880                     break;

   881                 line.setLineWidth(bounds.width());

   882                 line.setPosition(QPointF(0, height));

   883                 height += line.height();

   884                 widthUsed = qMax(widthUsed, line.naturalTextWidth());

   885             }

   886             textLayout.endLayout();

   887             const QSize size(qCeil(widthUsed), qCeil(height));

   888             return QSize(size.width() + 2 * textMargin, size.height());

   889         }

   890         break;

   891     case Qt::DecorationRole:

   892         if (option->features & QStyleOptionViewItemV2::HasDecoration) {

   893             return option->decorationSize;

   894         }

   895         break;

   896     default:

   897         break;

   898     }

   899 

   900     return QSize(0, 0);

   901 }

   902 

   903 static QSizeF viewItemTextLayout(QTextLayout &textLayout, int lineWidth)

   904 {

   905     qreal height = 0;

   906     qreal widthUsed = 0;

   907     textLayout.beginLayout();

   908     while (true) {

   909         QTextLine line = textLayout.createLine();

   910         if (!line.isValid())

   911             break;

   912         line.setLineWidth(lineWidth);

   913         line.setPosition(QPointF(0, height));

   914         height += line.height();

   915         widthUsed = qMax(widthUsed, line.naturalTextWidth());

   916     }

   917     textLayout.endLayout();

   918     return QSizeF(widthUsed, height);

   919 }

   920 

   921 void QCommonStylePrivate::viewItemDrawText(QPainter *p, const QStyleOptionViewItemV4 *option, const QRect &rect) const

   922 {

   923     Q_Q(const QCommonStyle);

   924     const QWidget *widget = option->widget;

   925     const int textMargin = q->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, widget) + 1;

   926 

   927     QRect textRect = rect.adjusted(textMargin, 0, -textMargin, 0); // remove width padding

   928     const bool wrapText = option->features & QStyleOptionViewItemV2::WrapText;

   929     QTextOption textOption;

   930     textOption.setWrapMode(wrapText ? QTextOption::WordWrap : QTextOption::ManualWrap);

   931     textOption.setTextDirection(option->direction);

   932     textOption.setAlignment(QStyle::visualAlignment(option->direction, option->displayAlignment));

   933     QTextLayout textLayout;

   934     textLayout.setTextOption(textOption);

   935     textLayout.setFont(option->font);

   936     textLayout.setText(option->text);

   937 

   938     QSizeF textLayoutSize = viewItemTextLayout(textLayout, textRect.width());

   939 

   940     QString elidedText;

   941     qreal height = 0;

   942     qreal width = 0;

   943     int elidedIndex = -1;

   944     const int lineCount = textLayout.lineCount();

   945     for (int j = 0; j < lineCount; ++j) {

   946         const QTextLine line = textLayout.lineAt(j);

   947         if (j + 1 <= lineCount - 1) {

   948             const QTextLine nextLine = textLayout.lineAt(j + 1);

   949             if ((nextLine.y() + nextLine.height()) > textRect.height()) {

   950                 int start = line.textStart();

   951                 int length = line.textLength() + nextLine.textLength();

   952                 const QStackTextEngine engine(textLayout.text().mid(start, length), option->font);

   953                 elidedText = engine.elidedText(option->textElideMode, textRect.width());

   954                 height += line.height();

   955                 width = textRect.width();

   956                 elidedIndex = j;

   957                 break;

   958             }

   959         }

   960         if (line.naturalTextWidth() > textRect.width()) {

   961             int start = line.textStart();

   962             int length = line.textLength();

   963             const QStackTextEngine engine(textLayout.text().mid(start, length), option->font);

   964             elidedText = engine.elidedText(option->textElideMode, textRect.width());

   965             height += line.height();

   966             width = textRect.width();

   967             elidedIndex = j;

   968             break;

   969         }

   970         width = qMax<qreal>(width, line.width());

   971         height += line.height();

   972     }

   973 

   974     const QRect layoutRect = QStyle::alignedRect(option->direction, option->displayAlignment,

   975                                                  QSize(int(width), int(height)), textRect);

   976     const QPointF position = layoutRect.topLeft();

   977     for (int i = 0; i < lineCount; ++i) {

   978         const QTextLine line = textLayout.lineAt(i);

   979         if (i == elidedIndex) {

   980             qreal x = position.x() + line.x();

   981             qreal y = position.y() + line.y() + line.ascent();

   982             p->save();

   983             p->setFont(option->font);

   984             p->drawText(int(x), int(y), elidedText);

   985             p->restore();

   986             break;

   987         }

   988         line.draw(p, position);

   989     }

   990 }

   991 

   992 /*! \internal

   993     compute the position for the different component of an item (pixmap, text, checkbox)

   994 

   995     Set sizehint to false to layout the elements inside opt->rect. Set sizehint to true to ignore

   996    opt->rect and return rectangles in infinite space

   997 

   998     Code duplicated in QItemDelegate::doLayout

   999 */

  1000 void QCommonStylePrivate::viewItemLayout(const QStyleOptionViewItemV4 *opt,  QRect *checkRect,

  1001                                          QRect *pixmapRect, QRect *textRect, bool sizehint) const

  1002 {

  1003     Q_Q(const QCommonStyle);

  1004     Q_ASSERT(checkRect && pixmapRect && textRect);

  1005     *pixmapRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::DecorationRole));

  1006     *textRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::DisplayRole));

  1007     *checkRect = QRect(QPoint(0, 0), viewItemSize(opt, Qt::CheckStateRole));

  1008 

  1009     const QWidget *widget = opt->widget;

  1010     const bool hasCheck = checkRect->isValid();

  1011     const bool hasPixmap = pixmapRect->isValid();

  1012     const bool hasText = textRect->isValid();

  1013     const int textMargin = hasText ? q->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;

  1014     const int pixmapMargin = hasPixmap ? q->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;

  1015     const int checkMargin = hasCheck ? q->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, widget) + 1 : 0;

  1016     int x = opt->rect.left();

  1017     int y = opt->rect.top();

  1018     int w, h;

  1019 

  1020     if (textRect->height() == 0 && (!hasPixmap || !sizehint)) {

  1021         //if there is no text, we still want to have a decent height for the item sizeHint and the editor size

  1022         textRect->setHeight(opt->fontMetrics.height());

  1023     }

  1024 

  1025     QSize pm(0, 0);

  1026     if (hasPixmap) {

  1027         pm = pixmapRect->size();

  1028         pm.rwidth() += 2 * pixmapMargin;

  1029     }

  1030     if (sizehint) {

  1031         h = qMax(checkRect->height(), qMax(textRect->height(), pm.height()));

  1032         if (opt->decorationPosition == QStyleOptionViewItem::Left

  1033             || opt->decorationPosition == QStyleOptionViewItem::Right) {

  1034             w = textRect->width() + pm.width();

  1035         } else {

  1036             w = qMax(textRect->width(), pm.width());

  1037         }

  1038     } else {

  1039         w = opt->rect.width();

  1040         h = opt->rect.height();

  1041     }

  1042 

  1043     int cw = 0;

  1044     QRect check;

  1045     if (hasCheck) {

  1046         cw = checkRect->width() + 2 * checkMargin;

  1047         if (sizehint) w += cw;

  1048         if (opt->direction == Qt::RightToLeft) {

  1049             check.setRect(x + w - cw, y, cw, h);

  1050         } else {

  1051             check.setRect(x, y, cw, h);

  1052         }

  1053     }

  1054 

  1055     QRect display;

  1056     QRect decoration;

  1057     switch (opt->decorationPosition) {

  1058     case QStyleOptionViewItem::Top: {

  1059         if (hasPixmap)

  1060             pm.setHeight(pm.height() + pixmapMargin); // add space

  1061         h = sizehint ? textRect->height() : h - pm.height();

  1062 

  1063         if (opt->direction == Qt::RightToLeft) {

  1064             decoration.setRect(x, y, w - cw, pm.height());

  1065             display.setRect(x, y + pm.height(), w - cw, h);

  1066         } else {

  1067             decoration.setRect(x + cw, y, w - cw, pm.height());

  1068             display.setRect(x + cw, y + pm.height(), w - cw, h);

  1069         }

  1070         break; }

  1071     case QStyleOptionViewItem::Bottom: {

  1072         if (hasText)

  1073             textRect->setHeight(textRect->height() + textMargin); // add space

  1074         h = sizehint ? textRect->height() + pm.height() : h;

  1075 

  1076         if (opt->direction == Qt::RightToLeft) {

  1077             display.setRect(x, y, w - cw, textRect->height());

  1078             decoration.setRect(x, y + textRect->height(), w - cw, h - textRect->height());

  1079         } else {

  1080             display.setRect(x + cw, y, w - cw, textRect->height());

  1081             decoration.setRect(x + cw, y + textRect->height(), w - cw, h - textRect->height());

  1082         }

  1083         break; }

  1084     case QStyleOptionViewItem::Left: {

  1085         if (opt->direction == Qt::LeftToRight) {

  1086             decoration.setRect(x + cw, y, pm.width(), h);

  1087             display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h);

  1088         } else {

  1089             display.setRect(x, y, w - pm.width() - cw, h);

  1090             decoration.setRect(display.right() + 1, y, pm.width(), h);

  1091         }

  1092         break; }

  1093     case QStyleOptionViewItem::Right: {

  1094         if (opt->direction == Qt::LeftToRight) {

  1095             display.setRect(x + cw, y, w - pm.width() - cw, h);

  1096             decoration.setRect(display.right() + 1, y, pm.width(), h);

  1097         } else {

  1098             decoration.setRect(x, y, pm.width(), h);

  1099             display.setRect(decoration.right() + 1, y, w - pm.width() - cw, h);

  1100         }

  1101         break; }

  1102     default:

  1103         qWarning("doLayout: decoration position is invalid");

  1104         decoration = *pixmapRect;

  1105         break;

  1106     }

  1107 

  1108     if (!sizehint) { // we only need to do the internal layout if we are going to paint

  1109         *checkRect = QStyle::alignedRect(opt->direction, Qt::AlignCenter,

  1110                                          checkRect->size(), check);

  1111         *pixmapRect = QStyle::alignedRect(opt->direction, opt->decorationAlignment,

  1112                                           pixmapRect->size(), decoration);

  1113         // the text takes up all available space, unless the decoration is not shown as selected

  1114         if (opt->showDecorationSelected)

  1115             *textRect = display;

  1116         else

  1117             *textRect = QStyle::alignedRect(opt->direction, opt->displayAlignment,

  1118                                             textRect->size().boundedTo(display.size()), display);

  1119     } else {

  1120         *checkRect = check;

  1121         *pixmapRect = decoration;

  1122         *textRect = display;

  1123     }

  1124 }

  1125 #endif // QT_NO_ITEMVIEWS

  1126 

  1127 

  1128 #ifndef QT_NO_TABBAR

  1129 /*! \internal

  1130     Compute the textRect and the pixmapRect from the opt rect

  1131 

  1132     Uses the same computation than in QTabBar::tabSizeHint

  1133  */

  1134 void QCommonStylePrivate::tabLayout(const QStyleOptionTabV3 *opt, const QWidget *widget, QRect *textRect, QRect *iconRect) const

  1135 {