--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qhbstyle/qhbstyle.cpp Mon May 03 13:18:40 2010 +0300
@@ -0,0 +1,3290 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Lesser General Public License as published by
+* the Free Software Foundation, version 2.1 of the License.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program. If not,
+* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
+*
+* Description:
+*
+*/
+//Qt includes
+#include <qapplication.h>
+#include <qpainter.h>
+#include <qstyleoption.h>
+#include <qevent.h>
+#include <qdebug.h>
+
+//Qt widgets
+#include <QtGui/qgroupbox.h>
+#include <QtGui/qheaderview.h>
+#include <QtGui/qlistwidget.h>
+#include <QtGui/qlistview.h>
+#include <QtGui/qpushbutton.h>
+#include <QtGui/qscrollbar.h>
+#include <QtGui/qtabbar.h>
+#include <QtGui/qtableview.h>
+#include <QtGui/qtablewidget.h>
+#include <QtGui/qtreeview.h>
+#include <QtGui/qtreewidget.h>
+#include <QtGui/qtextedit.h>
+#include <QtGui/qtoolbar.h>
+#include <QtGui/qtoolbutton.h>
+#include <QtGui/qradiobutton.h>
+#include <QtGui/qcheckbox.h>
+#include <QtGui/qprogressbar.h>
+#include <QtGui/qcombobox.h>
+#include <QtGui/qspinbox.h>
+#include <QtGui/qlineedit.h>
+
+//Animation
+#include <QParallelAnimationGroup>
+#include <QPropertyAnimation>
+#include <QTime>
+
+//Hb includes
+#include <hbinstance.h>
+#include <hbicon.h>
+#include <hbframedrawer.h>
+#include <hbstyle.h>
+#include <hbcolorscheme.h>
+#include <hbfontspec.h>
+
+#include "qhbstyle.h"
+#include "qhbstyle_p.h"
+#include "qhbstyleanimation.h"
+
+QT_BEGIN_NAMESPACE
+
+QHbStylePrivate::QHbStylePrivate()
+{
+ m_frameDrawer = 0;
+ m_styleManager = 0;
+
+ m_animationGroup = q_check_ptr(new QParallelAnimationGroup());
+}
+
+QHbStylePrivate::~QHbStylePrivate()
+{
+ delete m_frameDrawer;
+ delete m_animationGroup;
+}
+
+HbStyle* QHbStylePrivate::styleManager()
+{
+ return m_styleManager;
+}
+
+void QHbStylePrivate::setStyleManager(HbStyle* style)
+{
+ Q_ASSERT(style);
+ m_styleManager = style;
+}
+
+QParallelAnimationGroup* QHbStylePrivate::animationGroup()
+{
+ return m_animationGroup;
+}
+
+/*!
+ \internal
+ */
+QHbStyle::QHbStyle() : QCommonStyle()
+{
+ m_private = new QHbStylePrivate();
+ HbInstance *instance = HbInstance::instance();
+
+ m_private->setStyleManager(instance->style());
+}
+
+/*!
+ \internal
+ */
+QHbStyle::~QHbStyle()
+{
+ delete m_private;
+}
+
+void QHbStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
+ QPainter *painter, const QWidget *widget) const
+{
+ switch (element) {
+ case PE_IndicatorViewItemCheck: {
+ if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ ItemStates state;
+ if (itemOption->state & State_Selected)
+ state |= SS_Selected;
+ m_private->drawItem(SP_ItemDecoration, painter, option->rect, state);
+ }
+ break;
+ }
+ case PE_IndicatorHeaderArrow: {
+ if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+ ItemStates state;
+ if (header->sortIndicator & QStyleOptionHeader::SortDown)
+ m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state|SS_Flipped));
+ else if (header->sortIndicator & QStyleOptionHeader::SortUp)
+ m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state));
+ }
+ break;
+ }
+ case PE_IndicatorBranch: {
+ if (option->state & State_Children) {
+ QRect indicatorRect = option->rect;
+ const int rectSide = proxy()->pixelMetric(PM_MenuButtonIndicator, option, widget);
+ indicatorRect = QRect(0, 0, rectSide, rectSide);
+ indicatorRect.moveCenter(option->rect.center());
+ if (option->state & State_Open)
+ m_private->drawItem(SP_TreeViewExpanded, painter, indicatorRect);
+ else
+ m_private->drawItem(SP_TreeViewCollapsed, painter, indicatorRect);
+ }
+ break;
+ }
+ case PE_PanelItemViewRow: {
+ if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ ItemStates state = SS_Active;
+ if (vopt->state & State_HasFocus)
+ state |= SS_Focused;
+ if (vopt->state & State_Sunken || vopt->state & State_Raised)
+ state |= SS_Pressed;
+#ifndef QT_NO_TREEVIEW
+ if (qobject_cast<const QTreeWidget*>(widget)) {
+ if (option->state & State_Children) {
+ m_private->drawMultiPartItem(SM_ListParent, painter, vopt->rect, state);
+ break;
+ }
+ }
+#endif
+ if (vopt->features & QStyleOptionViewItemV2::Alternate)
+ state |= SS_Alternate; //@todo: how?
+ m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);
+ }
+ break;
+ }
+ case PE_PanelItemViewItem: {
+ if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ ItemStates state = SS_Active;
+ if (vopt->state & State_HasFocus)
+ state |= SS_Focused;
+ if (vopt->state & State_Sunken || vopt->state & State_Raised)
+ state |= SS_Pressed;
+ m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);
+ }
+ break;
+ }
+ case PE_IndicatorArrowLeft:
+ case PE_IndicatorArrowRight:
+ case PE_IndicatorArrowUp:
+ case PE_IndicatorArrowDown: {
+ ItemStates state;
+ if (element == PE_IndicatorArrowRight)
+ state = SS_Right;
+ else if (element == PE_IndicatorArrowLeft)
+ state = SS_Left;
+ else if (element == PE_IndicatorArrowUp)
+ state = SS_Up;
+ else
+ state = SS_Down;
+ m_private->drawItem(SP_Arrow, painter, option->rect, state);
+ break;
+ }
+ case PE_PanelTipLabel: {
+ m_private->drawMultiPartItem(SM_ToolTip, painter, option->rect);
+ break;
+ }
+ case PE_Frame: {
+ if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {
+#ifndef QT_NO_TEXTEDIT
+ if (qobject_cast<const QTextEdit *>(widget))
+ m_private->drawMultiPartItem(SM_TextEdit, painter, frame->rect);
+#endif //QT_NO_TEXTEDIT
+ }
+ break;
+ }
+ case PE_FrameTabWidget: {
+ m_private->drawMultiPartItem(SM_Panel, painter, option->rect);
+ break;
+ }
+#ifndef QT_NO_LINEEDIT
+ case PE_PanelLineEdit: {
+#ifndef QT_NO_COMBOBOX
+ if (widget && qobject_cast<const QComboBox *>(widget->parentWidget()))
+ break;
+#endif
+#ifndef QT_NO_SPINBOX
+ if (widget && qobject_cast<const QSpinBox *>(widget->parentWidget()))
+ break;
+#endif
+ if (const QStyleOptionFrame *lineEdit = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
+ ItemStates state = (lineEdit->state & State_Enabled) ? SS_Active : SS_Inactive;
+ if (lineEdit->state & State_HasFocus)
+ state |= SS_Selected;
+ m_private->drawMultiPartItem(SM_LineEdit, painter, lineEdit->rect, state);
+ }
+ break;
+ }
+#endif // QT_NO_LINEEDIT
+ case PE_PanelButtonTool: {
+ if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
+ //draw button
+ const bool isDisabled = !(toolbutton->state & State_Enabled);
+ const bool isPressed = (toolbutton->state & State_Sunken) ||
+ (toolbutton->state & State_On);
+
+ // 'latched' is a checkable button that is pressed down
+ bool isLatched = false;
+#ifndef QT_NO_TOOLBUTTON
+ if (const QToolButton *toolButtonWidget = qobject_cast<const QToolButton*>(widget))
+ isLatched = toolButtonWidget->isCheckable() && isPressed;
+#endif
+ ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
+ if (isLatched)
+ state = state | SS_Latched;
+ else if (isPressed)
+ state = state | SS_Pressed;
+
+ if (toolbutton->state & State_Selected || toolbutton->state & State_HasFocus)
+ state = state | SS_Selected;
+#ifndef QT_NO_TOOLBAR
+ if (widget && !qobject_cast<const QToolBar*>(widget->parentWidget()))
+ m_private->drawMultiPartItem(SM_ToolButton, painter, toolbutton->rect, state);
+ else
+#endif
+ m_private->drawMultiPartItem(SM_ToolBarButton, painter, toolbutton->rect, state);
+ }
+ break;
+ }
+ case PE_IndicatorCheckBox: {
+ ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;
+ if (option->direction == Qt::RightToLeft) state |= SS_Mirrored;
+ m_private->drawItem(SP_CheckBoxIndicator, painter, option->rect, state);
+ break;
+ }
+ case PE_IndicatorRadioButton: {
+ const ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;
+ m_private->drawItem(SP_RadioButtonIndicator, painter, option->rect, state);
+ break;
+ }
+ case PE_FrameFocusRect: {
+ if (const QStyleOptionFocusRect *highlight = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
+ if (false
+#ifndef QT_NO_LISTVIEW
+ || qobject_cast<const QListWidget *>(widget)
+#endif
+#ifndef QT_NO_TABLEVIEW
+ || qobject_cast<const QTableWidget *>(widget)
+#endif
+#ifndef QT_NO_TREEVIEW
+ || qobject_cast<const QTreeWidget *>(widget)
+#endif
+ )
+ m_private->drawMultiPartItem(SM_ItemViewHighlight, painter, highlight->rect);
+ }
+ break;
+ }
+ case PE_FrameMenu: {
+ break;
+ }
+ case PE_PanelMenu: {
+ m_private->drawMultiPartItem(SM_Menu, painter, option->rect);
+ break;
+ }
+ case PE_Widget: {
+ if (m_private->isDialog(widget))
+ m_private->drawMultiPartItem(SM_Dialog, painter, option->rect);
+ break;
+ }
+ case PE_IndicatorMenuCheckMark: {
+ m_private->drawItem(SP_ItemDecoration, painter, option->rect);
+ break;
+ }
+ case PE_FrameGroupBox: {
+ ItemStates groupBoxStates;
+ if ((option->state & State_Sunken) || (option->state & State_Raised))
+ groupBoxStates |= SS_Pressed;
+ if (option->state & State_HasFocus)
+ groupBoxStates |= SS_Selected;
+ if (option->state & State_On)
+ groupBoxStates |= SS_Active;
+ else if (option->state & State_Off)
+ groupBoxStates |= SS_Inactive;
+ m_private->drawMultiPartItem(SM_GroupBox, painter, option->rect, groupBoxStates);
+ break;
+ }
+ // Qt3 primitives are not supported
+ case PE_Q3CheckListController:
+ case PE_Q3CheckListExclusiveIndicator:
+ case PE_Q3CheckListIndicator:
+ case PE_Q3DockWindowSeparator:
+ case PE_Q3Separator: {
+ Q_ASSERT(false);
+ break;
+ }
+ case PE_PanelScrollAreaCorner: //no corner for scroll area
+ case PE_IndicatorTabTear: // no tab tear in uiemo
+ case PE_PanelMenuBar: { //no panel menu in uiemo
+ break;
+ }
+ default: {
+ QCommonStyle::drawPrimitive(element, option, painter, widget);
+ break;
+ }
+ }
+}
+
+void QHbStyle::drawControl(ControlElement element, const QStyleOption *option,
+ QPainter *painter, const QWidget *widget) const
+{
+ switch (element) {
+ case CE_HeaderEmptyArea: {
+ const bool isHorizontal = (option->state & State_Horizontal);
+ ItemStates states = (isHorizontal) ? SS_Horizontal : ItemState(SS_Vertical);
+ if (!isHorizontal)
+ states |= (option->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;
+ m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);
+ break;
+ }
+ case CE_HeaderSection: {
+ if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {
+ //Draw corner button as normal pushButton.
+ if (qobject_cast<const QAbstractButton *>(widget)) {
+ QStyleOptionButton cornerButton;
+ cornerButton.initFrom(widget);
+ drawControl(CE_PushButtonBevel, &cornerButton, painter, widget);
+ } else {
+ const bool isVertical = (header->orientation == Qt::Vertical);
+ ItemStates states = (isVertical) ? SS_Vertical : ItemState(SS_Horizontal);
+ if (isVertical)
+ states |= (header->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;
+ m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);
+ }
+ }
+ break;
+ }
+ case CE_ItemViewItem: {
+ if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ const QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, itemOption, widget);
+ const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, itemOption, widget);
+ QRect textRect = subElementRect(SE_ItemViewItemText, itemOption, widget);
+
+ //background for list items (other itemviews use PE_PanelItemViewRow drawing)
+ if (qobject_cast<const QListWidget *>(widget))
+ proxy()->drawPrimitive(PE_PanelItemViewItem, itemOption, painter, widget);
+
+ //checkbox
+ if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator && checkRect.isValid()) {
+ QStyleOptionViewItemV4 checkOption;
+ checkOption.QStyleOption::operator=(*itemOption);
+ checkOption.rect = checkRect;
+ proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &checkOption, painter, widget);
+ }
+
+ //selection indication
+ if (itemOption->state & State_Selected) {
+ const QAbstractItemView *itemView = qobject_cast<const QAbstractItemView *>(widget);
+ if (itemView->selectionMode() != QAbstractItemView::SingleSelection) {
+ QStyleOptionViewItemV4 selectOption;
+ selectOption.QStyleOption::operator=(*itemOption);
+ int iconSize = 0;
+ if (m_private->hbParameter(QLatin1String("hb-param-graphic-size-secondary"), iconSize)) {
+ QRect selectRect = QRect(0, 0, iconSize, iconSize);
+ if (itemOption->direction == Qt::LeftToRight) {
+ //translate to end of text area and reduce text area
+ selectRect.translate(textRect.topRight().x() - selectRect.width(), textRect.topRight().y());
+ } else {
+ //translate to the beginning of textRect, move textRect to the right
+ selectRect.translate(textRect.topLeft().x(), textRect.topRight().y());
+ textRect.translate(selectRect.width(), 0);
+ }
+ textRect.setWidth(textRect.width() - selectRect.width());
+ selectOption.rect = selectRect;
+ proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &selectOption, painter, widget);
+ }
+ }
+ }
+
+ //text
+ if (itemOption->text.length() > 0) {
+ uint flags = Qt::AlignVCenter | Qt::TextShowMnemonic;
+ if (!proxy()->styleHint(SH_UnderlineShortcut, itemOption, widget))
+ flags |= Qt::TextHideMnemonic;
+
+ drawItemText(painter, textRect, flags, itemOption->palette, (itemOption->state & State_Enabled), itemOption->text);
+ }
+ //icon
+ if (!itemOption->icon.isNull()) {
+ QIcon::Mode mode = QIcon::Normal;
+ if (!(option->state & State_Enabled))
+ mode = QIcon::Disabled;
+ else if (option->state & State_Selected)
+ mode = QIcon::Selected;
+ QIcon::State state = itemOption->state & State_Open ? QIcon::On : QIcon::Off;
+ itemOption->icon.paint(painter, iconRect, itemOption->decorationAlignment, mode, state);
+ }
+ }
+ break;
+ }
+ case CE_ShapedFrame: {
+ if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {
+ const int frameShape = frame->frameShape;
+ const int lineWidth = frame->lineWidth;
+ const int midLineWidth = frame->midLineWidth;
+ QPalette::ColorRole foregroundRole = QPalette::WindowText;
+ int frameShadow = QFrame::Plain;
+ if (frame->state & State_Sunken)
+ frameShadow = QFrame::Sunken;
+ else if (frame->state & State_Raised)
+ frameShadow = QFrame::Raised;
+
+ switch (frameShape) {
+ case QFrame::Box:
+ case QFrame::WinPanel:
+ if (frameShadow == QFrame::Plain)
+ qDrawPlainRect(painter, frame->rect, frame->palette.color(foregroundRole), lineWidth);
+ else
+ qDrawShadeRect(painter, frame->rect, frame->palette, frameShadow == QFrame::Sunken, lineWidth, midLineWidth);
+ break;
+ case QFrame::StyledPanel:
+ if (widget)
+ widget->style()->drawPrimitive(PE_Frame, option, painter, widget);
+ else
+ proxy()->drawPrimitive(PE_Frame, option, painter, widget);
+ break;
+ case QFrame::Panel:
+ //@todo: support sunken / raised?
+ m_private->drawMultiPartItem(SM_Panel, painter, option->rect);
+ break;
+ case QFrame::HLine:
+ case QFrame::VLine: {
+ ItemStates states = (frameShape == QFrame::HLine) ? SS_Horizontal : SS_Vertical;
+ //@todo: support sunken / raised separators?
+ m_private->drawItem(SP_SeparatorLine, painter, frame->rect, states);
+ break;
+ }
+ }
+ }
+ break;
+ }
+#ifndef QT_NO_TABBAR
+ case CE_TabBarTab: {
+ if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
+ proxy()->drawControl(CE_TabBarTabShape, tab, painter, widget);
+ proxy()->drawControl(CE_TabBarTabLabel, tab, painter, widget);
+ }
+ break;
+ }
+ case CE_TabBarTabShape: {
+ if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {
+ ItemStates states = (tab->shape == QTabBar::TriangularSouth ||
+ tab->shape == QTabBar::RoundedSouth ||
+ tab->shape == QTabBar::TriangularNorth ||
+ tab->shape == QTabBar::RoundedNorth) ? SS_Horizontal : SS_Vertical;
+ if (tab->state & State_Selected)
+ states |= SS_Selected;
+ if (tab->state & State_Raised || tab->state & State_Sunken)
+ states |= SS_Pressed;
+ if (!(tab->state & State_Enabled))
+ states |= SS_Disabled;
+
+ if (tab->shape == QTabBar::RoundedSouth || tab->shape == QTabBar::TriangularSouth ||
+ tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::TriangularEast)
+ states |= SS_Flipped;
+
+ if (tab->direction == Qt::RightToLeft) states |= SS_Mirrored;
+
+ //Tab's position
+ if (tab->position == QStyleOptionTab::Beginning)
+ states |= (states & SS_Flipped) ? SS_End : SS_Beginning;
+ else if (tab->position == QStyleOptionTab::Middle)
+ states |= SS_Middle;
+ if (tab->position == QStyleOptionTab::End)
+ states |= (states & SS_Flipped) ? SS_Beginning : SS_End;
+
+ m_private->drawMultiPartItem(SM_TabShape, painter, tab->rect, states);
+ }
+ break;
+ }
+ case CE_TabBarTabLabel: {
+ if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(option)) {
+ const bool enabled = tab->state & State_Enabled;
+ const QPixmap icon = tab->icon.pixmap(proxy()->pixelMetric(PM_TabBarIconSize, tab, widget),
+ enabled ? QIcon::Normal : QIcon::Disabled);
+
+ const bool verticalTabs = tab->shape == QTabBar::RoundedEast
+ || tab->shape == QTabBar::RoundedWest
+ || tab->shape == QTabBar::TriangularEast
+ || tab->shape == QTabBar::TriangularWest;
+
+ QRect tr = tab->rect;
+ //add a small space so that text/icon does not start from the border
+ const int margin = proxy()->pixelMetric(PM_DefaultFrameWidth, tab, widget);
+ if (!verticalTabs)
+ tr.adjust(margin, 0, -margin, 0);
+ else
+ tr.adjust(0, margin, 0, -margin);
+
+ // Need to do rotation separately here, instead of in drawItem/drawMultiItemPart, since we want to rotate text as well.
+ if (verticalTabs) {
+ painter->save();
+ int newX, newY, newRotation;
+ if (tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::TriangularEast) {
+ newX = tr.width();
+ newY = tr.y();
+ newRotation = 90;
+ } else {
+ newX = 0;
+ newY = tr.y() + tr.height();
+ newRotation = -90;
+ }
+ tr.setRect(0, 0, tr.height(), tr.width());
+ QTransform m;
+ m.translate(newX, newY);
+ m.rotate(newRotation);
+ painter->setTransform(m, true);
+ }
+
+ const int frameWidth = proxy()->pixelMetric((verticalTabs) ?
+ PM_LayoutVerticalSpacing : PM_LayoutHorizontalSpacing, option, widget);
+ const Qt::TextElideMode elideMode = (tab->direction == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;
+ const QRect textRect = QRect(0,
+ 0,
+ tab->rect.width() - icon.width() - frameWidth * 2,
+ tab->rect.height() - icon.height() - frameWidth * 2);
+ QString txt = tab->fontMetrics.elidedText(tab->text, elideMode, (verticalTabs ? textRect.height() : textRect.width()));
+
+ //Icon
+ if (!icon.isNull()) {
+ if (tab->text.isEmpty())
+ painter->drawPixmap(tr.center().x() - (icon.height() >> 1),
+ tr.center().y() - (icon.height() >> 1),
+ icon);
+ else
+ painter->drawPixmap(tr.left(),
+ tr.center().y() - (icon.height() >> 1),
+ icon);
+ tr.setLeft(tr.left() + icon.width() + frameWidth);
+ } else {
+ tr.setLeft(tr.left() + frameWidth);
+ }
+
+ //Text
+ if (tab->text.length() > 0) {
+ int alignment = Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic;
+ if (!proxy()->styleHint(SH_UnderlineShortcut, tab, widget))
+ alignment |= Qt::TextHideMnemonic;
+ proxy()->drawItemText(painter, tr, alignment, tab->palette, enabled, txt, QPalette::ButtonText);
+ }
+
+ if (verticalTabs)
+ painter->restore();
+ }
+ break;
+ }
+#ifndef QT_NO_COMBOBOX
+ case CE_ComboBoxLabel:
+ if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+ QRect editRect = proxy()->subControlRect(CC_ComboBox, combo, SC_ComboBoxEditField, widget);
+ const int spacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, combo, widget);
+ if (!combo->currentIcon.isNull()) {
+ const QIcon::Mode mode = combo->state & State_Enabled ? QIcon::Normal
+ : QIcon::Disabled;
+ const QPixmap pixmap = combo->currentIcon.pixmap(combo->iconSize, mode);
+ QRect iconRect(editRect);
+ iconRect.setWidth(combo->iconSize.width() + spacing);
+ iconRect = alignedRect(combo->direction,
+ Qt::AlignLeft | Qt::AlignVCenter,
+ iconRect.size(), editRect);
+ if (combo->editable)
+ painter->fillRect(iconRect, combo->palette.brush(QPalette::Base));
+ proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap);
+
+ if (combo->direction == Qt::RightToLeft)
+ editRect.translate(-spacing - combo->iconSize.width(), 0);
+ else
+ editRect.translate(combo->iconSize.width() + spacing, 0);
+ }
+ if (!combo->currentText.isEmpty() && !combo->editable) {
+ const Qt::TextElideMode elideMode = (combo->direction == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;
+ const QString txt = combo->fontMetrics.elidedText(combo->currentText, elideMode, editRect.width());
+ proxy()->drawItemText(painter, editRect.adjusted(1, 0, -1, 0),
+ visualAlignment(combo->direction, Qt::AlignLeft | Qt::AlignVCenter),
+ combo->palette, combo->state & State_Enabled, txt);
+ }
+ }
+ break;
+#endif // QT_NO_COMBOBOX
+#endif //QT_NO_TABBAR
+ case CE_PushButton: {
+ if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+ proxy()->drawControl(CE_PushButtonBevel, btn, painter, widget);
+ QStyleOptionButton subopt = *btn;
+ subopt.rect = subElementRect(SE_PushButtonContents, btn, widget);
+ proxy()->drawControl(CE_PushButtonLabel, &subopt, painter, widget);
+ if ((btn->state & State_HasFocus)) {
+ QStyleOptionFocusRect fropt;
+ fropt.QStyleOption::operator=(*btn);
+ fropt.rect = subElementRect(SE_PushButtonFocusRect, btn, widget);
+ proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget);
+ }
+ }
+ break;
+ }
+ case CE_PushButtonBevel: {
+ if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+ const bool isDisabled = !(button->state & State_Enabled);
+ const bool isFlat = button->features & QStyleOptionButton::Flat;
+ const bool isPressed = (button->state & State_Sunken) ||
+ (button->state & State_On);
+ // 'latched' is a checkable button that is pressed down
+ const QPushButton *pbutton = qobject_cast<const QPushButton *>(widget);
+ const bool isLatched = (!pbutton) ? false : (pbutton->isCheckable() && isPressed);
+
+ ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
+ if (isLatched)
+ state = state | SS_Latched;
+ else if (isPressed)
+ state = state | SS_Pressed;
+
+ if (button->state & State_Selected || button->state & State_HasFocus)
+ state = state | SS_Selected;
+
+ //todo: does Hb have flat buttons?
+ if (button->features & QStyleOptionButton::HasMenu) {
+ //draw menu indicator
+ const int menuButtonIndicator = proxy()->pixelMetric(PM_MenuButtonIndicator, button, widget);
+ QStyleOptionButton menuOpt = *button;
+ menuOpt.rect = QRect(button->rect.right() - menuButtonIndicator,
+ button->rect.y() + (button->rect.height() - menuButtonIndicator) / 2,
+ menuButtonIndicator,
+ menuButtonIndicator);
+ menuOpt.rect = visualRect(button->direction, button->rect, menuOpt.rect);
+ proxy()->drawPrimitive(PE_IndicatorArrowDown, &menuOpt, painter, widget);
+ }
+ if (isFlat) //lets draw flat buttons as toolbuttons
+ m_private->drawMultiPartItem(SM_ToolButton, painter, button->rect, state);
+ else
+ m_private->drawMultiPartItem(SM_PushButton, painter, button->rect, state);
+ }
+ break;
+ }
+ case CE_MenuScroller: {
+ ItemStates states = (option->state & State_DownArrow) ? SS_Down : SS_Up;
+ painter->fillRect(option->rect, option->palette.background());
+ m_private->drawMultiPartItem(SM_MenuScroller, painter, option->rect, states);
+ QStyleOption arrowOpt = *option;
+ arrowOpt.state |= State_Enabled;
+ const int side = proxy()->pixelMetric(PM_MenuScrollerHeight, option, widget);
+ arrowOpt.rect = option->rect;
+ arrowOpt.rect.setWidth(side);
+ arrowOpt.rect.moveCenter(option->rect.center());
+ proxy()->drawPrimitive(((option->state & State_DownArrow) ? PE_IndicatorArrowDown : PE_IndicatorArrowUp),
+ &arrowOpt, painter, widget);
+ break;
+ }
+ case CE_MenuItem: {
+ if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+ if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) {
+ const int margin = proxy()->pixelMetric(PM_MenuHMargin, menuItem, widget);
+ const int yoff = menuItem->rect.y() - 1 + menuItem->rect.height() / 2;
+ const int startX = menuItem->rect.x() + margin;
+ const int endX = menuItem->rect.x() + menuItem->rect.width() - margin;
+ QRect separatorRect = QRect(QPoint(startX, yoff), QPoint(endX, yoff));
+ m_private->drawItem(SP_MenuSeparator, painter, separatorRect);
+ return;
+ }
+
+ const bool isDisabled = !(menuItem->state & State_Enabled);
+ const bool isSelected = (menuItem->state & State_Selected);
+ const bool isPressed = (menuItem->state & State_Sunken) || (menuItem->state & State_Raised);
+ ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
+
+ if (isSelected)
+ state = state | SS_Selected;
+
+ if (isPressed)
+ state = state | SS_Pressed;
+
+ m_private->drawMultiPartItem(SM_MenuItem, painter, menuItem->rect, state);
+
+ uint text_flags = Qt::AlignLeading | Qt::TextShowMnemonic | Qt::TextDontClip
+ | Qt::TextSingleLine | Qt::AlignVCenter;
+ if (!styleHint(SH_UnderlineShortcut, menuItem, widget))
+ text_flags |= Qt::TextHideMnemonic;
+
+ if (menuItem->menuHasCheckableItems) {
+ const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, menuItem, widget);
+ if (checkBoxRect.isValid()) {
+ ItemStates checkBoxState;
+ if (menuItem->checked) checkBoxState |= SS_Selected;
+ if (menuItem->direction == Qt::RightToLeft) checkBoxState |= SS_Mirrored;
+ m_private->drawItem(SP_ItemDecoration, painter, checkBoxRect, checkBoxState);
+ }
+ }
+
+ if (!menuItem->icon.isNull()) {
+ const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, menuItem, widget);
+ if (iconRect.isValid()) {
+ QPixmap pix = menuItem->icon.pixmap(pixelMetric(PM_SmallIconSize),
+ !isDisabled ? QIcon::Normal : QIcon::Disabled);
+ drawItemPixmap(painter, iconRect, text_flags, pix);
+ }
+ }
+
+ if (menuItem->text.length() > 0) {
+ const QRect textRect = subElementRect(SE_ItemViewItemText, menuItem, widget);
+ if (textRect.isValid())
+ QCommonStyle::drawItemText(painter, textRect, text_flags, menuItem->palette,
+ (menuItem->state & State_Enabled), menuItem->text, QPalette::Text);
+ }
+ }
+ break;
+ }
+ case CE_MenuBarEmptyArea:
+ case CE_MenuEmptyArea: {
+ break;
+ }
+#ifndef QT_NO_PROGRESSBAR
+ case CE_ProgressBar: {
+ if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+ drawControl(CE_ProgressBarGroove, progressBar, painter, widget);
+ drawControl(CE_ProgressBarContents, progressBar, painter, widget);
+ //drawControl(CE_ProgressBarLabel, progressBar, painter, widget);
+ }
+ break;
+ }
+ case CE_ProgressBarGroove: {
+ if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+ const QRect progressBarGroove = subElementRect(SE_ProgressBarGroove, progressBar, widget);
+ const bool horizontal = progressBar->orientation == Qt::Horizontal;
+ ItemStates state = 0;
+ if (horizontal)
+ state = state | SS_Horizontal;
+ else
+ state = state | SS_Vertical;
+
+ m_private->drawMultiPartItem(SM_ProgressBarGroove, painter, progressBarGroove, state);
+ }
+ break;
+ }
+ case CE_ProgressBarContents: {
+ if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+ if (progressBar->minimum == 0 && progressBar->maximum == 0) {
+ //waiting bar
+ animateControl(CE_ProgressBarContents, option, painter, widget);
+ } else {
+ QRect rect = subElementRect(SE_ProgressBarGroove, progressBar, widget);
+ const qint64 minimum = qint64(progressBar->minimum);
+ const qint64 maximum = qint64(progressBar->maximum);
+ const qint64 progress = qint64(progressBar->progress);
+ if (progressBar->orientation == Qt::Horizontal) {
+ const qreal scale = rect.width() / qreal(maximum - minimum);
+ qint64 width = scale * progress;
+ width = progress >= maximum ? rect.width() : width;
+
+ if ((progressBar->direction == Qt::LeftToRight) ^ progressBar->invertedAppearance) {
+ rect = QRect(rect.x(), rect.y(), width, rect.height());
+ } else {
+ rect = QRect(rect.x() + (rect.width() - width), rect.y(), rect.width() - (rect.width() - width), rect.height());
+ }
+ m_private->drawMultiPartItem(SM_ProgressBarIndicator, painter, rect, SS_Horizontal);
+ } else{ //Vertical
+ const qreal scale = rect.height() / qreal(maximum - minimum);
+ qint64 height = scale * progress;
+ height = progress >= maximum ? rect.height() : height;
+ if (progressBar->invertedAppearance) {
+ rect = QRect(rect.x(), rect.y(), rect.width(), height);
+ } else {
+ rect = QRect(rect.x(), rect.y() + (rect.height() - height), rect.width(), rect.height() - (rect.height() - height));
+ }
+ m_private->drawMultiPartItem(SM_ProgressBarIndicator, painter, rect, SS_Vertical);
+ }
+ }
+ }
+ break;
+ }
+ case CE_ProgressBarLabel: {
+ if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+ if (progressBar->textVisible && (progressBar->minimum != 0 || progressBar->maximum != 0)) {
+ const QString minText = QString().setNum(progressBar->minimum);
+ const QString maxText = QString().setNum(progressBar->maximum);
+ const QRect textRect = subElementRect(SE_ProgressBarGroove, progressBar, widget);
+ if (progressBar->orientation == Qt::Horizontal) {
+ if (progressBar->invertedAppearance) {
+ //minText
+ proxy()->drawItemText(painter, textRect, Qt::AlignRight | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, minText, QPalette::Text);
+
+ //maxText
+ proxy()->drawItemText(painter, textRect, Qt::AlignLeft | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, maxText, QPalette::Text);
+
+ } else {
+ //minText
+ proxy()->drawItemText(painter, textRect, Qt::AlignLeft | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, minText, QPalette::Text);
+
+ //maxText
+ proxy()->drawItemText(painter, textRect, Qt::AlignRight | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, maxText, QPalette::Text);
+ }
+ } else { //Vertical
+ if (progressBar->invertedAppearance) {
+ //minText
+ proxy()->drawItemText(painter, textRect, Qt::AlignTop | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, minText, QPalette::Text);
+
+ //maxText
+ proxy()->drawItemText(painter, textRect, Qt::AlignBottom | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, maxText, QPalette::Text);
+
+ } else {
+ //minText
+ proxy()->drawItemText(painter, textRect, Qt::AlignBottom | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, minText, QPalette::Text);
+
+ //maxText
+ proxy()->drawItemText(painter, textRect, Qt::AlignTop | Qt::TextSingleLine, progressBar->palette,
+ progressBar->state & State_Enabled, maxText, QPalette::Text);
+ }
+
+ }
+
+ }
+ }
+ break;
+ }
+#endif //QT_NO_PROGRESSBAR
+ case CE_ToolButtonLabel:
+ default: {
+ QCommonStyle::drawControl(element, option, painter, widget);
+ break;
+ }
+ }
+}
+
+void QHbStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option,
+ QPainter *painter, const QWidget *widget) const
+{
+ switch (control) {
+#ifndef QT_NO_COMBOBOX
+ case CC_ComboBox: {
+ if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+ const QRect cmbxFrame = cmb->rect;
+ ItemStates state = SS_Active;
+
+ // Button frame
+ QStyleOptionFrame buttonOption;
+ buttonOption.QStyleOption::operator=(*cmb);
+ const int buttonMaxHeight = cmbxFrame.height();
+ const int buttonMaxWidth = buttonMaxHeight; //button is rect
+ const int topLeftPoint = (cmb->direction == Qt::LeftToRight) ? (cmbxFrame.width() - buttonMaxWidth) : 0;
+
+ const QRect buttonRect(topLeftPoint, cmbxFrame.top(), buttonMaxHeight, buttonMaxWidth);
+ buttonOption.rect = buttonRect;
+ buttonOption.state = cmb->state;
+ ItemStates buttonState = (buttonOption.state & State_Sunken) ? ItemStates(SS_Pressed | SS_Active) : ItemStates(SS_Active);
+ if (cmb->direction == Qt::RightToLeft)
+ buttonState |= SS_Mirrored;
+ if (buttonOption.state & State_HasFocus) {
+ buttonState |= SS_Selected;
+ state |= SS_Selected; //set frame status to follow button status for highlight
+ }
+
+ m_private->drawItem(SP_BoxButton, painter, buttonRect.adjusted(0, 1, 0, -1), buttonState); //@todo: remove magic
+
+ if (cmb->subControls & SC_ComboBoxFrame) {
+ const bool isDisabled = !(cmb->state & State_Enabled);
+ const bool isPressed = (cmb->state & State_Sunken);
+ const bool isEditable = cmb->editable;
+
+ if (isDisabled)
+ state = SS_Disabled;
+ else if (isPressed)
+ state |= SS_Pressed;
+ if (isEditable)
+ state |= SS_Edited;
+ QRect frameRect = QRect(cmb->rect);
+ int frameWidth = pixelMetric(PM_DefaultFrameWidth);
+ int maxRight = cmb->rect.height() - 2 * frameWidth;
+ frameRect.adjust(0, 0, -maxRight, 0);
+ int adjustX = 0;
+ if (option->direction == Qt::RightToLeft) {
+ adjustX = buttonOption.rect.topRight().x();
+ state |= SS_Mirrored;
+ }
+ const QRect frame = subControlRect(CC_ComboBox, option, SC_ComboBoxFrame, widget);
+ // @todo: if SC_ComboBoxFrame needs adjusting, move that code to subControlRect
+ m_private->drawMultiPartItem(SM_BoxFrame, painter, frame.adjusted(adjustX, 1, -4 + adjustX, -1), state);
+ }
+ }
+ break;
+ }
+#endif //QT_NO_COMBOBOX
+#ifndef QT_NO_SLIDER
+ case CC_Slider: {
+ if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ const QSlider* slider = qobject_cast<const QSlider*>(widget);
+ const QRect sliderGroove = subControlRect(control, optionSlider, SC_SliderGroove, widget);
+ const QRect sliderHandle = subControlRect(control, optionSlider, SC_SliderHandle, widget);
+ const bool horizontal = optionSlider->orientation == Qt::Horizontal;
+ const bool isDisabled = !(optionSlider->state & State_Enabled);
+ ItemStates grooveState = (isDisabled) ? SS_Disabled : SS_Active;
+ if (horizontal)
+ grooveState = grooveState | SS_Horizontal;
+ else
+ grooveState = grooveState | SS_Vertical;
+
+ ItemStates handleState = grooveState;
+
+ if (slider && slider->isSliderDown())
+ handleState = handleState | SS_Pressed;
+ else if ((optionSlider->state & State_Sunken) || (optionSlider->state & State_On))
+ grooveState = grooveState | SS_Pressed;
+
+ //Draw ticks
+ if (optionSlider->subControls & SC_SliderTickmarks) {
+ const QRect tickRect = subControlRect(control, optionSlider, SC_SliderTickmarks, widget);
+ const bool ticksAbove = optionSlider->tickPosition & QSlider::TicksAbove;
+ const bool ticksBelow = optionSlider->tickPosition & QSlider::TicksBelow;
+
+ int tickOffset = proxy()->pixelMetric(PM_SliderTickmarkOffset, optionSlider, widget);
+ const int thickness = proxy()->pixelMetric(PM_SliderControlThickness, optionSlider, widget);
+ const int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, optionSlider, widget);
+ int interval = optionSlider->tickInterval;
+ if (interval <= 0) {
+ interval = optionSlider->singleStep;
+ if (sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum, interval,available)
+ - sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum, 0, available) < 3)
+ interval = optionSlider->pageStep;
+ }
+ if (!interval)
+ interval = 1;
+ int pos;
+ const int fudge = proxy()->pixelMetric(PM_SliderLength, optionSlider, widget) / 2;
+ // Since there is no subrect for tickmarks do a translation here.
+ int v = optionSlider->minimum;
+
+ while (v <= (optionSlider->maximum + 1)) {
+ if ((v == optionSlider->maximum + 1) && (interval == 1))
+ break;
+ const int v_ = qMin(v, optionSlider->maximum);
+ pos = sliderPositionFromValue(optionSlider->minimum, optionSlider->maximum,
+ v_, available) + fudge;
+ QRect destRect = QRect();
+ if (horizontal) {
+ if (ticksAbove) {
+ destRect = QRect(pos, tickRect.y() - tickOffset + 1, tickRect.width(), tickRect.height());
+ m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);
+ }
+ if (ticksBelow) {
+ destRect = QRect(pos, tickOffset + thickness - 1, tickRect.width(), tickRect.height());
+ m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);
+ }
+ } else {
+ if (ticksAbove) {
+ destRect = QRect(tickRect.x() - tickOffset + 1, pos, tickRect.width(), tickRect.height());
+ m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);
+ }
+ if (ticksBelow) {
+ destRect = QRect(tickOffset + thickness - 1, pos, tickRect.width(), tickRect.height());
+ m_private->drawItem(SP_SliderTick, painter, destRect, grooveState);
+ }
+ }
+ // in the case where maximum is max int
+ int nextInterval = v + interval;
+ if (nextInterval < v)
+ break;
+ v = nextInterval;
+ }
+ }
+ QRect filledRect;
+ if ( horizontal ){
+ const int sliderPosition = sliderHandle.center().x();
+ const int sliderWidth = sliderHandle.width()/2;
+ if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){
+ filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderPosition+sliderWidth, sliderGroove.height());
+ } else {
+ filledRect = QRect(sliderGroove.x()+sliderPosition-sliderWidth, sliderGroove.y(), sliderGroove.width()-sliderPosition+sliderWidth, sliderGroove.height());
+ }
+ } else {
+ const int sliderPosition = sliderHandle.center().y();
+ const int sliderHeight = sliderHandle.height()/2;
+ if (slider && (slider->layoutDirection() == Qt::LeftToRight) ^ slider->invertedAppearance()){
+ filledRect = QRect(sliderGroove.x(), sliderGroove.y()+sliderPosition-sliderHeight, sliderGroove.width(), sliderGroove.height()-sliderPosition+sliderHeight);
+ } else {
+ filledRect = QRect(sliderGroove.x(), sliderGroove.y(), sliderGroove.width(), sliderPosition+sliderHeight);
+ }
+ }
+
+ //Groove
+ m_private->drawMultiPartItem(SM_SliderGroove, painter, sliderGroove, grooveState);
+
+ //Progress
+ m_private->drawMultiPartItem(SM_SliderProgress, painter, filledRect, grooveState | SS_Filled);
+
+ //handle
+ m_private->drawItem(SP_SliderHandle, painter, sliderHandle, handleState);
+ }
+ break;
+ }
+#endif //QT_NO_SLIDER
+#ifndef QT_NO_SCROLLBAR
+ case CC_ScrollBar: {
+ if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ ItemStates handleStates;
+ ItemStates grooveStates;
+ const bool horizontal = optionSlider->orientation == Qt::Horizontal;
+ const QRect handleRect = subControlRect(control, optionSlider, SC_ScrollBarSlider, widget);
+ const QRect grooveRect = subControlRect(control, optionSlider, SC_ScrollBarGroove, widget);
+ if (horizontal) {
+ handleStates |= SS_Horizontal;
+ grooveStates |= SS_Horizontal;
+ } else {
+ handleStates |= SS_Vertical;
+ grooveStates |= SS_Vertical;
+ }
+ const SubControls subControls = optionSlider->subControls;
+ const bool sliderPressed = ((optionSlider->state & State_Sunken) && (subControls & SC_ScrollBarSlider));
+ const bool groovePressed = ((optionSlider->state & State_Sunken) && (subControls & SC_ScrollBarGroove));
+
+ if (sliderPressed)
+ handleStates |= SS_Pressed;
+ if (groovePressed)
+ grooveStates |= SS_Pressed;
+
+ m_private->drawMultiPartItem(SM_ScrollBarGroove, painter, grooveRect, grooveStates);
+ m_private->drawMultiPartItem(SM_ScrollBarHandle, painter, handleRect, handleStates);
+ }
+ break;
+ }
+#endif // QT_NO_SCROLLBAR
+#ifndef QT_NO_GROUPBOX
+ case CC_GroupBox: {
+ if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {
+ // Draw frame
+ const QRect textRect = subControlRect(CC_GroupBox, option, SC_GroupBoxLabel, widget);
+
+ QRect headerRect = textRect;
+ headerRect.setWidth(groupBox->rect.width());
+ if (groupBox->subControls & SC_GroupBoxFrame) {
+ QStyleOptionFrameV2 frame;
+ frame.QStyleOption::operator=(*groupBox);
+ frame.features = groupBox->features;
+ frame.lineWidth = groupBox->lineWidth;
+ frame.midLineWidth = groupBox->midLineWidth;
+ frame.rect = subControlRect(CC_GroupBox, option, SC_GroupBoxFrame, widget);
+ proxy()->drawPrimitive(PE_FrameGroupBox, &frame, painter, widget);
+ }
+
+ // Draw title
+ if ((groupBox->subControls & SC_GroupBoxLabel) && !groupBox->text.isEmpty()) {
+ // Draw title background
+ m_private->drawMultiPartItem(SM_GroupBoxTitle, painter, headerRect);
+
+ const QColor textColor = groupBox->textColor;
+ painter->save();
+
+ if (textColor.isValid())
+ painter->setPen(textColor);
+ int alignment = int(groupBox->textAlignment);
+ if (!styleHint(SH_UnderlineShortcut, option, widget))
+ alignment |= Qt::TextHideMnemonic;
+
+ proxy()->drawItemText(painter, headerRect, Qt::TextShowMnemonic | Qt::AlignHCenter | Qt::AlignVCenter | alignment,
+ groupBox->palette, groupBox->state & State_Enabled, groupBox->text,
+ textColor.isValid() ? QPalette::NoRole : QPalette::WindowText);
+ painter->restore();
+ }
+ const QRect checkBoxRect = subControlRect(CC_GroupBox, option, SC_GroupBoxCheckBox, widget);
+ // Draw checkbox
+ if (groupBox->subControls & SC_GroupBoxCheckBox) {
+ QStyleOptionButton box;
+ box.QStyleOption::operator=(*groupBox);
+ box.rect = checkBoxRect;
+ proxy()->drawPrimitive(PE_IndicatorCheckBox, &box, painter, widget);
+ }
+ }
+ break;
+ }
+#endif //QT_NO_GROUPBOX
+#ifndef QT_NO_TOOLBUTTON
+ case CC_ToolButton: {
+ if (const QStyleOptionToolButton *toolBtn = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {
+ const QRect buttonRect(subControlRect(control, toolBtn, SC_ToolButton, widget));
+ QRect menuRect = QRect();
+ if (toolBtn->subControls & SC_ToolButtonMenu)
+ menuRect = subControlRect(control, toolBtn, SC_ToolButtonMenu, widget);
+
+ // Draw button bevel
+ if (toolBtn->subControls & SC_ToolButton)
+ proxy()->drawPrimitive(PE_PanelButtonTool, toolBtn, painter, widget);
+
+ //draw focus
+ if (toolBtn->state & State_HasFocus) {
+ QStyleOptionFocusRect frameOpt;
+ frameOpt.QStyleOption::operator=(*toolBtn);
+ frameOpt.rect = subElementRect(SE_PushButtonFocusRect, toolBtn, widget); //can we use this, or should we just reduce the button rect?
+ if (toolBtn->features & QStyleOptionToolButton::MenuButtonPopup)
+ frameOpt.rect.adjust(0, 0, -proxy()->pixelMetric(PM_MenuButtonIndicator), 0);
+ proxy()->drawPrimitive(PE_FrameFocusRect, &frameOpt, painter, widget);
+ }
+
+ if (toolBtn->text.length() > 0 || !toolBtn->icon.isNull() || (toolBtn->features & QStyleOptionToolButton::Arrow)) {
+ //draw label
+ QStyleOptionToolButton label = *toolBtn;
+ int fw = proxy()->pixelMetric(PM_DefaultFrameWidth, option, widget);
+ label.rect = buttonRect.adjusted(fw, fw, -fw, -fw);
+ proxy()->drawControl(CE_ToolButtonLabel, &label, painter, widget);
+ }
+ if (toolBtn->subControls & SC_ToolButtonMenu) {
+ //draw menu indicator
+ const int menuButtonIndicator = proxy()->pixelMetric(PM_MenuButtonIndicator, toolBtn, widget);
+ QStyleOptionToolButton menuOpt = *toolBtn;
+ menuOpt.rect = QRect(toolBtn->rect.right() - menuButtonIndicator,
+ toolBtn->rect.y() + (toolBtn->rect.height() - menuButtonIndicator) / 2,
+ menuButtonIndicator,
+ menuButtonIndicator);
+ menuOpt.rect = visualRect(toolBtn->direction, toolBtn->rect, menuOpt.rect);
+
+ PrimitiveElement pe;
+ bool arrow = true;
+ switch(toolBtn->arrowType) {
+ case Qt::UpArrow: {
+ pe = PE_IndicatorArrowUp;
+ break;
+ }
+ case Qt::LeftArrow: {
+ pe = PE_IndicatorArrowLeft;
+ break;
+ }
+ case Qt::RightArrow: {
+ pe = PE_IndicatorArrowRight;
+ break;
+ }
+ case Qt::DownArrow: {
+ pe = PE_IndicatorArrowDown;
+ break;
+ }
+ default: {
+ arrow = false;
+ }
+ }
+ if (arrow)
+ proxy()->drawPrimitive(pe, &menuOpt, painter, widget);
+ }
+ }
+ break;
+ }
+#endif //QT_NO_TOOLBUTTON
+ case CC_SpinBox: {
+ if (const QStyleOptionSpinBox *optionSpinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
+ const QRect spinboxFrame = subControlRect(control, optionSpinbox, SC_SpinBoxFrame, widget);
+ const QRect spinboxButtonUpRect = subControlRect(control, optionSpinbox, SC_SpinBoxUp, widget);
+ const QRect spinboxButtonDownRect = subControlRect(control, optionSpinbox, SC_SpinBoxDown, widget);
+ const QRect spinboxEditorRect = subControlRect(control, optionSpinbox, SC_SpinBoxEditField, widget);
+
+ QStyleOptionSpinBox copy = *optionSpinbox;
+
+ //Frame & background
+ const bool isDisabled = !(optionSpinbox->state & State_Enabled);
+ ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;
+ if (optionSpinbox->state & State_HasFocus)
+ state |= SS_Selected;
+ m_private->drawMultiPartItem(SM_BoxFrame, painter, spinboxEditorRect, state);
+
+ //Buttons
+ if (optionSpinbox->subControls & SC_SpinBoxUp) {
+ copy.subControls = SC_SpinBoxUp;
+ if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepUpEnabled))
+ copy.state &= ~State_Enabled;
+ if (optionSpinbox->activeSubControls == SC_SpinBoxUp && (optionSpinbox->state & State_Sunken)) {
+ copy.state |= State_On;
+ copy.state |= State_Sunken;
+ } else {
+ copy.state |= State_Raised;
+ copy.state &= ~State_Sunken;
+ }
+ const bool isPressed = (copy.state & State_Sunken);
+ ItemStates upButtonState = (isPressed) ? ItemStates(SS_Pressed | SS_Active) : ItemStates(SS_Active);
+ if (optionSpinbox->direction == Qt::RightToLeft)
+ upButtonState = upButtonState | SS_Flipped;
+ else
+ upButtonState = upButtonState | SS_Flipped | SS_Mirrored;
+ if (optionSpinbox->state & State_HasFocus)
+ upButtonState |= SS_Selected;
+ if (!(copy.state & State_Enabled))
+ upButtonState |= SS_Disabled;
+ m_private->drawItem(SP_BoxButton, painter, spinboxButtonUpRect, upButtonState);
+ }
+
+ if (optionSpinbox->subControls & SC_SpinBoxDown) {
+ copy.subControls = SC_SpinBoxDown;
+ if (!(optionSpinbox->stepEnabled & QAbstractSpinBox::StepDownEnabled))
+ copy.state &= ~State_Enabled;
+ if (optionSpinbox->activeSubControls == SC_SpinBoxDown && (optionSpinbox->state & State_Sunken)) {
+ copy.state |= State_On;
+ copy.state |= State_Sunken;
+ } else {
+ copy.state |= State_Raised;
+ copy.state &= ~State_Sunken;
+ }
+ const bool isPressed = (copy.state & State_Sunken);
+ ItemStates downButtonState = (isPressed) ? ItemStates(SS_Pressed | SS_Active) : ItemStates(SS_Active);
+ if (optionSpinbox->direction == Qt::RightToLeft)
+ downButtonState = downButtonState;
+ else
+ downButtonState = downButtonState | SS_Mirrored;
+ if (optionSpinbox->state & State_HasFocus)
+ downButtonState |= SS_Selected;
+ if (!(copy.state & State_Enabled))
+ downButtonState |= SS_Disabled;
+ m_private->drawItem(SP_BoxButton, painter, spinboxButtonDownRect, downButtonState);
+ }
+ }
+ break;
+ }
+ case CC_TitleBar:
+ case CC_Q3ListView:
+ case CC_Dial:
+ case CC_MdiControls:
+ default: {
+ QCommonStyle::drawComplexControl(control, option, painter, widget);
+ break;
+ }
+ }
+}
+
+QSize QHbStyle::sizeFromContents(ContentsType type, const QStyleOption *option,
+ const QSize &size, const QWidget *widget) const
+{
+ QSize newSize = QCommonStyle::sizeFromContents(type, option, size, widget);
+ switch (type) {
+#ifndef QT_NO_MENU
+ case CT_MenuItem: {
+ if (qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+ const int verticalMargin = pixelMetric(PM_MenuVMargin);
+ const int horizontalMargin = pixelMetric(PM_MenuHMargin);
+ newSize += QSize(horizontalMargin, 2 * verticalMargin);
+ }
+ break;
+ }
+#endif
+#ifndef QT_NO_ITEMVIEWS
+ case CT_ItemViewItem: {
+ newSize += QSize(0,22);
+ break;
+ }
+#endif
+ case CT_PushButton: {
+ newSize += QSize(0, 2 * proxy()->pixelMetric(PM_ButtonMargin, option, widget));
+ break;
+ }
+ default:
+ break;
+ }
+ return newSize;
+}
+
+QRect QHbStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
+{
+ const QRect baseSize = QCommonStyle::subElementRect(element, option, widget);
+ QRect elementSize = baseSize;
+ switch (element) {
+ case SE_ItemViewItemText: {
+ if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+ elementSize = menuItem->rect;
+ const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
+ const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
+ const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
+ int totalXMod = qMax(0, qMax((checkBoxRect.isValid() ? checkBoxRect.topRight().x() : 0),
+ (iconRect.isValid() ? iconRect.topRight().x() : 0)));
+ const int widthMod = checkBoxRect.width() + iconRect.width() + indicatorSpacing;
+ totalXMod = (menuItem->direction == Qt::LeftToRight) ? qMax(0, totalXMod - elementSize.topLeft().x()): 0;
+ totalXMod += indicatorSpacing;
+ elementSize.translate(totalXMod, 0);
+ elementSize.setWidth(menuItem->rect.width() - widthMod);
+ } else if (const QStyleOptionViewItemV4 *itemView = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ elementSize = itemView->rect;
+ const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, option, widget);
+ const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
+ const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
+ int totalXMod = qMax(0, qMax((checkBoxRect.isValid() ? checkBoxRect.topRight().x() : 0),
+ (iconRect.isValid() ? iconRect.topRight().x() : 0)));
+ const int widthMod = checkBoxRect.width() + iconRect.width() + indicatorSpacing;
+ totalXMod = (itemView->direction == Qt::LeftToRight) ? qMax(0, totalXMod - elementSize.topLeft().x()): 0;
+ totalXMod += indicatorSpacing;
+ elementSize.translate(totalXMod, 0);
+ elementSize.setWidth(itemView->rect.width() - widthMod);
+ elementSize = visualRect(itemView->direction, itemView->rect, elementSize);
+ }
+ break;
+ }
+ case SE_ViewItemCheckIndicator: {
+ if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+ if (menuItem->menuHasCheckableItems) {
+ const int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget);
+ const int htAdjust = (menuItem->rect.height() - indicatorWidth) / 2;
+ elementSize = QRect(menuItem->rect.x(), menuItem->rect.y() + htAdjust, indicatorWidth, indicatorWidth);
+ elementSize = visualRect(menuItem->direction, menuItem->rect, elementSize);
+ } else { elementSize = QRect(); }
+ } else if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator) {
+ const int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget);
+ const int htAdjust = (itemOption->rect.height() - indicatorWidth) / 2;
+ elementSize = QRect(itemOption->rect.x(), itemOption->rect.y() + htAdjust, indicatorWidth, indicatorWidth);
+ elementSize = visualRect(itemOption->direction, itemOption->rect, elementSize);
+ } else { elementSize = QRect(); }
+ }
+ break;
+ }
+ case SE_ItemViewItemDecoration: {
+ if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast<const QStyleOptionMenuItem *>(option)) {
+ if (!menuItem->icon.isNull()) {
+ const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
+ const int imageWidth = proxy()->pixelMetric(PM_SmallIconSize, option, widget);
+ const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
+ const int htAdjust = (menuItem->rect.height() - imageWidth) / 2;
+ if (checkBoxRect.isValid()) {
+ elementSize = QRect(menuItem->rect.x() + checkBoxRect.width() + indicatorSpacing, menuItem->rect.y() + htAdjust, imageWidth, imageWidth);
+ } else {
+ elementSize = QRect(menuItem->rect.x() + indicatorSpacing, menuItem->rect.y() + htAdjust, imageWidth, imageWidth);
+ }
+ elementSize = visualRect(menuItem->direction, menuItem->rect, elementSize);
+ } else { elementSize = QRect(); }
+ } else if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {
+ if (!itemOption->icon.isNull()) {
+ const QRect checkBoxRect = subElementRect(SE_ViewItemCheckIndicator, option, widget);
+ const int imageWidth = proxy()->pixelMetric(PM_SmallIconSize, option, widget);
+ const int indicatorSpacing = proxy()->pixelMetric(PM_LayoutHorizontalSpacing, option, widget);
+ const int htAdjust = (itemOption->rect.height() - imageWidth) / 2;
+ if (checkBoxRect.isValid()) {
+ elementSize = QRect(itemOption->rect.x() + checkBoxRect.width() + indicatorSpacing, itemOption->rect.y() + htAdjust, imageWidth, imageWidth);
+ } else {
+ elementSize = QRect(itemOption->rect.x() + indicatorSpacing, itemOption->rect.y() + htAdjust, imageWidth, imageWidth);
+ }
+ elementSize = visualRect(itemOption->direction, itemOption->rect, elementSize);
+ } else { elementSize = QRect(); }
+ }
+ break;
+ }
+ case SE_PushButtonFocusRect: {
+ if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
+ const int margin = proxy()->pixelMetric(PM_FocusFrameHMargin, button, widget);
+ elementSize = baseSize.adjusted(-margin, -margin, margin, margin);
+ }
+ break;
+ }
+ case SE_ProgressBarGroove: {
+ if (const QStyleOptionProgressBarV2 *progressBar = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(option)) {
+ elementSize = progressBar->rect;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ return elementSize;
+}
+
+QRect QHbStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex *option,
+ SubControl sc, const QWidget *widget) const
+{
+ const QRect baseSize = QCommonStyle::subControlRect(cc, option, sc, widget);
+ QRect elementSize = baseSize;
+ switch (cc) {
+ case CC_ComboBox: {
+ if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
+ const int buttonIconSize = pixelMetric(PM_ButtonIconSize);
+ const int buttonMargin = cmb->frame ? 2 : 0;
+ const int frameThickness = cmb->frame ? pixelMetric(PM_ComboBoxFrameWidth, cmb, widget) : 0;
+ const int buttonWidth = qMax(cmb->rect.height(), buttonIconSize);
+
+ QSize buttonSize;
+ buttonSize.setWidth(buttonWidth + 2 * buttonMargin);
+ buttonSize.setHeight(qMax(8, (cmb->rect.height() >> 1) - frameThickness));
+ buttonSize = buttonSize.expandedTo(QApplication::globalStrut());
+ switch (sc) {
+ case SC_ComboBoxArrow: {
+ elementSize = option->rect;
+ break;
+ }
+ case SC_ComboBoxFrame: {
+ QRect frameRect = QRect(cmb->rect);
+ int frameWidth = pixelMetric(PM_DefaultFrameWidth, cmb, widget);
+ int maxRight = cmb->rect.height() - 2 * frameWidth;
+ frameRect.adjust(0, 0, -maxRight, 0);
+ elementSize = frameRect;
+ break;
+ }
+ case SC_ComboBoxEditField: {
+ const int withFrameX = cmb->rect.x() + cmb->rect.width() - frameThickness - buttonSize.width();
+ elementSize = QRect(
+ frameThickness,
+ frameThickness - 2,
+ withFrameX - frameThickness,
+ cmb->rect.height() - 2 * frameThickness );
+ break;
+ }
+ case SC_ComboBoxListBoxPopup: {
+ QRect mover = cmb->rect;
+ mover.moveBottom(cmb->rect.top() - 2);
+ elementSize = mover;
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ break;
+ }
+#ifndef QT_NO_SCROLLBAR
+//todo: this was lifted "as-is" from QS60Style. Check that it is valid for uiemo.
+ case CC_ScrollBar: {
+ if (const QStyleOptionSlider *scrollbarOption = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ const QRect scrollBarRect = scrollbarOption->rect;
+ const bool isHorizontal = scrollbarOption->orientation == Qt::Horizontal;
+ const int maxlen = isHorizontal ? scrollBarRect.width() : scrollBarRect.height();
+ int sliderlen;
+
+ // calculate slider length
+ if (scrollbarOption->maximum != scrollbarOption->minimum) {
+ const uint range = scrollbarOption->maximum - scrollbarOption->minimum;
+ sliderlen = (qint64(scrollbarOption->pageStep) * maxlen) / (range + scrollbarOption->pageStep);
+
+ const int slidermin = proxy()->pixelMetric(PM_ScrollBarSliderMin, scrollbarOption, widget);
+ if (sliderlen < slidermin || range > (INT_MAX >> 1))
+ sliderlen = slidermin;
+ if (sliderlen > maxlen)
+ sliderlen = maxlen;
+ } else {
+ sliderlen = maxlen;
+ }
+
+ const int sliderstart = sliderPositionFromValue(scrollbarOption->minimum,
+ scrollbarOption->maximum,
+ scrollbarOption->sliderPosition,
+ maxlen - sliderlen,
+ scrollbarOption->upsideDown);
+
+ switch (sc) {
+ case SC_ScrollBarSubPage: { // between top/left button and slider
+ if (isHorizontal)
+ elementSize.setRect(0, 0, sliderstart, scrollBarRect.height());
+ else
+ elementSize.setRect(0, 0, scrollBarRect.width(), sliderstart);
+ break;
+ }
+ case SC_ScrollBarAddPage: { // between bottom/right button and slider
+ const int addPageLength = sliderstart + sliderlen;
+ if (isHorizontal)
+ elementSize = scrollBarRect.adjusted(addPageLength, 0, 0, 0);
+ else
+ elementSize = scrollBarRect.adjusted(0, addPageLength, 0, 0);
+ break;
+ }
+ case SC_ScrollBarGroove: {
+ elementSize = scrollBarRect;
+ break;
+ }
+ case SC_ScrollBarSlider: {
+ if (scrollbarOption->orientation == Qt::Horizontal)
+ elementSize.setRect(sliderstart, 0, sliderlen, scrollBarRect.height());
+ else
+ elementSize.setRect(0, sliderstart, scrollBarRect.width(), sliderlen);
+ break;
+ }
+ case SC_ScrollBarSubLine: // top/left button
+ case SC_ScrollBarAddLine: // bottom/right button
+ default: {
+ break;
+ }
+ }
+ elementSize = visualRect(scrollbarOption->direction, scrollBarRect, elementSize);
+ }
+ break;
+ }
+#endif // QT_NO_SCROLLBAR
+#ifndef QT_NO_GROUPBOX
+ case CC_GroupBox: {
+ if (const QStyleOptionGroupBox *groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option)) {
+ switch (sc) {
+ case SC_GroupBoxFrame: {
+ int topMargin = 0;
+ int topHeight = 0;
+ int verticalAlignment = proxy()->styleHint(SH_GroupBox_TextLabelVerticalAlignment, groupBox, widget);
+ if (groupBox->text.size() || (groupBox->subControls & SC_GroupBoxCheckBox)) {
+ topHeight = groupBox->fontMetrics.height();
+ if (verticalAlignment & Qt::AlignVCenter)
+ topMargin = topHeight / 2;
+ else if (verticalAlignment & Qt::AlignTop)
+ topMargin = topHeight;
+ }
+
+ QRect frameRect = groupBox->rect;
+ frameRect.setTop(topMargin);
+ elementSize = frameRect;
+ break;
+ }
+ case SC_GroupBoxContents: {
+ const QRect titleRect = proxy()->subControlRect(cc, option, SC_GroupBoxLabel, widget);
+ const QRect frameRect = proxy()->subControlRect(cc, option, SC_GroupBoxFrame, widget);
+ elementSize = frameRect;
+ elementSize.setHeight(frameRect.height() + titleRect.height());
+ elementSize.translate((groupBox->direction == Qt::LeftToRight) ? titleRect.bottomLeft() : titleRect.bottomRight());
+ break;
+ }
+ case SC_GroupBoxCheckBox:
+ case SC_GroupBoxLabel: {
+ QFontMetrics fontMetrics = groupBox->fontMetrics;
+ const int height = fontMetrics.height();
+ //margins
+ int labelTopMargin = 0; int labelBottomMargin = 0;
+ m_private->hbParameter(QLatin1String("hb-param-margin-gene-top"), labelTopMargin);
+ m_private->hbParameter(QLatin1String("hb-param-margin-gene-bottom"), labelBottomMargin);
+
+ //height
+ const int indicatorHeight = proxy()->pixelMetric(PM_IndicatorHeight, option, widget);
+ elementSize = groupBox->rect;
+ elementSize.setHeight(qMax(height, indicatorHeight) + labelTopMargin + labelBottomMargin);
+
+ const int indicatorSpace = proxy()->pixelMetric(PM_CheckBoxLabelSpacing, option, widget);
+ const bool hasCheckBox = groupBox->subControls & SC_GroupBoxCheckBox;
+ const int indicatorWidth = proxy()->pixelMetric(PM_IndicatorWidth, option, widget);
+ const int checkBoxSize = hasCheckBox ? (indicatorWidth + indicatorSpace) : 0;
+
+ QRect totalRect;
+ // Adjust totalRect if checkbox is set
+ if (hasCheckBox) {
+ int top = 0; int left = 0; int width = 0;
+ int height = elementSize.height();
+ // Adjust for check box
+ if (sc == SC_GroupBoxCheckBox) {
+ top = labelTopMargin + elementSize.top() + (fontMetrics.height() - indicatorHeight) / 2;
+ const int right = elementSize.right() - checkBoxSize;
+ left = right - checkBoxSize;
+ width = height = checkBoxSize;
+ // Adjust for label
+ } else {
+ left = (groupBox->direction == Qt::LeftToRight) ? elementSize.left()
+ : (elementSize.left() + checkBoxSize);
+ width = elementSize.width() - checkBoxSize;
+ }
+ totalRect.setRect(left, top, width, height);
+ }
+ elementSize = visualRect(option->direction, option->rect, totalRect);
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ }
+ break;
+ }
+#endif //QT_NO_GROUPBOX
+#ifndef QT_NO_SLIDER
+ case CC_Slider: {
+ if (const QStyleOptionSlider *slider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ qreal metric = 0;
+ m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metric);
+ const int metricValue = metric + 0.5;
+ switch (sc) {
+ //Hb differentiates between major and minor ticks.
+ //Unfortunately Qt does not, so we consider all ticks as major.
+ //Tick sizes from Hb widget illustrations.
+ case SC_SliderTickmarks: {
+ //This just returns first tick rect for slider. Others need to be translated.
+ const bool horizontal = (slider->orientation == Qt::Horizontal);
+ const qreal unitValue = HbDeviceProfile::current().unitValue();
+ qreal width = 0; qreal height = 0;
+ //width and height unit values from Hb widget gallery
+ if (horizontal) {
+ width = 0.5 * unitValue + 0.5;
+ height = unitValue + 0.5;
+ } else {
+ height = 0.5 * unitValue + 0.5;
+ width = unitValue + 0.5;
+ }
+ const QRect sliderGroove = subControlRect(cc, slider, SC_SliderGroove, widget);
+ QRect tickRect = QRect(sliderGroove.x(), sliderGroove.y(), width, height);
+ if (horizontal)
+ tickRect.translate(0, -metricValue);
+ else
+ tickRect.translate(-metricValue, 0);
+ elementSize = tickRect;
+ break;
+ }
+ case SC_SliderGroove: {
+ const int thickness = proxy()->pixelMetric(PM_SliderThickness, slider, widget);
+ const int tickOffset = proxy()->pixelMetric(PM_SliderTickmarkOffset, slider, widget);
+ if (slider->orientation == Qt::Horizontal)
+ elementSize.setRect(slider->rect.x(), slider->rect.y() + metricValue + tickOffset,
+ slider->rect.width(), thickness - 2 * (metricValue + tickOffset));
+ else
+ elementSize.setRect(slider->rect.x() + tickOffset + metricValue, slider->rect.y(),
+ thickness - 2 * (metricValue + tickOffset), slider->rect.height());
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ }
+ break;
+ }
+#endif //QT_NO_SLIDER
+#ifndef QT_NO_SPINBOX
+ case CC_SpinBox: {
+ if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(option)) {
+ const int buttonIconSize = pixelMetric(PM_ButtonIconSize);
+ const int buttonWidth = qMax(spinbox->rect.height(), buttonIconSize);
+ switch (sc) {
+ case SC_SpinBoxFrame:
+ elementSize = option->rect.adjusted(0, 0, -buttonWidth + 5, 0);
+ break;
+ case SC_SpinBoxDown: {
+ if (option->direction == Qt::RightToLeft)
+ elementSize = QRect(option->rect.right() - buttonWidth, option->rect.y(),buttonWidth, option->rect.height());
+ else
+ elementSize = QRect( option->rect.x(), option->rect.y(), buttonWidth,option->rect.height());
+ }
+ break;
+ case SC_SpinBoxUp: {
+ if (option->direction == Qt::RightToLeft)
+ elementSize = QRect( option->rect.x(), option->rect.y(), buttonWidth,option->rect.height());
+ else
+ elementSize = QRect(option->rect.right() - buttonWidth,option->rect.y(),buttonWidth,option->rect.height());
+ }
+ break;
+ case SC_SpinBoxEditField:
+ elementSize = option->rect.adjusted(buttonWidth, 0, -buttonWidth, 0);
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ }
+#endif //QT_NO_SPINBOX
+ default: {
+ break;
+ }
+ }
+ return elementSize;
+}
+
+int QHbStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
+ QStyleHintReturn *returnData) const
+{
+ int retValue = 0;
+ switch (hint) {
+ case SH_RequestSoftwareInputPanel:
+ retValue = RSIP_OnMouseClick;
+ break;
+ case SH_ToolButtonStyle:
+ retValue = Qt::ToolButtonIconOnly;
+ break;
+ case SH_TabWidget_DefaultTabPosition: {
+ retValue = QTabWidget::North;
+ break;
+ }
+ case SH_TabBar_ElideMode:
+ if (option)
+ retValue = (option->direction == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;
+ else if (widget)
+ retValue = (widget->layoutDirection() == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;
+ else
+ retValue = (QApplication::layoutDirection() == Qt::LeftToRight) ? Qt::ElideRight : Qt::ElideLeft;
+ break;
+ case SH_ItemView_ShowDecorationSelected:
+ retValue = true;
+ break;
+ case SH_SpinControls_DisableOnBounds: {
+ retValue = true;
+ break;
+ }
+ case SH_MessageBox_TextInteractionFlags: {
+ retValue = Qt::LinksAccessibleByMouse;
+ break;
+ }
+ case SH_MessageBox_CenterButtons: {
+ retValue = true;
+ break;
+ }
+ case SH_Button_FocusPolicy: {
+ retValue = Qt::StrongFocus;
+ break;
+ }
+ case SH_Table_GridLineColor: {
+ retValue = Qt::green; //@todo: fetch this
+ break;
+ }
+ case SH_TabBar_Alignment: {
+ retValue = Qt::AlignCenter;
+ break;
+ }
+ case SH_Header_ArrowAlignment: {
+ if (option)
+ retValue = (option->direction == Qt::LeftToRight) ? Qt::AlignLeft : Qt::AlignRight;
+ else if (widget)
+ retValue = (widget->layoutDirection() == Qt::LeftToRight) ? Qt::AlignLeft : Qt::AlignRight;
+ else
+ retValue = (QApplication::layoutDirection() == Qt::LeftToRight) ? Qt::AlignLeft : Qt::AlignRight;
+ break;
+ }
+ case SH_ToolTipLabel_Opacity: {
+ retValue = 255;
+ break;
+ }
+ case SH_ScrollBar_ContextMenu: {
+ retValue = false;
+ break;
+ }
+ case SH_Menu_MouseTracking: {
+ retValue = 0;
+ break;
+ }
+ case SH_ComboBox_ListMouseTracking: {
+ retValue = 0;
+ break;
+ }
+ case SH_ComboBox_Popup: {
+ retValue = 1;
+ break;
+ }
+ case SH_UnderlineShortcut: {
+ retValue = false;
+ break;
+ }
+ case SH_GroupBox_TextLabelColor: {
+ QColor test = HbColorScheme::color("popupforeground");
+ retValue = int(HbColorScheme::color("popupforeground").rgba()); //@todo: should use "qtc_viewtitle" but that is not yet available
+ break;
+ }
+ case SH_GroupBox_TextLabelVerticalAlignment: {
+ retValue = Qt::AlignBottom;
+ break;
+ }
+ case SH_ItemView_ActivateItemOnSingleClick: {
+ retValue = true;
+ break;
+ }
+ case SH_ItemView_ArrowKeysNavigateIntoChildren: {
+ retValue = true;
+ break;
+ }
+ case SH_ItemView_PaintAlternatingRowColorsForEmptyArea: {
+ retValue = true;
+ break;
+ }
+ default: {
+ retValue = QCommonStyle::styleHint(hint, option, widget, returnData);
+ break;
+ }
+ }
+ return retValue;
+}
+
+int QHbStyle::pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const
+{
+ qreal metricValue = 0.0;
+ const qreal unitValue = HbDeviceProfile::current().unitValue();
+ bool valueFound = false;
+ switch(metric) {
+ case PM_ButtonMargin: {
+ //Hb defines different margin values for each margin. We could use any of them,
+ // average, or mean, but lets settle for top margin for now.
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-background-button"), metricValue);
+ break;
+ }
+ case PM_ButtonDefaultIndicator: {
+ //Lets set default button indication frame width to zero as there is no such concept in uiemo
+ valueFound = true;
+ break;
+ }
+ case PM_MenuButtonIndicator: {
+ // Hb returns a square area for icon in a button.
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-secondary"), metricValue);
+ break;
+ }
+ case PM_ButtonShiftVertical:
+ case PM_ButtonShiftHorizontal: {
+ //No button shifting in Hb
+ valueFound = true;
+ break;
+ }
+ case PM_DefaultFrameWidth: {
+ valueFound = true;
+ metricValue = 2.0;
+ break;
+ }
+ case PM_SpinBoxFrameWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metricValue);
+ break;
+ }
+ case PM_ComboBoxFrameWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-top"), metricValue);
+ break;
+ }
+ case PM_MaximumDragDistance: {
+ valueFound = true;
+ metricValue = -1.0; //disable maximum drag distance functionality
+ break;
+ }
+ case PM_ScrollBarExtent: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-scroll-bar-indicative-width"), metricValue);
+ break;
+ }
+ case PM_ScrollBarSliderMin: {
+ valueFound = true;
+ metricValue = 8.0 * unitValue; //8.0 from uiemo graphic designers (to be updated to the specification)
+ //todo: for indicative scrollbars the slider is 4.0uns. Can we query the state of scrollbar?
+ break;
+ }
+ case PM_SliderThickness: {
+ int numberOfTicks = 0;
+ if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ if (optionSlider->tickPosition & QSlider::TicksAbove)
+ ++numberOfTicks;
+ if (optionSlider->tickPosition & QSlider::TicksBelow)
+ ++numberOfTicks;
+ }
+ metricValue = proxy()->pixelMetric(PM_SliderControlThickness, option, widget) +
+ numberOfTicks * (1.0 * unitValue + 0.5); //tickmarks are one unit tall
+ valueFound = true;
+ break;
+ }
+ // Slider handle size values from Hb widget illustrations library.
+ case PM_SliderControlThickness: {
+ valueFound = true;
+ metricValue = 4.0 * unitValue;
+ break;
+ }
+ case PM_SliderLength: {
+ valueFound = true;
+ metricValue = 2.0 * unitValue;
+ break;
+ }
+ case PM_SliderTickmarkOffset: {
+ valueFound = true;
+ if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option))
+ if (optionSlider->tickPosition & QSlider::TicksAbove || optionSlider->tickPosition & QSlider::TicksBelow)
+ //tick marks are one unit tall
+ metricValue = 1.0 * unitValue + 0.5;
+ break;
+ }
+ case PM_SliderSpaceAvailable: { // available space for slider to move
+ if (widget) {
+ const QSize sliderSize = widget->size();
+ qreal margin = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-screen"), margin)) {
+ metricValue = qMax(sliderSize.width(), sliderSize.height()) - 2 * margin;
+ valueFound = true;
+ }
+ } else if (const QStyleOptionSlider *optionSlider = qstyleoption_cast<const QStyleOptionSlider *>(option)) {
+ valueFound = true;
+ metricValue = (optionSlider->orientation == Qt::Horizontal) ? optionSlider->rect.width() : optionSlider->rect.height();
+ }
+ break;
+ }
+ case PM_DockWidgetTitleBarButtonMargin:
+ case PM_DockWidgetTitleMargin:
+ case PM_DockWidgetSeparatorExtent:
+ case PM_DockWidgetHandleExtent: {
+ break; //todo: no suitable values in Hb?
+ }
+ case PM_DockWidgetFrameWidth: {
+ valueFound = false; //was true
+ QSize screenSize = HbDeviceProfile::current().logicalSize();
+ metricValue = screenSize.width();
+ break;
+ }
+ //Hb does not have tabs. Lets use toolbar layout data
+ case PM_TabBarTabHSpace: {
+ qreal toolbarWidth = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-widget-chrome-height"), toolbarWidth)) {
+ valueFound = true;
+ qreal iconWidth = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), iconWidth))
+ metricValue = (toolbarWidth - iconWidth) / 2;
+ else
+ metricValue = toolbarWidth / 2;
+ }
+ break;
+ }
+ case PM_TabBarTabVSpace: {
+ qreal toolbarHeight = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-widget-toolbar-height"), toolbarHeight)) {
+ valueFound = true;
+ qreal iconHeight = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), iconHeight))
+ metricValue = (toolbarHeight - iconHeight) / 2;
+ else
+ metricValue = toolbarHeight / 2;
+ }
+ break;
+ }
+ case PM_TabBarBaseHeight: {
+ valueFound = true;
+ metricValue = 2.0;
+ break;
+ }
+ case PM_TabBarTabOverlap:
+ case PM_TabBarBaseOverlap: {
+ metricValue = 1.0;
+ valueFound = true;
+ break;
+ }
+ case PM_ProgressBarChunkWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-progress-bar-height"), metricValue);
+ break;
+ }
+ case PM_SplitterWidth: {
+ //No splitter in Hb, so lets use interactive scrollbar width
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-scroll-bar-interactive-width"), metricValue);
+ break;
+ }
+ case PM_TitleBarHeight: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-chrome-height"), metricValue);
+ break;
+ }
+ case PM_MenuScrollerHeight: {
+ //No menu scroller in Hb, lets use interactive scrollbar width
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-scroll-bar-interactive-width"), metricValue);
+ break;
+ }
+ case PM_MenuHMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-left"), metricValue);
+ break;
+ }
+ case PM_MenuVMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-top"), metricValue);
+ break;
+ }
+ case PM_MenuPanelWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-background-list-popup"), metricValue);
+ break;
+ }
+ case PM_MenuTearoffHeight: {
+ valueFound = true;
+ metricValue = 0.0;
+ break;
+ }
+ case PM_MenuDesktopFrameWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-background-list-popup"), metricValue);
+ break;
+ }
+ case PM_MenuBarPanelWidth: {
+ valueFound = true;
+ metricValue = 0.0;
+ break;
+ }
+ case PM_MenuBarItemSpacing: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metricValue);
+ break;
+ }
+ case PM_MenuBarVMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-top"), metricValue);
+ break;
+ }
+ case PM_MenuBarHMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-left"), metricValue);
+ break;
+ }
+ // Hb indicators are squares and radiobuttons and checkboxes are of similar size.
+ case PM_IndicatorWidth:
+ case PM_IndicatorHeight:
+ case PM_ExclusiveIndicatorWidth:
+ case PM_ExclusiveIndicatorHeight:
+ case PM_CheckListButtonSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-secondary"), metricValue);
+ // todo: or hb-param-graphic-size-primary-small?
+ break;
+ }
+ case PM_CheckListControllerSize: {
+ break;
+ }
+ case PM_DialogButtonsSeparator: {
+ qreal buttonArea = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-widget-chrome-height"), buttonArea)) {
+ qreal buttonIconArea = 0.0;
+ valueFound = true;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), buttonIconArea))
+ metricValue = (buttonArea - buttonIconArea) / 2;
+ else
+ metricValue = buttonArea / 2;
+ }
+ break;
+ }
+ case PM_DialogButtonsButtonWidth:
+ case PM_DialogButtonsButtonHeight: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), metricValue);
+ break;
+ }
+ case PM_MdiSubWindowFrameWidth: {
+ valueFound = true;
+ metricValue = 0.75 * unitValue; //0.75 from uiemo documentation (margin for TitleBar)
+ break;
+ }
+ case PM_MdiSubWindowMinimizedWidth: {
+ //todo: will it cause issues, if we use Hb minimized titlebar size? Will Qt want to put dialog buttons visible?
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-chrome-height"), metricValue);
+ metricValue = metricValue / 6; //from Hb documentation: minimized TitleBar width
+ break;
+ }
+ case PM_HeaderMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-vertical"), metricValue);
+ break;
+ }
+ case PM_HeaderMarkSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-secondary"), metricValue);
+ break;
+ }
+ case PM_HeaderGripMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-vertical"), metricValue);
+ break;
+ }
+ case PM_TabBar_ScrollButtonOverlap: {
+ valueFound = true; //Lets put the tabs side-by-side
+ break;
+ }
+ case PM_TabBarTabShiftHorizontal:
+ case PM_TabBarTabShiftVertical: {
+ //todo: should we have tab shifting?
+ break;
+ }
+ case PM_TabBarScrollButtonWidth: {
+ qreal margin = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-top"), margin)) {
+ qreal buttonIconWidth = 0.0;
+ if (m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-secondary"), buttonIconWidth)) {
+ metricValue = margin * 2 + buttonIconWidth;
+ valueFound = true;
+ }
+ }
+ break;
+ }
+ case PM_ToolBarItemSpacing:
+ case PM_ToolBarItemMargin:
+ case PM_ToolBarFrameWidth: {
+ valueFound = true; //Hb Toolbar buttons are laid out with no margins between them
+ break;
+ }
+ case PM_ToolBarHandleExtent: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-chrome-height"), metricValue);
+ metricValue = (2 * metricValue) / 3; //Use minimized Chrome width for toolbar handle size.
+ break;
+ }
+ case PM_ToolBarSeparatorExtent: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-widget-toolbar-height"), metricValue);
+ break;
+ }
+ case PM_ToolBarExtensionExtent: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-secondary"), metricValue);
+ break;
+ }
+ case PM_SpinBoxSliderHeight: {//todo: what's this...
+ break;
+ }
+ case PM_ToolBarIconSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), metricValue);
+ break;
+ }
+ case PM_LargeIconSize:
+ case PM_ListViewIconSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-primary-large"), metricValue);
+ break;
+ }
+ case PM_TabBarIconSize:
+ case PM_SmallIconSize:
+ case PM_IconViewIconSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-primary-small"), metricValue);
+ break;
+ }
+ case PM_FocusFrameVMargin:
+ case PM_FocusFrameHMargin: {
+ valueFound = true;
+ metricValue = 4.0; //from hbstyle.cpp (P_PushButton_focus); value is already in pixels
+ break;
+ }
+ case PM_ToolTipLabelFrameWidth: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-background-popup-preview"), metricValue);
+ break;
+ }
+ case PM_CheckBoxLabelSpacing: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metricValue);
+ break;
+ }
+ case PM_SizeGripSize: {
+ //todo: AFAIK, Hb does not have sizegrips
+ break;
+ }
+ case PM_MessageBoxIconSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-primary-large"), metricValue);
+ break;
+ }
+ case PM_ButtonIconSize: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-function"), metricValue);
+ break;
+ }
+ case PM_RadioButtonLabelSpacing: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metricValue);
+ break;
+ }
+ case PM_LayoutLeftMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-left"), metricValue);
+ break;
+ }
+ case PM_LayoutTopMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-top"), metricValue);
+ break;
+ }
+ case PM_LayoutRightMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-right"), metricValue);
+ break;
+ }
+ case PM_LayoutBottomMargin: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-bottom"), metricValue);
+ break;
+ }
+ case PM_LayoutHorizontalSpacing: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-horizontal"), metricValue);
+ break;
+ }
+ case PM_LayoutVerticalSpacing: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-margin-gene-middle-vertical"), metricValue);
+ break;
+ }
+ case PM_TabCloseIndicatorWidth:
+ case PM_TabCloseIndicatorHeight: {
+ valueFound = m_private->styleManager()->parameter(QLatin1String("hb-param-graphic-size-primary-small"), metricValue);
+ break;
+ }
+ case PM_TextCursorWidth: {
+ valueFound = true;
+ metricValue = 1.0; //directly from Hb designers
+ break;
+ }
+ case PM_SubMenuOverlap:
+ default: {
+ break;
+ }
+ }
+ if (!valueFound)
+ return metricValue = QCommonStyle::pixelMetric(metric, option, widget);
+ else
+ return metricValue + 0.5; //rounding since hb values are qreals
+}
+
+QPixmap QHbStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *option,
+ const QWidget *widget) const
+{
+ return QCommonStyle::standardPixmap(standardPixmap, option, widget);
+}
+
+void QHbStyle::polish(QWidget *widget)
+{
+ if (!widget)
+ return;
+
+ if (false
+#ifndef QT_NO_SCROLLBAR
+ || qobject_cast<QScrollBar *>(widget)
+#endif
+ ) {
+ widget->setAttribute(Qt::WA_OpaquePaintEvent, false);
+ }
+
+ if (m_private->isDialog(widget)) {
+ widget->setAttribute(Qt::WA_StyledBackground);
+ }
+
+ m_private->polishFont(widget);
+
+ QCommonStyle::polish(widget);
+
+#ifndef QT_NO_PROGRESSBAR
+ if (qobject_cast<QProgressBar *>(widget))
+ widget->installEventFilter(this);
+#endif
+}
+
+void QHbStyle::polish(QApplication *app)
+{
+ QCommonStyle::polish(app);
+}
+
+void QHbStyle::polish(QPalette &palette)
+{
+ QCommonStyle::polish(palette);
+
+ palette.setBrush(QPalette::Disabled, QPalette::WindowText, QColor(QRgb(0xff808080)));
+ palette.setBrush(QPalette::Disabled, QPalette::Button, QColor(QRgb(0xffdddfe4)));
+ palette.setBrush(QPalette::Disabled, QPalette::Light, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Disabled, QPalette::Midlight, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Disabled, QPalette::Dark, QColor(QRgb(0xff555555)));
+ palette.setBrush(QPalette::Disabled, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
+ palette.setBrush(QPalette::Disabled, QPalette::Text, QColor(QRgb(0xffc7c7c7)));
+ palette.setBrush(QPalette::Disabled, QPalette::BrightText, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Disabled, QPalette::ButtonText, QColor(QRgb(0xff808080)));
+ palette.setBrush(QPalette::Disabled, QPalette::Base, QColor(QRgb(0xffefefef)));
+ palette.setBrush(QPalette::Disabled, QPalette::AlternateBase, palette.color(QPalette::Disabled, QPalette::Base).darker(110));
+ palette.setBrush(QPalette::Disabled, QPalette::Window, QColor(QRgb(0xffefefef)));
+ palette.setBrush(QPalette::Disabled, QPalette::Shadow, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Disabled, QPalette::Highlight, QColor(QRgb(0xff567594)));
+ palette.setBrush(QPalette::Disabled, QPalette::HighlightedText, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Disabled, QPalette::Link, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Disabled, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
+ palette.setBrush(QPalette::Disabled, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Disabled, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
+
+ palette.setBrush(QPalette::Active, QPalette::WindowText, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Active, QPalette::Button, QColor(QRgb(0xffdddfe4)));
+ palette.setBrush(QPalette::Active, QPalette::Light, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Active, QPalette::Midlight, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Active, QPalette::Dark, QColor(QRgb(0xff555555)));
+ palette.setBrush(QPalette::Active, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
+ palette.setBrush(QPalette::Active, QPalette::Text, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Active, QPalette::BrightText, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Active, QPalette::ButtonText, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Active, QPalette::Base, QColor(QRgb(0xE4E4E4)));
+ palette.setBrush(QPalette::Active, QPalette::AlternateBase, palette.color(QPalette::Active, QPalette::Base).darker(110));
+ palette.setBrush(QPalette::Active, QPalette::Window, QColor(QRgb(0xffefefef)));
+ palette.setBrush(QPalette::Active, QPalette::Shadow, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Active, QPalette::Highlight, QColor(QRgb(0xffE4E4E4)));
+ palette.setBrush(QPalette::Active, QPalette::HighlightedText, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Active, QPalette::Link, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Active, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
+ palette.setBrush(QPalette::Active, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Active, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
+
+ palette.setBrush(QPalette::Inactive, QPalette::WindowText, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Inactive, QPalette::Button, QColor(QRgb(0xffdddfe4)));
+ palette.setBrush(QPalette::Inactive, QPalette::Light, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Inactive, QPalette::Midlight, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Inactive, QPalette::Dark, QColor(QRgb(0xff555555)));
+ palette.setBrush(QPalette::Inactive, QPalette::Mid, QColor(QRgb(0xffc7c7c7)));
+ palette.setBrush(QPalette::Inactive, QPalette::Text, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Inactive, QPalette::BrightText, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Inactive, QPalette::ButtonText, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Inactive, QPalette::Base, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Inactive, QPalette::AlternateBase, palette.color(QPalette::Inactive, QPalette::Base).darker(110));
+ palette.setBrush(QPalette::Inactive, QPalette::Window, QColor(QRgb(0xffefefef)));
+ palette.setBrush(QPalette::Inactive, QPalette::Shadow, QColor(QRgb(0xff000000)));
+ palette.setBrush(QPalette::Inactive, QPalette::Highlight, QColor(QRgb(0xff678db2)));
+ palette.setBrush(QPalette::Inactive, QPalette::HighlightedText, QColor(QRgb(0xffffffff)));
+ palette.setBrush(QPalette::Inactive, QPalette::Link, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Inactive, QPalette::LinkVisited, QColor(QRgb(0xff52188b)));
+ palette.setBrush(QPalette::Inactive, QPalette::ToolTipBase, QColor(QRgb(0xff0000ee)));
+ palette.setBrush(QPalette::Inactive, QPalette::ToolTipText, QColor(QRgb(0xff52188b)));
+}
+
+void QHbStyle::unpolish(QWidget *widget)
+{
+ if (!widget)
+ return;
+
+ if (false
+ #ifndef QT_NO_SCROLLBAR
+ || qobject_cast<QScrollBar *>(widget)
+ #endif
+ )
+ widget->setAttribute(Qt::WA_OpaquePaintEvent);
+
+ if (m_private->isDialog(widget)) {
+ widget->setAttribute(Qt::WA_StyledBackground, false);
+ }
+
+ QCommonStyle::unpolish(widget);
+
+#ifndef QT_NO_PROGRESSBAR
+ if (qobject_cast<QProgressBar *>(widget)) {
+ widget->removeEventFilter(this);
+ }
+#endif
+}
+
+void QHbStyle::unpolish(QApplication *app)
+{
+ QCommonStyle::unpolish(app);
+}
+
+QPalette QHbStyle::standardPalette() const
+{
+ // This function not called if system support system colors
+ return QCommonStyle::standardPalette();
+}
+
+QIcon QHbStyle::standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *option,
+ const QWidget *widget) const
+{
+ QRect iconRect;
+ if (option) {
+ iconRect = option->rect;
+ } else if (widget) {
+ iconRect = widget->rect();
+ } else {
+ iconRect.setWidth(proxy()->pixelMetric(PM_SmallIconSize, option, widget));
+ iconRect.setHeight(proxy()->pixelMetric(PM_SmallIconSize, option, widget));
+ }
+ QString iconName;
+
+ switch (standardIcon) {
+ case SP_TitleBarMenuButton: {
+ break;
+ }
+ case SP_TitleBarMinButton: {
+ break;
+ }
+ case SP_TitleBarMaxButton: {
+ break;
+ }
+ case SP_TitleBarCloseButton: {
+ break;
+ }
+ case SP_TitleBarNormalButton: {
+ break;
+ }
+ case SP_TitleBarShadeButton: {
+ break;
+ }
+ case SP_TitleBarUnshadeButton: {
+ break;
+ }
+ case SP_TitleBarContextHelpButton: {
+ break;
+ }
+ case SP_DockWidgetCloseButton: {
+ break;
+ }
+ case SP_MessageBoxInformation: {
+ iconName = QLatin1String("note_info");
+ break;
+ }
+ case SP_MessageBoxWarning: {
+ iconName = QLatin1String("note_warning");
+ break;
+ }
+ case SP_MessageBoxCritical: {
+ iconName = QLatin1String("note_error");
+ break;
+ }
+ case SP_MessageBoxQuestion: {
+ iconName = QLatin1String("qtg_large_question_mark");
+ break;
+ }
+ case SP_DesktopIcon: {
+ break;
+ }
+ case SP_TrashIcon: {
+ break;
+ }
+ case SP_ComputerIcon: {
+ iconName = QLatin1String("qtg_mono_mobile");
+ break;
+ }
+ case SP_DriveFDIcon: {
+ break;
+ }
+ case SP_DriveHDIcon: {
+ break;
+ }
+ case SP_DriveCDIcon: {
+ break;
+ }
+ case SP_DriveDVDIcon: {
+ break;
+ }
+ case SP_DriveNetIcon: {
+ break;
+ }
+ case SP_DirOpenIcon: {
+ break;
+ }
+ case SP_DirClosedIcon: {
+ break;
+ }
+ case SP_DirLinkIcon: {
+ break;
+ }
+ case SP_FileIcon: {
+ break;
+ }
+ case SP_FileLinkIcon: {
+ break;
+ }
+ case SP_ToolBarHorizontalExtensionButton: {
+ break;
+ }
+ case SP_ToolBarVerticalExtensionButton: {
+ break;
+ }
+ case SP_FileDialogStart: {
+ break;
+ }
+ case SP_FileDialogEnd: {
+ break;
+ }
+ case SP_FileDialogToParent: {
+ break;
+ }
+ case SP_FileDialogNewFolder: {
+ break;
+ }
+ case SP_FileDialogDetailedView: {
+ break;
+ }
+ case SP_FileDialogInfoView: {
+ break;
+ }
+ case SP_FileDialogContentsView: {
+ break;
+ }
+ case SP_FileDialogListView: {
+ break;
+ }
+ case SP_FileDialogBack: {
+ break;
+ }
+ case SP_DirIcon: {
+ break;
+ }
+ case SP_DialogOkButton: {
+ break;
+ }
+ case SP_DialogCancelButton: {
+ break;
+ }
+ case SP_DialogHelpButton: {
+ break;
+ }
+ case SP_DialogOpenButton: {
+ break;
+ }
+ case SP_DialogSaveButton: {
+ break;
+ }
+ case SP_DialogCloseButton: {
+ break;
+ }
+ case SP_DialogApplyButton: {
+ break;
+ }
+ case SP_DialogResetButton: {
+ break;
+ }
+ case SP_DialogDiscardButton: {
+ break;
+ }
+ case SP_DialogYesButton: {
+ break;
+ }
+ case SP_DialogNoButton: {
+ break;
+ }
+ case SP_ArrowUp: {
+ break;
+ }
+ case SP_ArrowDown: {
+ break;
+ }
+ case SP_ArrowLeft: {
+ break;
+ }
+ case SP_ArrowRight: {
+ break;
+ }
+ case SP_ArrowBack: {
+ break;
+ }
+ case SP_ArrowForward: {
+ break;
+ }
+ case SP_DirHomeIcon: {
+ break;
+ }
+ case SP_CommandLink: {
+ break;
+ }
+ case SP_VistaShield: {
+ break;
+ }
+ case SP_BrowserReload: {
+ break;
+ }
+ case SP_BrowserStop: {
+ break;
+ }
+ case SP_MediaPlay: {
+ iconName = QLatin1String("qtg_graf_progslider_handle_play_normal");
+ break;
+ }
+ case SP_MediaStop: {
+ break;
+ }
+ case SP_MediaPause: {
+ iconName = QLatin1String("qtg_graf_progslider_handle_pause_normal");
+ break;
+ }
+ case SP_MediaSkipForward: {
+ break;
+ }
+ case SP_MediaSkipBackward: {
+ break;
+ }
+ case SP_MediaSeekForward: {
+ break;
+ }
+ case SP_MediaSeekBackward: {
+ break;
+ }
+ case SP_MediaVolume: {
+ iconName = QLatin1String("qgn_indi_nslider_unmuted");
+ break;
+ }
+ case SP_MediaVolumeMuted: {
+ iconName = QLatin1String("qgn_indi_nslider_muted");
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+
+ QIcon icon;
+ if (!iconName.isNull()) {
+ HbIcon* hbicon = q_check_ptr(new HbIcon(iconName));
+ hbicon->setSize(iconRect.size());
+ icon = QIcon(hbicon->qicon());
+ delete hbicon;
+ } else {
+ icon = QCommonStyle::standardIconImplementation(standardIcon, option, widget);
+ }
+ return icon;
+}
+
+int QHbStyle::layoutSpacingImplementation(QSizePolicy::ControlType control1,
+ QSizePolicy::ControlType control2,
+ Qt::Orientation orientation,
+ const QStyleOption *option,
+ const QWidget *widget) const
+{
+ return QCommonStyle::layoutSpacingImplementation(control1, control2, orientation, option, widget);
+}
+
+bool QHbStyle::eventFilter(QObject *watched, QEvent *event)
+{
+ switch( event->type()) {
+#ifndef QT_NO_PROGRESSBAR
+ case QEvent::StyleChange:
+ case QEvent::Show: {
+ if (m_private->animationGroup()->state() != QAbstractAnimation::Running )
+ m_private->animationGroup()->start();
+ break;
+ }
+ case QEvent::ApplicationLayoutDirectionChange:
+ case QEvent::LayoutDirectionChange:
+ case QEvent::Resize:
+ case QEvent::Destroy:
+ case QEvent::Hide: {
+ if (QProgressBar *bar = qobject_cast<QProgressBar *>(watched)) {
+ const int count = m_private->animationGroup()->animationCount();
+ for (int i(count-1); i >= 0; i--) {
+ QAbstractAnimation* animation = m_private->animationGroup()->animationAt(i);
+ if (QPropertyAnimation *pAnimation = qobject_cast<QPropertyAnimation *>(animation)) {
+ QHbStyleAnimation* styleAnimation = qobject_cast<QHbStyleAnimation *>(pAnimation->targetObject());
+ if (bar == styleAnimation->target()) {
+ animation = m_private->animationGroup()->takeAnimation(i);
+ animation->deleteLater();
+ }
+ }
+ }
+ if (m_private->animationGroup()->animationCount() == 0 &&
+ m_private->animationGroup()->state() == QAbstractAnimation::Running)
+ m_private->animationGroup()->stop();
+ }
+ break;
+ }
+#endif // QT_NO_PROGRESSBAR
+ default: {
+ break;
+ }
+ };
+
+ return QCommonStyle::eventFilter(watched, event);
+}
+
+void QHbStyle::animateControl(ControlElement element, const QStyleOption *option,
+ QPainter *painter, const QWidget *widget) const{
+ switch(element) {
+ case CE_ProgressBarContents: {
+ if (const QProgressBar *bar = static_cast<const QProgressBar *>(widget)) {
+ if (bar->minimum() == 0 && bar->maximum() == 0) {
+ QHbStyleAnimation* styleAnimation = 0;
+ const int count = m_private->animationGroup()->animationCount();
+ bool alreadyAnimated = false;
+ for (int i(0); i < count; i++) {
+ QAbstractAnimation* animation = m_private->animationGroup()->animationAt(i);
+ if (QPropertyAnimation *pAnimation = qobject_cast<QPropertyAnimation *>(animation)) {
+ styleAnimation = qobject_cast<QHbStyleAnimation *>(pAnimation->targetObject());
+ if (bar == styleAnimation->target()) {
+ alreadyAnimated = true;
+ break;
+ }
+ }
+ }
+ if (!alreadyAnimated) {
+ QHbStyleAnimation* target = q_check_ptr(new QHbStyleAnimation(const_cast<QProgressBar*>(bar)));
+ target->createAnimationIcon(CE_ProgressBarContents, bar->orientation());
+ QPropertyAnimation* animation = q_check_ptr(new QPropertyAnimation(target, "point"));
+ animation->setLoopCount(-1); //run until stopped
+ const int chunk = pixelMetric(PM_ProgressBarChunkWidth, option, widget)-1;
+ if (bar->orientation()== Qt::Horizontal) {
+ if ((option->direction == Qt::LeftToRight) ^ const_cast<QProgressBar*>(bar)->invertedAppearance()) {
+ animation->setStartValue(bar->rect().topLeft());
+ animation->setEndValue(QPoint(bar->rect().x()-chunk, bar->rect().y()));
+ } else {
+ animation->setStartValue(QPoint(bar->rect().x()-chunk, bar->rect().y()));
+ animation->setEndValue(bar->rect().topLeft());
+ }
+ }
+ else {
+ if ((option->direction == Qt::LeftToRight) ^ const_cast<QProgressBar*>(bar)->invertedAppearance()) {
+ animation->setStartValue(bar->rect().topLeft());
+ animation->setEndValue(QPoint(bar->rect().x(), bar->rect().y()-chunk));
+ } else {
+ animation->setStartValue(QPoint(bar->rect().x(), bar->rect().y()-chunk));
+ animation->setEndValue(bar->rect().topLeft());
+ }
+ }
+ m_private->animationGroup()->addAnimation(animation);
+ } else {
+ styleAnimation->paintAnimation(painter);
+ }
+ }
+ }
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+
+ if (m_private->animationGroup()->animationCount() > 0 &&
+ m_private->animationGroup()->state() != QAbstractAnimation::Running)
+ m_private->animationGroup()->start();
+}
+
+bool QHbStylePrivate::drawItem(Item part, QPainter *painter, const QRect &rect, ItemStates state, const QColor &color)
+{
+ QString iconName;
+ switch(part) {
+ case SP_Arrow: {
+ if (state & SS_Up)
+ iconName = QLatin1String("qgn_indi_input_arrow_up");
+ else if (state & SS_Down)
+ iconName = QLatin1String("qgn_indi_input_arrow_down");
+ else if (state && SS_Left)
+ iconName = QLatin1String("qgn_indi_input_arrow_left");
+ else
+ iconName = QLatin1String("qgn_indi_input_arrow_right");
+ break;
+ }
+ case SP_BoxButton: {
+ if (state & SS_Disabled)
+ iconName = QString("qtg_graf_combobox_button_disabled");
+ else if (state & SS_Pressed)
+ iconName = QString("qtg_graf_combobox_button_pressed");
+ else if (state & SS_Selected)
+ iconName = QString("qtg_graf_combobox_button_highlight");
+ else
+ iconName = QString("qtg_graf_combobox_button_normal");
+ break;
+ }
+ case SP_CheckBoxIndicator: {
+ if (state & SS_Inactive)
+ iconName = QLatin1String("qtg_small_unselected");
+ else
+ iconName = QLatin1String("qtg_small_selected");
+ break;
+ }
+ case SP_HeaderOrderIndicator: {
+ iconName = QLatin1String("qtg_mono_sort");
+ break;
+ }
+ case SP_ItemDecoration: {
+ if (state & SS_Selected)
+ iconName = QString("qtg_small_tick");
+ break;
+ }
+ case SP_MenuSeparator: {
+ iconName = QLatin1String("qtg_graf_popup_separator");
+ break;
+ }
+ case SP_RadioButtonIndicator: {
+ if (state & SS_Inactive)
+ iconName = QLatin1String("qtg_small_radio_unselected");
+ else
+ iconName = QLatin1String("qtg_small_radio_selected");
+ break;
+ }
+ case SP_SliderHandle: {
+ if (state & SS_Horizontal) {
+ if (state & SS_Pressed)
+ iconName = QLatin1String("qtg_graf_slider_h_handle_pressed");
+ else
+ iconName = QLatin1String("qtg_graf_slider_h_handle_normal");
+ } else {
+ if (state & SS_Pressed)
+ iconName = QLatin1String("qtg_graf_slider_v_handle_pressed");
+ else
+ iconName = QLatin1String("qtg_graf_slider_v_handle_normal");
+ }
+ break;
+ }
+ case SP_SliderTick: {
+ if (state & SS_Horizontal)
+ iconName = QLatin1String("qtg_graf_slider_h_tick_major");
+ else
+ iconName = QLatin1String("qtg_graf_slider_v_tick_major");
+ break;
+ }
+ case SP_SeparatorLine: {
+ // @todo: or "qtg_graf_popup_separator" and states and rotation
+ if (state & SS_Horizontal)
+ iconName = QLatin1String("qtg_graf_devider_h_thin");
+ else
+ iconName = QLatin1String("qtg_graf_devider_v_thin");
+ break;
+ }
+ case SP_TreeViewExpanded: {
+ iconName = QLatin1String("qtg_small_hl_opened");
+ break;
+ }
+ case SP_TreeViewCollapsed: {
+ iconName = QLatin1String("qtg_small_hl_closed");
+ break;
+ }
+ case SP_SubMenuIndicator:
+ default: {
+ return false;
+ }
+ }
+ if (!iconName.isNull() && !rect.isEmpty()) {
+ HbIcon *icon = q_check_ptr(new HbIcon(iconName));
+ icon->setSize(rect.size());
+ if (color.spec() != QColor::Invalid)
+ icon->setColor(color);
+ if (state & SS_Mirrored)
+ icon->setMirroringMode(HbIcon::Forced);
+
+ painter->save();
+ painter->setRenderHint(QPainter::Antialiasing);
+
+ if (state & SS_Flipped) {
+ QTransform m;
+ m.rotate(180);
+ m.translate(-rect.width() - 2 * rect.left(), -rect.height() - 2 * rect.top());
+ painter->setTransform(m, true);
+ }
+ icon->paint(painter, rect, Qt::IgnoreAspectRatio, Qt::AlignCenter, QIcon::Normal, QIcon::On);
+ painter->restore();
+ delete icon;
+ }
+ return true;
+}
+
+bool QHbStylePrivate::drawMultiPartItem(MultiPartItem multiPart, QPainter *painter, const QRect &rect, ItemStates state)
+{
+ //Q_Q(QHbStyle);
+
+ if (!m_frameDrawer)
+ m_frameDrawer = q_check_ptr(new HbFrameDrawer());
+
+ HbFrameDrawer::FrameType frameType = HbFrameDrawer::Undefined;
+ QString frameName;
+ qreal border = 0.0;
+ HbIcon::MirroringMode mirrorMode = HbIcon::Default;
+ bool fillRect = false;
+
+ QStringList framePartList;
+ QString frameGraphicsFooter;
+ QString frameGraphicsHeader;
+ switch (multiPart) {
+ case SM_BoxFrame: {
+ fillRect = true;
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ if (state & SS_Disabled)
+ frameName = QString("qtg_fr_combobox_disabled");
+ else if (state & SS_Pressed)
+ frameName = QString("qtg_fr_combobox_pressed");
+ else if (state & SS_Edited)
+ frameName = QString("qtg_fr_combobox_edit");
+ else if (state & SS_Selected)
+ frameName = QString("qtg_fr_combobox_highlight");
+ else
+ frameName = QString("qtg_fr_combobox_normal");
+ break;
+ }
+ case SM_Dialog: {
+ frameName = QLatin1String("qtg_fr_popup");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_GroupBox: {
+ styleManager()->parameter(QLatin1String("hb-param-background-groupbox"), border);
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_groupbox_pressed");
+ else if (state & SS_Selected && state & SS_Active)
+ frameName = QLatin1String("qtg_fr_groupbox_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_groupbox_normal");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_GroupBoxTitle: {
+ frameName = QLatin1String("qtg_fr_groupbox");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_ItemViewHighlight: {
+ frameName = QLatin1String("qtg_fr_list_highlight");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_ItemViewItem: {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_list_pressed");
+ else if (state & SS_Focused)
+ frameName = QLatin1String("qtg_fr_list_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_list_normal");
+ frameType = HbFrameDrawer::NinePieces;
+ styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
+ break;
+ }
+ case SM_LineEdit: {
+ styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
+ if (state & SS_Selected)
+ frameName = QLatin1String("qtg_fr_editor_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_editor_normal");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_ListParent: {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_list_pressed");
+ else if (state & SS_Focused)
+ frameName = QLatin1String("qtg_fr_list_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_list_parent_normal");
+ frameType = HbFrameDrawer::NinePieces;
+ styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
+ break;
+ }
+ case SM_Menu: {
+ frameName = QLatin1String("qtg_fr_popup_secondary");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_MenuScroller: {
+ if (state & SS_Down)
+ frameName = QLatin1String("qtg_graf_list_mask_b");
+ else if (state & SS_Up)
+ frameName = QLatin1String("qtg_graf_list_mask_t");
+ frameType = HbFrameDrawer::OnePiece;
+ break;
+ }
+ case SM_MenuItem: {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_popup_list_pressed");
+ else if (state & SS_Selected)
+ frameName = QLatin1String("qtg_fr_popup_list_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_popup_list_normal");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_Panel: {
+ frameName = QLatin1String("qtg_fr_settingform");
+ frameType = HbFrameDrawer::NinePieces;
+ styleManager()->parameter(QLatin1String("hb-param-background-list-main"), border);
+ break;
+ }
+ case SM_ProgressBarGroove: {
+ fillRect = true;
+ if (state & SS_Horizontal) {
+ frameName = QLatin1String("qtg_fr_progbar_h_frame");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ frameName = QLatin1String("qtg_fr_progbar_v_frame");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ break;
+ }
+ case SM_ProgressBarIndicator: {
+ fillRect = true;
+ if (state & SS_Horizontal) {
+ frameName = QLatin1String("qtg_fr_progbar_h_filled");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ frameName = QLatin1String("qtg_fr_progbar_v_filled");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ break;
+ }
+ case SM_ToolButton: {
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ frameGraphicsHeader = QLatin1String("qtg_fr_tb_h_");
+
+ framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_cr");
+
+ if (state & SS_Disabled)
+ frameGraphicsFooter = QLatin1String("disabled");
+ else if (state & SS_Pressed)
+ frameGraphicsFooter = QLatin1String("pressed");
+ else if (state & SS_Selected)
+ frameGraphicsFooter = QLatin1String("highlight");
+ else
+ frameGraphicsFooter = QLatin1String("normal");
+ break;
+ }
+ case SM_PushButton: {
+ frameType = HbFrameDrawer::NinePieces;
+ if (state & SS_Disabled)
+ frameName = QLatin1String("qtg_fr_btn_disabled");
+ else if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_btn_pressed");
+ else if (state & SS_Selected)
+ frameName = QLatin1String("qtg_fr_btn_highlight");
+ else if (state & SS_Latched)
+ frameName = QLatin1String("qtg_fr_btn_latched");
+ else
+ frameName = QLatin1String("qtg_fr_btn_normal");
+ styleManager()->parameter(QLatin1String("hb-param-background-button"), border);
+ break;
+ }
+ case SM_ScrollBarGroove: {
+ fillRect = true;
+ if (state & SS_Horizontal) {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_scroll_h_active_frame_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_scroll_h_active_frame_normal");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_scroll_v_active_frame_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_scroll_v_active_frame_normal");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ break;
+ }
+ case SM_ScrollBarHandle: {
+ fillRect = true;
+ if (state & SS_Horizontal) {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_scroll_h_active_handle_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_scroll_h_active_handle_normal");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_scroll_v_active_handle_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_scroll_v_active_handle_normal");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ break;
+ }
+ case SM_SliderGroove: {
+ fillRect = true;
+ if (state & SS_Horizontal) {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_slider_h_frame_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_slider_h_frame_normal");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_slider_v_frame_pressed");
+ else
+ frameName = QLatin1String("qtg_fr_slider_v_frame_normal");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ break;
+ }
+ case SM_SliderProgress: {
+ fillRect = true;
+ if (state & SS_Filled) {
+ if (state & SS_Horizontal) {
+ frameName = QLatin1String("qtg_fr_slider_h_filled");
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ } else {
+ frameName = QLatin1String("qtg_fr_slider_v_filled");
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ }
+ }
+ break;
+ }
+ case SM_TabShape: {
+ if (state & SS_Horizontal) {
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ frameGraphicsHeader = QLatin1String("qtg_fr_tb_h_");
+
+ if (state & SS_Beginning)
+ framePartList << QLatin1String("_l") << QLatin1String("_c") << QLatin1String("_cr");
+ else if (state & SS_Middle)
+ framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_cr");
+ else if (state & SS_End)
+ framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_r");
+ else
+ framePartList << QLatin1String("_cl") << QLatin1String("_c") << QLatin1String("_r");
+ } else if (state & SS_Vertical) {
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ frameGraphicsHeader = QLatin1String("qtg_fr_tb_v_");
+ if (state & SS_Beginning)
+ framePartList << QLatin1String("_t") << QLatin1String("_c") << QLatin1String("_cb");
+ else if (state & SS_Middle)
+ framePartList << QLatin1String("_ct") << QLatin1String("_c") << QLatin1String("_cb");
+ else if (state & SS_End)
+ framePartList << QLatin1String("_ct") << QLatin1String("_c") << QLatin1String("_b");
+ else
+ framePartList << QLatin1String("_t") << QLatin1String("_c") << QLatin1String("_b");
+ }
+ if (state & SS_Disabled)
+ frameGraphicsFooter = QLatin1String("disabled");
+ else if (state & SS_Pressed)
+ frameGraphicsFooter = QLatin1String("pressed");
+ else if (state & SS_Selected)
+ frameGraphicsFooter = QLatin1String("highlight");
+ else
+ frameGraphicsFooter = QLatin1String("normal");
+ break;
+ }
+ case SM_TextEdit: { //@todo: combine this and case SM_LineEdit to "case SM_TextEditor"?
+ styleManager()->parameter(QLatin1String("hb-param-background-editor"), border);
+ frameName = QLatin1String("qtg_fr_editor");
+ frameType = HbFrameDrawer::NinePieces;
+ break;
+ }
+ case SM_ToolBarButton: {
+ if (state & SS_Horizontal) {
+ frameType = HbFrameDrawer::ThreePiecesHorizontal;
+ if (state & SS_Disabled)
+ frameName = QLatin1String("qtg_fr_tb_h_disabled");
+ else if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_tb_h_pressed");
+ else if (state & SS_Latched)
+ frameName = QLatin1String("qtg_fr_tb_h_latched");
+ else if (state & SS_Selected)
+ frameName = QLatin1String("qtg_fr_tb_h_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_tb_h_normal");
+ } else {
+ frameType = HbFrameDrawer::ThreePiecesVertical;
+ if (state & SS_Disabled)
+ frameName = QLatin1String("qtg_fr_tb_v_disabled");
+ else if (state & SS_Pressed)
+ frameName = QLatin1String("qtg_fr_tb_v_pressed");
+ else if (state & SS_Latched)
+ frameName = QLatin1String("qtg_fr_tb_v_latched");
+ else if (state & SS_Selected)
+ frameName = QLatin1String("qtg_fr_tb_v_highlight");
+ else
+ frameName = QLatin1String("qtg_fr_tb_v_normal");
+ }
+ styleManager()->parameter(QLatin1String("hb-param-background-button"), border);
+ break;
+ }
+ case SM_ToolTip: {
+ fillRect = true;
+ frameType = HbFrameDrawer::NinePieces;
+ frameName = QLatin1String("qtg_fr_popup_preview");
+ break;
+ }
+ case SM_HeaderItem:
+ case SM_TableItem:
+ case SM_ThemeBackground:
+ case SM_ToolBar:
+ default: {
+ break;
+ }
+ }
+
+ if (frameType != HbFrameDrawer::Undefined)
+ m_frameDrawer->setFrameType(frameType);
+ else
+ return false;
+
+ if (!frameName.isNull()) {
+ m_frameDrawer->setFrameGraphicsName(frameName);
+ } else if (framePartList.count() > 0) {
+ m_frameDrawer->setFileNameSuffixList(framePartList);
+ m_frameDrawer->setFrameGraphicsName(QString ("%0%1").arg(frameGraphicsHeader).arg(frameGraphicsFooter));
+ } else {
+ return false;
+ }
+
+ m_frameDrawer->setBorderWidth(border);
+ m_frameDrawer->setFillWholeRect(fillRect);
+ if (state & SS_Mirrored)
+ mirrorMode = HbIcon::Forced;
+
+ m_frameDrawer->setMirroringMode(mirrorMode);
+
+ const bool rotated = (state & SS_Flipped || state & SS_RotatedRight || state & SS_RotatedLeft) ? true : false;
+ QRect validRect = rect;
+ if (rotated) {
+ QTransform m;
+ painter->save();
+
+ //Calculate new coordinates
+ int newX = 0, newY = 0;
+ if (state & SS_RotatedRight) {
+ newX = 0;
+ newY = rect.y() + rect.height() - 1;
+ } else if (state & SS_RotatedLeft) {
+ newX = rect.width();
+ newY = rect.y() - 1;
+ } else if (state & SS_Flipped) {
+ if (state & SS_Horizontal) {
+ newX = rect.width() + 2 * rect.left();
+ newY = rect.height() + rect.top();
+ } else {
+ newX = rect.width() + rect.left();
+ newY = rect.height() + 2 * rect.top();
+ }
+ }
+
+ //Translate rect and transform
+ if ((state & SS_RotatedRight) || (state & SS_RotatedLeft))
+ validRect.setRect(0, 0, rect.height(), rect.width());
+ m.translate(newX, newY);
+
+ // Set rotation
+ int rotation = 0;
+ if (state & SS_Flipped)
+ rotation = 180;
+ else if (state & SS_RotatedRight)
+ rotation = -90;
+ else if (state & SS_RotatedLeft)
+ rotation = 90;
+ m.rotate(rotation);
+ painter->setTransform(m, true);
+ }
+ m_frameDrawer->paint(painter, validRect);
+
+ if (rotated)
+ painter->restore();
+
+ //Need to clear the list after use.
+ framePartList.clear();
+ m_frameDrawer->setFileNameSuffixList(framePartList);
+ return true;
+}
+
+bool QHbStylePrivate::isDialog(const QWidget *widget)
+{
+ return (widget ? (widget->windowType() == Qt::Dialog) : false);
+}
+
+bool QHbStylePrivate::hbParameter(const QString ¶meterName, int &value)
+{
+ bool retValue = false;
+ qreal valueInReal = 0.0;
+ retValue = styleManager()->parameter(parameterName, valueInReal);
+ valueInReal += 0.5; //to make the real->int to round correctly
+ value = valueInReal;
+ return retValue;
+}
+
+void QHbStylePrivate::polishFont(QWidget *widget)
+{
+ HbFontSpec::Role fontRole = HbFontSpec::Undefined;
+ qreal fontSize = 0.0;
+ bool valueFound = false;
+
+ //Widget font role specifications from hb documentation.
+ if (false
+#ifndef QT_NO_COMBOBOX
+ || qobject_cast<QComboBox *>(widget)
+#endif
+#ifndef QT_NO_SPINBOX
+ || qobject_cast<QSpinBox *>(widget)
+#endif
+ || qobject_cast<QRadioButton *>(widget)
+ ) {
+ valueFound = styleManager()->parameter(QLatin1String("b-param-text-height-secondary"), fontSize);
+ fontRole = HbFontSpec::Primary;
+ } else if (false
+ || qobject_cast<QPushButton *>(widget)
+#ifndef QT_NO_TOOLBUTTON
+ || qobject_cast<QToolButton *>(widget)
+#endif
+#ifndef QT_NO_TABWIDGET
+ || qobject_cast<QTabWidget *>(widget)
+#endif
+ ) {
+ valueFound = styleManager()->parameter(QLatin1String("hb-param-text-height-tiny"), fontSize);
+ fontRole = HbFontSpec::Primary;
+ } else if (false
+#ifndef QT_NO_HEADERVIEW
+ || qobject_cast<QHeaderView *>(widget)
+#endif
+#ifndef QT_NO_LISTVIEW
+ || qobject_cast<QListView *>(widget)
+#endif
+#ifndef QT_NO_TABLEVIEW
+ || qobject_cast<QTableView *>(widget)
+#endif
+#ifndef QT_NO_TREEVIEW
+ || qobject_cast<QTreeView *>(widget)
+#endif
+#ifndef QT_NO_LINEEDIT
+ || qobject_cast<QLineEdit *>(widget)
+#endif
+#ifndef QT_NO_TEXTEDIT
+ || qobject_cast<QTextEdit *>(widget)
+#endif
+ || qobject_cast<QSlider *>(widget)
+#ifndef QT_NO_SLIDER
+ || qobject_cast<QGroupBox *>(widget)
+#endif
+ || qobject_cast<QCheckBox *>(widget)
+ ) {
+ fontRole = HbFontSpec::Secondary;
+ valueFound = styleManager()->parameter(QLatin1String("hb-param-text-height-secondary"), fontSize);
+ } else if (false
+#ifndef QT_NO_PROGRESSBAR
+ || qobject_cast<QProgressBar *>(widget)
+#endif
+ ) {
+ fontRole = HbFontSpec::Secondary;
+ valueFound = styleManager()->parameter(QLatin1String("hb-param-text-height-tiny"), fontSize);
+ }
+
+ HbFontSpec *fontSpec = q_check_ptr(new HbFontSpec(fontRole));
+ if (valueFound) {
+ fontSpec->setTextHeight(fontSize);
+ QFont widgetFont = fontSpec->font();
+ widgetFont.setPixelSize(fontSpec->font().pixelSize());
+ widget->setFont(widgetFont);
+ }
+ delete fontSpec;
+}
+
+QT_END_NAMESPACE