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

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

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

    41 

    42 #include "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             else if (!(vopt->state & QStyle::State_Enabled))

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

   775         }

   776         break;

   777     case PE_PanelItemViewItem:

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

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

   780                                       ? QPalette::Normal : QPalette::Disabled;

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

   782                 cg = QPalette::Inactive;

   783 

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

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

   786             } else {

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

   788                     QPointF oldBO = p->brushOrigin();

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

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

   791                     p->setBrushOrigin(oldBO);

   792                 }

   793 

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

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

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

   797                 }

   798             }

   799         }

   800         break;

   801 #endif //QT_NO_ITEMVIEWS

   802     case PE_PanelScrollAreaCorner: {

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

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

   805         } break;

   806     default:

   807         break;

   808     }

   809 }

   810 

   811 #ifndef QT_NO_TOOLBUTTON

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

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

   814 {

   815     QStyle::PrimitiveElement pe;

   816     switch (toolbutton->arrowType) {

   817     case Qt::LeftArrow:

   818         pe = QStyle::PE_IndicatorArrowLeft;

   819         break;

   820     case Qt::RightArrow:

   821         pe = QStyle::PE_IndicatorArrowRight;

   822         break;

   823     case Qt::UpArrow:

   824         pe = QStyle::PE_IndicatorArrowUp;

   825         break;

   826     case Qt::DownArrow:

   827         pe = QStyle::PE_IndicatorArrowDown;

   828         break;

   829     default:

   830         return;

   831     }

   832     QStyleOption arrowOpt;

   833     arrowOpt.rect = rect;

   834     arrowOpt.palette = toolbutton->palette;

   835     arrowOpt.state = toolbutton->state;

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

   837 }

   838 #endif // QT_NO_TOOLBUTTON

   839 

   840 #ifndef QT_NO_ITEMVIEWS

   841 

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

   843 {

   844     Q_Q(const QCommonStyle);

   845 

   846     const QWidget *widget = option->widget;

   847     switch (role) {

   848     case Qt::CheckStateRole:

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

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

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

   852         break;

   853     case Qt::DisplayRole:

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

   855             QTextOption textOption;

   856             textOption.setWrapMode(QTextOption::WordWrap);

   857             QTextLayout textLayout;

   858             textLayout.setTextOption(textOption);

   859             textLayout.setFont(option->font);

   860             textLayout.setText(option->text);

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

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

   863             QRect bounds = option->rect;

   864             switch (option->decorationPosition) {

   865             case QStyleOptionViewItem::Left:

   866             case QStyleOptionViewItem::Right:

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

   868                 break;

   869             case QStyleOptionViewItem::Top:

   870             case QStyleOptionViewItem::Bottom:

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

   872                 break;

   873             default:

   874                 break;

   875             }

   876 

   877             qreal height = 0, widthUsed = 0;

   878             textLayout.beginLayout();

   879             while (true) {

   880                 QTextLine line = textLayout.createLine();

   881                 if (!line.isValid())

   882                     break;

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

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

   885                 height += line.height();

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

   887             }

   888             textLayout.endLayout();

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

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

   891         }

   892         break;

   893     case Qt::DecorationRole:

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

   895             return option->decorationSize;

   896         }

   897         break;

   898     default:

   899         break;

   900     }

   901 

   902     return QSize(0, 0);

   903 }

   904 

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

   906 {

   907     qreal height = 0;

   908     qreal widthUsed = 0;

   909     textLayout.beginLayout();

   910     while (true) {

   911         QTextLine line = textLayout.createLine();

   912         if (!line.isValid())

   913             break;

   914         line.setLineWidth(lineWidth);

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

   916         height += line.height();

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

   918     }

   919     textLayout.endLayout();

   920     return QSizeF(widthUsed, height);

   921 }

   922 

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

   924 {

   925     Q_Q(const QCommonStyle);

   926     const QWidget *widget = option->widget;

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

   928 

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

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

   931     QTextOption textOption;

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

   933     textOption.setTextDirection(option->direction);

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

   935     QTextLayout textLayout;

   936     textLayout.setTextOption(textOption);

   937     textLayout.setFont(option->font);

   938     textLayout.setText(option->text);

   939 

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

   941 

   942     QString elidedText;

   943     qreal height = 0;

   944     qreal width = 0;

   945     int elidedIndex = -1;

   946     const int lineCount = textLayout.lineCount();

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

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

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

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

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

   952                 int start = line.textStart();

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

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

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

   956                 height += line.height();

   957                 width = textRect.width();

   958                 elidedIndex = j;

   959                 break;

   960             }

   961         }

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

   963             int start = line.textStart();

   964             int length = line.textLength();

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

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

   967             height += line.height();

   968             width = textRect.width();

   969             elidedIndex = j;

   970             break;

   971         }

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

   973         height += line.height();

   974     }

   975 

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

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

   978     const QPointF position = layoutRect.topLeft();

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

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

   981         if (i == elidedIndex) {

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

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

   984             p->save();

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

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

   987             p->restore();

   988             break;

   989         }

   990         line.draw(p, position);

   991     }

   992 }

   993 

   994 /*! \internal

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

   996 

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

   998    opt->rect and return rectangles in infinite space

   999 

  1000     Code duplicated in QItemDelegate::doLayout

  1001 */

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

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

  1004 {

  1005     Q_Q(const QCommonStyle);

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

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

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

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

  1010 

  1011     const QWidget *widget = opt->widget;

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

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

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

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

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

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

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

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

  1020     int w, h;

  1021 

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

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

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

  1025     }

  1026 

  1027     QSize pm(0, 0);

  1028     if (hasPixmap) {

  1029         pm = pixmapRect->size();

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

  1031     }

  1032     if (sizehint) {

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

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

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

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

  1037         } else {

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

  1039         }

  1040     } else {

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

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

  1043     }

  1044 

  1045     int cw = 0;

  1046     QRect check;

  1047     if (hasCheck) {

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

  1049         if (sizehint) w += cw;

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

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

  1052         } else {

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

  1054         }

  1055     }

  1056 

  1057     QRect display;

  1058     QRect decoration;

  1059     switch (opt->decorationPosition) {

  1060     case QStyleOptionViewItem::Top: {

  1061         if (hasPixmap)

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

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

  1064 

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

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

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

  1068         } else {

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

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

  1071         }

  1072         break; }

  1073     case QStyleOptionViewItem::Bottom: {

  1074         if (hasText)

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

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

  1077 

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

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

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

  1081         } else {

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

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

  1084         }

  1085         break; }

  1086     case QStyleOptionViewItem::Left: {

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

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

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

  1090         } else {

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

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

  1093         }

  1094         break; }

  1095     case QStyleOptionViewItem::Right: {

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

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

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

  1099         } else {

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

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

  1102         }

  1103         break; }

  1104     default:

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

  1106         decoration = *pixmapRect;

  1107         break;

  1108     }

  1109 

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

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

  1112                                          checkRect->size(), check);

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

  1114                                           pixmapRect->size(), decoration);

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

  1116         if (opt->showDecorationSelected)

  1117             *textRect = display;

  1118         else

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

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

  1121     } else {

  1122         *checkRect = check;

  1123         *pixmapRect = decoration;

  1124         *textRect = display;

  1125     }

  1126 }

  1127 #endif // QT_NO_ITEMVIEWS

  1128 

  1129 

  1130 #ifndef QT_NO_TABBAR

  1131 /*! \internal

  1132     Compute the textRect and the pixmapRect from the opt rect

  1133 

  1134     Uses the same computation than in QTabBar::tabSizeHint