Revision control
Copy as Markdown
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qohosstyle_p.h"
#include <QtGui/qicon.h>
#include <QtGui/qpainter.h>
#include <QtGui/qpainterpath.h>
#include <QtWidgets/qabstractscrollarea.h>
#include <QtWidgets/qcheckbox.h>
#include <QtWidgets/qcombobox.h>
#include <QtWidgets/qlineedit.h>
#include <QtWidgets/qlistview.h>
#include <QtWidgets/qmdisubwindow.h>
#include <QtWidgets/qpushbutton.h>
#include <QtWidgets/qradiobutton.h>
#include <QtWidgets/qscrollbar.h>
#include <QtWidgets/qspinbox.h>
#include <QtWidgets/qstyleditemdelegate.h>
#include <QtWidgets/qstyleoption.h>
#include <QtWidgets/qtoolbutton.h>
#include <QtWidgets/qtreeview.h>
#include "qpa/qplatformtheme.h"
#include "private/qguiapplication_p.h"
#include "private/qstylehelper_p.h"
#include <algorithm>
namespace {
// Map a standard pixmap to the XDG icon-theme name that QAbstractFileIconProvider
// uses for the same QFileIconProvider type, so the widgets path resolves through the
// platform theme's icon engine exactly as the gui path does.
QString ohosThemeIconName(QStyle::StandardPixmap standardPixmap)
{
switch (standardPixmap) {
case QStyle::SP_ComputerIcon: return QStringLiteral("computer");
case QStyle::SP_DesktopIcon: return QStringLiteral("user-desktop");
case QStyle::SP_TrashIcon: return QStringLiteral("user-trash");
case QStyle::SP_DriveNetIcon: return QStringLiteral("network-workgroup");
case QStyle::SP_DriveHDIcon: return QStringLiteral("drive-harddisk");
case QStyle::SP_DirClosedIcon: return QStringLiteral("folder");
case QStyle::SP_DirIcon: return QStringLiteral("folder");
case QStyle::SP_FileIcon: return QStringLiteral("text-x-generic");
default: break;
}
return QString();
}
constexpr int checkBoxOrRadioButtonIndicatorSize = 24;
constexpr int checkBoxOrRadioButtonIndicatorStrokeWidth = 1;
constexpr int checkBoxOrRadioButtonIndicatorGap = 2;
constexpr int checkBoxOrRadioButtonHoverSize =
checkBoxOrRadioButtonIndicatorSize + (2 * checkBoxOrRadioButtonIndicatorGap);
constexpr int checkBoxOrRadioButtonFocusStrokeWidth = 2;
constexpr int checkBoxOrRadioButtonSize =
checkBoxOrRadioButtonIndicatorSize + (2 * checkBoxOrRadioButtonIndicatorGap)
+ (2 * checkBoxOrRadioButtonFocusStrokeWidth);
constexpr int radioButtonIndicatorStrokeWidth = 6;
constexpr int textCursorWidth = 1;
constexpr int itemViewItemHorizontalMargin = 16;
constexpr int itemViewItemVerticalMargin = 8;
constexpr int itemViewItemWithDecorationVerticalMargin = 10;
constexpr int itemViewItemSpacing = 8;
constexpr int itemViewSeparatorHeight = 5;
constexpr int focusFrameWidth = 2;
constexpr int focusFrameCornerRadius = 16;
constexpr int headerMargin = 16;
constexpr int headerDefaultSectionSizeVertical = 48;
constexpr double lineEditCornerRadius = 32.0;
constexpr int lineEditHorizontalMargin = 16;
constexpr int lineEditVerticalMargin = 9;
constexpr int menuBarItemSpacing = 16;
constexpr int menuBarVerticalMargin = 8;
constexpr int menuBarHorizontalMargin = 8;
constexpr int menuItemVerticalMargin = 8;
constexpr int menuItemCornerRadius = 4;
constexpr int menuItemHoverHorizontalMargin = 4;
constexpr int pushButtonHorizontalMargin = 16;
constexpr int pushButtonVerticalMargin = 8;
constexpr int pushButtonCornerRadius = 8;
constexpr int pushButtonFocusFrameGap = 2;
constexpr int pushButtonFocusFrameWidth = 2;
constexpr int progressBarMinHeight = 24;
constexpr int progressBarGrooveHeight = 4;
constexpr int progressBarCornerRadius = 2;
constexpr int shadowXSRadius = 22;
constexpr int sliderThickness = 40;
constexpr int sliderGrooveHeight = 4;
constexpr int sliderCornerRadius = 2;
constexpr int sliderThumbSize = 16;
constexpr int sliderHoverSize = 4;
constexpr int sliderFocusStrokeWidth = 2;
constexpr int smallIconSize = 12;
constexpr int splitterHandleWidth = 6;
constexpr int splitterWidth = 12;
constexpr int titleBarHeight = 46;
constexpr int toolButtonCornerRadius = 4;
constexpr int toolButtonFocusFrameWidth = 2;
constexpr int toolTipCornerRadius = 8;
constexpr int toolTipFrameWidth = 8;
constexpr int toolTipBackgroundAlpha = 204;
constexpr int spinBoxFrameHeight = 32;
constexpr int spinBoxButtonBoxWidth = 32;
constexpr int spinBoxButtonBoxHeight = 16;
constexpr int spinBoxEditHorizontalMargin = 4;
constexpr double spinBoxFrameRadius = 12.0;
constexpr int spinBoxFrameStroke = 2;
constexpr int maxScrollBarSize = 9;
constexpr int thinScrollBarSize = 3;
constexpr int thickScrollBarSize = 6;
constexpr int tabBarTabRadius = 8;
constexpr int tabBarTabFrameWidth = 2;
constexpr int tabBarTabUnderLineWidth = 2;
constexpr int groupBoxBottomPadding = 8;
constexpr int groupBoxFrameCornerRadius = 8;
constexpr int groupBoxHorizontalPadding = 12;
constexpr int groupBoxTitleToContentSpacing = 8;
constexpr int groupBoxTopPadding = 24;
constexpr int comboBoxVerticalMargin = 4;
constexpr int comboBoxFrameRadius = 8;
constexpr int comboBoxFrameLeftRightPadding = 16;
constexpr int comboBoxFocusFrameWidth = 2;
constexpr int tabWidgetFrameWidth = 1;
constexpr double ohos_id_alpha_disabled = 0.4;
constexpr double ohos_id_alpha_content_tertiary = 0.4;
QColor makeInactiveOrDisabledFromColor(const QColor &color)
{
auto disabledColor = color;
disabledColor.setAlphaF(qBound(0.0, color.alphaF() * ohos_id_alpha_disabled, 1.0));
return disabledColor;
}
template<typename T>
bool qobjectIsInstanceOf(const QObject *obj)
{
return qobject_cast<const T *>(obj) != nullptr;
}
template<typename T>
bool qStyleOptionIs(const QStyleOption *option)
{
return qstyleoption_cast<const T *>(option) != nullptr;
}
bool isItemViewSeparator(const QModelIndex &index)
{
return index.data(Qt::AccessibleDescriptionRole).toString() == QLatin1String("separator");
}
bool isFirstItem(const QModelIndex &index)
{
return index.isValid() && index.row() == 0 && index.column() == 0;
}
bool isLastItem(const QModelIndex &index)
{
return index.isValid()
&& index.row() == index.model()->rowCount(index.parent()) - 1
&& index.column() == index.model()->columnCount(index.parent()) - 1;
}
bool isHoverable(const QWidget *widget)
{
static bool (* const hoverTypeCheckFuncs[])(const QObject *obj) = {
&qobjectIsInstanceOf<QCheckBox>,
&qobjectIsInstanceOf<QPushButton>,
&qobjectIsInstanceOf<QRadioButton>,
&qobjectIsInstanceOf<QSlider>,
&qobjectIsInstanceOf<QToolButton>,
&qobjectIsInstanceOf<QComboBox>,
&qobjectIsInstanceOf<QScrollBar>,
};
return std::any_of(
std::begin(hoverTypeCheckFuncs), std::end(hoverTypeCheckFuncs),
[&](const auto &typeCheckFunc) {
return typeCheckFunc(widget);
});
}
QRect adjusted(const QRect &rect, int growth)
{
return rect.adjusted(-growth, -growth, growth, growth);
}
QFont getGroupBoxTitleFont(const QWidget *widget)
{
const bool widgetHasItsOwnFont = widget != nullptr && widget->testAttribute(Qt::WA_SetFont);
if (widgetHasItsOwnFont)
return widget->font();
const auto *themeFont =
QGuiApplicationPrivate::platformTheme()->font(QPlatformTheme::GroupBoxTitleFont);
return themeFont != nullptr ? *themeFont : QFont();
}
QColor getSunkenOrHoverColor(bool isSunken, const QPalette &palette)
{
return isSunken
? palette.color(QPalette::Active, QPalette::Dark)
: palette.color(QPalette::Active, QPalette::Light);
}
void paintOnStackTop(QPainter &painter, const std::function<void(QPainter &painter)> &paint)
{
painter.save();
paint(painter);
painter.restore();
}
void drawLine(QPainter &painter, const QPen &pen, const QPoint &aPoint, const QPoint &bPoint)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(pen);
painter.drawLine(aPoint, bPoint);
});
}
void drawEllipse(QPainter &painter, const QPen &pen, const QBrush &brush, const QRect &rect)
{
painter.save();
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.drawEllipse(rect);
painter.restore();
}
void drawRect(QPainter &painter, const QPen &pen, const QBrush &brush, const QRect &rect)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.drawRect(rect);
});
}
void drawRoundedRect(
QPainter &painter, const QPen &pen, const QBrush &brush, const QRectF &rect, qreal xRadius, qreal yRadius)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.drawRoundedRect(rect, xRadius, yRadius);
});
}
QPainterPath roundedPathInRect(
const QRectF &rect, qreal topLeftCornerRadius, qreal topRightCornerRadius, qreal bottomLeftCornerRadius,
qreal bottomRightCornerRadius)
{
QPainterPath path;
const auto bottom = rect.y() + rect.height();
const auto right = rect.x() + rect.width();
const auto topLeftDiameter = 2 * topLeftCornerRadius;
path.moveTo(rect.x() + topLeftCornerRadius, rect.y());
path.arcTo(rect.x(), rect.y(), topLeftDiameter, topLeftDiameter, 90.0, 90.0);
const auto bottomLeftDiameter = 2 * bottomLeftCornerRadius;
path.lineTo(rect.x(), bottom - bottomLeftCornerRadius);
path.arcTo(rect.x(), bottom - bottomLeftDiameter, bottomLeftDiameter, bottomLeftDiameter, 180.0, 90.0);
const auto bottomRightDiameter = 2 * bottomRightCornerRadius;
path.lineTo(right - bottomRightCornerRadius, bottom);
path.arcTo(
right - bottomRightDiameter, bottom - bottomRightDiameter, bottomRightDiameter, bottomRightDiameter, 270.0,
90.0);
const auto topRightDiameter = 2 * topRightCornerRadius;
path.lineTo(right, rect.y() + topRightCornerRadius);
path.arcTo(right - topRightDiameter, rect.y(), topRightDiameter, topRightDiameter, 360.0, 90.0);
path.closeSubpath();
return path;
}
void drawPath(QPainter &painter, const QPen &pen, const QBrush &brush, const QPainterPath& path)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(pen);
painter.setBrush(brush);
painter.drawPath(path);
});
}
void drawRoundedRect(
QPainter &painter, const QPen &pen, const QBrush brush, const QRectF &rect, qreal topLeftCornerRadius,
qreal topRightCornerRadius, qreal bottomLeftCornerRadius, qreal bottomRightCornerRadius)
{
drawPath(
painter, pen, brush, roundedPathInRect(rect, topLeftCornerRadius, topRightCornerRadius, bottomLeftCornerRadius,
bottomRightCornerRadius));
}
void drawPolyline(
QPainter &painter, const QPen &pen, const QBrush &brush, const std::vector<QPointF> &polygonPoints)
{
paintOnStackTop(painter, [&](auto &p) {
p.setRenderHint(QPainter::Antialiasing);
p.setPen(pen);
p.setBrush(brush);
p.drawPolyline(polygonPoints.data(), polygonPoints.size());
});
}
enum class ArrowDirection { Up, Down, Left, Right };
void drawArrow(
QPainter &painter, const QRectF &boundingRect, qreal arrowSize, ArrowDirection direction,
const QColor &color)
{
const auto arrowWidth = 2;
const auto arrowCenter = boundingRect.center();
auto arrowRect = QRectF(0, 0, arrowSize, arrowSize * 0.5);
arrowRect.moveCenter(arrowCenter);
arrowRect.adjust(arrowWidth * 0.5, arrowWidth * 0.5, -arrowWidth * 0.5, -arrowWidth * 0.5);
const std::vector<QPointF> polygonPoints = {
QPointF(arrowRect.x(), arrowRect.y()),
QPointF(arrowRect.x() + arrowRect.width() * 0.5, arrowRect.y() + arrowRect.height()),
QPointF(arrowRect.x() + arrowRect.width(), arrowRect.y())
};
paintOnStackTop(painter, [&](auto &p) {
p.translate(arrowCenter);
switch (direction) {
case ArrowDirection::Down:
break;
case ArrowDirection::Up:
p.rotate(180);
break;
case ArrowDirection::Left:
p.rotate(90);
break;
case ArrowDirection::Right:
p.rotate(-90);
break;
}
p.translate(-arrowCenter);
drawPolyline(
p, QPen(color, arrowWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin), Qt::NoBrush,
polygonPoints);
});
}
void drawCheckBoxOrRadioButtonIndicator(QPainter &painter, const QStyleOption &option, bool isCheckBox)
{
const auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
const auto isOn = option.state.testFlag(QStyle::State_On);
const auto isMouseOver = option.state.testFlag(QStyle::State_MouseOver);
const auto isSunken = option.state.testFlag(QStyle::State_Sunken);
painter.save();
painter.setRenderHints(QPainter::Antialiasing);
painter.setOpacity(isEnabled ? 1.0 : ohos_id_alpha_disabled);
QRect hoverRect(0, 0, checkBoxOrRadioButtonHoverSize, checkBoxOrRadioButtonHoverSize);
hoverRect.moveCenter(option.rect.center());
if (isMouseOver || isSunken)
drawEllipse(painter, Qt::NoPen, getSunkenOrHoverColor(isSunken, option.palette), hoverRect);
QRect indicatorRect(0, 0, checkBoxOrRadioButtonIndicatorSize, checkBoxOrRadioButtonIndicatorSize);
indicatorRect.moveCenter(option.rect.center());
auto activeColor = option.palette.color(QPalette::Active, QPalette::Highlight);
if (isOn) {
if (isCheckBox) {
drawEllipse(painter, Qt::NoPen, activeColor, indicatorRect);
QPixmap svgPixmap(indicatorRect.size());
if (svgPixmap.load(QString::fromStdString(":/resources/ic_gallery_material_select_checkbo.svg"))) {
painter.drawPixmap(indicatorRect.topLeft(), svgPixmap);
}
} else {
drawEllipse(
painter, QPen(activeColor, radioButtonIndicatorStrokeWidth), Qt::NoBrush,
adjusted(indicatorRect, -radioButtonIndicatorStrokeWidth / 2));
}
} else {
const auto outlineColor = option.palette.color(QPalette::Inactive, QPalette::Button);
const auto backgroundBrush = option.palette.brush(QPalette::Inactive, QPalette::Base);
const auto discRect = adjusted(indicatorRect, -checkBoxOrRadioButtonIndicatorStrokeWidth);
drawEllipse(
painter, QPen(outlineColor, checkBoxOrRadioButtonIndicatorStrokeWidth), backgroundBrush,
discRect);
if (const auto *themePalette = QGuiApplicationPrivate::platformTheme()->palette(
isCheckBox
? QPlatformTheme::Palette::CheckBoxPalette
: QPlatformTheme::Palette::RadioButtonPalette)) {
const auto overlayOutlineColor = themePalette->color(QPalette::Inactive, QPalette::Button);
const auto overlayBackgroundBrush = themePalette->brush(QPalette::Inactive, QPalette::Base);
const bool shouldPresentOverlayForOverriddenOutlineColor =
outlineColor != overlayOutlineColor;
const bool shouldPresentOverlayForOverriddenBackgroundBrush =
backgroundBrush != overlayBackgroundBrush;
if (shouldPresentOverlayForOverriddenOutlineColor
|| shouldPresentOverlayForOverriddenBackgroundBrush) {
drawEllipse(
painter,
shouldPresentOverlayForOverriddenOutlineColor
? QPen(overlayOutlineColor, checkBoxOrRadioButtonIndicatorStrokeWidth)
: QPen(Qt::NoPen),
shouldPresentOverlayForOverriddenBackgroundBrush
? overlayBackgroundBrush
: QBrush(Qt::NoBrush),
discRect);
}
}
}
painter.restore();
}
void drawLineEditBackground(QPainter &painter, const QStyleOption &option)
{
auto radius = std::min(
std::min(option.rect.size().width(), option.rect.size().height()) * 0.5, lineEditCornerRadius);
const auto colorGroup = option.palette.currentColorGroup();
const auto baseBrush = option.palette.brush(colorGroup, QPalette::Base);
drawRoundedRect(painter, Qt::NoPen, baseBrush, option.rect, radius, radius);
if (const auto *ohosThemePalette = QGuiApplicationPrivate::platformTheme()->palette(
QPlatformTheme::Palette::TextLineEditPalette)) {
const auto overlayBaseBrush = ohosThemePalette->brush(colorGroup, QPalette::Base);
const bool shouldPresentOverlayForOverriddenBaseBrush = baseBrush != overlayBaseBrush;
if (shouldPresentOverlayForOverriddenBaseBrush)
drawRoundedRect(painter, Qt::NoPen, overlayBaseBrush, option.rect, radius, radius);
}
}
QColor getPushButtonOverlayFill(bool isPressed, const QStyleOptionButton &option)
{
const auto role = isPressed ? QPalette::Dark : QPalette::Light;
if (const auto *themePalette =
QGuiApplicationPrivate::platformTheme()->palette(QPlatformTheme::Palette::ButtonPalette))
return themePalette->color(QPalette::Active, role);
return option.palette.color(QPalette::Active, role);
}
QBrush getPushButtonBackgroundBrush(const QStyleOptionButton &option)
{
const auto isDefaultButton = option.features.testFlag(QStyleOptionButton::DefaultButton);
const auto isAutoDefaultButton = option.features.testFlag(QStyleOptionButton::AutoDefaultButton);
const auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
const auto isOn = option.state.testFlag(QStyle::State_On);
const auto defaultButtonBackgroundColor = isEnabled
? option.palette.color(QPalette::Active, QPalette::AlternateBase)
: makeInactiveOrDisabledFromColor(option.palette.color(QPalette::Active, QPalette::AlternateBase));
if (isOn)
return isDefaultButton || isAutoDefaultButton
? defaultButtonBackgroundColor
: getPushButtonOverlayFill(true, option);
if (isDefaultButton)
return defaultButtonBackgroundColor;
return option.palette.brush(
isEnabled ? QPalette::Active : QPalette::Inactive, QPalette::Button);
}
std::optional<QBrush> getPushButtonFillOverlayBrush(const QStyleOptionButton &option)
{
const auto isDefaultButton = option.features.testFlag(QStyleOptionButton::DefaultButton);
const auto isOn = option.state.testFlag(QStyle::State_On);
if (isDefaultButton || isOn)
return std::nullopt;
const auto colorGroup = option.state.testFlag(QStyle::State_Enabled)
? QPalette::Active
: QPalette::Inactive;
if (option.palette.isBrushSet(colorGroup, QPalette::Button))
return std::nullopt;
if (const auto *themePalette =
QGuiApplicationPrivate::platformTheme()->palette(QPlatformTheme::Palette::ButtonPalette)) {
const auto themeBrush = themePalette->brush(colorGroup, QPalette::Button);
if (option.palette.brush(colorGroup, QPalette::Button) != themeBrush)
return themeBrush;
}
return std::nullopt;
}
QColor getPushButtonTextColor(const QStyleOptionButton &option)
{
const auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
const auto isDefaultButton = option.features.testFlag(QStyleOptionButton::DefaultButton);
const auto isOn = option.state.testFlag(QStyle::State_On);
return isDefaultButton || isOn
? option.palette.color(QPalette::Active, QPalette::BrightText)
: option.palette.color(
isEnabled
? QPalette::Active
: QPalette::Disabled,
QPalette::ButtonText);
}
void drawPushButtonBackground(QPainter &painter, const QStyleOptionButton &option)
{
paintOnStackTop(painter, [&](QPainter &painter) {
const auto isMouseOver = option.state.testFlag(QStyle::State_MouseOver);
const auto isSunken = option.state.testFlag(QStyle::State_Sunken);
painter.setRenderHints(QPainter::Antialiasing);
painter.setPen(Qt::NoPen);
auto adjustment = pushButtonFocusFrameGap + pushButtonFocusFrameWidth;
auto rect = option.rect.adjusted(adjustment, adjustment, -adjustment, -adjustment);
painter.setBrush(getPushButtonBackgroundBrush(option));
painter.drawRoundedRect(rect, pushButtonCornerRadius, pushButtonCornerRadius);
const auto fillOverlayBrush = getPushButtonFillOverlayBrush(option);
if (fillOverlayBrush) {
painter.setBrush(*fillOverlayBrush);
painter.drawRoundedRect(rect, pushButtonCornerRadius, pushButtonCornerRadius);
}
if (isMouseOver || isSunken) {
painter.setBrush(getPushButtonOverlayFill(isSunken, option));
painter.drawRoundedRect(rect, pushButtonCornerRadius, pushButtonCornerRadius);
}
});
}
void drawPushButtonFocus(QPainter &painter, const QStyleOption &option)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.setBrush(Qt::NoBrush);
painter.setPen(QPen(option.palette.color(QPalette::Active, QPalette::Highlight), pushButtonFocusFrameWidth));
auto cornerRadius = pushButtonCornerRadius + pushButtonFocusFrameGap;
painter.drawRoundedRect(option.rect, cornerRadius, cornerRadius);
});
}
QRect getProgressBarGrooveRect(const QStyleOptionProgressBar &option)
{
auto rect = option.rect;
const bool horizontal = option.state & QStyle::State_Horizontal;
if (horizontal) {
rect.setHeight(progressBarGrooveHeight);
rect.moveTop(option.rect.center().y());
} else {
rect.setWidth(progressBarGrooveHeight);
rect.moveRight(option.rect.center().x());
}
return rect;
}
void drawProgressBarContent(QPainter &painter, const QStyleOptionProgressBar &option)
{
auto rect = getProgressBarGrooveRect(option);
const bool horizontal = option.state & QStyle::State_Horizontal;
const bool isIndeterminate = option.maximum == 0 && option.minimum == 0;
if (isIndeterminate) {
// TODO: proper busy indicator pending UI spec. Fill groove as a placeholder.
drawRoundedRect(painter, Qt::NoPen, option.palette.brush(QPalette::Highlight),
rect, progressBarCornerRadius, progressBarCornerRadius);
return;
}
const qint64 totalSteps = std::max(qint64(1), qint64(option.maximum) - option.minimum);
const double fraction = static_cast<double>(qint64(option.progress) - option.minimum)
/ static_cast<double>(totalSteps);
if (horizontal) {
rect.setWidth(fraction * rect.width());
rect.moveLeft(option.invertedAppearance ? option.rect.width() - rect.width() : 0);
} else {
rect.setHeight(fraction * rect.height());
rect.moveTop(option.invertedAppearance ? 0 : option.rect.height() - rect.height());
}
drawRoundedRect(
painter, Qt::NoPen, option.palette.brush(QPalette::Highlight), rect, progressBarCornerRadius,
progressBarCornerRadius);
}
void drawSliderGroove(QPainter &painter, const QStyleOptionSlider &option)
{
drawRoundedRect(
painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::Mid),
option.rect, sliderCornerRadius, sliderCornerRadius);
QRect fillRect;
if (option.orientation == Qt::Horizontal) {
const auto sliderPosition = QStyle::sliderPositionFromValue(
option.minimum, option.maximum, option.sliderPosition, option.rect.width(), option.upsideDown);
fillRect = QRect(option.rect.topLeft(), QSize(sliderPosition, option.rect.height()));
} else {
const auto sliderPosition = QStyle::sliderPositionFromValue(
option.minimum, option.maximum, option.sliderPosition, option.rect.height(), option.upsideDown);
fillRect = QRect(
option.rect.x(), option.rect.y() + sliderPosition, option.rect.width(), option.rect.height() - sliderPosition);
}
drawRoundedRect(
painter, Qt::NoPen, option.palette.brush(QPalette::Highlight), fillRect, sliderCornerRadius,
sliderCornerRadius);
}
void drawSliderThumb(QPainter &painter, const QStyleOptionSlider &option)
{
QRect shadowRect(0, 0, shadowXSRadius, shadowXSRadius);
shadowRect.moveCenter(option.rect.center());
QRadialGradient radialGrad(shadowRect.center(), shadowXSRadius * 1.0);
radialGrad.setColorAt(0.0, Qt::transparent);
radialGrad.setColorAt(1.0, option.palette.color(QPalette::Active, QPalette::Shadow));
drawEllipse(painter, Qt::NoPen, QBrush(radialGrad), shadowRect);
if (option.state.testFlag(QStyle::State_MouseOver))
drawEllipse(painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::Light), option.rect);
auto adjustedRect = option.rect.adjusted(sliderHoverSize, sliderHoverSize, -sliderHoverSize, -sliderHoverSize);
drawEllipse(painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::AlternateBase), adjustedRect);
if (option.state.testFlag(QStyle::State_Sunken))
drawEllipse(painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::Dark), adjustedRect);
if (option.state.testFlag(QStyle::State_HasFocus)) {
drawEllipse(
painter, QPen(option.palette.color(QPalette::Active, QPalette::Highlight), sliderFocusStrokeWidth),
Qt::NoBrush, adjusted(option.rect, -1));
}
}
void drawToolButton(QPainter &painter, const QStyleOption &option)
{
const auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
const auto isMouseOver = option.state.testFlag(QStyle::State_MouseOver);
const auto isSunken = option.state.testFlag(QStyle::State_Sunken);
drawRoundedRect(
painter, Qt::NoPen, option.palette.brush(isEnabled ? QPalette::Active : QPalette::Disabled, QPalette::Button),
option.rect, toolButtonCornerRadius, toolButtonCornerRadius);
if (isMouseOver || isSunken) {
drawRoundedRect(
painter, Qt::NoPen, getSunkenOrHoverColor(isSunken, option.palette), option.rect, toolButtonCornerRadius,
toolButtonCornerRadius);
}
}
void drawToolBarbackground(QPainter &painter, const QStyleOption &option)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.fillRect(option.rect, option.palette.brush(QPalette::Active, QPalette::Window));
});
}
void drawMenuBarBarbackground(QPainter &painter, const QStyleOption &option)
{
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setRenderHints(QPainter::Antialiasing);
painter.fillRect(option.rect, option.palette.brush(QPalette::Active, QPalette::Window));
});
}
void drawListItemSeparator(QPainter &painter, const QStyleOption &option)
{
QPoint center = option.rect.center();
drawLine(
painter, option.palette.color(QPalette::Active, QPalette::Mid),
QPoint(option.rect.left(), center.y()), QPoint(option.rect.right(), center.y()));
}
void drawMenuItem(QPainter &painter, const QStyleOptionMenuItem &option, int checkMarkSize, int iconSize)
{
const auto contentRect = option.rect.adjusted(itemViewItemHorizontalMargin, 0, -itemViewItemHorizontalMargin, 0);
if (option.menuItemType == QStyleOptionMenuItem::Separator) {
auto copyOption = option;
copyOption.rect = contentRect;
drawListItemSeparator(painter, copyOption);
} else {
const bool isSelected = option.state.testFlag(QStyle::State_Selected);
const bool isSunken = option.state.testFlag(QStyle::State_Sunken);
if (isSelected || isSunken) {
drawRoundedRect(
painter, Qt::NoPen, getSunkenOrHoverColor(isSunken, option.palette),
option.rect.adjusted(menuItemHoverHorizontalMargin, 0, -menuItemHoverHorizontalMargin, 0),
menuItemCornerRadius, menuItemCornerRadius);
}
const bool isCheckable = option.checkType != QStyleOptionMenuItem::NotCheckable;
QRect checkMarkRect;
if (isCheckable) {
checkMarkRect = contentRect;
checkMarkRect.setWidth(checkMarkSize);
auto copyOption = option;
copyOption.rect = checkMarkRect;
if (option.checked)
copyOption.state |= QStyle::State_On;
drawCheckBoxOrRadioButtonIndicator(painter, copyOption, true);
}
const bool hasIcon = !option.icon.isNull();
QRect iconRect;
if (hasIcon) {
iconRect = QRect(contentRect.x(), contentRect.center().y() - iconSize * 0.5, iconSize, iconSize);
iconRect.moveLeft(checkMarkRect.right() + itemViewItemHorizontalMargin);
option.icon.paint(
&painter, iconRect, Qt::AlignCenter,
option.state.testFlag(QStyle::State_Enabled) ? QIcon::Normal : QIcon::Disabled,
option.checked ? QIcon::On : QIcon::Off);
}
QRect textRect = contentRect;
if (isCheckable)
textRect.setLeft(checkMarkRect.right() + itemViewItemHorizontalMargin);
if (hasIcon)
textRect.setLeft(iconRect.right() + itemViewItemHorizontalMargin);
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setPen(option.palette.color(QPalette::Text));
painter.drawText(
textRect, (Qt::AlignLeft | Qt::AlignVCenter | Qt::TextShowMnemonic), option.text);
});
}
}
void drawMenuTearOff(QPainter &painter, const QStyleOption &option)
{
const auto pointY = option.rect.y() + option.rect.height() / 2;
drawLine(
painter, QPen(option.palette.color(QPalette::Text), 1, Qt::DashLine), QPoint(option.rect.x(), pointY),
QPoint(option.rect.x() + option.rect.width(), pointY)
);
}
void drawSplitter(QPainter &painter, const QStyleOption &option)
{
constexpr int splitterAvailableSizeDivider = 12;
const bool isHorizontal = option.state.testFlag(QStyle::State_Horizontal);
if (option.rect.width() > 1 && option.rect.height() > 1) {
const auto handleSize = isHorizontal
? QSize(splitterHandleWidth, option.rect.height() / splitterAvailableSizeDivider)
: QSize(option.rect.width() / splitterAvailableSizeDivider, splitterHandleWidth);
const auto handleRect = QRect(
QPoint(
(option.rect.width() - handleSize.width()) * 0.5,
(option.rect.height() - handleSize.height()) * 0.5),
handleSize);
const auto cornerRadius = std::min(handleSize.width(), handleSize.height()) * 0.5;
drawRoundedRect(
painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::Mid),
handleRect, cornerRadius, cornerRadius);
} else {
auto endPoint = isHorizontal ? option.rect.bottomLeft() : option.rect.topRight();
drawLine(painter, option.palette.dark().color(), option.rect.topLeft(), endPoint);
}
}
void drawSpinBoxFrame(
QPainter &painter, const QStyleOptionSpinBox &option, const QRect &frameRect, int frameWidth)
{
auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
QPen pen =
option.frame && option.subControls.testFlag(QStyle::SC_SpinBoxFrame)
? QPen(option.palette.color(QPalette::Active, QPalette::Mid), frameWidth)
: Qt::NoPen;
const qreal strokeInset = frameWidth / 2.0;
const QRectF strokeRect = QRectF(frameRect)
.adjusted(strokeInset, strokeInset, -strokeInset, -strokeInset);
paintOnStackTop(painter, [&](auto &p) {
p.setOpacity(isEnabled ? 1.0 : ohos_id_alpha_disabled);
drawRoundedRect(
p, pen, option.palette.window(), strokeRect, spinBoxFrameRadius, spinBoxFrameRadius);
});
}
void drawSpinBoxButton(QPainter &painter, const QStyleOptionSpinBox &option, int penWidth)
{
const bool isDownButton = option.subControls == QStyle::SC_SpinBoxDown;
const bool mirrored = option.direction == Qt::RightToLeft;
const qreal strokeInset = penWidth / 2.0;
const qreal outerLeftInset = mirrored ? strokeInset : 0.0;
const qreal outerRightInset = mirrored ? 0.0 : -strokeInset;
const QRectF rect = isDownButton
? QRectF(option.rect).adjusted(outerLeftInset, 0.0, outerRightInset, -strokeInset)
: QRectF(option.rect).adjusted(outerLeftInset, strokeInset, outerRightInset, 0.0);
auto isEnabled = option.state.testFlag(QStyle::State_Enabled);
auto isPressed = option.state.testFlag(QStyle::State_Sunken);
QPen pen(option.palette.color(QPalette::Active, QPalette::Mid), penWidth);
QBrush brush(option.palette.window());
if (isPressed)
brush = QBrush(option.palette.highlight());
const qreal topLeftRadius = (mirrored && !isDownButton) ? spinBoxFrameRadius : 0.0;
const qreal topRightRadius = (!mirrored && !isDownButton) ? spinBoxFrameRadius : 0.0;
const qreal bottomLeftRadius = (mirrored && isDownButton) ? spinBoxFrameRadius : 0.0;
const qreal bottomRightRadius = (!mirrored && isDownButton) ? spinBoxFrameRadius : 0.0;
paintOnStackTop(painter, [&](auto &p) {
p.setOpacity(isEnabled ? 1.0 : ohos_id_alpha_disabled);
drawRoundedRect(
p, pen, brush, rect, topLeftRadius, topRightRadius, bottomLeftRadius, bottomRightRadius);
});
}
void drawScrollBarSlider(QPainter &painter, const QStyleOptionSlider &option)
{
int scrollBarRadius =
option.orientation == Qt::Vertical
? option.rect.width() * 0.5
: option.rect.height() * 0.5;
paintOnStackTop(painter, [&](QPainter &painter) {
painter.setOpacity(ohos_id_alpha_content_tertiary);
drawRoundedRect(
painter, Qt::NoPen, option.palette.color(QPalette::Active, QPalette::Midlight),
option.rect, scrollBarRadius, scrollBarRadius);
});
}
Qt::Orientation tabBarShapeToOrientation(QTabBar::Shape shape)
{
switch (shape) {
case QTabBar::RoundedNorth:
case QTabBar::RoundedSouth:
case QTabBar::TriangularNorth:
case QTabBar::TriangularSouth:
return Qt::Horizontal;
case QTabBar::RoundedWest:
case QTabBar::TriangularWest:
case QTabBar::RoundedEast:
case QTabBar::TriangularEast:
return Qt::Vertical;
}
}
void drawTabBarTabShape(QPainter &painter, const QStyleOptionTab &option)
{
auto isSelected = option.state.testFlag(QStyle::State_Selected);
auto isFocused = option.state.testFlag(QStyle::State_HasFocus);
QRect rect(option.rect);
adjusted(rect, -tabBarTabFrameWidth - 1);
QPoint underLineStart, underLineEnd;
if (tabBarShapeToOrientation(option.shape) == Qt::Horizontal) {
int lineY = rect.y() + rect.height() - tabBarTabUnderLineWidth;
underLineStart = QPoint(rect.x() + tabBarTabRadius, lineY);
underLineEnd = QPoint(rect.x() + rect.width() - tabBarTabRadius, lineY);
} else {
int lineX = rect.x();
if (option.shape == QTabBar::RoundedWest || option.shape == QTabBar::TriangularWest)
lineX += rect.width() - tabBarTabUnderLineWidth;
else
lineX += tabBarTabUnderLineWidth;
underLineStart = QPoint(lineX, rect.y() + tabBarTabRadius);
underLineEnd = QPoint(lineX, rect.y() + rect.height() - tabBarTabRadius);
}
drawRoundedRect(painter, Qt::NoPen, option.palette.window(), rect, tabBarTabRadius, tabBarTabRadius);
if (!isFocused && isSelected)
drawLine(painter, QPen(option.palette.highlight(), tabBarTabUnderLineWidth), underLineStart, underLineEnd);
}
void drawComboBoxFrame(QPainter &painter, const QStyleOptionComboBox &option)
{
const auto isMouseOver = option.state.testFlag(QStyle::State_MouseOver);
const auto isOpened = option.state.testFlag(QStyle::State_On);
const auto isFocused = option.state.testFlag(QStyle::State_HasFocus);
auto focusedPen = QPen(
option.palette.color(QPalette::Active, QPalette::AlternateBase),
comboBoxFocusFrameWidth);
const auto buttonBrush = option.palette.brush(QPalette::Button);
drawRoundedRect(
painter, isFocused ? focusedPen : Qt::NoPen, buttonBrush, option.rect,
comboBoxFrameRadius, comboBoxFrameRadius);
const auto *ohosThemePalette =
QGuiApplicationPrivate::platformTheme()->palette(QPlatformTheme::Palette::ComboBoxPalette);
const auto overlayButtonBrush = ohosThemePalette->brush(QPalette::Button);
bool shouldPresentOverlayForOverriddenButtonBrush = buttonBrush != overlayButtonBrush;
if (shouldPresentOverlayForOverriddenButtonBrush)
drawRoundedRect(
painter, Qt::NoPen, overlayButtonBrush, option.rect, comboBoxFrameRadius, comboBoxFrameRadius);
if (isMouseOver || isOpened) {
auto pen = isOpened ? focusedPen : Qt::NoPen;
auto brush = getSunkenOrHoverColor(isOpened, option.palette);
drawRoundedRect(painter, pen, brush, option.rect, comboBoxFrameRadius, comboBoxFrameRadius);
}
}
void drawComboBoxListViewItem(QPainter &painter, const QStyleOptionViewItem &option, const QBrush &brush)
{
if (isFirstItem(option.index)) {
drawRoundedRect(
painter, Qt::NoPen, brush, option.rect, focusFrameCornerRadius, focusFrameCornerRadius, 0, 0);
} else if (isLastItem(option.index)) {
drawRoundedRect(
painter, Qt::NoPen, brush, option.rect, 0, 0, focusFrameCornerRadius, focusFrameCornerRadius);
} else {
drawRect(painter, Qt::NoPen, brush, option.rect);
}
}
void drawTreeViewHighlightItem(QPainter &painter, const QStyleOptionViewItem &option, const QBrush &brush)
{
switch (option.viewItemPosition) {
case QStyleOptionViewItem::OnlyOne:
drawRoundedRect(
painter, Qt::NoPen, brush, option.rect, focusFrameCornerRadius, focusFrameCornerRadius);
break;
case QStyleOptionViewItem::Beginning:
drawRoundedRect(
painter, Qt::NoPen, brush, option.rect, focusFrameCornerRadius, 0, focusFrameCornerRadius, 0);
break;
case QStyleOptionViewItem::Invalid:
case QStyleOptionViewItem::Middle:
drawRect(painter, Qt::NoPen, brush, option.rect);
break;
case QStyleOptionViewItem::End:
drawRoundedRect(
painter, Qt::NoPen, brush, option.rect, 0, focusFrameCornerRadius, 0, focusFrameCornerRadius);
break;
}
}
void drawPanelItemViewItem(QPainter &painter, const QStyleOptionViewItem &option, bool isComboBoxListViewItem)
{
if (isItemViewSeparator(option.index)) {
auto copyOption = option;
copyOption.rect = option.rect.adjusted(itemViewItemHorizontalMargin, 0, -itemViewItemHorizontalMargin, 0);
drawListItemSeparator(painter, copyOption);
} else {
auto isSelected = option.state.testFlag(QStyle::State_Selected);
auto isMouseOver = option.state.testFlag(QStyle::State_MouseOver);
auto colorGroup = option.state.testFlag(QStyle::State_Enabled) ? QPalette::Normal : QPalette::Disabled;
if (colorGroup == QPalette::Normal && !option.state.testFlag(QStyle::State_Active))
colorGroup = QPalette::Inactive;
const QBrush brush =
isSelected
? option.palette.brush(colorGroup, QPalette::Highlight)
: isMouseOver
? option.palette.color(QPalette::Active, QPalette::Light)
: option.backgroundBrush.style() == Qt::NoBrush
? Qt::NoBrush
: option.backgroundBrush;
if (isComboBoxListViewItem)
drawComboBoxListViewItem(painter, option, brush);
else
drawTreeViewHighlightItem(painter, option, brush);
}
}
void drawHeaderSection(QPainter &painter, const QStyleOptionHeader &option)
{
QRect rect =
option.position == QStyleOptionHeader::OnlyOneSection
? option.rect
: option.orientation == Qt::Horizontal
? option.rect.adjusted(-1, 0, 0, 0)
: option.rect.adjusted(0, -1, 0, 0);
drawRect(painter, QPen(Qt::black), option.palette.brush(QPalette::Button), rect);
}
void drawWindowBackgroundAndFrame(
QPainter &painter, const QStyleOptionFrame &option, QFlags<Qt::WindowState> state, int titleBarHeight)
{
const auto offset = option.lineWidth * 0.5;
const auto windowFrameColor =
state.testFlag(Qt::WindowActive)
? option.palette.color(QPalette::Active, QPalette::Base)
: option.palette.color(QPalette::Inactive, QPalette::Base);
if (state.testFlag(Qt::WindowMinimized)) {
drawRoundedRect(
painter, QPen(windowFrameColor, option.lineWidth), Qt::NoBrush,
option.rect.adjusted(offset, offset, -offset, -offset), focusFrameCornerRadius, focusFrameCornerRadius, 0,
0);
drawRect(
painter, Qt::NoPen, option.palette.brush(QPalette::Window),
option.rect.adjusted(option.lineWidth, titleBarHeight, -option.lineWidth, 0));
} else {
drawRoundedRect(
painter, Qt::NoPen, windowFrameColor, option.rect.adjusted(0, titleBarHeight, 0, 0), 0, 0,
focusFrameCornerRadius, focusFrameCornerRadius);
drawRoundedRect(
painter, Qt::NoPen, option.palette.brush(QPalette::Window),
option.rect.adjusted(option.lineWidth, titleBarHeight, -option.lineWidth, -option.lineWidth),
focusFrameCornerRadius, focusFrameCornerRadius);
drawRoundedRect(
painter, QPen(windowFrameColor, option.lineWidth), Qt::NoBrush,
option.rect.adjusted(offset, offset, -offset, -offset), focusFrameCornerRadius, focusFrameCornerRadius);
}
}
void drawToolTip(QPainter &painter, const QStyleOptionFrame &option)
{
drawRoundedRect(
painter, option.palette.color(QPalette::Active, QPalette::Base),
option.palette.toolTipBase(), option.rect, toolTipCornerRadius,
toolTipCornerRadius);
}
QRect titleBarSubControlRect(const QStyleOptionTitleBar &option, QCommonStyle::SubControl subControl)
{
const bool isMinimized = (option.titleBarState & Qt::WindowMinimized) != 0;
const bool isMaximized = (option.titleBarState & Qt::WindowMaximized) != 0;
const bool hasTitle = option.titleBarFlags.testFlag(Qt::WindowTitleHint);
const bool hasSystemMenuButton = option.titleBarFlags.testFlag(Qt::WindowSystemMenuHint);
const bool hasShadeButton = option.titleBarFlags.testFlag(Qt::WindowShadeButtonHint);
const bool hasContextHelpButton = option.titleBarFlags.testFlag(Qt::WindowContextHelpButtonHint);
const bool hasMinimizeButton = option.titleBarFlags.testFlag(Qt::WindowMinimizeButtonHint);
const bool hasMaximizeButton = option.titleBarFlags.testFlag(Qt::WindowMaximizeButtonHint);
const auto controlSize = QSize(30, 30);
const int titleBarHorizontalMargin = 25;
const int titleBarControlVerticalMargin = 15;
const auto titleBarContentRect = QRect(
option.rect.x() + titleBarHorizontalMargin, (option.rect.height() - controlSize.height()) / 2,
option.rect.width() - 2 * titleBarHorizontalMargin, controlSize.height());
const auto titleBarContentRectRight = titleBarContentRect.x() + titleBarContentRect.width();
const auto delta = controlSize.width() + titleBarControlVerticalMargin;
QRect result;
switch (subControl) {
case QCommonStyle::SC_TitleBarSysMenu:
if (hasSystemMenuButton)
result = QRect(titleBarContentRect.topLeft(), controlSize);
break;
case QCommonStyle::SC_TitleBarLabel:
if (hasTitle) {
result = titleBarContentRect;
if (hasSystemMenuButton)
result.adjust(delta, 0, -delta, 0);
if (hasMinimizeButton)
result.adjust(0, 0, -delta, 0);
if (hasMaximizeButton)
result.adjust(0, 0, -delta, 0);
if (hasShadeButton)
result.adjust(0, 0, -delta, 0);
if (hasContextHelpButton)
result.adjust(0, 0, -delta, 0);
}
break;
case QCommonStyle::SC_TitleBarMaxButton:
if (!isMaximized && hasMaximizeButton) {
result = QRect(
QPoint(titleBarContentRectRight - 3 * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
}
break;
case QCommonStyle::SC_TitleBarNormalButton:
if (isMinimized && hasMinimizeButton) {
result = QRect(
QPoint(titleBarContentRectRight - 2 * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
} else if (isMaximized && hasMaximizeButton) {
result = QRect(
QPoint(titleBarContentRectRight - 3 * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
}
break;
case QCommonStyle::SC_TitleBarMinButton:
if (!isMinimized && hasMinimizeButton) {
result = QRect(
QPoint(titleBarContentRectRight - 2 * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
}
break;
case QCommonStyle::SC_TitleBarCloseButton:
result = QRect(
QPoint(titleBarContentRectRight - controlSize.width(), titleBarContentRect.y()), controlSize);
break;
case QCommonStyle::SC_TitleBarShadeButton:
case QCommonStyle::SC_TitleBarUnshadeButton:
result = QRect(
QPoint(titleBarContentRectRight - 4 * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
break;
case QCommonStyle::SC_TitleBarContextHelpButton:
result = QRect(
QPoint(titleBarContentRectRight - (hasShadeButton ? 5 : 4) * delta + titleBarControlVerticalMargin,
titleBarContentRect.y()), controlSize);
break;
default:
break;
}
return result;
}
}
QOhosStyle::QOhosStyle()
: QCommonStyle()
{
}
void QOhosStyle::drawPrimitive(
PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const
{
switch (element) {
case PE_Frame: {
if (qobjectIsInstanceOf<QAbstractScrollArea>(widget)) {
if (const auto *frameOption = qstyleoption_cast<const QStyleOptionFrame *>(option)) {
const int frameWidth = frameOption->lineWidth;
drawRect(
*painter, QPen(option->palette.color(QPalette::Active, QPalette::Mid), frameWidth), Qt::NoBrush,
adjusted(frameOption->rect, -frameWidth));
} else {
QCommonStyle::drawPrimitive(element, option, painter, widget);
}
} else if (widget && !qobjectIsInstanceOf<QComboBox>(widget->parent())) {
QCommonStyle::drawPrimitive(element, option, painter, widget);
}
break;
}
case PE_FrameWindow:
if (qStyleOptionIs<QStyleOptionFrame>(option)) {
drawWindowBackgroundAndFrame(
*painter, *qstyleoption_cast<const QStyleOptionFrame *>(option), widget->windowState(),
pixelMetric(PM_TitleBarHeight, option, widget));
}
break;
case PE_FrameFocusRect:
if (qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
if (qobjectIsInstanceOf<QPushButton>(widget)) {
drawPushButtonFocus(*painter, *option);
} else if (qobjectIsInstanceOf<QToolButton>(widget)) {
const auto menuButtonIndicatorSize =
qobject_cast<const QToolButton *>(widget)->popupMode() == QToolButton::MenuButtonPopup
? pixelMetric(PM_MenuButtonIndicator, option, widget)
: 0;
drawRoundedRect(
*painter,
QPen(option->palette.color(QPalette::Active, QPalette::Highlight), toolButtonFocusFrameWidth),
Qt::NoBrush, option->rect.adjusted(-1, -1, 1 + menuButtonIndicatorSize, 1),
toolButtonCornerRadius, toolButtonCornerRadius);
} else if (qobjectIsInstanceOf<QCheckBox>(widget) || qobjectIsInstanceOf<QRadioButton>(widget)) {
drawEllipse(
*painter, QPen(option->palette.color(QPalette::Active, QPalette::Highlight),
checkBoxOrRadioButtonFocusStrokeWidth), Qt::NoBrush, option->rect);
} else if (qobjectIsInstanceOf<QTabBar>(widget)) {
drawRoundedRect(
*painter, QPen(option->palette.highlight(), tabBarTabFrameWidth), Qt::NoBrush,
option->rect, tabBarTabRadius, tabBarTabRadius);
} else {
drawRoundedRect(
*painter, QPen(option->palette.color(QPalette::Active, QPalette::Highlight), focusFrameWidth),
Qt::NoBrush, option->rect, focusFrameCornerRadius, focusFrameCornerRadius);
}
}
break;
case PE_PanelButtonCommand:
if (qStyleOptionIs<QStyleOptionButton>(option))
drawPushButtonBackground(*painter, *qstyleoption_cast<const QStyleOptionButton *>(option));
break;
case PE_PanelButtonTool:
if (qobjectIsInstanceOf<QMdiSubWindow>(widget)) {
const QPalette *toolButtonThemePalette =
QGuiApplicationPrivate::platformTheme()->palette(QPlatformTheme::Palette::ToolButtonPalette);
const auto panelButtonColor =
toolButtonThemePalette->color(QPalette::Active, QPalette::AlternateBase);
drawEllipse(
*painter, Qt::NoPen,
widget->windowState().testFlag(Qt::WindowActive)
? panelButtonColor
: makeInactiveOrDisabledFromColor(panelButtonColor),
option->rect);
} else {
const QToolButton *toolButton = qobject_cast<const QToolButton *>(widget);
const auto menuButtonIndicatorSize =
toolButton != nullptr && toolButton->popupMode() == QToolButton::MenuButtonPopup
? pixelMetric(PM_MenuButtonIndicator, option, widget)
: 0;
auto optionCopy = *option;
optionCopy.rect.setWidth(option->rect.width() + menuButtonIndicatorSize);
drawToolButton(*painter, optionCopy);
}
break;
case PE_PanelMenuBar:
drawMenuBarBarbackground(*painter, *option);
break;
case PE_IndicatorCheckBox:
drawCheckBoxOrRadioButtonIndicator(*painter, *option, true);
break;
case PE_IndicatorRadioButton:
drawCheckBoxOrRadioButtonIndicator(*painter, *option, false);
break;
case PE_PanelLineEdit: {
// HACK: Q(Abstrace)SpinBox contains a QLineEdit inside, which is painted separately from
// the QSpinBox itself. We will be drawing the whole QSpinBox in the drawComplexControl.
if (widget != nullptr && qobjectIsInstanceOf<QAbstractSpinBox>(widget->parentWidget()))
break;
// HACK: QComboBox in editable mode presents line edit in the center. This line edit is drawn
// above QComboBox. There are two issues here: QComboBox has different base color than line edit.
// Second, line edit and QComboBox has the same size - so drawing a line edit overlays a frame border.
// To fix above, do not draw line edit background.
if (widget != nullptr && qobjectIsInstanceOf<QComboBox>(widget->parentWidget()))
break;
// HACK: while editing Tree View/Widget item - line edit component is presented above it. If the line edit has
// some opacity in background content below it (item content) is visible. This causes an effect that original
// text is still visible while editing. To fix it, override background (base) color and use solid color value.
auto optionCopy = *option;
if (widget != nullptr && qstrcmp(widget->metaObject()->className(), "QExpandingLineEdit") == 0) {
optionCopy.palette.setColor(
QPalette::Base,
option->palette.color(QPalette::Active, QPalette::AlternateBase));
}
drawLineEditBackground(*painter, optionCopy);
break;
}
case PE_PanelButtonBevel:
if (qStyleOptionIs<QStyleOptionSpinBox>(option)) {
drawSpinBoxButton(
*painter, *qstyleoption_cast<const QStyleOptionSpinBox *>(option),
pixelMetric(PM_SpinBoxFrameWidth, option, widget));
}
break;
case PE_IndicatorSpinDown:
case PE_IndicatorSpinUp: {
// HACK: QCommonStyle adjusts the indicator left as follows: copy.rect.adjust(3, 0, -4, 0);
// However, Ohos requires 4 pixels of horizontal margin and 2 pixels of vertical margin
QRect indicatorRect = option->rect.adjusted(1, 2, 0, -2);
constexpr int arrowWidth = 2;
auto x = indicatorRect.x();
auto y = indicatorRect.y();
auto width = indicatorRect.width();
auto height = indicatorRect.height();
auto verticalSpacing = 4;
auto horizontalSpacing = 7;
qreal x1 = x + horizontalSpacing;
qreal x2 = x + width * 0.5;
qreal x3 = x + width - horizontalSpacing;
qreal y1, y2;
if (element == PE_IndicatorSpinDown) {
y1 = y + verticalSpacing;
y2 = y + height - verticalSpacing;
} else {
y1 = y + height - verticalSpacing;
y2 = y + verticalSpacing;
}
auto y3 = y1;
QPen indicatorPen(option->palette.color(QPalette::Active, QPalette::Text), arrowWidth);
indicatorPen.setCapStyle(Qt::RoundCap);
indicatorPen.setJoinStyle(Qt::RoundJoin);
paintOnStackTop(*painter, [&](auto &p) {
p.setOpacity(option->state.testFlag(State_Enabled) ? 1.0 : ohos_id_alpha_disabled);
p.setRenderHint(QPainter::Antialiasing);
p.setPen(indicatorPen);
p.setBrush(Qt::NoBrush);
p.drawLine(x1, y1, x2, y2);
p.drawLine(x2, y2, x3, y3);
});
break;
}
case PE_FrameGroupBox: {
const auto frame = qstyleoption_cast<const QStyleOptionFrame *>(option);
if (frame != nullptr) {
QPen pen;
pen.setColor(option->palette.mid().color());
pen.setStyle(
frame->features.testFlag(QStyleOptionFrame::FrameFeature::Flat)
? Qt::NoPen : Qt::SolidLine);
painter->setClipRegion(frame->rect);
drawRoundedRect(
*painter, pen, option->palette.window(), frame->rect, groupBoxFrameCornerRadius,
groupBoxFrameCornerRadius);
}
break;
}
case PE_IndicatorArrowUp:
case PE_IndicatorArrowDown:
case PE_IndicatorArrowLeft:
case PE_IndicatorArrowRight: {
QRect availableRect;
int maxArrowSize = 0;
if (qobjectIsInstanceOf<QComboBox>(widget)) {
availableRect = option->rect;
maxArrowSize = std::min(availableRect.width(), availableRect.height()) * 0.5;
} else if (qobjectIsInstanceOf<QToolButton>(widget) || qobjectIsInstanceOf<QPushButton>(widget)) {
const auto menuButtonIndicatorSize = pixelMetric(PM_MenuButtonIndicator, option, widget);
availableRect = QRect(
widget->size().width() - menuButtonIndicatorSize, 0, menuButtonIndicatorSize, widget->size().height());
maxArrowSize = std::min(availableRect.width(), availableRect.height()) * 0.5;
} else {
availableRect = option->rect;
maxArrowSize = std::min(availableRect.width(), availableRect.height());
}
auto direction = ArrowDirection::Down;
switch (element) {
default:
case PE_IndicatorArrowDown:
break;
case PE_IndicatorArrowUp:
direction = ArrowDirection::Up;
break;
case PE_IndicatorArrowLeft:
direction = ArrowDirection::Left;
break;
case PE_IndicatorArrowRight:
direction = ArrowDirection::Right;
break;
}
const auto isEnabled = option->state.testFlag(QStyle::State_Enabled);
paintOnStackTop(*painter, [&](auto &p) {
p.setOpacity(isEnabled ? 1.0 : ohos_id_alpha_disabled);
drawArrow(
p, availableRect, maxArrowSize, direction,
option->palette.color(QPalette::Active, QPalette::WindowText));
});
break;
}
case PE_IndicatorButtonDropDown: {
if (qobjectIsInstanceOf<QToolButton>(widget))
break;
QCommonStyle::drawPrimitive(element, option, painter, widget);
break;
}
case PE_IndicatorHeaderArrow: {
const auto headerOption = qstyleoption_cast<const QStyleOptionHeader *>(option);
if (headerOption == nullptr || headerOption->sortIndicator == QStyleOptionHeader::None)
break;
const auto direction = headerOption->sortIndicator == QStyleOptionHeader::SortDown
? ArrowDirection::Up
: ArrowDirection::Down;
drawArrow(
*painter, option->rect, option->rect.width(), direction,
option->palette.color(QPalette::Active, QPalette::ButtonText));
break;
}
case PE_PanelItemViewItem:
if (qStyleOptionIs<QStyleOptionViewItem>(option)) {
drawPanelItemViewItem(
*painter, *qstyleoption_cast<const QStyleOptionViewItem *>(option),
widget != nullptr && qstrcmp(widget->metaObject()->className(), "QComboBoxListView") == 0);
}
break;
case PE_FrameTabWidget:
if (qStyleOptionIs<QStyleOptionTabWidgetFrame>(option)) {
QRect rect = option->rect;
switch (qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(option)->shape) {
case QTabBar::RoundedNorth:
case QTabBar::TriangularNorth:
rect.adjust(0, tabWidgetFrameWidth, 0, 0);
break;
case QTabBar::RoundedWest:
case QTabBar::TriangularWest:
rect.adjust(tabWidgetFrameWidth, 0, 0, 0);
break;
case QTabBar::RoundedSouth:
case QTabBar::TriangularSouth:
rect.adjust(0, 0, 0, -(tabWidgetFrameWidth * 2));
break;
case QTabBar::RoundedEast:
case QTabBar::TriangularEast:
rect.adjust(0, 0, -(tabWidgetFrameWidth * 2), 0);
break;
}
drawRect(
*painter, QPen(option->palette.color(QPalette::Dark), tabWidgetFrameWidth),
Qt::NoBrush, rect);
}
break;
case PE_PanelTipLabel:
if (qStyleOptionIs<QStyleOptionFrame>(option))
drawToolTip(*painter, *qstyleoption_cast<const QStyleOptionFrame *>(option));
break;
default:
QCommonStyle::drawPrimitive(element, option, painter, widget);
break;
}
}
void QOhosStyle::drawControl(
ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const
{
switch (element) {
case CE_HeaderSection:
if (qStyleOptionIs<QStyleOptionHeader>(option))
drawHeaderSection(*painter, *qstyleoption_cast<const QStyleOptionHeader *>(option));
break;
case CE_MenuBarEmptyArea:
break;
case CE_MenuItem:
if (qStyleOptionIs<QStyleOptionMenuItem>(option)) {
const auto *menuItemStyleOption = qstyleoption_cast<const QStyleOptionMenuItem *>(option);
drawMenuItem(
*painter, *menuItemStyleOption, pixelMetric(PM_IndicatorWidth, option, widget),
pixelMetric(PM_SmallIconSize, option, widget));
if (menuItemStyleOption->menuItemType == QStyleOptionMenuItem::SubMenu) {
const auto iconSize = pixelMetric(PM_SmallIconSize, option, widget);
const auto menuItemRect = menuItemStyleOption->rect;
QStyleOptionMenuItem menuArrowStyleOption = *menuItemStyleOption;
menuArrowStyleOption.rect = QRect(
menuItemRect.right() - itemViewItemHorizontalMargin - iconSize,
menuItemRect.top() + (menuItemRect.height() - iconSize) / 2, iconSize, iconSize);
QColor arrowColor = menuItemStyleOption->palette.color(QPalette::Active, QPalette::Text);
menuArrowStyleOption.palette.setColor(
QPalette::Active, QPalette::WindowText, arrowColor);
drawPrimitive(
menuArrowStyleOption.direction == Qt::RightToLeft ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight,
&menuArrowStyleOption, painter, widget);
}
}
break;
case CE_MenuTearoff:
drawMenuTearOff(*painter, *option);
break;
case CE_ProgressBarGroove:
if (qstyleoption_cast<const QStyleOptionProgressBar *>(option)) {
drawRoundedRect(
*painter, Qt::NoPen, option->palette.color(QPalette::Active, QPalette::Mid),
getProgressBarGrooveRect(*qstyleoption_cast<const QStyleOptionProgressBar *>(option)),
progressBarCornerRadius, progressBarCornerRadius);
}
break;
case CE_ProgressBarContents:
if (qstyleoption_cast<const QStyleOptionProgressBar *>(option))
drawProgressBarContent(*painter, *qstyleoption_cast<const QStyleOptionProgressBar *>(option));
break;
case CE_ProgressBarLabel:
break;
case CE_Splitter:
drawSplitter(*painter, *option);
break;
case CE_ToolBar:
drawToolBarbackground(*painter, *option);
break;
case CE_ScrollBarSlider:
if (qStyleOptionIs<QStyleOptionSlider>(option))
drawScrollBarSlider(*painter, *qstyleoption_cast<const QStyleOptionSlider *>(option));
break;
case CE_TabBarTabShape: {
auto tabOption = qstyleoption_cast<const QStyleOptionTab *>(option);
if (tabOption != nullptr)
drawTabBarTabShape(*painter, *tabOption);
break;
}
case CE_TabBarTabLabel: {
auto tabOption = qstyleoption_cast<const QStyleOptionTab *>(option);
if (tabOption != nullptr) {
auto copy = *tabOption;
if (!option->state.testFlag(State_Selected))
copy.palette.setCurrentColorGroup(QPalette::Inactive);
QCommonStyle::drawControl(element, ©, painter, widget);
}
break;
}
case CE_PushButtonLabel: {
if (qStyleOptionIs<QStyleOptionButton>(option)) {
auto buttonOption = qstyleoption_cast<const QStyleOptionButton *>(option);
auto buttonOptionCopy = *buttonOption;
buttonOptionCopy.palette.setColor(QPalette::ButtonText, getPushButtonTextColor(*buttonOption));
QCommonStyle::drawControl(element, &buttonOptionCopy, painter, widget);
}
break;
}
case CE_DockWidgetTitle: {
const auto *dockWidgetOption = qstyleoption_cast<const QStyleOptionDockWidget *>(option);
if (dockWidgetOption == nullptr)
break;
auto dockWidgetOptionCopy = *dockWidgetOption;
if (!dockWidgetOptionCopy.title.isEmpty()) {
QRect titleRect = subElementRect(SE_DockWidgetTitleBarText, option, widget);
if (dockWidgetOptionCopy.verticalTitleBar) {
QRect rect = dockWidgetOptionCopy.rect;
QRect verticalRect = rect.transposed();
titleRect = QRect(
verticalRect.left() + rect.bottom() - titleRect.bottom(),
verticalRect.top() + titleRect.left() - rect.left(),
titleRect.height(),
titleRect.width());
}
dockWidgetOptionCopy.title = painter->fontMetrics().elidedText(
dockWidgetOptionCopy.title, Qt::ElideRight, titleRect.width());
}
QCommonStyle::drawControl(element, &dockWidgetOptionCopy, painter, widget);
break;
}
default:
QCommonStyle::drawControl(element, option, painter, widget);
}
}
void QOhosStyle::drawComplexControl(
ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget) const
{
switch (control) {
case CC_Slider: {
const auto sliderStyleOption = qstyleoption_cast<const QStyleOptionSlider *>(option);
if (sliderStyleOption != nullptr) {
if (option->subControls.testFlag(SC_SliderGroove)) {
auto sliderStyleOptionCopy = *sliderStyleOption;
sliderStyleOptionCopy.rect = subControlRect(control, option, SC_SliderGroove, widget);
drawSliderGroove(*painter, sliderStyleOptionCopy);
}
if (option->subControls.testFlag(SC_SliderHandle)) {
auto sliderStyleOptionCopy = *sliderStyleOption;
sliderStyleOptionCopy.rect = subControlRect(control, option, SC_SliderHandle, widget);
drawSliderThumb(*painter, sliderStyleOptionCopy);
}
}
break;
}
case CC_SpinBox:
if (qStyleOptionIs<QStyleOptionSpinBox>(option)) {
auto spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option);
auto frameRect = subControlRect(control, spinBox, SC_SpinBoxFrame, widget);
auto frameWidth = pixelMetric(PM_SpinBoxFrameWidth, spinBox, widget);
drawSpinBoxFrame(*painter, *spinBox, frameRect, frameWidth);
auto copy = *spinBox;
copy.frame = false;
QCommonStyle::drawComplexControl(control, ©, painter, widget);
}
break;
case CC_ScrollBar: {
const auto scrollBarStyleOption = qstyleoption_cast<const QStyleOptionSlider *>(option);
if (scrollBarStyleOption != nullptr) {
if (option->subControls.testFlag(SC_ScrollBarSlider)) {
auto scrollBarStyleOptionCopy = *scrollBarStyleOption;
scrollBarStyleOptionCopy.rect = subControlRect(control, option, SC_ScrollBarSlider, widget);
drawControl(CE_ScrollBarSlider, &scrollBarStyleOptionCopy, painter, widget);
}
}
break;
}
case CC_GroupBox: {
if (qStyleOptionIs<QStyleOptionGroupBox>(option)) {
auto groupBox = *qstyleoption_cast<const QStyleOptionGroupBox *>(option);
groupBox.textAlignment |= Qt::AlignVCenter;
const auto colorGroup = option->state.testFlag(QStyle::State_Enabled)
? QPalette::Active
: QPalette::Disabled;
if (!groupBox.palette.isBrushSet(colorGroup, QPalette::WindowText))
groupBox.textColor = groupBox.palette.color(QPalette::Text);
const auto titleFont = getGroupBoxTitleFont(widget);
painter->setFont(titleFont);
QCommonStyle::drawComplexControl(control, &groupBox, painter, widget);
}
break;
}
case CC_ComboBox: {
if (qStyleOptionIs<QStyleOptionComboBox>(option)) {
const auto comboBoxStyleOption = qstyleoption_cast<const QStyleOptionComboBox *>(option);
if (option->subControls.testFlag(SC_ComboBoxFrame)) {
auto comboBoxStyleOptionCopy = *comboBoxStyleOption;
comboBoxStyleOptionCopy.rect = subControlRect(control, option, SC_ComboBoxFrame, widget);
drawComboBoxFrame(*painter, comboBoxStyleOptionCopy);
}
if (option->subControls.testFlag(SC_ComboBoxArrow)) {
auto optionCopy = *option;
auto comboBoxOptions = static_cast<QStyleOption *>(&optionCopy);
comboBoxOptions->rect = subControlRect(control, option, SC_ComboBoxArrow, widget);
drawPrimitive(PE_IndicatorArrowDown, comboBoxOptions, painter, widget);
}
} else {
QCommonStyle::drawComplexControl(control, option, painter, widget);
}
break;
}
default:
QCommonStyle::drawComplexControl(control, option, painter, widget);
}
}
QRect QOhosStyle::subControlRect(
ComplexControl control, const QStyleOptionComplex *option, SubControl subControl, const QWidget *widget) const
{
switch (control) {
case CC_Slider:
if (qStyleOptionIs<QStyleOptionSlider>(option)) {
const auto sliderStyleOption = qstyleoption_cast<const QStyleOptionSlider *>(option);
switch (subControl) {
case SC_SliderGroove: {
const auto sliderLengthOffset = pixelMetric(PM_SliderLength, option, widget) * 0.5;
auto grooveRect = QCommonStyle::subControlRect(control, option, subControl, widget);
if (sliderStyleOption->orientation == Qt::Horizontal) {
grooveRect.adjust(sliderLengthOffset, 0, -sliderLengthOffset, 0);
grooveRect.setHeight(sliderGrooveHeight);
grooveRect.moveTop(option->rect.center().y() - sliderGrooveHeight * 0.5);
} else {
grooveRect.adjust(0, sliderLengthOffset, 0, -sliderLengthOffset);
grooveRect.setWidth(sliderGrooveHeight);
grooveRect.moveLeft(option->rect.center().x() - sliderGrooveHeight * 0.5);
}
return grooveRect;
}
case SC_SliderHandle: {
auto handleRect = QCommonStyle::subControlRect(control, option, subControl, widget);
if (sliderStyleOption->orientation == Qt::Horizontal)
handleRect.moveTop(option->rect.center().y() - handleRect.height() * 0.5);
else
handleRect.moveLeft(option->rect.center().x() - handleRect.width() * 0.5);
return handleRect;
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
case CC_SpinBox:
if (qStyleOptionIs<QStyleOptionSpinBox>(option)) {
const auto spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option);
auto frameWidth = spinBox->frame ? pixelMetric(PM_SpinBoxFrameWidth, option, widget) : 0;
switch (subControl) {
case SC_SpinBoxFrame: {
auto frameRect = spinBox->rect;
frameRect.setHeight(spinBoxFrameHeight);
frameRect.moveCenter(spinBox->rect.center());
return visualRect(spinBox->direction, spinBox->rect, frameRect);
}
case SC_SpinBoxDown:
case SC_SpinBoxUp: {
auto frameRect = subControlRect(CC_SpinBox, option, SC_SpinBoxFrame, widget);
if (spinBox->buttonSymbols == QAbstractSpinBox::NoButtons)
return QRect();
auto buttonRect = QRect(
frameRect.left() + frameRect.width() - spinBoxButtonBoxWidth,
frameRect.top() + (frameRect.height() - spinBoxFrameHeight) * 0.5,
spinBoxButtonBoxWidth, spinBoxButtonBoxHeight);
if (subControl == SC_SpinBoxDown)
buttonRect.translate(0, spinBoxButtonBoxHeight);
return visualRect(spinBox->direction, frameRect, buttonRect);
}
case SC_SpinBoxEditField: {
auto editRect = adjusted(spinBox->rect, -frameWidth);
if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) {
editRect.setWidth(spinBox->rect.width() - frameWidth - spinBoxButtonBoxWidth);
editRect = visualRect(spinBox->direction, spinBox->rect, editRect);
}
return editRect;
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
case CC_ScrollBar:
if (qStyleOptionIs<QStyleOptionSlider>(option)) {
auto scrollBoxStyleOption = qstyleoption_cast<const QStyleOptionSlider *>(option);
auto defaultUpButtonRect = QCommonStyle::subControlRect(control, option, SC_ScrollBarSubLine, widget);
auto defaultDownButtonRect = QCommonStyle::subControlRect(control, option, SC_ScrollBarAddLine, widget);
switch (subControl) {
case SC_ScrollBarAddLine:
case SC_ScrollBarSubLine:
return QRect();
case SC_ScrollBarSubPage: {
auto subPageRect = QCommonStyle::subControlRect(control, option, subControl, widget);
if (scrollBoxStyleOption->orientation == Qt::Vertical)
subPageRect.moveTop(subPageRect.top() - defaultDownButtonRect.height());
else
subPageRect.moveLeft(subPageRect.left() - defaultDownButtonRect.width());
return subPageRect;
}
case SC_ScrollBarAddPage: {
auto addPageRect = QCommonStyle::subControlRect(control, option, subControl, widget);
if (scrollBoxStyleOption->orientation == Qt::Vertical)
addPageRect.moveTop(addPageRect.top() + defaultUpButtonRect.height());
else
addPageRect.moveLeft(addPageRect.left() + defaultUpButtonRect.width());
return addPageRect;
}
case SC_ScrollBarSlider: {
const bool activeScrollBar =
option->state.testFlag(QCommonStyle::State_Enabled)
&& option->state.testFlag(QCommonStyle::State_MouseOver);
auto scrollBarExtent = activeScrollBar ? thickScrollBarSize : thinScrollBarSize;
auto sliderRect = QCommonStyle::subControlRect(control, option, subControl, widget);
if (scrollBoxStyleOption->orientation == Qt::Vertical) {
sliderRect.setWidth(scrollBarExtent);
sliderRect.setHeight(sliderRect.height() + defaultUpButtonRect.height() + defaultDownButtonRect.height());
sliderRect.moveTop(sliderRect.top() - defaultUpButtonRect.height());
sliderRect.moveLeft((option->rect.width() - sliderRect.width()) * 0.5);
} else {
sliderRect.setHeight(scrollBarExtent);
sliderRect.setWidth(sliderRect.width() + defaultUpButtonRect.width() + defaultDownButtonRect.width());
sliderRect.moveTop((option->rect.height() - sliderRect.height()) * 0.5);
sliderRect.moveLeft(sliderRect.left() - defaultUpButtonRect.width());
}
return sliderRect;
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
case CC_GroupBox:
if (qStyleOptionIs<QStyleOptionGroupBox>(option)) {
auto groupBox = *qstyleoption_cast<const QStyleOptionGroupBox *>(option);
groupBox.fontMetrics = QFontMetrics(getGroupBoxTitleFont(widget));
auto labelRect =
QCommonStyle::subControlRect(control, &groupBox, SC_GroupBoxLabel, widget);
if (groupBox.text.isEmpty()) {
labelRect.moveTop(groupBox.rect.top() + groupBoxTopPadding);
labelRect.moveBottom(labelRect.top());
} else {
labelRect.moveTop(
groupBox.rect.top() + groupBoxTopPadding + groupBox.fontMetrics.height() / 2);
}
switch (subControl) {
case SC_GroupBoxFrame:
return QCommonStyle::subControlRect(control, &groupBox, subControl, widget);
case SC_GroupBoxLabel: {
return labelRect;
}
case SC_GroupBoxCheckBox: {
auto checkBoxRect =
QCommonStyle::subControlRect(control, &groupBox, subControl, widget);
checkBoxRect.moveTop(labelRect.center().y() - checkBoxRect.height() / 2);
return checkBoxRect;
}
case SC_GroupBoxContents: {
auto contentsRect =
QCommonStyle::subControlRect(control, &groupBox, SC_GroupBoxContents, widget);
contentsRect.setTop(labelRect.bottom() + (groupBox.text.isEmpty() ? 0 : groupBoxTitleToContentSpacing));
contentsRect.setBottom(groupBox.rect.bottom() - groupBoxBottomPadding);
contentsRect.adjust(groupBoxHorizontalPadding, 0, -groupBoxHorizontalPadding, 0);
return contentsRect;
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
case CC_ComboBox:
if (qStyleOptionIs<QStyleOptionComboBox>(option)) {
auto comboBoxStyleOption = qstyleoption_cast<const QStyleOptionComboBox *>(option);
const auto arrowSize = pixelMetric(PM_MenuButtonIndicator, option, widget);
switch (subControl) {
case SC_ComboBoxFrame: {
return adjusted(comboBoxStyleOption->rect, -comboBoxFocusFrameWidth);;
}
case SC_ComboBoxEditField: {
const auto editFieldRect = comboBoxStyleOption->rect.adjusted(
comboBoxFrameLeftRightPadding, comboBoxVerticalMargin,
-arrowSize - comboBoxFrameLeftRightPadding, -comboBoxVerticalMargin);
return visualRect(comboBoxStyleOption->direction, comboBoxStyleOption->rect, editFieldRect);
}
case SC_ComboBoxArrow: {
auto arrowIconRect = comboBoxStyleOption->rect;
arrowIconRect.setWidth(arrowSize);
arrowIconRect.moveRight(comboBoxStyleOption->rect.right() - comboBoxFrameLeftRightPadding);
return visualRect(comboBoxStyleOption->direction, comboBoxStyleOption->rect, arrowIconRect);
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
case CC_TitleBar:
if (qStyleOptionIs<QStyleOptionTitleBar>(option)) {
auto titleBarOption = qstyleoption_cast<const QStyleOptionTitleBar *>(option);
return visualRect(
titleBarOption->direction, titleBarOption->rect, titleBarSubControlRect(*titleBarOption, subControl));
} else {
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
default:
return QCommonStyle::subControlRect(control, option, subControl, widget);
}
}
QRect QOhosStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const
{
switch (element) {
case SE_PushButtonContents:
return option->rect.adjusted(pushButtonHorizontalMargin, 0, -pushButtonHorizontalMargin, 0);
case SE_ItemViewItemFocusRect:
return option->rect.adjusted(focusFrameWidth, focusFrameWidth, -focusFrameWidth, -focusFrameWidth);
case SE_ProgressBarGroove:
case SE_ProgressBarContents:
return option->rect;
case SE_ProgressBarLabel:
return QRect();
case SE_LineEditContents: {
int horizontalMargin =
widget != nullptr && qobjectIsInstanceOf<QAbstractSpinBox>(widget->parent())
? spinBoxEditHorizontalMargin
: lineEditHorizontalMargin;
return option->rect.adjusted(horizontalMargin, 0, -horizontalMargin, 0);
}
case SE_CheckBoxFocusRect:
case SE_RadioButtonFocusRect:
return QRect(
checkBoxOrRadioButtonFocusStrokeWidth, (option->rect.height() - checkBoxOrRadioButtonHoverSize) * 0.5,
checkBoxOrRadioButtonHoverSize, checkBoxOrRadioButtonHoverSize);
case SE_CheckBoxClickRect:
return subElementRect(SE_CheckBoxIndicator, option, widget)
| subElementRect(SE_CheckBoxContents, option, widget);
case SE_RadioButtonClickRect:
return subElementRect(SE_RadioButtonIndicator, option, widget)
| subElementRect(SE_RadioButtonContents, option, widget);
default:
return QCommonStyle::subElementRect(element, option, widget);;
}
}
QSize QOhosStyle::sizeFromContents(
ContentsType contents, const QStyleOption *option, const QSize &contentsSize, const QWidget *widget) const
{
switch (contents) {
case CT_ItemViewItem: {
const auto viewItemStyleOption = qstyleoption_cast<const QStyleOptionViewItem *>(option);
if (viewItemStyleOption != nullptr) {
if (isItemViewSeparator(viewItemStyleOption->index)) {
return QSize(option->rect.width(), itemViewSeparatorHeight);
} else {
auto verticalMargin = viewItemStyleOption->features.testFlag(QStyleOptionViewItem::HasDecoration)
? itemViewItemWithDecorationVerticalMargin
: itemViewItemVerticalMargin;
return QCommonStyle::sizeFromContents(contents, option, contentsSize, widget)
+ QSize(0, 2 * verticalMargin);
}
} else {
return QCommonStyle::sizeFromContents(contents, option, contentsSize, widget);
}
}
case CT_PushButton: {
auto sizeAlignment = (2 * pushButtonFocusFrameGap) + (2 * pushButtonFocusFrameWidth);
return contentsSize + QSize(
(pushButtonHorizontalMargin * 2) + sizeAlignment, (pushButtonVerticalMargin * 2) + sizeAlignment);
}
case CT_ComboBox: {
const auto arrowSize = pixelMetric(PM_MenuButtonIndicator, option, widget);
auto comboBoxSize = qStyleOptionIs<QStyleOptionComboBox>(option)
&& qstyleoption_cast<const QStyleOptionComboBox *>(option)->editable
? contentsSize + QSize(2 * lineEditHorizontalMargin, 0)
: contentsSize;
const auto frameWidthCompensation = 2 * comboBoxFocusFrameWidth;
comboBoxSize.rwidth() += (arrowSize + frameWidthCompensation + 2 * comboBoxFrameLeftRightPadding);
comboBoxSize.rheight() += (frameWidthCompensation + 2 * comboBoxVerticalMargin + 2 * lineEditVerticalMargin);
return comboBoxSize;
}
case CT_ProgressBar: {
const auto progressBarStyleOption = qstyleoption_cast<const QStyleOptionProgressBar *>(option);
if (progressBarStyleOption != nullptr) {
const bool horizontal = progressBarStyleOption->state & QStyle::State_Horizontal;
if (horizontal)
return QSize(contentsSize.width(), std::max(contentsSize.height(), progressBarMinHeight));
else
return QSize(std::max(contentsSize.height(), progressBarMinHeight), contentsSize.height());
} else {
return QCommonStyle::sizeFromContents(contents, option, contentsSize, widget);
}
}
case CT_MenuItem: {
const auto defaultSize = QCommonStyle::sizeFromContents(contents, option, contentsSize, widget);
const auto *menuItemStyleOption = qstyleoption_cast<const QStyleOptionMenuItem *>(option);
if (menuItemStyleOption != nullptr) {
if (menuItemStyleOption->menuItemType == QStyleOptionMenuItem::Separator) {
return QSize(defaultSize.width(), itemViewSeparatorHeight);
} else {
const auto menuVMargin = pixelMetric(PM_MenuVMargin, option, widget);
const auto arrowWidth = menuItemStyleOption->menuItemType == QStyleOptionMenuItem::SubMenu
? menuVMargin + pixelMetric(PM_SmallIconSize, option, widget)
: 0;
const auto checkboxWidth = menuItemStyleOption->checkType != QStyleOptionMenuItem::NotCheckable
? menuVMargin + pixelMetric(PM_IndicatorWidth, option, widget)
: 0;
return defaultSize
+ QSize(2 * itemViewItemHorizontalMargin, 2 * menuVMargin)
+ QSize(arrowWidth, 0)
+ QSize(checkboxWidth, 0);
}
} else {
return defaultSize;
}
}
case CT_GroupBox: {
const auto groupBox = qstyleoption_cast<const QStyleOptionGroupBox *>(option);
if (groupBox == nullptr)
return QCommonStyle::sizeFromContents(contents, option, contentsSize, widget);
const QFontMetrics titleMetrics(getGroupBoxTitleFont(widget));
QSize titleSize(
titleMetrics.horizontalAdvance(groupBox->text) + titleMetrics.horizontalAdvance(u' '),
titleMetrics.height());
if (groupBox->subControls.testFlag(SC_GroupBoxCheckBox)) {
titleSize.rwidth() += pixelMetric(PM_IndicatorWidth, option, widget)
+ pixelMetric(PM_CheckBoxLabelSpacing, option, widget);
titleSize.rheight() =
std::max(titleSize.height(), pixelMetric(PM_IndicatorHeight, option, widget));
}
return QCommonStyle::sizeFromContents(contents, option, titleSize, widget);
}
case CT_LineEdit: {
int horizontalMargin;
if (widget != nullptr && qobjectIsInstanceOf<QAbstractSpinBox>(widget->parent()))
horizontalMargin = spinBoxEditHorizontalMargin;
else
horizontalMargin = lineEditHorizontalMargin;
return contentsSize + QSize(horizontalMargin * 2, lineEditVerticalMargin * 2);
}
case CT_SpinBox: {
const auto spinBox = qstyleoption_cast<const QStyleOptionSpinBox *>(option);
if (spinBox != nullptr) {
int buttonWidth;
if (spinBox->subControls.testFlag(QStyle::SC_SpinBoxUp)
&& spinBox->subControls.testFlag(QStyle::SC_SpinBoxDown)) {
buttonWidth = subControlRect(CC_SpinBox, spinBox, SC_SpinBoxDown, widget).width();
} else {
buttonWidth = 0;
}
const int frameWidth
= spinBox->frame ? pixelMetric(PM_SpinBoxFrameWidth, option, widget) : 0;
return QSize(contentsSize.width() + buttonWidth + 2 * frameWidth + spinBoxEditHorizontalMargin * 2,
std::max(contentsSize.height() + 2 * frameWidth, spinBoxFrameHeight));
}
return contentsSize;
}
default:
return QCommonStyle::sizeFromContents(contents, option, contentsSize, widget);
}
}
int QOhosStyle::pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const
{
switch (metric) {
case PM_ButtonMargin:
case PM_ButtonDefaultIndicator:
case PM_ButtonShiftHorizontal:
case PM_ButtonShiftVertical:
return 0;
case PM_IndicatorWidth:
case PM_ExclusiveIndicatorWidth:
return checkBoxOrRadioButtonSize;
case PM_IndicatorHeight:
case PM_ExclusiveIndicatorHeight:
return checkBoxOrRadioButtonSize;
case PM_FocusFrameHMargin:
return qStyleOptionIs<QStyleOptionViewItem>(option)
? itemViewItemSpacing
: QCommonStyle::pixelMetric(metric, option, widget);
case PM_TextCursorWidth:
return textCursorWidth;
case PM_DefaultFrameWidth:
if (qobjectIsInstanceOf<QLineEdit>(widget) || qobjectIsInstanceOf<QPushButton>(widget))
return 0;
else
return QCommonStyle::pixelMetric(metric, option, widget);
case PM_MenuBarPanelWidth:
return 0;
case PM_MenuBarItemSpacing:
return menuBarItemSpacing;
case PM_MenuBarVMargin:
return menuBarVerticalMargin;
case PM_MenuBarHMargin:
return menuBarHorizontalMargin;
case PM_MenuPanelWidth:
return 0;
case PM_MenuHMargin:
return 0;
case PM_MenuVMargin:
return menuItemVerticalMargin;
case PM_ProgressBarChunkWidth:
return 0;
case PM_SliderThickness:
return sliderThickness;
case PM_SliderLength:
case PM_SliderControlThickness:
return sliderThumbSize + 2 * sliderHoverSize;
case PM_SmallIconSize:
return qStyleOptionIs<QStyleOptionMenuItem>(option) || qStyleOptionIs<QStyleOptionComboBox>(option)
? smallIconSize
: QCommonStyle::pixelMetric(metric, option, widget);
case PM_SplitterWidth:
return splitterWidth;
case PM_SpinBoxFrameWidth:
return spinBoxFrameStroke;
case PM_ScrollBarExtent:
return maxScrollBarSize;
case PM_TabBarTabShiftVertical:
case PM_TabBarBaseOverlap:
return 0;
case PM_TabBarTabHSpace:
return 2 * tabBarTabRadius + 2 * tabBarTabFrameWidth;
case PM_TitleBarHeight:
return titleBarHeight;
case PM_HeaderMargin:
return headerMargin;
case PM_HeaderDefaultSectionSizeVertical:
return headerDefaultSectionSizeVertical;
case PM_ToolTipLabelFrameWidth:
return toolTipFrameWidth;
case PM_MenuButtonIndicator:
return 2 * QCommonStyle::pixelMetric(metric, option, widget);
default:
return QCommonStyle::pixelMetric(metric, option, widget);
}
}
int QOhosStyle::styleHint(
StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *hintReturn) const
{
switch (hint) {
case SH_Slider_AbsoluteSetButtons:
return Qt::LeftButton | Qt::MiddleButton;
case SH_Slider_PageSetButtons:
return 0;
case SH_ItemView_ShowDecorationSelected:
return qobjectIsInstanceOf<QTreeView>(widget) ? 0 : 1;
case SH_ToolTipLabel_Opacity:
return toolTipBackgroundAlpha;
case SH_Menu_MouseTracking:
case SH_MenuBar_MouseTracking:
return 1;
default:
return QCommonStyle::styleHint(hint, option, widget, hintReturn);
}
}
void QOhosStyle::polish(QWidget *widget)
{
QCommonStyle::polish(widget);
if (isHoverable(widget))
widget->setAttribute(Qt::WA_Hover);
if (qobjectIsInstanceOf<QPushButton>(widget)) {
if (qobject_cast<QPushButton *>(widget)->isDefault()) {
QPalette palette = widget->palette();
auto textDisabledColor = palette.color(QPalette::Active, QPalette::Base);
textDisabledColor.setAlphaF(ohos_id_alpha_disabled);
palette.setColor(QPalette::All, QPalette::ButtonText, palette.color(QPalette::Active, QPalette::Base));
palette.setColor(QPalette::Disabled, QPalette::ButtonText, textDisabledColor);
widget->setPalette(palette);
}
} else if (qobjectIsInstanceOf<QScrollBar>(widget)) {
widget->setAttribute(Qt::WA_NoSystemBackground);
widget->setAttribute(Qt::WA_OpaquePaintEvent, false);
} else if (qobjectIsInstanceOf<QListView>(widget)) {
qobject_cast<QListView *>(widget)->viewport()->setAttribute(Qt::WA_Hover);
} else if (qobjectIsInstanceOf<QComboBox>(widget)) {
auto comboBox = qobject_cast<QComboBox *>(widget);
const char *delegateClassName = comboBox->itemDelegate()->metaObject()->className();
bool isDefaultComboBoxDelegate =
qstrcmp(delegateClassName, "QComboBoxDelegate") == 0
|| qstrcmp(delegateClassName, "QComboMenuDelegate") == 0;
if (isDefaultComboBoxDelegate)
comboBox->setItemDelegate(new QStyledItemDelegate(comboBox->view()));
} else if (qobjectIsInstanceOf<QMdiSubWindow>(widget)) {
widget->setAttribute(Qt::WA_TranslucentBackground);
widget->setAutoFillBackground(false);
auto palette = widget->palette();
palette.setColor(QPalette::Highlight, palette.color(QPalette::Active, QPalette::Base));
palette.setColor(QPalette::Inactive, QPalette::Dark, palette.color(QPalette::Inactive, QPalette::Base));
palette.setColor(
QPalette::Inactive, QPalette::Window,
makeInactiveOrDisabledFromColor(palette.color(QPalette::Active, QPalette::AlternateBase)));
palette.setColor(QPalette::HighlightedText, Qt::black);
widget->setPalette(palette);
}
}
void QOhosStyle::unpolish(QWidget *widget)
{
if (isHoverable(widget)) {
widget->setAttribute(Qt::WA_Hover, false);
} else if (qobjectIsInstanceOf<QScrollBar>(widget)) {
widget->setAttribute(Qt::WA_NoSystemBackground, false);
widget->setAttribute(Qt::WA_OpaquePaintEvent);
} else if (qobjectIsInstanceOf<QListView>(widget)) {
qobject_cast<QListView *>(widget)->viewport()->setAttribute(Qt::WA_Hover, false);
}
QCommonStyle::unpolish(widget);
}
QPalette QOhosStyle::standardPalette() const
{
return *QGuiApplicationPrivate::platformTheme()->palette();
}
QIcon QOhosStyle::standardIcon(
StandardPixmap standardPixmap, const QStyleOption *option, const QWidget *widget) const
{
const QString iconName = ohosThemeIconName(standardPixmap);
if (!iconName.isEmpty()) {
const QIcon icon = QIcon::fromTheme(iconName);
if (!icon.isNull())
return icon;
}
return QCommonStyle::standardIcon(standardPixmap, option, widget);
}