Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qhbstyle/qhbstyle.cpp
branchGCC_SURGE
changeset 17 6745d806c5ff
parent 14 6fbed849b4f4
equal deleted inserted replaced
12:ce961d2c008b 17:6745d806c5ff 
    26 #include <qdebug.h>
 
    26 #include <qdebug.h>
 
    27 
    27 
    28 //Qt widgets
 
    28 //Qt widgets
 
    29 #include <QtGui/qgroupbox.h>
 
    29 #include <QtGui/qgroupbox.h>
 
    30 #include <QtGui/qheaderview.h>
 
    30 #include <QtGui/qheaderview.h>
 
    31 #include <QtGui/qlistwidget.h>
 
       
    32 #include <QtGui/qlistview.h>
 
    31 #include <QtGui/qlistview.h>
 
    33 #include <QtGui/qpushbutton.h>
 
    32 #include <QtGui/qpushbutton.h>
 
    34 #include <QtGui/qscrollbar.h>
 
    33 #include <QtGui/qscrollbar.h>
 
    35 #include <QtGui/qtabbar.h>
 
    34 #include <QtGui/qtabbar.h>
 
    36 #include <QtGui/qtableview.h>
 
    35 #include <QtGui/qtableview.h>
 
    37 #include <QtGui/qtablewidget.h>
 
       
    38 #include <QtGui/qtreeview.h>
 
    36 #include <QtGui/qtreeview.h>
 
    39 #include <QtGui/qtreewidget.h>
 
       
    40 #include <QtGui/qtextedit.h>
 
    37 #include <QtGui/qtextedit.h>
 
    41 #include <QtGui/qtoolbar.h>
 
    38 #include <QtGui/qtoolbar.h>
 
    42 #include <QtGui/qtoolbutton.h>
 
    39 #include <QtGui/qtoolbutton.h>
 
    43 #include <QtGui/qradiobutton.h>
 
    40 #include <QtGui/qradiobutton.h>
 
    44 #include <QtGui/qcheckbox.h>
 
    41 #include <QtGui/qcheckbox.h>
 
    64 #include "qhbstyle_p.h"
 
    61 #include "qhbstyle_p.h"
 
    65 #include "qhbstyleanimation.h"
 
    62 #include "qhbstyleanimation.h"
 
    66 
    63 
    67 QT_BEGIN_NAMESPACE
 
    64 QT_BEGIN_NAMESPACE
 
    68 
    65 
    69 QHbStylePrivate::QHbStylePrivate()
 
    66 QHbStylePrivate::QHbStylePrivate() : m_styleManager(0),
 
       
    67     m_frameDrawer(0),
 
       
    68     m_animationGroup(0)
 
    70 {
 
    69 {
 
    71     m_frameDrawer = 0;
 
       
    72     m_styleManager = 0;
 
       
    73 
       
    74     m_animationGroup = q_check_ptr(new QParallelAnimationGroup());
 
       
    75 }
 
    70 }
 
    76 
    71 
    77 QHbStylePrivate::~QHbStylePrivate()
 
    72 QHbStylePrivate::~QHbStylePrivate()
 
    78 {
 
    73 {
 
    79     delete m_frameDrawer;
 
       
    80     delete m_animationGroup;
 
       
    81 }
 
    74 }
 
    82 
    75 
    83 HbStyle* QHbStylePrivate::styleManager()
 
    76 HbStyle* QHbStylePrivate::styleManager()
 
    84 {
 
    77 {
 
       
    78     if (!m_styleManager) {
 
       
    79         HbInstance *instance = HbInstance::instance();
 
       
    80         setStyleManager(instance->style());
 
       
    81     }
 
       
    82     
    85     return m_styleManager;
 
    83     return m_styleManager;
 
    86 }
 
    84 }
 
    87 
    85 
    88 void QHbStylePrivate::setStyleManager(HbStyle* style)
 
    86 void QHbStylePrivate::setStyleManager(HbStyle* style)
 
    89 {
 
    87 {
 
    91     m_styleManager = style;
 
    89     m_styleManager = style;
 
    92 }
 
    90 }
 
    93 
    91 
    94 QParallelAnimationGroup* QHbStylePrivate::animationGroup()
 
    92 QParallelAnimationGroup* QHbStylePrivate::animationGroup()
 
    95 {
 
    93 {
 
    96     return m_animationGroup;
 
    94     if (m_animationGroup.isNull())
 
       
    95         m_animationGroup.reset(new QParallelAnimationGroup());
 
       
    96     return m_animationGroup.data();
 
    97 }
 
    97 }
 
    98 
    98 
    99 /*!
 
    99 /*!
 
   100   \internal
 
   100   \internal
 
   101  */
 
   101  */
 
   102 QHbStyle::QHbStyle() : QCommonStyle()
 
   102 QHbStyle::QHbStyle() : QCommonStyle()
 
   103 {
 
   103 {
 
   104     m_private = new QHbStylePrivate();
 
   104     m_private = new QHbStylePrivate();
 
   105     HbInstance *instance = HbInstance::instance();
 
       
   106 
       
   107     m_private->setStyleManager(instance->style());
 
       
   108 }
 
   105 }
 
   109 
   106 
   110 /*!
 
   107 /*!
 
   111   \internal
 
   108   \internal
 
   112  */
 
   109  */
 
   156             ItemStates state = SS_Active;
 
   153             ItemStates state = SS_Active;
 
   157             if (vopt->state & State_HasFocus)
 
   154             if (vopt->state & State_HasFocus)
 
   158                 state |= SS_Focused;
 
   155                 state |= SS_Focused;
 
   159             if (vopt->state & State_Sunken || vopt->state & State_Raised)
 
   156             if (vopt->state & State_Sunken || vopt->state & State_Raised)
 
   160                 state |= SS_Pressed;
 
   157                 state |= SS_Pressed;
 
   161 #ifndef QT_NO_TREEVIEW
 
   158 
   162                 if (qobject_cast<const QTreeWidget*>(widget)) {
 
   159 #ifndef QT_NO_TABLEVIEW
 
   163                     if (option->state & State_Children) {
 
   160                 if (qobject_cast<const QTableView *>(widget)) {
 
   164                         m_private->drawMultiPartItem(SM_ListParent, painter, vopt->rect, state);
 
   161                     m_private->drawMultiPartItem(SM_TableItem, painter, vopt->rect, state);
 
   165                         break;
 
   162                     break;
 
   166                     }
 
       
   167                 }
 
   163                 }
 
   168 #endif
 
   164 #endif
 
   169             if (vopt->features & QStyleOptionViewItemV2::Alternate)
 
   165             if (vopt->features & QStyleOptionViewItemV2::Alternate)
 
   170                 state |= SS_Alternate; //@todo: how?
 
   166                 state |= SS_Alternate; //@todo: how?
 
   171             m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);
 
   167             m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);
 
   217             break;
 
   213             break;
 
   218         }
 
   214         }
 
   219 #ifndef QT_NO_LINEEDIT
 
   215 #ifndef QT_NO_LINEEDIT
 
   220         case PE_PanelLineEdit: {
 
   216         case PE_PanelLineEdit: {
 
   221 #ifndef QT_NO_COMBOBOX
 
   217 #ifndef QT_NO_COMBOBOX
 
   222             if (widget && qobject_cast<const QComboBox *>(widget->parentWidget()))
 
   218             if ( (widget && qobject_cast<const QComboBox *>(widget->parentWidget()) ) && (!widget->hasFocus()))
 
   223                 break;
 
   219                 break;
 
   224 #endif
 
   220 #endif
 
   225 #ifndef QT_NO_SPINBOX
 
   221 #ifndef QT_NO_SPINBOX
 
   226             if (widget && qobject_cast<const QSpinBox *>(widget->parentWidget()))
 
   222             if (widget && qobject_cast<const QSpinBox *>(widget->parentWidget()))
 
   227                 break;
 
   223                 break;
 
   278         }
 
   274         }
 
   279         case PE_FrameFocusRect: {
 
   275         case PE_FrameFocusRect: {
 
   280             if (const QStyleOptionFocusRect *highlight = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
 
   276             if (const QStyleOptionFocusRect *highlight = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
 
   281                 if (false
 
   277                 if (false
 
   282 #ifndef QT_NO_LISTVIEW
 
   278 #ifndef QT_NO_LISTVIEW
 
   283                         || qobject_cast<const QListWidget *>(widget)
 
   279                         || qobject_cast<const QListView *>(widget)
 
   284 #endif
 
   280 #endif
 
   285 #ifndef QT_NO_TABLEVIEW
 
   281 #ifndef QT_NO_TABLEVIEW
 
   286                         || qobject_cast<const QTableWidget *>(widget)
 
   282                         || qobject_cast<const QTableView *>(widget)
 
   287 #endif
 
   283 #endif
 
   288 #ifndef QT_NO_TREEVIEW
 
   284 #ifndef QT_NO_TREEVIEW
 
   289                         || qobject_cast<const QTreeWidget *>(widget)
 
   285                         || qobject_cast<const QTreeView *>(widget)
 
   290 #endif
 
   286 #endif
 
   291                     )
 
   287                     )
 
   292                     m_private->drawMultiPartItem(SM_ItemViewHighlight, painter, highlight->rect);
 
   288                     if (option->state & State_HasFocus)
 
       
   289                         m_private->drawMultiPartItem(SM_ItemViewItem, painter, highlight->rect, SS_Focused);
 
   293             }
 
   290             }
 
   294             break;
 
   291             break;
 
   295         }
 
   292         }
 
   296         case PE_FrameMenu: {
 
   293         case PE_FrameMenu: {
 
   297             break;
 
   294             break;
 
   371                 }
 
   368                 }
 
   372             }
 
   369             }
 
   373             break;
 
   370             break;
 
   374         }
 
   371         }
 
   375         case CE_ItemViewItem: {
 
   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)) {
 
   376             if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
 
   377                 const QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, itemOption, widget);
 
   377                 const QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, itemOption, widget);
 
   378                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, itemOption, widget);
 
   378                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, itemOption, widget);
 
   379                 QRect textRect = subElementRect(SE_ItemViewItemText, itemOption, widget);
 
   379                 QRect textRect = subElementRect(SE_ItemViewItemText, itemOption, widget);
 
   380 
   380 
   381                 //background for list items (other itemviews use PE_PanelItemViewRow drawing)
 
   381                 //background for list items (other itemviews use PE_PanelItemViewRow drawing)
 
   382                 if (qobject_cast<const QListWidget *>(widget))
 
   382                 if (qobject_cast<const QListView *>(widget))
 
   383                     proxy()->drawPrimitive(PE_PanelItemViewItem, itemOption, painter, widget);
 
   383                     proxy()->drawPrimitive(PE_PanelItemViewItem, itemOption, painter, widget);
 
   384 
   384 
   385                 //checkbox
 
   385                 //checkbox
 
   386                 if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator && checkRect.isValid()) {
 
   386                 if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator && checkRect.isValid()) {
 
   387                     QStyleOptionViewItemV4 checkOption;
 
   387                     QStyleOptionViewItemV4 checkOption;
 
   391                 }
 
   391                 }
 
   392 
   392 
   393                 //selection indication
 
   393                 //selection indication
 
   394                 if (itemOption->state & State_Selected) {
 
   394                 if (itemOption->state & State_Selected) {
 
   395                     const QAbstractItemView *itemView = qobject_cast<const QAbstractItemView *>(widget);
 
   395                     const QAbstractItemView *itemView = qobject_cast<const QAbstractItemView *>(widget);
 
   396                     if (itemView->selectionMode() != QAbstractItemView::SingleSelection) {
 
   396                     if (itemView->selectionMode() != QAbstractItemView::NoSelection) {
 
   397                         QStyleOptionViewItemV4 selectOption;
 
   397                         QStyleOptionViewItemV4 selectOption;
 
   398                         selectOption.QStyleOption::operator=(*itemOption);
 
   398                         selectOption.QStyleOption::operator=(*itemOption);
 
   399                         int iconSize = 0;
 
   399                         int iconSize = 0;
 
   400                         if (m_private->hbParameter(QLatin1String("hb-param-graphic-size-secondary"), iconSize)) {
 
   400                         if (m_private->hbParameter(QLatin1String("hb-param-graphic-size-secondary"), iconSize)) {
 
   401                             QRect selectRect = QRect(0, 0, iconSize, iconSize);
 
   401                             QRect selectRect = QRect(0, 0, iconSize, iconSize);
 
   879     switch (control) {
 
   879     switch (control) {
 
   880 #ifndef QT_NO_COMBOBOX
 
   880 #ifndef QT_NO_COMBOBOX
 
   881         case CC_ComboBox: {
 
   881         case CC_ComboBox: {
 
   882             if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
 
   882             if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
 
   883                 const QRect cmbxFrame = cmb->rect;
 
   883                 const QRect cmbxFrame = cmb->rect;
 
   884                 ItemStates state = SS_Active;
 
   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                 }*/
 
   885 
   921 
   886                 // Button frame
 
   922                 // Button frame
 
   887                 QStyleOptionFrame  buttonOption;
 
   923                 QStyleOptionFrame  buttonOption;
 
   888                 buttonOption.QStyleOption::operator=(*cmb);
 
   924                 buttonOption.QStyleOption::operator=(*cmb);
 
   889                 const int buttonMaxHeight = cmbxFrame.height();
 
   925                 const int buttonMaxHeight = cmbxFrame.height();
 
   890                 const int buttonMaxWidth = buttonMaxHeight; //button is rect
 
   926                 const int buttonMaxWidth = buttonMaxHeight; //button is rect
 
   891                 const int topLeftPoint = (cmb->direction == Qt::LeftToRight) ? (cmbxFrame.width() - buttonMaxWidth) : 0;
 
   927                 const int topLeftPoint = (cmb->direction == Qt::LeftToRight) ? (cmbxFrame.width() - buttonMaxWidth) : 0;
 
   892 
   928 
   893                 const QRect buttonRect(topLeftPoint, cmbxFrame.top(), buttonMaxHeight, buttonMaxWidth);
 
   929                 const QRect buttonRect(topLeftPoint, cmbxFrame.top(), buttonMaxHeight, buttonMaxWidth);
 
   894                 buttonOption.rect = buttonRect;
 
   930                 if (cmb->direction == Qt::RightToLeft){
 
   895                 buttonOption.state = cmb->state;
 
   931 
   896                 ItemStates buttonState = (buttonOption.state & State_Sunken) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);
 
   932                     state |= SS_Mirrored;
 
   897                 if (cmb->direction == Qt::RightToLeft)
 
   933                 }
 
   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 
   934 
   906                 if (cmb->subControls & SC_ComboBoxFrame) {
 
   935                 if (cmb->subControls & SC_ComboBoxFrame) {
 
   907                     const bool isDisabled = !(cmb->state & State_Enabled);
 
   936 
   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);
 
   937                     QRect frameRect = QRect(cmb->rect);
 
   918                     int frameWidth = pixelMetric(PM_DefaultFrameWidth);
 
   938                     int frameWidth = pixelMetric(PM_DefaultFrameWidth);
 
   919                     int maxRight = cmb->rect.height() - 2 * frameWidth;
 
   939                     int maxRight = cmb->rect.height() - 2 * frameWidth;
 
   920                     frameRect.adjust(0, 0, -maxRight, 0);
 
   940                     frameRect.adjust(0, 0, -maxRight, 0);
 
   921                     int adjustX = 0;
 
   941 
   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);
 
   942                     const QRect frame = subControlRect(CC_ComboBox, option, SC_ComboBoxFrame, widget);
 
   927                     // @todo: if SC_ComboBoxFrame needs adjusting, move that code to subControlRect
 
   943                     //Draw the frame
 
   928                     m_private->drawMultiPartItem(SM_BoxFrame, painter, frame.adjusted(adjustX, 1, -4 + adjustX, -1), state);
 
   944                     m_private->drawMultiPartItem(SM_BoxFrame, painter, frame, state);
 
   929                 }
 
   945                 }
 
       
   946                 //Draw the dropdown button
 
       
   947                 m_private->drawItem(SP_BoxButton, painter, buttonRect, state); //@todo: remove magic
 
   930             }
 
   948             }
 
   931             break;
 
   949             break;
 
   932         }
 
   950         }
 
   933 #endif //QT_NO_COMBOBOX
 
   951 #endif //QT_NO_COMBOBOX
 
   934 #ifndef QT_NO_SLIDER
 
   952 #ifndef QT_NO_SLIDER
 
  1006                         if (nextInterval < v)
 
  1024                         if (nextInterval < v)
 
  1007                             break;
 
  1025                             break;
 
  1008                         v = nextInterval;
 
  1026                         v = nextInterval;
 
  1009                     }
 
  1027                     }
 
  1010                 }
 
  1028                 }
 
  1011                  QRect filledRect;
 
  1029 
  1012                  if ( horizontal ){
 
  1030                 QRect filledRect;
 
  1013                     const int sliderPosition = sliderHandle.center().x();
 
  1031                 QRect filledRectMask;
 
  1014                     const int sliderWidth = sliderHandle.width()/2;
 
  1032                 if ( horizontal ){
 
  1015                     if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){
 
  1033                     if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){
 
  1016                         filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderPosition+sliderWidth, sliderGroove.height());
 
  1034                         filledRect = QRect( sliderGroove.x(),
 
  1017                      } else {
 
  1035                                             sliderGroove.y(),
 
  1018                         filledRect = QRect(sliderGroove.x()+sliderPosition-sliderWidth, sliderGroove.y(), sliderGroove.width()-sliderPosition+sliderWidth, sliderGroove.height());
 
  1036                                             qMax(sliderGroove.width()-sliderHandle.right(), sliderHandle.right()),
 
  1019                      }
 
  1037                                             sliderGroove.height());
 
  1020                  } else {
 
  1038 
  1021                     const int sliderPosition = sliderHandle.center().y();
 
  1039                         int x = qMin(sliderHandle.left(), sliderGroove.x() + sliderGroove.width()-sliderHandle.right());
 
  1022                     const int sliderHeight = sliderHandle.height()/2;
 
  1040                         filledRectMask = QRect(x,
 
  1023                      if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){
 
  1041                                                sliderGroove.y(),
 
  1024                         filledRect = QRect(sliderGroove.x(), sliderGroove.y()+sliderPosition-sliderHeight, sliderGroove.width(), sliderGroove.height()-sliderPosition+sliderHeight);
 
  1042                                                sliderGroove.width()-x,
 
  1025                      } else {
 
  1043                                                sliderGroove.height());
 
  1026                         filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderGroove.width(), sliderPosition+sliderHeight);
 
  1044                     } else {
 
  1027                      }
 
  1045                         filledRect = QRect( qMin(sliderGroove.width()-sliderHandle.left(),sliderHandle.left()),
 
  1028                   }
 
  1046                                             sliderGroove.y(),
 
  1029 
  1047                                             qMax(sliderGroove.width()-sliderHandle.left(), sliderHandle.left()),
 
  1030                 //Groove
 
  1048                                             sliderGroove.height());
 
  1031                 m_private->drawMultiPartItem(SM_SliderGroove, painter, sliderGroove, grooveState);
 
  1049 
  1032 
  1050                         filledRectMask = QRect( sliderGroove.x(),
 
  1033                 //Progress
 
  1051                                                 sliderGroove.y(),
 
  1034                 m_private->drawMultiPartItem(SM_SliderProgress, painter, filledRect, grooveState | SS_Filled);
 
  1052                                                 qMax(sliderGroove.width()-sliderHandle.right(), sliderHandle.right()),
 
  1035 
  1053                                                 sliderGroove.height());
 
  1036                  //handle
 
  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
 
  1037                 m_private->drawItem(SP_SliderHandle, painter, sliderHandle, handleState);
 
  1098                 m_private->drawItem(SP_SliderHandle, painter, sliderHandle, handleState);
 
  1038             }
 
  1099             }
 
  1039             break;
 
  1100             break;
 
  1040         }
 
  1101         }
 
  1041 #endif //QT_NO_SLIDER
 
  1102 #endif //QT_NO_SLIDER
 
  1192                 const QRect spinboxFrame = subControlRect(control, optionSpinbox, SC_SpinBoxFrame, widget);
 
  1253                 const QRect spinboxFrame = subControlRect(control, optionSpinbox, SC_SpinBoxFrame, widget);
 
  1193                 const QRect spinboxButtonUpRect = subControlRect(control, optionSpinbox, SC_SpinBoxUp, widget);
 
  1254                 const QRect spinboxButtonUpRect = subControlRect(control, optionSpinbox, SC_SpinBoxUp, widget);
 
  1194                 const QRect spinboxButtonDownRect = subControlRect(control, optionSpinbox, SC_SpinBoxDown, widget);
 
  1255                 const QRect spinboxButtonDownRect = subControlRect(control, optionSpinbox, SC_SpinBoxDown, widget);
 
  1195                 const QRect spinboxEditorRect = subControlRect(control, optionSpinbox, SC_SpinBoxEditField, widget);
 
  1256                 const QRect spinboxEditorRect = subControlRect(control, optionSpinbox, SC_SpinBoxEditField, widget);
 
  1196 
  1257 
  1197                 QStyleOptionSpinBox copy = *optionSpinbox;
 
       
  1198 
       
  1199                 //Frame & background
 
  1258                 //Frame & background
 
  1200                 const bool isDisabled = !(optionSpinbox->state & State_Enabled);
 
  1259                 const bool isDisabled = !(optionSpinbox->state & State_Enabled);
 
  1201                 ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
 
  1260                 ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
 
  1202                 if (optionSpinbox->state & State_HasFocus)
 
  1261                 if (optionSpinbox->state & State_HasFocus)
 
  1203                     state |= SS_Selected;
 
  1262                     state |= SS_Selected;
 
  1204                 m_private->drawMultiPartItem(SM_BoxFrame, painter, spinboxEditorRect, state);
 
  1263                 //Draw the rounded border of edit field frame under button, half spin button width
 
  1205 
  1264                 //Label drawn to spinboxEditorRect
 
       
  1265                 m_private->drawMultiPartItem(SM_BoxFrame, painter, spinboxEditorRect.adjusted((-0.5*spinboxButtonDownRect.width()),0,0,0), state);
 
       
  1266 
       
  1267 
       
  1268                 QStyle::State buttonState;
 
  1206                 //Buttons
 
  1269                 //Buttons
 
  1207                 if (optionSpinbox->subControls & SC_SpinBoxUp) {
 
  1270                 if (optionSpinbox->subControls & SC_SpinBoxUp) {
 
  1208                     copy.subControls = SC_SpinBoxUp;
 
       
  1209                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepUpEnabled))
 
  1271                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepUpEnabled))
 
  1210                         copy.state &= ~State_Enabled;
 
  1272                         buttonState &= ~State_Enabled;
 
  1211                     if (optionSpinbox->activeSubControls == SC_SpinBoxUp && (optionSpinbox->state & State_Sunken)) {
 
  1273                     if (optionSpinbox->activeSubControls == SC_SpinBoxUp && (optionSpinbox->state & State_Sunken)) {
 
  1212                         copy.state |= State_On;
 
  1274                         buttonState |= State_On;
 
  1213                         copy.state |= State_Sunken;
 
  1275                         buttonState |= State_Sunken;
 
  1214                     } else {
 
  1276                     } else {
 
  1215                         copy.state |= State_Raised;
 
  1277                         buttonState |= State_Raised;
 
  1216                         copy.state &= ~State_Sunken;
 
  1278                         buttonState &= ~State_Sunken;
 
  1217                     }
 
  1279                     }
 
  1218                     const bool isPressed = (copy.state & State_Sunken);
 
  1280                     const bool isPressed = (buttonState & State_Sunken);
 
  1219                     ItemStates upButtonState = (isPressed) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);
 
  1281                     ItemStates upButtonState = (isPressed) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);
 
  1220                     if (optionSpinbox->direction == Qt::RightToLeft)
 
  1282                     if (optionSpinbox->direction == Qt::RightToLeft)
 
  1221                         upButtonState = upButtonState | SS_Flipped;
 
  1283                         upButtonState = upButtonState | SS_Flipped;
 
  1222                     else
 
  1284                     else
 
  1223                         upButtonState = upButtonState | SS_Flipped | SS_Mirrored;
 
  1285                         upButtonState = upButtonState | SS_Flipped | SS_Mirrored;
 
  1224                     if (optionSpinbox->state & State_HasFocus)
 
  1286                     if (optionSpinbox->state & State_HasFocus)
 
  1225                         upButtonState |= SS_Selected;
 
  1287                         upButtonState |= SS_Selected;
 
  1226                     if (!(copy.state & State_Enabled))
 
  1288                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepUpEnabled))
 
  1227                         upButtonState |= SS_Disabled;
 
  1289                         upButtonState |= SS_Disabled;
 
  1228                     m_private->drawItem(SP_BoxButton, painter, spinboxButtonUpRect, upButtonState);
 
  1290                     m_private->drawItem(SP_BoxButton, painter, spinboxButtonUpRect, upButtonState);
 
  1229                 }
 
  1291                 }
 
  1230 
  1292 
  1231                 if (optionSpinbox->subControls & SC_SpinBoxDown) {
 
  1293                 if (optionSpinbox->subControls & SC_SpinBoxDown) {
 
  1232                     copy.subControls = SC_SpinBoxDown;
 
       
  1233                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepDownEnabled))
 
  1294                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepDownEnabled))
 
  1234                         copy.state &= ~State_Enabled;
 
  1295                         buttonState &= ~State_Enabled;
 
  1235                     if (optionSpinbox->activeSubControls == SC_SpinBoxDown && (optionSpinbox->state & State_Sunken)) {
 
  1296                     if (optionSpinbox->activeSubControls == SC_SpinBoxDown && (optionSpinbox->state & State_Sunken)) {
 
  1236                         copy.state |= State_On;
 
  1297                         buttonState |= State_On;
 
  1237                         copy.state |= State_Sunken;
 
  1298                         buttonState |= State_Sunken;
 
  1238                     } else {
 
  1299                     } else {
 
  1239                         copy.state |= State_Raised;
 
  1300                         buttonState |= State_Raised;
 
  1240                         copy.state &= ~State_Sunken;
 
  1301                         buttonState &= ~State_Sunken;
 
  1241                     }
 
  1302                     }
 
  1242                     const bool isPressed = (copy.state & State_Sunken);
 
  1303                     const bool isPressed = (buttonState & State_Sunken);
 
  1243                     ItemStates downButtonState = (isPressed) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);
 
  1304                     ItemStates downButtonState = (isPressed) ? ItemStates(SS_Pressed  | SS_Active) : ItemStates(SS_Active);
 
  1244                     if (optionSpinbox->direction == Qt::RightToLeft)
 
  1305                     if (optionSpinbox->direction == Qt::RightToLeft)
 
  1245                         downButtonState = downButtonState;
 
  1306                         downButtonState = downButtonState;
 
  1246                     else
 
  1307                     else
 
  1247                         downButtonState = downButtonState | SS_Mirrored;
 
  1308                         downButtonState = downButtonState | SS_Mirrored;
 
  1248                     if (optionSpinbox->state & State_HasFocus)
 
  1309                     if (optionSpinbox->state & State_HasFocus)
 
  1249                         downButtonState |= SS_Selected;
 
  1310                         downButtonState |= SS_Selected;
 
  1250                     if (!(copy.state & State_Enabled))
 
  1311                     if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepDownEnabled))
 
  1251                         downButtonState |= SS_Disabled;
 
  1312                         downButtonState |= SS_Disabled;
 
  1252                     m_private->drawItem(SP_BoxButton, painter, spinboxButtonDownRect, downButtonState);
 
  1313                     m_private->drawItem(SP_BoxButton, painter, spinboxButtonDownRect, downButtonState);
 
  1253                 }
 
  1314                 }
 
  1254             }
 
  1315             }
 
  1255             break;
 
  1316             break;
 
  1299 QRect QHbStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
 
  1360 QRect QHbStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
 
  1300 {
 
  1361 {
 
  1301     const QRect baseSize = QCommonStyle::subElementRect(element, option, widget);
 
  1362     const QRect baseSize = QCommonStyle::subElementRect(element, option, widget);
 
  1302     QRect elementSize = baseSize;
 
  1363     QRect elementSize = baseSize;
 
  1303     switch (element) {
 
  1364     switch (element) {
 
       
  1365         case SE_LineEditContents: {
 
       
  1366             qreal metric = 0;
 
       
  1367             m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metric);
 
       
  1368             const int metricValue = metric + 0.5;
 
       
  1369             elementSize = visualRect(
 
       
  1370                 option->direction, option->rect, option->rect.adjusted(metricValue, 0, 0, 0));
 
       
  1371             }
 
       
  1372             break;
 
  1304         case SE_ItemViewItemText: {
 
  1373         case SE_ItemViewItemText: {
 
  1305             if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 
  1374             if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 
  1306                 elementSize = menuItem->rect;
 
  1375                 elementSize = menuItem->rect;
 
  1307                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
 
  1376                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
 
  1308                 const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
 
  1377                 const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
 
  1314                 totalXMod += indicatorSpacing;
 
  1383                 totalXMod += indicatorSpacing;
 
  1315                 elementSize.translate(totalXMod, 0);
 
  1384                 elementSize.translate(totalXMod, 0);
 
  1316                 elementSize.setWidth(menuItem->rect.width() - widthMod);
 
  1385                 elementSize.setWidth(menuItem->rect.width() - widthMod);
 
  1317             } else if (const QStyleOptionViewItemV4 *itemView = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
 
  1386             } else if (const QStyleOptionViewItemV4 *itemView = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
 
  1318                 elementSize = itemView->rect;
 
  1387                 elementSize = itemView->rect;
 
  1319                 const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
 
  1388                 if (itemView->decorationPosition == QStyleOptionViewItem::Left ||
 
  1320                 const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
 
  1389                     itemView->decorationPosition == QStyleOptionViewItem::Right) {
 
  1321                 const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
 
  1390                     const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
 
  1322                 int totalXMod = qMax(0, qMax((checkBoxRect.isValid() ? checkBoxRect.topRight().x() : 0),
 
  1391                     const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
 
  1323                                      (iconRect.isValid() ? iconRect.topRight().x() : 0)));
 
  1392                     const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
 
  1324                 const int widthMod = checkBoxRect.width() + iconRect.width() + indicatorSpacing;
 
  1393                     int totalXMod = qMax(0, qMax((checkBoxRect.isValid() ? checkBoxRect.topRight().x() : 0),
 
  1325                 totalXMod = (itemView->direction == Qt::LeftToRight) ? qMax(0, totalXMod - elementSize.topLeft().x()): 0;
 
  1394                                          (iconRect.isValid() ? iconRect.topRight().x() : 0)));
 
  1326                 totalXMod += indicatorSpacing;
 
  1395                     const int widthMod = checkBoxRect.width() + iconRect.width() + indicatorSpacing;
 
  1327                 elementSize.translate(totalXMod, 0);
 
  1396                     totalXMod = (itemView->direction == Qt::LeftToRight) ? qMax(0, totalXMod - elementSize.topLeft().x()): 0;
 
  1328                 elementSize.setWidth(itemView->rect.width() - widthMod);
 
  1397                     totalXMod += indicatorSpacing;
 
  1329                 elementSize = visualRect(itemView->direction, itemView->rect, elementSize);
 
  1398                     elementSize.translate(totalXMod, 0);
 
       
  1399                     elementSize.setWidth(itemView->rect.width() - widthMod);
 
       
  1400                     elementSize = visualRect(itemView->direction, itemView->rect, elementSize);
 
       
  1401                 } else {
 
       
  1402                     const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
 
       
  1403                     const bool decoratorOnTop = (itemView->decorationPosition == QStyleOptionViewItem::Top);
 
       
  1404                     if (decoratorOnTop)
 
       
  1405                         elementSize.translate(0, iconRect.height());
 
       
  1406                     else
 
       
  1407                         elementSize.translate(0, -iconRect.height());
 
       
  1408                 }
 
  1330             }
 
  1409             }
 
  1331             break;
 
  1410             break;
 
  1332         }
 
  1411         }
 
  1333         case SE_ViewItemCheckIndicator: {
 
  1412         case SE_ViewItemCheckIndicator: {
 
  1334             if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 
  1413             if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
 
  1421                    }
 
  1500                    }
 
  1422                     case SC_ComboBoxFrame: {
 
  1501                     case SC_ComboBoxFrame: {
 
  1423                         QRect frameRect = QRect(cmb->rect);
 
  1502                         QRect frameRect = QRect(cmb->rect);
 
  1424                         int frameWidth = pixelMetric(PM_DefaultFrameWidth, cmb, widget);
 
  1503                         int frameWidth = pixelMetric(PM_DefaultFrameWidth, cmb, widget);
 
  1425                         int maxRight = cmb->rect.height() - 2 * frameWidth;
 
  1504                         int maxRight = cmb->rect.height() - 2 * frameWidth;
 
  1426                         frameRect.adjust(0, 0, -maxRight, 0);
 
  1505                         if(cmb->direction == Qt::RightToLeft) {
 
       
  1506                             frameRect.adjust(+ 0.25 * buttonWidth, 0, -0.25 * buttonWidth, 0);
 
       
  1507                         }else{
 
       
  1508                             frameRect.adjust(0, 0, -maxRight-4, 0);
 
       
  1509                         }
 
  1427                         elementSize = frameRect;
 
  1510                         elementSize = frameRect;
 
  1428                         break;
 
  1511                         break;
 
  1429                     }
 
  1512                     }
 
  1430                     case SC_ComboBoxEditField: {
 
  1513                     case SC_ComboBoxEditField: {
 
  1431                         const int withFrameX = cmb->rect.x() + cmb->rect.width() - frameThickness - buttonSize.width();
 
  1514                         int withFrameX = 0;
 
       
  1515                         int offSet = 0;
 
       
  1516                         if(cmb->direction == Qt::RightToLeft) {
 
       
  1517                             withFrameX = cmb->rect.x() + cmb->rect.width() - frameThickness;
 
       
  1518                             offSet = buttonWidth;
 
       
  1519                         }
 
       
  1520                         else{
 
       
  1521                             withFrameX = cmb->rect.x() + cmb->rect.width() - frameThickness - buttonSize.width();
 
       
  1522                         }
 
  1432                         elementSize = QRect(
 
  1523                         elementSize = QRect(
 
  1433                             frameThickness,
 
  1524                             frameThickness + offSet,
 
  1434                             frameThickness - 2,
 
  1525                             frameThickness - 2,
 
  1435                             withFrameX - frameThickness,
 
  1526                             withFrameX - frameThickness - offSet,
 
  1436                             cmb->rect.height() - 2 * frameThickness );
 
  1527                             cmb->rect.height() - 2 * frameThickness );
 
  1437                         break;
 
  1528                         break;
 
  1438                     }
 
  1529                     }
 
  1439                     case SC_ComboBoxListBoxPopup: {
 
  1530                     case SC_ComboBoxListBoxPopup: {
 
  1440                         QRect mover = cmb->rect;
 
  1531                         QRect mover = cmb->rect;
 
  1646 #endif //QT_NO_SLIDER
 
  1737 #endif //QT_NO_SLIDER
 
  1647 #ifndef QT_NO_SPINBOX
 
  1738 #ifndef QT_NO_SPINBOX
 
  1648         case CC_SpinBox: {
 
  1739         case CC_SpinBox: {
 
  1649             if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
 
  1740             if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
 
  1650                 const int buttonIconSize = pixelMetric(PM_ButtonIconSize);
 
  1741                 const int buttonIconSize = pixelMetric(PM_ButtonIconSize);
 
  1651                 const int buttonWidth = qMax(spinbox->rect.height(), buttonIconSize);
 
  1742                 // Spinbox buttons should be no larger than one fourth of total width.
 
       
  1743                 const int maxSize = qMax(spinbox->rect.width() / 4, buttonIconSize + 4); //@magic
 
       
  1744                 QSize buttonSize;
 
       
  1745                 buttonSize.setHeight(qMin(maxSize, qMax(8, spinbox->rect.height())));
 
       
  1746                 buttonSize.setWidth(buttonSize.height()); //make buttons square
 
       
  1747 
  1652                 switch (sc) {
 
  1748                 switch (sc) {
 
  1653                     case SC_SpinBoxFrame:
 
  1749                     case SC_SpinBoxFrame:
 
  1654                          elementSize = option->rect.adjusted(0, 0, -buttonWidth + 5, 0);
 
  1750                          elementSize = option->rect.adjusted(0, 0, -buttonSize.width() + 5, 0); //@magic
 
  1655                          break;
 
  1751                          break;
 
  1656                     case SC_SpinBoxDown: {
 
  1752                     case SC_SpinBoxDown: {
 
  1657                         if (option->direction == Qt::RightToLeft)
 
  1753                         if (option->direction == Qt::RightToLeft)
 
  1658                             elementSize = QRect(option->rect.right() - buttonWidth, option->rect.y(),buttonWidth, option->rect.height());
 
  1754                             elementSize = QRect(option->rect.right() - buttonSize.width(), option->rect.y(), buttonSize.width(), option->rect.height());
 
  1659                         else
 
  1755                         else
 
  1660                             elementSize = QRect( option->rect.x(), option->rect.y(), buttonWidth,option->rect.height());
 
  1756                             elementSize = QRect(option->rect.x(), option->rect.y(), buttonSize.width(), option->rect.height());
 
  1661                     }
 
  1757                     }
 
  1662                     break;
 
  1758                     break;
 
  1663                     case SC_SpinBoxUp: {
 
  1759                     case SC_SpinBoxUp: {
 
  1664                         if (option->direction == Qt::RightToLeft)
 
  1760                         if (option->direction == Qt::RightToLeft)
 
  1665                             elementSize = QRect( option->rect.x(), option->rect.y(), buttonWidth,option->rect.height());
 
  1761                             elementSize = QRect(option->rect.x(), option->rect.y(), buttonSize.width(), option->rect.height());
 
  1666                         else
 
  1762                         else
 
  1667                             elementSize = QRect(option->rect.right() - buttonWidth,option->rect.y(),buttonWidth,option->rect.height());
 
  1763                             elementSize = QRect(option->rect.right() - buttonSize.width(), option->rect.y(), buttonSize.width(), option->rect.height());
 
  1668                     }
 
  1764                     }
 
  1669                     break;
 
  1765                     break;
 
  1670                     case SC_SpinBoxEditField:
 
  1766                     case SC_SpinBoxEditField:
 
  1671                         elementSize = option->rect.adjusted(buttonWidth, 0, -buttonWidth, 0);
 
  1767                         elementSize = option->rect.adjusted(buttonSize.width(), 0, -buttonSize.width(), 0);
 
  1672                         break;
 
  1768                         break;
 
  1673                     default:
 
  1769                     default:
 
  1674                         break;
 
  1770                         break;
 
  1675                  }
 
  1771                  }
 
  1676              }
 
  1772              }
 
  2193     return QCommonStyle::standardPixmap(standardPixmap, option, widget);
 
  2289     return QCommonStyle::standardPixmap(standardPixmap, option, widget);
 
  2194 }
 
  2290 }
 
  2195 
  2291 
  2196 void QHbStyle::polish(QWidget *widget)
 
  2292 void QHbStyle::polish(QWidget *widget)
 
  2197 {
 
  2293 {
 
       
  2294     QCommonStyle::polish(widget);
 
       
  2295 
  2198     if (!widget)
 
  2296     if (!widget)
 
  2199         return;
 
  2297         return;
 
  2200 
  2298 
  2201     if (false
 
  2299     if (false
 
  2202 #ifndef QT_NO_SCROLLBAR
 
  2300 #ifndef QT_NO_SCROLLBAR
 
  2209     if (m_private->isDialog(widget)) {
 
  2307     if (m_private->isDialog(widget)) {
 
  2210         widget->setAttribute(Qt::WA_StyledBackground);
 
  2308         widget->setAttribute(Qt::WA_StyledBackground);
 
  2211     }
 
  2309     }
 
  2212 
  2310 
  2213     m_private->polishFont(widget);
 
  2311     m_private->polishFont(widget);
 
  2214 
  2312     m_private->polishPalette(widget);
 
  2215     QCommonStyle::polish(widget);
 
       
  2216 
  2313 
  2217 #ifndef QT_NO_PROGRESSBAR
 
  2314 #ifndef QT_NO_PROGRESSBAR
 
  2218     if (qobject_cast<QProgressBar *>(widget))
 
  2315     if (qobject_cast<QProgressBar *>(widget))
 
  2219         widget->installEventFilter(this);
 
  2316         widget->installEventFilter(this);
 
  2220 #endif
 
  2317 #endif
 
  2226 }
 
  2323 }
 
  2227 
  2324 
  2228 void QHbStyle::polish(QPalette &palette)
 
  2325 void QHbStyle::polish(QPalette &palette)
 
  2229 {
 
  2326 {
 
  2230     QCommonStyle::polish(palette);
 
  2327     QCommonStyle::polish(palette);
 
  2231 
       
  2232     palette.setBrush(QPalette::Disabled, QPalette::WindowText, QColor(QRgb(0xff808080)));
 
       
  2233     palette.setBrush(QPalette::Disabled, QPalette::Button, QColor(QRgb(0xffdddfe4)));
 
       
  2234     palette.setBrush(QPalette::Disabled, QPalette::Light, QColor(QRgb(0xffffffff)));
 
       
  2235     palette.setBrush(QPalette::Disabled, QPalette::Midlight, QColor(QRgb(0xffffffff)));
 
       
  2236     palette.setBrush(QPalette::Disabled, QPalette::Dark, QColor(QRgb(0xff555555)));
 
       
  2237     palette.setBrush(QPalette::Disabled, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
 
       
  2238     palette.setBrush(QPalette::Disabled, QPalette::Text, QColor(QRgb(0xffc7c7c7)));
 
       
  2239     palette.setBrush(QPalette::Disabled, QPalette::BrightText, QColor(QRgb(0xffffffff)));
 
       
  2240     palette.setBrush(QPalette::Disabled, QPalette::ButtonText, QColor(QRgb(0xff808080)));
 
       
  2241     palette.setBrush(QPalette::Disabled, QPalette::Base, QColor(QRgb(0xffefefef)));
 
       
  2242     palette.setBrush(QPalette::Disabled, QPalette::AlternateBase, palette.color(QPalette::Disabled, QPalette::Base).darker(110));
 
       
  2243     palette.setBrush(QPalette::Disabled, QPalette::Window, QColor(QRgb(0xffefefef)));
 
       
  2244     palette.setBrush(QPalette::Disabled, QPalette::Shadow, QColor(QRgb(0xff000000)));
 
       
  2245     palette.setBrush(QPalette::Disabled, QPalette::Highlight, QColor(QRgb(0xff567594)));
 
       
  2246     palette.setBrush(QPalette::Disabled, QPalette::HighlightedText, QColor(QRgb(0xffffffff)));
 
       
  2247     palette.setBrush(QPalette::Disabled, QPalette::Link, QColor(QRgb(0xff0000ee)));
 
       
  2248     palette.setBrush(QPalette::Disabled, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
 
       
  2249     palette.setBrush(QPalette::Disabled, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
 
       
  2250     palette.setBrush(QPalette::Disabled, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
 
       
  2251 
       
  2252     palette.setBrush(QPalette::Active, QPalette::WindowText, QColor(QRgb(0xff000000)));
 
       
  2253     palette.setBrush(QPalette::Active, QPalette::Button, QColor(QRgb(0xffdddfe4)));
 
       
  2254     palette.setBrush(QPalette::Active, QPalette::Light, QColor(QRgb(0xffffffff)));
 
       
  2255     palette.setBrush(QPalette::Active, QPalette::Midlight, QColor(QRgb(0xffffffff)));
 
       
  2256     palette.setBrush(QPalette::Active, QPalette::Dark, QColor(QRgb(0xff555555)));
 
       
  2257     palette.setBrush(QPalette::Active, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
 
       
  2258     palette.setBrush(QPalette::Active, QPalette::Text, QColor(QRgb(0xff000000)));
 
       
  2259     palette.setBrush(QPalette::Active, QPalette::BrightText, QColor(QRgb(0xffffffff)));
 
       
  2260     palette.setBrush(QPalette::Active, QPalette::ButtonText, QColor(QRgb(0xff000000)));
 
       
  2261     palette.setBrush(QPalette::Active, QPalette::Base, QColor(QRgb(0xE4E4E4)));
 
       
  2262     palette.setBrush(QPalette::Active, QPalette::AlternateBase, palette.color(QPalette::Active, QPalette::Base).darker(110));
 
       
  2263     palette.setBrush(QPalette::Active, QPalette::Window, QColor(QRgb(0xffefefef)));
 
       
  2264     palette.setBrush(QPalette::Active, QPalette::Shadow, QColor(QRgb(0xff000000)));
 
       
  2265     palette.setBrush(QPalette::Active, QPalette::Highlight, QColor(QRgb(0xffE4E4E4)));
 
       
  2266     palette.setBrush(QPalette::Active, QPalette::HighlightedText, QColor(QRgb(0xff000000)));
 
       
  2267     palette.setBrush(QPalette::Active, QPalette::Link, QColor(QRgb(0xff0000ee)));
 
       
  2268     palette.setBrush(QPalette::Active, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
 
       
  2269     palette.setBrush(QPalette::Active, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
 
       
  2270     palette.setBrush(QPalette::Active, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
 
       
  2271 
       
  2272     palette.setBrush(QPalette::Inactive, QPalette::WindowText, QColor(QRgb(0xff000000)));
 
       
  2273     palette.setBrush(QPalette::Inactive, QPalette::Button, QColor(QRgb(0xffdddfe4)));
 
       
  2274     palette.setBrush(QPalette::Inactive, QPalette::Light, QColor(QRgb(0xffffffff)));
 
       
  2275     palette.setBrush(QPalette::Inactive, QPalette::Midlight, QColor(QRgb(0xffffffff)));
 
       
  2276     palette.setBrush(QPalette::Inactive, QPalette::Dark, QColor(QRgb(0xff555555)));
 
       
  2277     palette.setBrush(QPalette::Inactive, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
 
       
  2278     palette.setBrush(QPalette::Inactive, QPalette::Text, QColor(QRgb(0xff000000)));
 
       
  2279     palette.setBrush(QPalette::Inactive, QPalette::BrightText, QColor(QRgb(0xffffffff)));
 
       
  2280     palette.setBrush(QPalette::Inactive, QPalette::ButtonText, QColor(QRgb(0xff000000)));
 
       
  2281     palette.setBrush(QPalette::Inactive, QPalette::Base, QColor(QRgb(0xffffffff)));
 
       
  2282     palette.setBrush(QPalette::Inactive, QPalette::AlternateBase, palette.color(QPalette::Inactive, QPalette::Base).darker(110));
 
       
  2283     palette.setBrush(QPalette::Inactive, QPalette::Window, QColor(QRgb(0xffefefef)));
 
       
  2284     palette.setBrush(QPalette::Inactive, QPalette::Shadow, QColor(QRgb(0xff000000)));
 
       
  2285     palette.setBrush(QPalette::Inactive, QPalette::Highlight, QColor(QRgb(0xff678db2)));
 
       
  2286     palette.setBrush(QPalette::Inactive, QPalette::HighlightedText, QColor(QRgb(0xffffffff)));
 
       
  2287     palette.setBrush(QPalette::Inactive, QPalette::Link, QColor(QRgb(0xff0000ee)));
 
       
  2288     palette.setBrush(QPalette::Inactive, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
 
       
  2289     palette.setBrush(QPalette::Inactive, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
 
       
  2290     palette.setBrush(QPalette::Inactive, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
 
       
  2291 }
 
  2328 }
 
  2292 
  2329 
  2293 void QHbStyle::unpolish(QWidget *widget)
 
  2330 void QHbStyle::unpolish(QWidget *widget)
 
  2294 {
 
  2331 {
 
  2295     if (!widget)
 
  2332     if (!widget)
 
  2389         }
 
  2426         }
 
  2390         case SP_TrashIcon: {
 
  2427         case SP_TrashIcon: {
 
  2391             break;
 
  2428             break;
 
  2392         }
 
  2429         }
 
  2393         case SP_ComputerIcon: {
 
  2430         case SP_ComputerIcon: {
 
  2394             iconName = QLatin1String("qtg_mono_mobile");
 
  2431             iconName = QLatin1String("qtg_small_mobile");
 
  2395             break;
 
  2432             break;
 
  2396         }
 
  2433         }
 
  2397         case SP_DriveFDIcon: {
 
  2434         case SP_DriveFDIcon:
 
  2398             break;
 
  2435         case SP_DriveHDIcon:
 
  2399         }
 
  2436         case SP_DriveCDIcon:
 
  2400         case SP_DriveHDIcon: {
 
       
  2401             break;
 
       
  2402         }
 
       
  2403         case SP_DriveCDIcon: {
 
       
  2404             break;
 
       
  2405         }
 
       
  2406         case SP_DriveDVDIcon: {
 
  2437         case SP_DriveDVDIcon: {
 
       
  2438             iconName = QLatin1String("qtg_large_mmc");
 
  2407             break;
 
  2439             break;
 
  2408         }
 
  2440         }
 
  2409         case SP_DriveNetIcon: {
 
  2441         case SP_DriveNetIcon: {
 
  2410             break;
 
  2442             break;
 
  2411         }
 
  2443         }
 
  2417         }
 
  2449         }
 
  2418         case SP_DirLinkIcon: {
 
  2450         case SP_DirLinkIcon: {
 
  2419             break;
 
  2451             break;
 
  2420         }
 
  2452         }
 
  2421         case SP_FileIcon: {
 
  2453         case SP_FileIcon: {
 
       
  2454             iconName = QLatin1String("qtg_large_notes");
 
  2422             break;
 
  2455             break;
 
  2423         }
 
  2456         }
 
  2424         case SP_FileLinkIcon: {
 
  2457         case SP_FileLinkIcon: {
 
  2425             break;
 
  2458             break;
 
  2426         }
 
  2459         }
 
  2427         case SP_ToolBarHorizontalExtensionButton: {
 
  2460         case SP_ToolBarHorizontalExtensionButton: {
 
       
  2461             iconName = QLatin1String("qtg_mono_more");
 
  2428             break;
 
  2462             break;
 
  2429         }
 
  2463         }
 
  2430         case SP_ToolBarVerticalExtensionButton: {
 
  2464         case SP_ToolBarVerticalExtensionButton: {
 
       
  2465             iconName = QLatin1String("qtg_mono_more");
 
  2431             break;
 
  2466             break;
 
  2432         }
 
  2467         }
 
  2433         case SP_FileDialogStart: {
 
  2468         case SP_FileDialogStart: {
 
  2434             break;
 
  2469             break;
 
  2435         }
 
  2470         }
 
  2444         }
 
  2479         }
 
  2445         case SP_FileDialogDetailedView: {
 
  2480         case SP_FileDialogDetailedView: {
 
  2446             break;
 
  2481             break;
 
  2447         }
 
  2482         }
 
  2448         case SP_FileDialogInfoView: {
 
  2483         case SP_FileDialogInfoView: {
 
       
  2484             iconName = QLatin1String("qtg_large_info");
 
  2449             break;
 
  2485             break;
 
  2450         }
 
  2486         }
 
  2451         case SP_FileDialogContentsView: {
 
  2487         case SP_FileDialogContentsView: {
 
  2452             break;
 
  2488             break;
 
  2453         }
 
  2489         }
 
  2459         }
 
  2495         }
 
  2460         case SP_DirIcon: {
 
  2496         case SP_DirIcon: {
 
  2461             break;
 
  2497             break;
 
  2462         }
 
  2498         }
 
  2463         case SP_DialogOkButton: {
 
  2499         case SP_DialogOkButton: {
 
       
  2500             iconName = QLatin1String("qtg_large_ok");
 
  2464             break;
 
  2501             break;
 
  2465         }
 
  2502         }
 
  2466         case SP_DialogCancelButton: {
 
  2503         case SP_DialogCancelButton: {
 
  2467             break;
 
  2504             break;
 
  2468         }
 
  2505         }
 
  2469         case SP_DialogHelpButton: {
 
  2506         case SP_DialogHelpButton: {
 
       
  2507             iconName = QLatin1String("qtg_large_help");
 
  2470             break;
 
  2508             break;
 
  2471         }
 
  2509         }
 
  2472         case SP_DialogOpenButton: {
 
  2510         case SP_DialogOpenButton: {
 
  2473             break;
 
  2511             break;
 
  2474         }
 
  2512         }
 
  2477         }
 
  2515         }
 
  2478         case SP_DialogCloseButton: {
 
  2516         case SP_DialogCloseButton: {
 
  2479             break;
 
  2517             break;
 
  2480         }
 
  2518         }
 
  2481         case SP_DialogApplyButton: {
 
  2519         case SP_DialogApplyButton: {
 
       
  2520             iconName = QLatin1String("qtg_large_ok");
 
  2482             break;
 
  2521             break;
 
  2483         }
 
  2522         }
 
  2484         case SP_DialogResetButton: {
 
  2523         case SP_DialogResetButton: {
 
  2485             break;
 
  2524             break;
 
  2486         }
 
  2525         }
 
  2487         case SP_DialogDiscardButton: {
 
  2526         case SP_DialogDiscardButton: {
 
       
  2527             iconName = QLatin1String("qtg_small_fail");
 
  2488             break;
 
  2528             break;
 
  2489         }
 
  2529         }
 
  2490         case SP_DialogYesButton: {
 
  2530         case SP_DialogYesButton: {
 
  2491             break;
 
  2531             break;
 
  2492         }
 
  2532         }
 
  2562         }
 
  2602         }
 
  2563     }
 
  2603     }
 
  2564 
  2604 
  2565     QIcon icon;
 
  2605     QIcon icon;
 
  2566     if (!iconName.isNull()) {
 
  2606     if (!iconName.isNull()) {
 
  2567         HbIcon* hbicon = q_check_ptr(new HbIcon(iconName));
 
  2607         HbIcon* hbicon = new HbIcon(iconName);
 
  2568         hbicon->setSize(iconRect.size());
 
  2608         hbicon->setSize(iconRect.size());
 
  2569         icon =  QIcon(hbicon->qicon());
 
  2609         icon =  QIcon(hbicon->qicon());
 
  2570         delete hbicon;
 
  2610         delete hbicon;
 
  2571     } else {
 
  2611     } else {
 
  2572         icon = QCommonStyle::standardIconImplementation(standardIcon, option, widget);
 
  2612         icon = QCommonStyle::standardIconImplementation(standardIcon, option, widget);
 
  2643                                  break;
 
  2683                                  break;
 
  2644                              }
 
  2684                              }
 
  2645                          }
 
  2685                          }
 
  2646                      }
 
  2686                      }
 
  2647                      if (!alreadyAnimated) {
 
  2687                      if (!alreadyAnimated) {
 
  2648                          QHbStyleAnimation* target = q_check_ptr(new QHbStyleAnimation(const_cast<QProgressBar*>(bar)));
 
  2688                          QHbStyleAnimation* target = new QHbStyleAnimation(const_cast<QProgressBar*>(bar));
 
  2649                          target->createAnimationIcon(CE_ProgressBarContents, bar->orientation());
 
  2689                          target->createAnimationIcon(CE_ProgressBarContents, bar->orientation());
 
  2650                          QPropertyAnimation* animation = q_check_ptr(new QPropertyAnimation(target, "point"));
 
  2690                          QPropertyAnimation* animation = new QPropertyAnimation(target, "point");
 
  2651                          animation->setLoopCount(-1); //run until stopped
 
  2691                          animation->setLoopCount(-1); //run until stopped
 
  2652                          const int chunk = pixelMetric(PM_ProgressBarChunkWidth, option, widget)-1;
 
  2692                          const int chunk = pixelMetric(PM_ProgressBarChunkWidth, option, widget)-1;
 
  2653                          if (bar->orientation()== Qt::Horizontal) {
 
  2693                          if (bar->orientation()== Qt::Horizontal) {
 
  2654                              if ((option->direction == Qt::LeftToRight) ^ const_cast<QProgressBar*>(bar)->invertedAppearance()) {
 
  2694                              if ((option->direction == Qt::LeftToRight) ^ const_cast<QProgressBar*>(bar)->invertedAppearance()) {
 
  2655                                  animation->setStartValue(bar->rect().topLeft());
 
  2695                                  animation->setStartValue(bar->rect().topLeft());
 
  2767             else
 
  2807             else
 
  2768                 iconName = QLatin1String("qtg_graf_devider_v_thin");
 
  2808                 iconName = QLatin1String("qtg_graf_devider_v_thin");
 
  2769             break;
 
  2809             break;
 
  2770         }
 
  2810         }
 
  2771         case SP_TreeViewExpanded: {
 
  2811         case SP_TreeViewExpanded: {
 
  2772             iconName = QLatin1String("qtg_small_hl_opened");
 
  2812             iconName = QLatin1String("qtg_small_expand");
 
  2773             break;
 
  2813             break;
 
  2774         }
 
  2814         }
 
  2775         case SP_TreeViewCollapsed: {
 
  2815         case SP_TreeViewCollapsed: {
 
  2776             iconName = QLatin1String("qtg_small_hl_closed");
 
  2816             iconName = QLatin1String("qtg_small_collapse");
 
  2777             break;
 
  2817             break;
 
  2778         }
 
  2818         }
 
  2779         case SP_SubMenuIndicator:
 
  2819         case SP_SubMenuIndicator:
 
  2780         default: {
 
  2820         default: {
 
  2781             return false;
 
  2821             return false;
 
  2782         }
 
  2822         }
 
  2783     }
 
  2823     }
 
  2784     if (!iconName.isNull() && !rect.isEmpty()) {
 
  2824     if (!iconName.isNull() && !rect.isEmpty()) {
 
  2785         HbIcon *icon = q_check_ptr(new HbIcon(iconName));
 
  2825         HbIcon *icon = new HbIcon(iconName);
 
  2786         icon->setSize(rect.size());
 
  2826         icon->setSize(rect.size());
 
  2787         if (color.spec() != QColor::Invalid)
 
  2827         if (color.spec() != QColor::Invalid)
 
  2788             icon->setColor(color);
 
  2828             icon->setColor(color);
 
  2789         if (state & SS_Mirrored)
 
  2829         if (state & SS_Mirrored)
 
  2790             icon->setMirroringMode(HbIcon::Forced);
 
  2830             icon->setMirroringMode(HbIcon::Forced);
 
  2807 
  2847 
  2808 bool QHbStylePrivate::drawMultiPartItem(MultiPartItem multiPart, QPainter *painter, const QRect &rect, ItemStates state)
 
  2848 bool QHbStylePrivate::drawMultiPartItem(MultiPartItem multiPart, QPainter *painter, const QRect &rect, ItemStates state)
 
  2809 {
 
  2849 {
 
  2810     //Q_Q(QHbStyle);
 
  2850     //Q_Q(QHbStyle);
 
  2811 
  2851 
  2812     if (!m_frameDrawer)
 
  2852     if (m_frameDrawer.isNull())
 
  2813         m_frameDrawer = q_check_ptr(new HbFrameDrawer());
 
  2853         m_frameDrawer.reset(new HbFrameDrawer());
 
  2814 
  2854 
  2815     HbFrameDrawer::FrameType frameType = HbFrameDrawer::Undefined;
 
  2855     HbFrameDrawer::FrameType frameType = HbFrameDrawer::Undefined;
 
  2816     QString frameName;
 
  2856     QString frameName;
 
  2817     qreal border = 0.0;
 
  2857     qreal border = 0.0;
 
  2818     HbIcon::MirroringMode mirrorMode = HbIcon::Default;
 
  2858     HbIcon::MirroringMode mirrorMode = HbIcon::Default;
 
  2856         case SM_GroupBoxTitle: {
 
  2896         case SM_GroupBoxTitle: {
 
  2857             frameName = QLatin1String("qtg_fr_groupbox");
 
  2897             frameName = QLatin1String("qtg_fr_groupbox");
 
  2858             frameType = HbFrameDrawer::NinePieces;
 
  2898             frameType = HbFrameDrawer::NinePieces;
 
  2859             break;
 
  2899             break;
 
  2860         }
 
  2900         }
 
  2861         case SM_ItemViewHighlight: {
 
       
  2862             frameName = QLatin1String("qtg_fr_list_highlight");
 
       
  2863             frameType = HbFrameDrawer::NinePieces;
 
       
  2864             break;
 
       
  2865         }
 
       
  2866         case SM_ItemViewItem: {
 
  2901         case SM_ItemViewItem: {
 
  2867             if (state & SS_Pressed)
 
  2902             if (state & SS_Pressed)
 
  2868                 frameName = QLatin1String("qtg_fr_list_pressed");
 
  2903                 frameName = QLatin1String("qtg_fr_list_pressed");
 
  2869             else if (state & SS_Focused)
 
  2904             else if (state & SS_Focused)
 
  2870                 frameName = QLatin1String("qtg_fr_list_highlight");
 
  2905                 frameName = QLatin1String("qtg_fr_list_highlight");
 
  2871             else
 
       
  2872                 frameName = QLatin1String("qtg_fr_list_normal");
 
       
  2873             frameType = HbFrameDrawer::NinePieces;
 
  2906             frameType = HbFrameDrawer::NinePieces;
 
  2874             styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
 
  2907             styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
 
  2875             break;
 
  2908             break;
 
  2876         }
 
  2909         }
 
       
  2910         case SM_TextEdit: //@todo: fallthrough for now, since no specific graphic for editors in releases
 
  2877         case SM_LineEdit: {
 
  2911         case SM_LineEdit: {
 
  2878             styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
 
  2912             styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
 
  2879             if (state & SS_Selected)
 
  2913             if (state & SS_Selected)
 
  2880                 frameName = QLatin1String("qtg_fr_editor_highlight");
 
  2914                 frameName = QLatin1String("qtg_fr_lineedit_highlight");
 
  2881             else
 
  2915             else
 
  2882                 frameName = QLatin1String("qtg_fr_editor_normal");
 
  2916                 frameName = QLatin1String("qtg_fr_lineedit_normal");
 
  2883             frameType = HbFrameDrawer::NinePieces;
 
  2917             frameType = HbFrameDrawer::NinePieces;
 
  2884             break;
 
  2918             break;
 
  2885         }
 
  2919         }
 
  2886         case SM_ListParent: {
 
  2920         case SM_ListParent: {
 
  2887             if (state & SS_Pressed)
 
  2921             if (state & SS_Pressed)
 
  2916                 frameName = QLatin1String("qtg_fr_popup_list_normal");
 
  2950                 frameName = QLatin1String("qtg_fr_popup_list_normal");
 
  2917             frameType = HbFrameDrawer::NinePieces;
 
  2951             frameType = HbFrameDrawer::NinePieces;
 
  2918             break;
 
  2952             break;
 
  2919         }
 
  2953         }
 
  2920         case SM_Panel: {
 
  2954         case SM_Panel: {
 
  2921             frameName = QLatin1String("qtg_fr_settingform");
 
  2955             frameName = QLatin1String("qtg_fr_groupbox_normal");
 
  2922             frameType = HbFrameDrawer::NinePieces;
 
  2956             frameType = HbFrameDrawer::NinePieces;
 
  2923             styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
 
  2957             styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
 
  2924             break;
 
  2958             break;
 
  2925         }
 
  2959         }
 
  2926         case SM_ProgressBarGroove: {
 
  2960         case SM_ProgressBarGroove: {
 
  2943                 frameName = QLatin1String("qtg_fr_progbar_v_filled");
 
  2977                 frameName = QLatin1String("qtg_fr_progbar_v_filled");
 
  2944                 frameType = HbFrameDrawer::ThreePiecesVertical;
 
  2978                 frameType = HbFrameDrawer::ThreePiecesVertical;
 
  2945             }
 
  2979             }
 
  2946             break;
 
  2980             break;
 
  2947         }
 
  2981         }
 
       
  2982         //@todo: enable separate graphic for texteditor. Graphic was not included in the wk12 release.
 
       
  2983         /*case SM_TextEdit: {
 
       
  2984             styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
 
       
  2985             if (state & SS_Selected)
 
       
  2986                 frameName = QLatin1String("qtg_fr_textedit_highlight");
 
       
  2987             else
 
       
  2988                 frameName = QLatin1String("qtg_fr_textedit_normal");
 
       
  2989             frameType = HbFrameDrawer::NinePieces;
 
       
  2990             break;
 
       
  2991         }*/
 
  2948         case SM_ToolButton: {
 
  2992         case SM_ToolButton: {
 
  2949             frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  2993             frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  2950             frameGraphicsHeader = QLatin1String("qtg_fr_tb_h_");
 
  2994             frameGraphicsHeader = QLatin1String("qtg_fr_tb_h_");
 
  2951 
  2995 
  2952             framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_cr");
 
  2996             framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_cr");
 
  3036                 } else {
 
  3080                 } else {
 
  3037                     frameName = QLatin1String("qtg_fr_slider_v_filled");
 
  3081                     frameName = QLatin1String("qtg_fr_slider_v_filled");
 
  3038                     frameType = HbFrameDrawer::ThreePiecesVertical;
 
  3082                     frameType = HbFrameDrawer::ThreePiecesVertical;
 
  3039                 }
 
  3083                 }
 
  3040             }
 
  3084             }
 
       
  3085             break;
 
       
  3086         }
 
       
  3087         case SM_TableItem: {
 
       
  3088             if (state & SS_Pressed)
 
       
  3089                 frameName = QLatin1String("qtg_fr_grid_pressed");
 
       
  3090             else if (state & SS_Focused)
 
       
  3091                 frameName = QLatin1String("qtg_fr_grid_highlight");
 
       
  3092             frameType = HbFrameDrawer::NinePieces;
 
       
  3093             styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
 
  3041             break;
 
  3094             break;
 
  3042         }
 
  3095         }
 
  3043         case SM_TabShape: {
 
  3096         case SM_TabShape: {
 
  3044             if (state & SS_Horizontal) {
 
  3097             if (state & SS_Horizontal) {
 
  3045                 frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  3098                 frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  3071                 frameGraphicsFooter = QLatin1String("pressed");
 
  3124                 frameGraphicsFooter = QLatin1String("pressed");
 
  3072             else if (state & SS_Selected)
 
  3125             else if (state & SS_Selected)
 
  3073                 frameGraphicsFooter = QLatin1String("highlight");
 
  3126                 frameGraphicsFooter = QLatin1String("highlight");
 
  3074             else
 
  3127             else
 
  3075                 frameGraphicsFooter = QLatin1String("normal");
 
  3128                 frameGraphicsFooter = QLatin1String("normal");
 
  3076             break;
 
       
  3077         }
 
       
  3078         case SM_TextEdit: { //@todo: combine this and  case SM_LineEdit to "case SM_TextEditor"?
 
       
  3079             styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
 
       
  3080             frameName = QLatin1String("qtg_fr_editor");
 
       
  3081             frameType = HbFrameDrawer::NinePieces;
 
       
  3082             break;
 
  3129             break;
 
  3083         }
 
  3130         }
 
  3084         case SM_ToolBarButton: {
 
  3131         case SM_ToolBarButton: {
 
  3085             if (state & SS_Horizontal) {
 
  3132             if (state & SS_Horizontal) {
 
  3086                 frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  3133                 frameType = HbFrameDrawer::ThreePiecesHorizontal;
 
  3108                     frameName = QLatin1String("qtg_fr_tb_v_normal");
 
  3155                     frameName = QLatin1String("qtg_fr_tb_v_normal");
 
  3109             }
 
  3156             }
 
  3110             styleManager()->parameter(QLatin1String("hb-param-background-button"), border);
 
  3157             styleManager()->parameter(QLatin1String("hb-param-background-button"), border);
 
  3111             break;
 
  3158             break;
 
  3112         }
 
  3159         }
 
       
  3160         case SM_ToolBarExtension:{
 
       
  3161 //            fillRect = true;
 
       
  3162 //            styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
 
       
  3163             frameName = QLatin1String("qtg_fr_tb_ext");
 
       
  3164             frameType = HbFrameDrawer::NinePieces;
 
       
  3165             }
 
       
  3166             break;
 
  3113         case SM_ToolTip: {
 
  3167         case SM_ToolTip: {
 
  3114             fillRect = true;
 
  3168             fillRect = true;
 
  3115             frameType = HbFrameDrawer::NinePieces;
 
  3169             frameType = HbFrameDrawer::NinePieces;
 
  3116             frameName = QLatin1String("qtg_fr_popup_preview");
 
  3170             frameName = QLatin1String("qtg_fr_popup_preview");
 
  3117             break;
 
  3171             break;
 
  3118         }
 
  3172         }
 
  3119         case SM_HeaderItem:
 
  3173         case SM_HeaderItem:
 
  3120         case SM_TableItem:
 
       
  3121         case SM_ThemeBackground:
 
  3174         case SM_ThemeBackground:
 
  3122         case SM_ToolBar:
 
  3175         case SM_ToolBar:
 
  3123         default: {
 
  3176         default: {
 
  3124             break;
 
  3177             break;
 
  3125         }
 
  3178         }
 
  3275         ) {
 
  3328         ) {
 
  3276         fontRole = HbFontSpec::Secondary;
 
  3329         fontRole = HbFontSpec::Secondary;
 
  3277         valueFound = styleManager()->parameter(QLatin1String("hb-param-text-height-tiny"), fontSize);
 
  3330         valueFound = styleManager()->parameter(QLatin1String("hb-param-text-height-tiny"), fontSize);
 
  3278     }
 
  3331     }
 
  3279 
  3332 
  3280     HbFontSpec *fontSpec = q_check_ptr(new HbFontSpec(fontRole));
 
  3333     HbFontSpec *fontSpec = new HbFontSpec(fontRole);
 
  3281     if (valueFound) {
 
  3334     if (valueFound) {
 
  3282         fontSpec->setTextHeight(fontSize);
 
  3335         fontSpec->setTextHeight(fontSize);
 
  3283         QFont widgetFont = fontSpec->font();
 
  3336         QFont widgetFont = fontSpec->font();
 
  3284         widgetFont.setPixelSize(fontSpec->font().pixelSize());
 
  3337         widgetFont.setPixelSize(fontSpec->font().pixelSize());
 
  3285         widget->setFont(widgetFont);
 
  3338         widget->setFont(widgetFont);
 
  3286     }
 
  3339     }
 
  3287     delete fontSpec;
 
  3340     delete fontSpec;
 
  3288 }
 
  3341 }
 
  3289 
  3342 
       
  3343 void QHbStylePrivate::polishPalette(QWidget *widget)
 
       
  3344 {
 
       
  3345     QPalette widgetPalette = widget->palette();
 
       
  3346     if (false
 
       
  3347 #ifndef QT_NO_TEXTEDIT
 
       
  3348         || qobject_cast<QTextEdit *>(widget)
 
       
  3349 #endif
 
       
  3350     ) {
 
       
  3351         widgetPalette.setColor(QPalette::Active, QPalette::Highlight, HbColorScheme::color("qtc_lineedit_marker_normal"));
 
       
  3352         widgetPalette.setColor(QPalette::Active, QPalette::HighlightedText, HbColorScheme::color("qtc_lineedit_selected"));
 
       
  3353         widgetPalette.setColor(QPalette::Active, QPalette::Text, HbColorScheme::color("qtc_lineedit_normal"));
 
       
  3354         //QTextEdits have specific graphic in QHbStyle for background
 
       
  3355         widgetPalette.setColor(QPalette::Active, QPalette::Base, Qt::transparent);
 
       
  3356     } else if (false
 
       
  3357 #ifndef QT_NO_LINEEDIT
 
       
  3358         || qobject_cast<QLineEdit *>(widget)
 
       
  3359 #endif
 
       
  3360         ) {
 
       
  3361         widgetPalette.setColor(QPalette::Active, QPalette::Highlight, HbColorScheme::color("qtc_lineedit_marker_normal"));
 
       
  3362         widgetPalette.setColor(QPalette::Active, QPalette::HighlightedText, HbColorScheme::color("qtc_lineedit_selected"));
 
       
  3363         widgetPalette.setColor(QPalette::Active, QPalette::Text, HbColorScheme::color("qtc_lineedit_normal"));
 
       
  3364     }
 
       
  3365     widget->setPalette(widgetPalette);
 
       
  3366 }
 
       
  3367 
  3290 QT_END_NAMESPACE
 
  3368 QT_END_NAMESPACE
FCL/sf/mw/qtextensions