1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 *

     5 * This program is free software: you can redistribute it and/or modify

     6 * it under the terms of the GNU Lesser General Public License as published by

     7 * the Free Software Foundation, version 2.1 of the License.

     8 *

     9 * This program is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 * GNU Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public License

    15 * along with this program.  If not,

    16 * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

    17 *

    18 * Description:

    19 *

    20 */

    21 //Qt includes

    22 #include <qapplication.h>

    23 #include <qpainter.h>

    24 #include <qstyleoption.h>

    25 #include <qevent.h>

    26 #include <qdebug.h>

    27 

    28 //Qt widgets

    29 #include <QtGui/qgroupbox.h>

    30 #include <QtGui/qheaderview.h>

    31 #include <QtGui/qlistwidget.h>

    32 #include <QtGui/qlistview.h>

    33 #include <QtGui/qpushbutton.h>

    34 #include <QtGui/qscrollbar.h>

    35 #include <QtGui/qtabbar.h>

    36 #include <QtGui/qtableview.h>

    37 #include <QtGui/qtablewidget.h>

    38 #include <QtGui/qtreeview.h>

    39 #include <QtGui/qtreewidget.h>

    40 #include <QtGui/qtextedit.h>

    41 #include <QtGui/qtoolbar.h>

    42 #include <QtGui/qtoolbutton.h>

    43 #include <QtGui/qradiobutton.h>

    44 #include <QtGui/qcheckbox.h>

    45 #include <QtGui/qprogressbar.h>

    46 #include <QtGui/qcombobox.h>

    47 #include <QtGui/qspinbox.h>

    48 #include <QtGui/qlineedit.h>

    49 

    50 //Animation

    51 #include <QParallelAnimationGroup>

    52 #include <QPropertyAnimation>

    53 #include <QTime>

    54 

    55 //Hb includes

    56 #include <hbinstance.h>

    57 #include <hbicon.h>

    58 #include <hbframedrawer.h>

    59 #include <hbstyle.h>

    60 #include <hbcolorscheme.h>

    61 #include <hbfontspec.h>

    62 

    63 #include "qhbstyle.h"

    64 #include "qhbstyle_p.h"

    65 #include "qhbstyleanimation.h"

    66 

    67 QT_BEGIN_NAMESPACE

    68 

    69 QHbStylePrivate::QHbStylePrivate()

    70 {

    71     m_frameDrawer = 0;

    72     m_styleManager = 0;

    73 

    74     m_animationGroup = q_check_ptr(new QParallelAnimationGroup());

    75 }

    76 

    77 QHbStylePrivate::~QHbStylePrivate()

    78 {

    79     delete m_frameDrawer;

    80     delete m_animationGroup;

    81 }

    82 

    83 HbStyle* QHbStylePrivate::styleManager()

    84 {

    85     return m_styleManager;

    86 }

    87 

    88 void QHbStylePrivate::setStyleManager(HbStyle* style)

    89 {

    90     Q_ASSERT(style);

    91     m_styleManager = style;

    92 }

    93 

    94 QParallelAnimationGroup* QHbStylePrivate::animationGroup()

    95 {

    96     return m_animationGroup;

    97 }

    98 

    99 /*!

   100   \internal

   101  */

   102 QHbStyle::QHbStyle() : QCommonStyle()

   103 {

   104     m_private = new QHbStylePrivate();

   105     HbInstance *instance = HbInstance::instance();

   106 

   107     m_private->setStyleManager(instance->style());

   108 }

   109 

   110 /*!

   111   \internal

   112  */

   113 QHbStyle::~QHbStyle()

   114 {

   115     delete m_private;

   116 }

   117 

   118 void QHbStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,

   119                        QPainter *painter, const QWidget *widget) const

   120 {

   121     switch (element) {

   122         case PE_IndicatorViewItemCheck: {

   123             if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

   124                 ItemStates state;

   125                 if (itemOption->state & State_Selected)

   126                     state |= SS_Selected;

   127                 m_private->drawItem(SP_ItemDecoration, painter, option->rect, state);

   128             }

   129             break;

   130         }

   131         case PE_IndicatorHeaderArrow: {

   132             if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {

   133                 ItemStates state;

   134                 if (header->sortIndicator & QStyleOptionHeader::SortDown)

   135                     m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state|SS_Flipped));

   136                 else if (header->sortIndicator & QStyleOptionHeader::SortUp)

   137                     m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state));

   138             }

   139             break;

   140         }

   141         case PE_IndicatorBranch: {

   142             if (option->state & State_Children) {

   143                 QRect indicatorRect = option->rect;

   144                 const int rectSide = proxy()->pixelMetric(PM_MenuButtonIndicator, option, widget);

   145                 indicatorRect = QRect(0, 0, rectSide, rectSide);

   146                 indicatorRect.moveCenter(option->rect.center());

   147                 if (option->state & State_Open)

   148                     m_private->drawItem(SP_TreeViewExpanded, painter, indicatorRect);

   149                 else

   150                     m_private->drawItem(SP_TreeViewCollapsed, painter, indicatorRect);

   151             }

   152             break;

   153         }

   154         case PE_PanelItemViewRow: {

   155             if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

   156             ItemStates state = SS_Active;

   157             if (vopt->state & State_HasFocus)

   158                 state |= SS_Focused;

   159             if (vopt->state & State_Sunken || vopt->state & State_Raised)

   160                 state |= SS_Pressed;

   161 #ifndef QT_NO_TREEVIEW

   162                 if (qobject_cast<const QTreeWidget*>(widget)) {

   163                     if (option->state & State_Children) {

   164                         m_private->drawMultiPartItem(SM_ListParent, painter, vopt->rect, state);

   165                         break;

   166                     }

   167                 }

   168 #endif

   169             if (vopt->features & QStyleOptionViewItemV2::Alternate)

   170                 state |= SS_Alternate; //@todo: how?

   171             m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);

   172             }

   173             break;

   174         }

   175         case PE_PanelItemViewItem: {

   176             if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

   177                 ItemStates state = SS_Active;

   178                 if (vopt->state & State_HasFocus)

   179                     state |= SS_Focused;

   180                 if (vopt->state & State_Sunken || vopt->state & State_Raised)

   181                     state |= SS_Pressed;

   182                 m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);

   183             }

   184             break;

   185         }

   186         case PE_IndicatorArrowLeft:

   187         case PE_IndicatorArrowRight:

   188         case PE_IndicatorArrowUp:

   189         case PE_IndicatorArrowDown: {

   190             ItemStates state;

   191             if (element == PE_IndicatorArrowRight)

   192                 state = SS_Right;

   193             else if (element == PE_IndicatorArrowLeft)

   194                 state = SS_Left;

   195             else if (element == PE_IndicatorArrowUp)

   196                 state = SS_Up;

   197             else

   198                 state = SS_Down;

   199             m_private->drawItem(SP_Arrow, painter, option->rect, state);

   200             break;

   201         }

   202         case PE_PanelTipLabel: {

   203             m_private->drawMultiPartItem(SM_ToolTip, painter, option->rect);

   204             break;

   205         }

   206         case PE_Frame: {

   207             if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {

   208 #ifndef QT_NO_TEXTEDIT

   209                 if (qobject_cast<const QTextEdit *>(widget))

   210                     m_private->drawMultiPartItem(SM_TextEdit, painter, frame->rect);

   211 #endif //QT_NO_TEXTEDIT

   212             }

   213             break;

   214         }

   215         case PE_FrameTabWidget: {

   216             m_private->drawMultiPartItem(SM_Panel, painter, option->rect);

   217             break;

   218         }

   219 #ifndef QT_NO_LINEEDIT

   220         case PE_PanelLineEdit: {

   221 #ifndef QT_NO_COMBOBOX

   222             if (widget && qobject_cast<const QComboBox *>(widget->parentWidget()))

   223                 break;

   224 #endif

   225 #ifndef QT_NO_SPINBOX

   226             if (widget && qobject_cast<const QSpinBox *>(widget->parentWidget()))

   227                 break;

   228 #endif

   229             if (const QStyleOptionFrame *lineEdit = qstyleoption_cast<const QStyleOptionFrame *>(option)) {

   230                 ItemStates state = (lineEdit->state & State_Enabled) ? SS_Active : SS_Inactive;

   231                 if (lineEdit->state & State_HasFocus)

   232                     state |= SS_Selected;

   233                 m_private->drawMultiPartItem(SM_LineEdit, painter, lineEdit->rect, state);

   234             }

   235             break;

   236         }

   237 #endif // QT_NO_LINEEDIT

   238         case PE_PanelButtonTool: {

   239             if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {

   240                 //draw button

   241                 const bool isDisabled = !(toolbutton->state & State_Enabled);

   242                 const bool isPressed = (toolbutton->state & State_Sunken) ||

   243                                        (toolbutton->state & State_On);

   244 

   245                 // 'latched' is a checkable button that is pressed down

   246                 bool isLatched = false;

   247 #ifndef QT_NO_TOOLBUTTON

   248                 if (const QToolButton *toolButtonWidget = qobject_cast<const QToolButton*>(widget))

   249                     isLatched = toolButtonWidget->isCheckable() && isPressed;

   250 #endif

   251                 ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;

   252                 if (isLatched)

   253                     state = state | SS_Latched;

   254                 else if (isPressed)

   255                     state = state | SS_Pressed;

   256 

   257                 if (toolbutton->state & State_Selected || toolbutton->state & State_HasFocus)

   258                     state = state | SS_Selected;

   259 #ifndef QT_NO_TOOLBAR

   260                 if (widget && !qobject_cast<const QToolBar*>(widget->parentWidget()))

   261                     m_private->drawMultiPartItem(SM_ToolButton, painter, toolbutton->rect, state);

   262                 else

   263 #endif

   264                     m_private->drawMultiPartItem(SM_ToolBarButton, painter, toolbutton->rect, state);

   265             }

   266             break;

   267         }

   268         case PE_IndicatorCheckBox: {

   269             ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;

   270             if (option->direction == Qt::RightToLeft) state |= SS_Mirrored;

   271             m_private->drawItem(SP_CheckBoxIndicator, painter, option->rect, state);

   272             break;

   273         }

   274         case PE_IndicatorRadioButton: {

   275             const ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;

   276             m_private->drawItem(SP_RadioButtonIndicator, painter, option->rect, state);

   277             break;

   278         }

   279         case PE_FrameFocusRect: {

   280             if (const QStyleOptionFocusRect *highlight = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {

   281                 if (false

   282 #ifndef QT_NO_LISTVIEW

   283                         || qobject_cast<const QListWidget *>(widget)

   284 #endif

   285 #ifndef QT_NO_TABLEVIEW

   286                         || qobject_cast<const QTableWidget *>(widget)

   287 #endif

   288 #ifndef QT_NO_TREEVIEW

   289                         || qobject_cast<const QTreeWidget *>(widget)

   290 #endif

   291                     )

   292                     m_private->drawMultiPartItem(SM_ItemViewHighlight, painter, highlight->rect);

   293             }

   294             break;

   295         }

   296         case PE_FrameMenu: {

   297             break;

   298         }

   299         case PE_PanelMenu: {

   300             m_private->drawMultiPartItem(SM_Menu, painter, option->rect);

   301             break;

   302         }

   303         case PE_Widget: {

   304             if (m_private->isDialog(widget))

   305                 m_private->drawMultiPartItem(SM_Dialog, painter, option->rect);

   306             break;

   307         }

   308         case PE_IndicatorMenuCheckMark: {

   309             m_private->drawItem(SP_ItemDecoration, painter, option->rect);

   310             break;

   311         }

   312         case PE_FrameGroupBox: {

   313             ItemStates groupBoxStates;

   314             if ((option->state & State_Sunken) || (option->state & State_Raised))

   315                 groupBoxStates |= SS_Pressed;

   316             if (option->state & State_HasFocus)

   317                 groupBoxStates |= SS_Selected;

   318             if (option->state & State_On)

   319                 groupBoxStates |= SS_Active;

   320             else if (option->state & State_Off)

   321                 groupBoxStates |= SS_Inactive;

   322             m_private->drawMultiPartItem(SM_GroupBox, painter, option->rect, groupBoxStates);

   323             break;

   324         }

   325         // Qt3 primitives are not supported

   326         case PE_Q3CheckListController:

   327         case PE_Q3CheckListExclusiveIndicator:

   328         case PE_Q3CheckListIndicator:

   329         case PE_Q3DockWindowSeparator:

   330         case PE_Q3Separator: {

   331             Q_ASSERT(false);

   332             break;

   333         }

   334         case PE_PanelScrollAreaCorner: //no corner for scroll area

   335         case PE_IndicatorTabTear: // no tab tear in uiemo

   336         case PE_PanelMenuBar: { //no panel menu in uiemo

   337             break;

   338         }

   339         default: {

   340             QCommonStyle::drawPrimitive(element, option, painter, widget);

   341             break;

   342         }

   343     }

   344 }

   345 

   346 void QHbStyle::drawControl(ControlElement element, const QStyleOption *option,

   347                      QPainter *painter, const QWidget *widget) const

   348 {

   349     switch (element) {

   350         case CE_HeaderEmptyArea: {

   351             const bool isHorizontal = (option->state & State_Horizontal);

   352             ItemStates states = (isHorizontal) ? SS_Horizontal : ItemState(SS_Vertical);

   353             if (!isHorizontal)

   354                 states |= (option->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;

   355             m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);

   356             break;

   357         }

   358         case CE_HeaderSection: {

   359             if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {

   360                 //Draw corner button as normal pushButton.

   361                 if (qobject_cast<const QAbstractButton *>(widget)) {

   362                     QStyleOptionButton cornerButton;

   363                     cornerButton.initFrom(widget);

   364                     drawControl(CE_PushButtonBevel, &cornerButton, painter, widget);

   365                 } else {

   366                     const bool isVertical = (header->orientation == Qt::Vertical);

   367                     ItemStates states = (isVertical) ? SS_Vertical : ItemState(SS_Horizontal);

   368                     if (isVertical)

   369                         states |= (header->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;

   370                     m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);

   371                 }

   372             }

   373             break;

   374         }

   375         case CE_ItemViewItem: {

   376             if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

   377                 const QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, itemOption, widget);

   378                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, itemOption, widget);

   379                 QRect textRect = subElementRect(SE_ItemViewItemText, itemOption, widget);

   380 

   381                 //background for list items (other itemviews use PE_PanelItemViewRow drawing)

   382                 if (qobject_cast<const QListWidget *>(widget))

   383                     proxy()->drawPrimitive(PE_PanelItemViewItem, itemOption, painter, widget);

   384 

   385                 //checkbox

   386                 if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator && checkRect.isValid()) {

   387                     QStyleOptionViewItemV4 checkOption;

   388                     checkOption.QStyleOption::operator=(*itemOption);

   389                     checkOption.rect = checkRect;

   390                     proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &checkOption, painter, widget);

   391                 }

   392 

   393                 //selection indication

   394                 if (itemOption->state & State_Selected) {

   395                     const QAbstractItemView *itemView = qobject_cast<const QAbstractItemView *>(widget);

   396                     if (itemView->selectionMode() != QAbstractItemView::SingleSelection) {

   397                         QStyleOptionViewItemV4 selectOption;

   398                         selectOption.QStyleOption::operator=(*itemOption);

   399                         int iconSize = 0;

   400                         if (m_private->hbParameter(QLatin1String("hb-param-graphic-size-secondary"), iconSize)) {

   401                             QRect selectRect = QRect(0, 0, iconSize, iconSize);

   402                             if (itemOption->direction == Qt::LeftToRight) {

   403                                 //translate to end of text area and reduce text area

   404                                 selectRect.translate(textRect.topRight().x() - selectRect.width(), textRect.topRight().y());

   405                             } else {

   406                                 //translate to the beginning of textRect, move textRect to the right

   407                                 selectRect.translate(textRect.topLeft().x(), textRect.topRight().y());

   408                                 textRect.translate(selectRect.width(), 0);

   409                             }

   410                             textRect.setWidth(textRect.width() - selectRect.width());

   411                             selectOption.rect = selectRect;

   412                             proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &selectOption, painter, widget);

   413                         }

   414                     }

   415                 }

   416 

   417                 //text

   418                 if (itemOption->text.length() > 0) {

   419                     uint flags = Qt::AlignVCenter | Qt::TextShowMnemonic;

   420                     if (!proxy()->styleHint(SH_UnderlineShortcut, itemOption, widget))

   421                         flags |= Qt::TextHideMnemonic;

   422 

   423                     drawItemText(painter, textRect, flags, itemOption->palette, (itemOption->state & State_Enabled), itemOption->text);

   424                 }

   425                 //icon

   426                 if (!itemOption->icon.isNull()) {

   427                     QIcon::Mode mode = QIcon::Normal;

   428                     if (!(option->state & State_Enabled))

   429                         mode = QIcon::Disabled;

   430                     else if (option->state & State_Selected)

   431                         mode = QIcon::Selected;

   432                     QIcon::State state = itemOption->state & State_Open ? QIcon::On : QIcon::Off;

   433                     itemOption->icon.paint(painter, iconRect, itemOption->decorationAlignment, mode, state);

   434                 }

   435             }

   436             break;

   437         }

   438         case CE_ShapedFrame: {

   439             if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {

   440                 const int frameShape  = frame->frameShape;

   441                 const int lineWidth = frame->lineWidth;

   442                 const int midLineWidth = frame->midLineWidth;

   443                 QPalette::ColorRole foregroundRole = QPalette::WindowText;

   444                 int frameShadow = QFrame::Plain;

   445                 if (frame->state & State_Sunken)

   446                     frameShadow = QFrame::Sunken;

   447                 else if (frame->state & State_Raised)

   448                     frameShadow = QFrame::Raised;

   449 

   450                 switch (frameShape) {

   451                 case QFrame::Box:

   452                 case QFrame::WinPanel:

   453                     if (frameShadow == QFrame::Plain)

   454                         qDrawPlainRect(painter, frame->rect, frame->palette.color(foregroundRole), lineWidth);

   455                     else

   456                         qDrawShadeRect(painter, frame->rect, frame->palette, frameShadow == QFrame::Sunken, lineWidth, midLineWidth);

   457                     break;

   458                 case QFrame::StyledPanel:

   459                     if (widget)

   460                         widget->style()->drawPrimitive(PE_Frame, option, painter, widget);

   461                     else

   462                         proxy()->drawPrimitive(PE_Frame, option, painter, widget);

   463                     break;

   464                 case QFrame::Panel:

   465                     //@todo: support sunken / raised?

   466                     m_private->drawMultiPartItem(SM_Panel, painter, option->rect);

   467                     break;

   468                 case QFrame::HLine:

   469                 case QFrame::VLine: {

   470                     ItemStates states = (frameShape == QFrame::HLine) ? SS_Horizontal : SS_Vertical;

   471                     //@todo: support sunken / raised separators?

   472                     m_private->drawItem(SP_SeparatorLine, painter, frame->rect, states);

   473                     break;

   474                     }

   475                 }

   476             }

   477             break;

   478         }

   479 #ifndef QT_NO_TABBAR

   480         case CE_TabBarTab: {

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

   482                 proxy()->drawControl(CE_TabBarTabShape, tab, painter, widget);

   483                 proxy()->drawControl(CE_TabBarTabLabel, tab, painter, widget);

   484             }

   485             break;

   486         }

   487         case CE_TabBarTabShape: {

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

   489                 ItemStates states = (tab->shape == QTabBar::TriangularSouth ||

   490                                      tab->shape == QTabBar::RoundedSouth ||

   491                                      tab->shape == QTabBar::TriangularNorth ||

   492                                      tab->shape == QTabBar::RoundedNorth) ? SS_Horizontal : SS_Vertical;

   493                 if (tab->state & State_Selected)

   494                     states |= SS_Selected;

   495                 if (tab->state & State_Raised || tab->state & State_Sunken)

   496                     states |= SS_Pressed;

   497                 if (!(tab->state & State_Enabled))

   498                     states |= SS_Disabled;

   499 

   500                 if (tab->shape == QTabBar::RoundedSouth || tab->shape == QTabBar::TriangularSouth ||

   501                     tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::TriangularEast)

   502                     states |= SS_Flipped;

   503 

   504                 if (tab->direction == Qt::RightToLeft) states |= SS_Mirrored;

   505 

   506                 //Tab's position

   507                 if (tab->position == QStyleOptionTab::Beginning)

   508                     states |= (states & SS_Flipped) ? SS_End : SS_Beginning;

   509                 else if (tab->position == QStyleOptionTab::Middle)

   510                     states |= SS_Middle;

   511                 if (tab->position == QStyleOptionTab::End)

   512                     states |= (states & SS_Flipped) ? SS_Beginning : SS_End;

   513 

   514                 m_private->drawMultiPartItem(SM_TabShape, painter, tab->rect, states);

   515             }

   516             break;

   517         }

   518         case CE_TabBarTabLabel: {

   519             if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(option)) {

   520                 const bool enabled = tab->state & State_Enabled;

   521                 const QPixmap icon = tab->icon.pixmap(proxy()->pixelMetric(PM_TabBarIconSize, tab, widget),

   522                                              enabled ? QIcon::Normal : QIcon::Disabled);

   523 

   524                 const bool verticalTabs = tab->shape == QTabBar::RoundedEast

   525                                     || tab->shape == QTabBar::RoundedWest

   526                                     || tab->shape == QTabBar::TriangularEast

   527                                     || tab->shape == QTabBar::TriangularWest;

   528 

   529                 QRect tr = tab->rect;

   530                 //add a small space so that text/icon does not start from the border

   531                 const int margin = proxy()->pixelMetric(PM_DefaultFrameWidth, tab, widget);

   532                 if (!verticalTabs)

   533                     tr.adjust(margin, 0, -margin, 0);

   534                 else

   535                     tr.adjust(0, margin, 0, -margin);

   536 

   537                 // Need to do rotation separately here, instead of in drawItem/drawMultiItemPart, since we want to rotate text as well.

   538                 if (verticalTabs) {

   539                     painter->save();

   540                     int newX, newY, newRotation;

   541                     if (tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::TriangularEast) {

   542                         newX = tr.width();

   543                         newY = tr.y();

   544                         newRotation = 90;

   545                     } else {

   546                         newX = 0;

   547                         newY = tr.y() + tr.height();

   548                         newRotation = -90;

   549                     }

   550                     tr.setRect(0, 0, tr.height(), tr.width());

   551                     QTransform m;

   552                     m.translate(newX, newY);

   553                     m.rotate(newRotation);

   554                     painter->setTransform(m, true);

   555                 }

   556 

   557                 const int frameWidth = proxy()->pixelMetric((verticalTabs) ?

   558                     PM_LayoutVerticalSpacing : PM_LayoutHorizontalSpacing, option, widget);

   559                 const Qt::TextElideMode elideMode = (tab->direction == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;

   560                 const QRect textRect = QRect(0,

   561                                              0,

   562                                              tab->rect.width() - icon.width() - frameWidth * 2,

   563                                              tab->rect.height() - icon.height() - frameWidth * 2);

   564                 QString txt = tab->fontMetrics.elidedText(tab->text, elideMode, (verticalTabs ? textRect.height() : textRect.width()));

   565 

   566                 //Icon

   567                 if (!icon.isNull()) {

   568                     if (tab->text.isEmpty())

   569                         painter->drawPixmap(tr.center().x() - (icon.height() >> 1),

   570                                             tr.center().y() - (icon.height() >> 1),

   571                                             icon);

   572                     else

   573                         painter->drawPixmap(tr.left(),

   574                                             tr.center().y() - (icon.height() >> 1),

   575                                             icon);

   576                     tr.setLeft(tr.left() + icon.width() + frameWidth);

   577                 } else {

   578                     tr.setLeft(tr.left() + frameWidth);

   579                 }

   580 

   581                 //Text

   582                 if (tab->text.length() > 0) {

   583                     int alignment = Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic;

   584                     if (!proxy()->styleHint(SH_UnderlineShortcut, tab, widget))

   585                         alignment |= Qt::TextHideMnemonic;

   586                     proxy()->drawItemText(painter, tr, alignment, tab->palette, enabled, txt, QPalette::ButtonText);

   587                 }

   588 

   589                 if (verticalTabs)

   590                     painter->restore();

   591             }

   592             break;

   593         }

   594 #ifndef QT_NO_COMBOBOX

   595     case CE_ComboBoxLabel:

   596         if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {

   597             QRect editRect = proxy()->subControlRect(CC_ComboBox, combo, SC_ComboBoxEditField, widget);

   598             const int spacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, combo, widget);

   599             if (!combo->currentIcon.isNull()) {

   600                 const QIcon::Mode mode = combo->state & State_Enabled ? QIcon::Normal

   601                                                              : QIcon::Disabled;

   602                 const QPixmap pixmap = combo->currentIcon.pixmap(combo->iconSize, mode);

   603                 QRect iconRect(editRect);

   604                 iconRect.setWidth(combo->iconSize.width() + spacing);

   605                 iconRect = alignedRect(combo->direction,

   606                                        Qt::AlignLeft | Qt::AlignVCenter,

   607                                        iconRect.size(), editRect);

   608                 if (combo->editable)

   609                     painter->fillRect(iconRect, combo->palette.brush(QPalette::Base));

   610                 proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap);

   611 

   612                 if (combo->direction == Qt::RightToLeft)

   613                     editRect.translate(-spacing - combo->iconSize.width(), 0);

   614                 else

   615                     editRect.translate(combo->iconSize.width() + spacing, 0);

   616             }

   617             if (!combo->currentText.isEmpty() && !combo->editable) {

   618                 const Qt::TextElideMode elideMode = (combo->direction == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;

   619                 const QString txt = combo->fontMetrics.elidedText(combo->currentText, elideMode, editRect.width());

   620                 proxy()->drawItemText(painter, editRect.adjusted(1, 0, -1, 0),

   621                              visualAlignment(combo->direction, Qt::AlignLeft | Qt::AlignVCenter),

   622                              combo->palette, combo->state & State_Enabled, txt);

   623             }

   624         }

   625         break;

   626 #endif // QT_NO_COMBOBOX

   627 #endif //QT_NO_TABBAR

   628         case CE_PushButton: {

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

   630                 proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget);

   631                 QStyleOptionButton subopt = *btn;

   632                 subopt.rect = subElementRect(SE_PushButtonContents, btn, widget);

   633                 proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget);

   634                 if ((btn->state & State_HasFocus)) {

   635                     QStyleOptionFocusRect fropt;

   636                     fropt.QStyleOption::operator=(*btn);

   637                     fropt.rect = subElementRect(SE_PushButtonFocusRect, btn, widget);

   638                     proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget);

   639                 }

   640             }

   641             break;

   642         }

   643         case CE_PushButtonBevel: {

   644             if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {

   645                 const bool isDisabled = !(button->state & State_Enabled);

   646                 const bool isFlat = button->features & QStyleOptionButton::Flat;

   647                 const bool isPressed = (button->state & State_Sunken) ||

   648                                        (button->state & State_On);

   649                 // 'latched' is a checkable button that is pressed down

   650                 const QPushButton *pbutton = qobject_cast<const QPushButton *>(widget);

   651                 const bool isLatched = (!pbutton) ? false : (pbutton->isCheckable() && isPressed);

   652 

   653                 ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;

   654                 if (isLatched)

   655                     state = state | SS_Latched;

   656                 else if (isPressed)

   657                     state = state | SS_Pressed;

   658 

   659                 if (button->state & State_Selected || button->state & State_HasFocus)

   660                     state = state | SS_Selected;

   661 

   662                 //todo: does Hb have flat buttons?

   663                 if (button->features & QStyleOptionButton::HasMenu) {

   664                     //draw menu indicator

   665                     const int menuButtonIndicator = proxy()->pixelMetric(PM_MenuButtonIndicator, button, widget);

   666                     QStyleOptionButton menuOpt = *button;

   667                     menuOpt.rect = QRect(button->rect.right() - menuButtonIndicator,

   668                                          button->rect.y() + (button->rect.height() - menuButtonIndicator) / 2,

   669                                          menuButtonIndicator,

   670                                          menuButtonIndicator);

   671                     menuOpt.rect = visualRect(button->direction, button->rect, menuOpt.rect);

   672                     proxy()->drawPrimitive(PE_IndicatorArrowDown, &menuOpt, painter, widget);

   673                 }

   674                 if (isFlat) //lets draw flat buttons as toolbuttons

   675                     m_private->drawMultiPartItem(SM_ToolButton, painter, button->rect, state);

   676                 else

   677                     m_private->drawMultiPartItem(SM_PushButton, painter, button->rect, state);

   678                 }

   679             break;

   680         }

   681         case CE_MenuScroller: {

   682             ItemStates states = (option->state & State_DownArrow) ? SS_Down : SS_Up;

   683             painter->fillRect(option->rect, option->palette.background());

   684             m_private->drawMultiPartItem(SM_MenuScroller, painter, option->rect, states);

   685             QStyleOption arrowOpt = *option;

   686             arrowOpt.state |= State_Enabled;

   687             const int side = proxy()->pixelMetric(PM_MenuScrollerHeight, option, widget);

   688             arrowOpt.rect = option->rect;

   689             arrowOpt.rect.setWidth(side);

   690             arrowOpt.rect.moveCenter(option->rect.center());

   691             proxy()->drawPrimitive(((option->state & State_DownArrow) ? PE_IndicatorArrowDown : PE_IndicatorArrowUp),

   692                     &arrowOpt, painter, widget);

   693             break;

   694         }

   695         case CE_MenuItem: {

   696             if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {

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

   698                     const int margin = proxy()->pixelMetric(PM_MenuHMargin, menuItem, widget);

   699                     const int yoff = menuItem->rect.y() - 1 + menuItem->rect.height() / 2;

   700                     const int startX = menuItem->rect.x() + margin;

   701                     const int endX = menuItem->rect.x() + menuItem->rect.width() - margin;

   702                     QRect separatorRect = QRect(QPoint(startX, yoff), QPoint(endX, yoff));

   703                     m_private->drawItem(SP_MenuSeparator, painter, separatorRect);

   704                     return;

   705                 }

   706 

   707                 const bool isDisabled = !(menuItem->state & State_Enabled);

   708                 const bool isSelected = (menuItem->state & State_Selected);

   709                 const bool isPressed = (menuItem->state & State_Sunken) || (menuItem->state & State_Raised);

   710                 ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;

   711 

   712                 if (isSelected)

   713                     state = state | SS_Selected;

   714 

   715                 if (isPressed)

   716                     state = state | SS_Pressed;

   717 

   718                 m_private->drawMultiPartItem(SM_MenuItem, painter, menuItem->rect, state);

   719 

   720                 uint text_flags = Qt::AlignLeading | Qt::TextShowMnemonic | Qt::TextDontClip

   721                     | Qt::TextSingleLine | Qt::AlignVCenter;

   722                 if (!styleHint(SH_UnderlineShortcut, menuItem, widget))

   723                     text_flags |= Qt::TextHideMnemonic;

   724 

   725                 if (menuItem->menuHasCheckableItems) {

   726                     const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, menuItem, widget);

   727                     if (checkBoxRect.isValid()) {

   728                         ItemStates checkBoxState;

   729                         if (menuItem->checked) checkBoxState |= SS_Selected;

   730                         if (menuItem->direction == Qt::RightToLeft) checkBoxState |= SS_Mirrored;

   731                         m_private->drawItem(SP_ItemDecoration, painter, checkBoxRect, checkBoxState);

   732                     }

   733                 }

   734 

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

   736                     const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, menuItem, widget);

   737                     if (iconRect.isValid()) {

   738                         QPixmap pix = menuItem->icon.pixmap(pixelMetric(PM_SmallIconSize),

   739                                 !isDisabled ? QIcon::Normal : QIcon::Disabled);

   740                         drawItemPixmap(painter, iconRect, text_flags, pix);

   741                     }

   742                 }

   743 

   744                 if (menuItem->text.length() > 0) {

   745                     const QRect textRect = subElementRect(SE_ItemViewItemText, menuItem, widget);

   746                     if (textRect.isValid())

   747                         QCommonStyle::drawItemText(painter, textRect, text_flags, menuItem->palette,

   748                             (menuItem->state & State_Enabled), menuItem->text, QPalette::Text);

   749                 }

   750             }

   751             break;

   752         }

   753         case CE_MenuBarEmptyArea:

   754         case CE_MenuEmptyArea: {

   755             break;

   756         }

   757 #ifndef QT_NO_PROGRESSBAR

   758         case CE_ProgressBar: {

   759             if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {

   760                 drawControl(CE_ProgressBarGroove, progressBar, painter, widget);

   761                 drawControl(CE_ProgressBarContents, progressBar, painter, widget);

   762                 //drawControl(CE_ProgressBarLabel, progressBar, painter, widget);

   763             }

   764             break;

   765         }

   766         case CE_ProgressBarGroove: {

   767             if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {

   768                 const QRect progressBarGroove = subElementRect(SE_ProgressBarGroove, progressBar, widget);

   769                 const bool horizontal = progressBar->orientation == Qt::Horizontal;

   770                 ItemStates state = 0;

   771                 if (horizontal)

   772                     state = state | SS_Horizontal;

   773                 else

   774                     state = state | SS_Vertical;

   775 

   776                 m_private->drawMultiPartItem(SM_ProgressBarGroove, painter, progressBarGroove, state);

   777             }

   778             break;

   779         }

   780         case CE_ProgressBarContents: {

   781             if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {

   782                 if (progressBar->minimum == 0 && progressBar->maximum == 0) {

   783                     //waiting bar

   784                     animateControl(CE_ProgressBarContents, option, painter, widget);

   785                 } else {

   786                     QRect rect = subElementRect(SE_ProgressBarGroove, progressBar, widget);

   787                     const qint64 minimum = qint64(progressBar->minimum);

   788                     const qint64 maximum = qint64(progressBar->maximum);

   789                     const qint64 progress = qint64(progressBar->progress);

   790                     if (progressBar->orientation == Qt::Horizontal) {

   791                         const qreal scale = rect.width() / qreal(maximum - minimum);

   792                         qint64 width = scale * progress;

   793                         width = progress >= maximum ? rect.width() : width;

   794 

   795                         if ((progressBar->direction == Qt::LeftToRight) ^ progressBar->invertedAppearance) {

   796                             rect = QRect(rect.x(), rect.y(), width, rect.height());

   797                         } else {

   798                             rect = QRect(rect.x() + (rect.width() - width), rect.y(), rect.width() - (rect.width() - width), rect.height());

   799                         }

   800                         m_private->drawMultiPartItem(SM_ProgressBarIndicator, painter, rect, SS_Horizontal);

   801                     } else{ //Vertical

   802                         const qreal scale = rect.height() / qreal(maximum - minimum);

   803                         qint64 height = scale * progress;

   804                         height = progress >= maximum ? rect.height() : height;

   805                         if (progressBar->invertedAppearance) {

   806                             rect = QRect(rect.x(), rect.y(), rect.width(), height);

   807                         } else {

   808                             rect = QRect(rect.x(), rect.y() + (rect.height() - height), rect.width(), rect.height() - (rect.height() - height));

   809                         }

   810                         m_private->drawMultiPartItem(SM_ProgressBarIndicator, painter, rect, SS_Vertical);

   811                     }

   812                 }

   813             }

   814             break;

   815         }

   816         case CE_ProgressBarLabel: {

   817             if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {

   818                 if (progressBar->textVisible && (progressBar->minimum != 0 || progressBar->maximum != 0)) {

   819                     const QString minText = QString().setNum(progressBar->minimum);

   820                     const QString maxText = QString().setNum(progressBar->maximum);

   821                     const QRect textRect = subElementRect(SE_ProgressBarGroove, progressBar, widget);

   822                     if (progressBar->orientation == Qt::Horizontal) {

   823                         if (progressBar->invertedAppearance) {

   824                             //minText

   825                             proxy()->drawItemText(painter, textRect, Qt::AlignRight | Qt::TextSingleLine, progressBar->palette,

   826                                          progressBar->state & State_Enabled, minText, QPalette::Text);

   827 

   828                             //maxText

   829                             proxy()->drawItemText(painter, textRect, Qt::AlignLeft | Qt::TextSingleLine, progressBar->palette,

   830                                          progressBar->state & State_Enabled, maxText, QPalette::Text);

   831 

   832                         } else {

   833                             //minText

   834                             proxy()->drawItemText(painter, textRect, Qt::AlignLeft | Qt::TextSingleLine, progressBar->palette,

   835                                          progressBar->state & State_Enabled, minText, QPalette::Text);

   836 

   837                             //maxText

   838                             proxy()->drawItemText(painter, textRect, Qt::AlignRight | Qt::TextSingleLine, progressBar->palette,

   839                                          progressBar->state & State_Enabled, maxText, QPalette::Text);

   840                         }

   841                     } else { //Vertical

   842                         if (progressBar->invertedAppearance) {

   843                             //minText

   844                             proxy()->drawItemText(painter, textRect, Qt::AlignTop | Qt::TextSingleLine, progressBar->palette,

   845                                          progressBar->state & State_Enabled, minText, QPalette::Text);

   846 

   847                             //maxText

   848                             proxy()->drawItemText(painter, textRect, Qt::AlignBottom | Qt::TextSingleLine, progressBar->palette,

   849                                          progressBar->state & State_Enabled, maxText, QPalette::Text);

   850 

   851                         } else {

   852                             //minText

   853                             proxy()->drawItemText(painter, textRect, Qt::AlignBottom | Qt::TextSingleLine, progressBar->palette,

   854                                          progressBar->state & State_Enabled, minText, QPalette::Text);

   855 

   856                             //maxText

   857                             proxy()->drawItemText(painter, textRect, Qt::AlignTop | Qt::TextSingleLine, progressBar->palette,

   858                                          progressBar->state & State_Enabled, maxText, QPalette::Text);

   859                         }

   860 

   861                     }

   862 

   863                 }

   864             }

   865             break;

   866         }

   867 #endif //QT_NO_PROGRESSBAR

   868         case CE_ToolButtonLabel:

   869         default: {

   870             QCommonStyle::drawControl(element, option, painter, widget);

   871             break;

   872         }

   873     }

   874 }

   875 

   876 void QHbStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,

   877                             QPainter *painter, const QWidget *widget) const

   878 {

   879     switch (control) {

   880 #ifndef QT_NO_COMBOBOX

   881         case CC_ComboBox: {

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

   883                 const QRect cmbxFrame = cmb->rect;

   884                 ItemStates state = SS_Active;

   885 

   886                 // Button frame

   887                 QStyleOptionFrame  buttonOption;

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

   889                 const int buttonMaxHeight = cmbxFrame.height();

   890                 const int buttonMaxWidth = buttonMaxHeight; //button is rect

   891                 const int topLeftPoint = (cmb->direction == Qt::LeftToRight) ? (cmbxFrame.width() - buttonMaxWidth) : 0;

   892 

   893                 const QRect buttonRect(topLeftPoint, cmbxFrame.top(), buttonMaxHeight, buttonMaxWidth);

   894                 buttonOption.rect = buttonRect;

   895                 buttonOption.state = cmb->state;

   896                 ItemStates buttonState = (buttonOption.state & State_Sunken) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);

   897                 if (cmb->direction == Qt::RightToLeft)

   898                     buttonState |= SS_Mirrored;

   899                 if (buttonOption.state & State_HasFocus) {

   900                     buttonState |= SS_Selected;

   901                     state |= SS_Selected; //set frame status to follow button status for highlight

   902                 }

   903 

   904                 m_private->drawItem(SP_BoxButton, painter, buttonRect.adjusted(0, 1, 0, -1), buttonState); //@todo: remove magic

   905 

   906                 if (cmb->subControls & SC_ComboBoxFrame) {

   907                     const bool isDisabled = !(cmb->state & State_Enabled);

   908                     const bool isPressed = (cmb->state & State_Sunken);

   909                     const bool isEditable = cmb->editable;

   910 

   911                     if (isDisabled)

   912                         state = SS_Disabled;

   913                     else if (isPressed)

   914                         state |= SS_Pressed;

   915                     if (isEditable)

   916                         state |= SS_Edited;

   917                     QRect frameRect = QRect(cmb->rect);

   918                     int frameWidth = pixelMetric(PM_DefaultFrameWidth);

   919                     int maxRight = cmb->rect.height() - 2 * frameWidth;

   920                     frameRect.adjust(0, 0, -maxRight, 0);

   921                     int adjustX = 0;

   922                     if (option->direction == Qt::RightToLeft) {

   923                         adjustX = buttonOption.rect.topRight().x();

   924                         state |= SS_Mirrored;

   925                     }

   926                     const QRect frame = subControlRect(CC_ComboBox, option, SC_ComboBoxFrame, widget);

   927                     // @todo: if SC_ComboBoxFrame needs adjusting, move that code to subControlRect

   928                     m_private->drawMultiPartItem(SM_BoxFrame, painter, frame.adjusted(adjustX, 1, -4 + adjustX, -1), state);

   929                 }

   930             }

   931             break;

   932         }

   933 #endif //QT_NO_COMBOBOX

   934 #ifndef QT_NO_SLIDER

   935         case CC_Slider: {

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

   937                 const QSlider* slider = qobject_cast<const QSlider*>(widget);

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

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

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

   941                 const bool isDisabled = !(optionSlider->state & State_Enabled);

   942                 ItemStates grooveState = (isDisabled) ? SS_Disabled : SS_Active;

   943                 if (horizontal)

   944                     grooveState = grooveState | SS_Horizontal;

   945                 else

   946                     grooveState = grooveState | SS_Vertical;

   947 

   948                 ItemStates handleState = grooveState;

   949 

   950                 if (slider && slider->isSliderDown())

   951                     handleState = handleState | SS_Pressed;

   952                 else if ((optionSlider->state & State_Sunken) || (optionSlider->state & State_On))

   953                     grooveState = grooveState | SS_Pressed;

   954 

   955                 //Draw ticks

   956                 if (optionSlider->subControls & SC_SliderTickmarks) {

   957                     const QRect tickRect = subControlRect(control, optionSlider, SC_SliderTickmarks, widget);

   958                     const bool ticksAbove = optionSlider->tickPosition & QSlider::TicksAbove;

   959                     const bool ticksBelow = optionSlider->tickPosition & QSlider::TicksBelow;

   960 

   961                     int tickOffset = proxy()->pixelMetric(PM_SliderTickmarkOffset, optionSlider, widget);

   962                     const int thickness = proxy()->pixelMetric(PM_SliderControlThickness, optionSlider, widget);

   963                     const int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, optionSlider, widget);

   964                     int interval = optionSlider->tickInterval;

   965                     if (interval <= 0) {

   966                         interval = optionSlider->singleStep;

   967                         if (sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum, interval,available)

   968                             - sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum, 0, available) < 3)

   969                             interval = optionSlider->pageStep;

   970                     }

   971                     if (!interval)

   972                         interval = 1;

   973                     int pos;

   974                     const int fudge = proxy()->pixelMetric(PM_SliderLength, optionSlider, widget) / 2;

   975                     // Since there is no subrect for tickmarks do a translation here.

   976                     int v = optionSlider->minimum;

   977 

   978                     while (v <= (optionSlider->maximum + 1)) {

   979                         if ((v == optionSlider->maximum + 1) && (interval == 1))

   980                             break;

   981                         const int v_ = qMin(v, optionSlider->maximum);

   982                         pos = sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum,

   983                                                               v_, available) + fudge;

   984                         QRect destRect = QRect();

   985                         if (horizontal) {

   986                             if (ticksAbove) {

   987                                 destRect = QRect(pos, tickRect.y() - tickOffset + 1, tickRect.width(), tickRect.height());

   988                                 m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);

   989                             }

   990                             if (ticksBelow) {

   991                                 destRect = QRect(pos, tickOffset + thickness - 1, tickRect.width(), tickRect.height());

   992                                 m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);

   993                             }

   994                         } else {

   995                             if (ticksAbove) {

   996                                 destRect = QRect(tickRect.x() - tickOffset + 1, pos, tickRect.width(), tickRect.height());

   997                                 m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);

   998                             }

   999                             if (ticksBelow) {

  1000                                 destRect = QRect(tickOffset + thickness - 1, pos, tickRect.width(), tickRect.height());

  1001                                 m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);

  1002                             }

  1003                         }

  1004                         // in the case where maximum is max int

  1005                         int nextInterval = v + interval;

  1006                         if (nextInterval < v)

  1007                             break;

  1008                         v = nextInterval;

  1009                     }

  1010                 }

  1011                  QRect filledRect;

  1012                  if ( horizontal ){

  1013                     const int sliderPosition = sliderHandle.center().x();

  1014                     const int sliderWidth = sliderHandle.width()/2;

  1015                     if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){

  1016                         filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderPosition+sliderWidth, sliderGroove.height());

  1017                      } else {

  1018                         filledRect = QRect(sliderGroove.x()+sliderPosition-sliderWidth, sliderGroove.y(), sliderGroove.width()-sliderPosition+sliderWidth, sliderGroove.height());

  1019                      }

  1020                  } else {

  1021                     const int sliderPosition = sliderHandle.center().y();

  1022                     const int sliderHeight = sliderHandle.height()/2;

  1023                      if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){

  1024                         filledRect = QRect(sliderGroove.x(), sliderGroove.y()+sliderPosition-sliderHeight, sliderGroove.width(), sliderGroove.height()-sliderPosition+sliderHeight);

  1025                      } else {

  1026                         filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderGroove.width(), sliderPosition+sliderHeight);

  1027                      }

  1028                   }

  1029 

  1030                 //Groove

  1031                 m_private->drawMultiPartItem(SM_SliderGroove, painter, sliderGroove, grooveState);

  1032 

  1033                 //Progress

  1034                 m_private->drawMultiPartItem(SM_SliderProgress, painter, filledRect, grooveState | SS_Filled);

  1035 

  1036                  //handle

  1037                 m_private->drawItem(SP_SliderHandle, painter, sliderHandle, handleState);

  1038             }

  1039             break;

  1040         }

  1041 #endif //QT_NO_SLIDER

  1042 #ifndef QT_NO_SCROLLBAR

  1043         case CC_ScrollBar: {

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

  1045                 ItemStates handleStates;

  1046                 ItemStates grooveStates;

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

  1048                 const QRect handleRect = subControlRect(control, optionSlider, SC_ScrollBarSlider, widget);

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

  1050                 if (horizontal) {

  1051                     handleStates |= SS_Horizontal;

  1052                     grooveStates |= SS_Horizontal;

  1053                 } else {

  1054                     handleStates |= SS_Vertical;

  1055                     grooveStates |= SS_Vertical;

  1056                 }

  1057                 const SubControls subControls = optionSlider->subControls;

  1058                 const bool sliderPressed = ((optionSlider->state & State_Sunken) && (subControls & SC_ScrollBarSlider));

  1059                 const bool groovePressed = ((optionSlider->state & State_Sunken) && (subControls & SC_ScrollBarGroove));

  1060 

  1061                 if (sliderPressed)

  1062                     handleStates |= SS_Pressed;

  1063                 if (groovePressed)

  1064                     grooveStates |= SS_Pressed;

  1065 

  1066                 m_private->drawMultiPartItem(SM_ScrollBarGroove, painter, grooveRect, grooveStates);

  1067                 m_private->drawMultiPartItem(SM_ScrollBarHandle, painter, handleRect, handleStates);

  1068             }

  1069             break;

  1070         }

  1071 #endif // QT_NO_SCROLLBAR

  1072 #ifndef QT_NO_GROUPBOX

  1073         case CC_GroupBox: {

  1074             if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {

  1075                 // Draw frame

  1076                 const QRect textRect = subControlRect(CC_GroupBox, option, SC_GroupBoxLabel, widget);

  1077 

  1078                 QRect headerRect = textRect;

  1079                 headerRect.setWidth(groupBox->rect.width());

  1080                 if (groupBox->subControls & SC_GroupBoxFrame) {

  1081                     QStyleOptionFrameV2 frame;

  1082                     frame.QStyleOption::operator=(*groupBox);

  1083                     frame.features = groupBox->features;

  1084                     frame.lineWidth = groupBox->lineWidth;

  1085                     frame.midLineWidth = groupBox->midLineWidth;

  1086                     frame.rect = subControlRect(CC_GroupBox, option, SC_GroupBoxFrame, widget);

  1087                     proxy()->drawPrimitive(PE_FrameGroupBox, &frame, painter, widget);

  1088                 }

  1089 

  1090                 // Draw title

  1091                 if ((groupBox->subControls & SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {

  1092                     // Draw title background

  1093                     m_private->drawMultiPartItem(SM_GroupBoxTitle, painter, headerRect);

  1094 

  1095                     const QColor textColor = groupBox->textColor;

  1096                     painter->save();

  1097 

  1098                     if (textColor.isValid())

  1099                         painter->setPen(textColor);

  1100                     int alignment = int(groupBox->textAlignment);

  1101                     if (!styleHint(SH_UnderlineShortcut, option, widget))

  1102                         alignment |= Qt::TextHideMnemonic;

  1103 

  1104                     proxy()->drawItemText(painter, headerRect,  Qt::TextShowMnemonic | Qt::AlignHCenter | Qt::AlignVCenter | alignment,

  1105                                  groupBox->palette, groupBox->state & State_Enabled, groupBox->text,

  1106                                  textColor.isValid() ? QPalette::NoRole : QPalette::WindowText);

  1107                     painter->restore();

  1108                 }

  1109                 const QRect checkBoxRect = subControlRect(CC_GroupBox, option, SC_GroupBoxCheckBox, widget);

  1110                 // Draw checkbox

  1111                 if (groupBox->subControls & SC_GroupBoxCheckBox) {

  1112                     QStyleOptionButton box;

  1113                     box.QStyleOption::operator=(*groupBox);

  1114                     box.rect = checkBoxRect;

  1115                     proxy()->drawPrimitive(PE_IndicatorCheckBox, &box, painter, widget);

  1116                 }

  1117             }

  1118             break;

  1119         }

  1120 #endif //QT_NO_GROUPBOX

  1121 #ifndef QT_NO_TOOLBUTTON

  1122         case CC_ToolButton: {

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

  1124                 const QRect buttonRect(subControlRect(control, toolBtn, SC_ToolButton, widget));

  1125                 QRect menuRect = QRect();

  1126                 if (toolBtn->subControls & SC_ToolButtonMenu)

  1127                     menuRect = subControlRect(control, toolBtn, SC_ToolButtonMenu, widget);

  1128 

  1129                 // Draw button bevel

  1130                 if (toolBtn->subControls & SC_ToolButton)

  1131                     proxy()->drawPrimitive(PE_PanelButtonTool, toolBtn, painter, widget);

  1132 

  1133                 //draw focus

  1134                 if (toolBtn->state & State_HasFocus) {