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/qlistview.h>

    32 #include <QtGui/qpushbutton.h>

    33 #include <QtGui/qscrollbar.h>

    34 #include <QtGui/qtabbar.h>

    35 #include <QtGui/qtableview.h>

    36 #include <QtGui/qtreeview.h>

    37 #include <QtGui/qtextedit.h>

    38 #include <QtGui/qtoolbar.h>

    39 #include <QtGui/qtoolbutton.h>

    40 #include <QtGui/qradiobutton.h>

    41 #include <QtGui/qcheckbox.h>

    42 #include <QtGui/qprogressbar.h>

    43 #include <QtGui/qcombobox.h>

    44 #include <QtGui/qspinbox.h>

    45 #include <QtGui/qlineedit.h>

    46 

    47 //Animation

    48 #include <QParallelAnimationGroup>

    49 #include <QPropertyAnimation>

    50 #include <QTime>

    51 

    52 //Hb includes

    53 #include <hbinstance.h>

    54 #include <hbicon.h>

    55 #include <hbframedrawer.h>

    56 #include <hbstyle.h>

    57 #include <hbcolorscheme.h>

    58 #include <hbfontspec.h>

    59 

    60 #include "qhbstyle.h"

    61 #include "qhbstyle_p.h"

    62 #include "qhbstyleanimation.h"

    63 

    64 QT_BEGIN_NAMESPACE

    65 

    66 QHbStylePrivate::QHbStylePrivate() : m_styleManager(0),

    67     m_frameDrawer(0),

    68     m_animationGroup(0)

    69 {

    70 }

    71 

    72 QHbStylePrivate::~QHbStylePrivate()

    73 {

    74 }

    75 

    76 HbStyle* QHbStylePrivate::styleManager()

    77 {

    78     if (!m_styleManager) {

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

    80         setStyleManager(instance->style());

    81     }

    82     

    83     return m_styleManager;

    84 }

    85 

    86 void QHbStylePrivate::setStyleManager(HbStyle* style)

    87 {

    88     Q_ASSERT(style);

    89     m_styleManager = style;

    90 }

    91 

    92 QParallelAnimationGroup* QHbStylePrivate::animationGroup()

    93 {

    94     if (m_animationGroup.isNull())

    95         m_animationGroup.reset(new QParallelAnimationGroup());

    96     return m_animationGroup.data();

    97 }

    98 

    99 /*!

   100   \internal

   101  */

   102 QHbStyle::QHbStyle() : QCommonStyle()

   103 {

   104     m_private = new QHbStylePrivate();

   105 }

   106 

   107 /*!

   108   \internal

   109  */

   110 QHbStyle::~QHbStyle()

   111 {

   112     delete m_private;

   113 }

   114 

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

   116                        QPainter *painter, const QWidget *widget) const

   117 {

   118     switch (element) {

   119         case PE_IndicatorViewItemCheck: {

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

   121                 ItemStates state;

   122                 if (itemOption->state & State_Selected)

   123                     state |= SS_Selected;

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

   125             }

   126             break;

   127         }

   128         case PE_IndicatorHeaderArrow: {

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

   130                 ItemStates state;

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

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

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

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

   135             }

   136             break;

   137         }

   138         case PE_IndicatorBranch: {

   139             if (option->state & State_Children) {

   140                 QRect indicatorRect = option->rect;

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

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

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

   144                 if (option->state & State_Open)

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

   146                 else

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

   148             }

   149             break;

   150         }

   151         case PE_PanelItemViewRow: {

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

   153             ItemStates state = SS_Active;

   154             if (vopt->state & State_HasFocus)

   155                 state |= SS_Focused;

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

   157                 state |= SS_Pressed;

   158 

   159 #ifndef QT_NO_TABLEVIEW

   160                 if (qobject_cast<const QTableView *>(widget)) {

   161                     m_private->drawMultiPartItem(SM_TableItem, painter, vopt->rect, state);

   162                     break;

   163                 }

   164 #endif

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

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

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

   168             }

   169             break;

   170         }

   171         case PE_PanelItemViewItem: {

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

   173                 ItemStates state = SS_Active;

   174                 if (vopt->state & State_HasFocus)

   175                     state |= SS_Focused;

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

   177                     state |= SS_Pressed;

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

   179             }

   180             break;

   181         }

   182         case PE_IndicatorArrowLeft:

   183         case PE_IndicatorArrowRight:

   184         case PE_IndicatorArrowUp:

   185         case PE_IndicatorArrowDown: {

   186             ItemStates state;

   187             if (element == PE_IndicatorArrowRight)

   188                 state = SS_Right;

   189             else if (element == PE_IndicatorArrowLeft)

   190                 state = SS_Left;

   191             else if (element == PE_IndicatorArrowUp)

   192                 state = SS_Up;

   193             else

   194                 state = SS_Down;

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

   196             break;

   197         }

   198         case PE_PanelTipLabel: {

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

   200             break;

   201         }

   202         case PE_Frame: {

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

   204 #ifndef QT_NO_TEXTEDIT

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

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

   207 #endif //QT_NO_TEXTEDIT

   208             }

   209             break;

   210         }

   211         case PE_FrameTabWidget: {

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

   213             break;

   214         }

   215 #ifndef QT_NO_LINEEDIT

   216         case PE_PanelLineEdit: {

   217 #ifndef QT_NO_COMBOBOX

   218             if ( (widget && qobject_cast<const QComboBox *>(widget->parentWidget()) ) && (!widget->hasFocus()))

   219                 break;

   220 #endif

   221 #ifndef QT_NO_SPINBOX

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

   223                 break;

   224 #endif

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

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

   227                 if (lineEdit->state & State_HasFocus)

   228                     state |= SS_Selected;

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

   230             }

   231             break;

   232         }

   233 #endif // QT_NO_LINEEDIT

   234         case PE_PanelButtonTool: {

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

   236                 //draw button

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

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

   239                                        (toolbutton->state & State_On);

   240 

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

   242                 bool isLatched = false;

   243 #ifndef QT_NO_TOOLBUTTON

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

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

   246 #endif

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

   248                 if (isLatched)

   249                     state = state | SS_Latched;

   250                 else if (isPressed)

   251                     state = state | SS_Pressed;

   252 

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

   254                     state = state | SS_Selected;

   255 #ifndef QT_NO_TOOLBAR

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

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

   258                 else

   259 #endif

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

   261             }

   262             break;

   263         }

   264         case PE_IndicatorCheckBox: {

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

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

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

   268             break;

   269         }

   270         case PE_IndicatorRadioButton: {

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

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

   273             break;

   274         }

   275         case PE_FrameFocusRect: {

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

   277                 if (false

   278 #ifndef QT_NO_LISTVIEW

   279                         || qobject_cast<const QListView *>(widget)

   280 #endif

   281 #ifndef QT_NO_TABLEVIEW

   282                         || qobject_cast<const QTableView *>(widget)

   283 #endif

   284 #ifndef QT_NO_TREEVIEW

   285                         || qobject_cast<const QTreeView *>(widget)

   286 #endif

   287                     )

   288                     if (option->state & State_HasFocus)

   289                         m_private->drawMultiPartItem(SM_ItemViewItem, painter, highlight->rect, SS_Focused);

   290             }

   291             break;

   292         }

   293         case PE_FrameMenu: {

   294             break;

   295         }

   296         case PE_PanelMenu: {

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

   298             break;

   299         }

   300         case PE_Widget: {

   301             if (m_private->isDialog(widget))

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

   303             break;

   304         }

   305         case PE_IndicatorMenuCheckMark: {

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

   307             break;

   308         }

   309         case PE_FrameGroupBox: {

   310             ItemStates groupBoxStates;

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

   312                 groupBoxStates |= SS_Pressed;

   313             if (option->state & State_HasFocus)

   314                 groupBoxStates |= SS_Selected;

   315             if (option->state & State_On)

   316                 groupBoxStates |= SS_Active;

   317             else if (option->state & State_Off)

   318                 groupBoxStates |= SS_Inactive;

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

   320             break;

   321         }

   322         // Qt3 primitives are not supported

   323         case PE_Q3CheckListController:

   324         case PE_Q3CheckListExclusiveIndicator:

   325         case PE_Q3CheckListIndicator:

   326         case PE_Q3DockWindowSeparator:

   327         case PE_Q3Separator: {

   328             Q_ASSERT(false);

   329             break;

   330         }

   331         case PE_PanelScrollAreaCorner: //no corner for scroll area

   332         case PE_IndicatorTabTear: // no tab tear in uiemo

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

   334             break;

   335         }

   336         default: {

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

   338             break;

   339         }

   340     }

   341 }

   342 

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

   344                      QPainter *painter, const QWidget *widget) const

   345 {

   346     switch (element) {

   347         case CE_HeaderEmptyArea: {

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

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

   350             if (!isHorizontal)

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

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

   353             break;

   354         }

   355         case CE_HeaderSection: {

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

   357                 //Draw corner button as normal pushButton.

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

   359                     QStyleOptionButton cornerButton;

   360                     cornerButton.initFrom(widget);

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

   362                 } else {

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

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

   365                     if (isVertical)

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

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

   368                 }

   369             }

   370             break;

   371         }

   372         case CE_ItemViewItem: {

   373         //@todo: headerviews and listviews should show selection tick at the beginning of the row (in place of checkbox rect)

   374         //@todo: headerview should select also parent when child is selected

   375         //@todo: headerview should draw highlight rect

   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 QListView *>(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::NoSelection) {

   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 

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

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

   887 

   888                 if (cmb->state & State_Active &&

   889                     cmb->state & State_Enabled &&

   890                     !cmb->state & State_HasFocus &&

   891                     !cmb->state & State_MouseOver &&

   892                     !cmb->state & State_Selected) {

   893                     state |= SS_Active;

   894                 }

   895                 if (cmb->state & State_Active &&

   896                     cmb->state & State_Enabled &&

   897                     cmb->state & State_On &&

   898                     !cmb->state & State_HasFocus &&

   899                     !cmb->state & State_MouseOver &&

   900                     !cmb->state & State_Selected) {

   901                     state |= SS_Active;

   902                 }

   903                 else if (cmb->state & State_Active &&

   904                          cmb->state & State_Enabled &&

   905                          cmb->state & State_HasFocus &&

   906                          cmb->state & State_MouseOver &&

   907                          cmb->state & State_Selected) {

   908                     state |= SS_Pressed;

   909                 }

   910                 else if (cmb->state & State_Active &&

   911                          cmb->state & State_Enabled &&

   912                          cmb->state & State_HasFocus &&

   913                          cmb->state & State_MouseOver) {

   914                     state |= SS_Pressed;

   915                 }

   916                /* else if (cmb->state & State_Active &&

   917                          cmb->state & State_Enabled &&

   918                          cmb->state & State_Sunken) {

   919                     state |= SS_Pressed;

   920                 }*/

   921 

   922                 // Button frame

   923                 QStyleOptionFrame  buttonOption;

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

   925                 const int buttonMaxHeight = cmbxFrame.height();

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

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

   928 

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

   930                 if (cmb->direction == Qt::RightToLeft){

   931 

   932                     state |= SS_Mirrored;

   933                 }

   934 

   935                 if (cmb->subControls & SC_ComboBoxFrame) {

   936 

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

   938                     int frameWidth = pixelMetric(PM_DefaultFrameWidth);

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

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

   941 

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

   943                     //Draw the frame

   944                     m_private->drawMultiPartItem(SM_BoxFrame, painter, frame, state);

   945                 }

   946                 //Draw the dropdown button

   947                 m_private->drawItem(SP_BoxButton, painter, buttonRect, state); //@todo: remove magic

   948             }

   949             break;

   950         }

   951 #endif //QT_NO_COMBOBOX

   952 #ifndef QT_NO_SLIDER

   953         case CC_Slider: {

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

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

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

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

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

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

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

   961                 if (horizontal)

   962                     grooveState = grooveState | SS_Horizontal;

   963                 else

   964                     grooveState = grooveState | SS_Vertical;

   965 

   966                 ItemStates handleState = grooveState;

   967 

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

   969                     handleState = handleState | SS_Pressed;

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

   971                     grooveState = grooveState | SS_Pressed;

   972 

   973                 //Draw ticks

   974                 if (optionSlider->subControls & SC_SliderTickmarks) {

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

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

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

   978 

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

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

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

   982                     int interval = optionSlider->tickInterval;

   983                     if (interval <= 0) {

   984                         interval = optionSlider->singleStep;

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

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

   987                             interval = optionSlider->pageStep;

   988                     }

   989                     if (!interval)

   990                         interval = 1;

   991                     int pos;

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

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

   994                     int v = optionSlider->minimum;

   995 

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

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

   998                             break;

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

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

  1001                                                               v_, available) + fudge;

  1002                         QRect destRect = QRect();

  1003                         if (horizontal) {

  1004                             if (ticksAbove) {

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

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

  1007                             }

  1008                             if (ticksBelow) {

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

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

  1011                             }

  1012                         } else {

  1013                             if (ticksAbove) {

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

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

  1016                             }

  1017                             if (ticksBelow) {

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

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

  1020                             }

  1021                         }

  1022                         // in the case where maximum is max int

  1023                         int nextInterval = v + interval;

  1024                         if (nextInterval < v)

  1025                             break;

  1026                         v = nextInterval;

  1027                     }

  1028                 }

  1029 

  1030                 QRect filledRect;

  1031                 QRect filledRectMask;

  1032                 if ( horizontal ){

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

  1034                         filledRect = QRect( sliderGroove.x(),

  1035                                             sliderGroove.y(),

  1036                                             qMax(sliderGroove.width()-sliderHandle.right(), sliderHandle.right()),

  1037                                             sliderGroove.height());

  1038 

  1039                         int x = qMin(sliderHandle.left(), sliderGroove.x() + sliderGroove.width()-sliderHandle.right());

  1040                         filledRectMask = QRect(x,

  1041                                                sliderGroove.y(),

  1042                                                sliderGroove.width()-x,

  1043                                                sliderGroove.height());

  1044                     } else {

  1045                         filledRect = QRect( qMin(sliderGroove.width()-sliderHandle.left(),sliderHandle.left()),

  1046                                             sliderGroove.y(),

  1047                                             qMax(sliderGroove.width()-sliderHandle.left(), sliderHandle.left()),

  1048                                             sliderGroove.height());

  1049 

  1050                         filledRectMask = QRect( sliderGroove.x(),

  1051                                                 sliderGroove.y(),

  1052                                                 qMax(sliderGroove.width()-sliderHandle.right(), sliderHandle.right()),

  1053                                                 sliderGroove.height());

  1054 

  1055                     }

  1056                 } else {

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

  1058                         filledRect = QRect(sliderGroove.x(),

  1059                                            qMin(sliderGroove.height()-sliderHandle.top(), sliderHandle.top()),

  1060                                            sliderGroove.width(),

  1061                                            qMax(sliderGroove.height()-sliderHandle.top(), sliderHandle.top()));

  1062 

  1063                         filledRectMask = QRect(sliderGroove.x(),

  1064                                                sliderGroove.y(),

  1065                                                sliderGroove.width(),

  1066                                                qMax(sliderGroove.height()-sliderHandle.bottom(), sliderHandle.bottom()));

  1067                     } else {

  1068                         filledRect = QRect(sliderGroove.x(),

  1069                                            sliderGroove.y(),

  1070                                            sliderGroove.width(),

  1071                                            qMax(sliderGroove.height()-sliderHandle.bottom(),sliderHandle.bottom()));

  1072 

  1073                         int y = qMin(sliderHandle.top(), sliderGroove.y() + sliderGroove.height()-sliderHandle.bottom());

  1074                         filledRectMask = QRect( sliderGroove.x(),

  1075                                                 y,

  1076                                                 sliderGroove.width(),

  1077                                                 sliderGroove.height()-y );

  1078                     }

  1079                 }

  1080 

  1081                 if (filledRect.width() <  filledRectMask.width() || filledRect.height() <  filledRectMask.height()){

  1082                     // Progress + groove

  1083                     m_private->drawMultiPartItem(SM_SliderGroove, painter, filledRect, grooveState );

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

  1085 

  1086                     // Groove

  1087                     m_private->drawMultiPartItem(SM_SliderGroove, painter, filledRectMask, grooveState);

  1088                 } else {

  1089                     // Groove

  1090                     m_private->drawMultiPartItem(SM_SliderGroove, painter, filledRectMask, grooveState);

  1091 

  1092                     // Progess + groove

  1093                     m_private->drawMultiPartItem(SM_SliderGroove, painter, filledRect, grooveState );

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

  1095                 }

  1096 

  1097                 //handle

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

  1099             }

  1100             break;

  1101         }

  1102 #endif //QT_NO_SLIDER

  1103 #ifndef QT_NO_SCROLLBAR

  1104         case CC_ScrollBar: {

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

  1106                 ItemStates handleStates;

  1107                 ItemStates grooveStates;

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

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

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

  1111                 if (horizontal) {

  1112                     handleStates |= SS_Horizontal;

  1113                     grooveStates |= SS_Horizontal;

  1114                 } else {

  1115                     handleStates |= SS_Vertical;

  1116                     grooveStates |= SS_Vertical;

  1117                 }

  1118                 const SubControls subControls = optionSlider->subControls;

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

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

  1121 

  1122                 if (sliderPressed)

  1123                     handleStates |= SS_Pressed;

  1124                 if (groovePressed)

  1125                     grooveStates |= SS_Pressed;

  1126 

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

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

  1129             }

  1130             break;

  1131         }

  1132 #endif // QT_NO_SCROLLBAR

  1133 #ifndef QT_NO_GROUPBOX

  1134         case CC_GroupBox: {