File indexing completed on 2024-03-03 04:09:07

0001 /*
0002     SPDX-FileCopyrightText: 2016 The Qt Company Ltd. <https://www.qt.io/licensing/>
0003     SPDX-FileCopyrightText: 2017 Marco Martin <mart@kde.org>
0004     SPDX-FileCopyrightText: 2017 David Edmundson <davidedmundson@kde.org>
0005     SPDX-FileCopyrightText: 2019 David Redondo <david@david-redondo.de>
0006     SPDX-FileCopyrightText: 2023 ivan tkachenko <me@ratijas.tk>
0007 
0008     SPDX-License-Identifier: LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KFQF-Accepted-GPL OR LicenseRef-Qt-Commercial
0009 */
0010 
0011 #include "kquickstyleitem_p.h"
0012 
0013 #include <QApplication>
0014 #include <QPainter>
0015 #include <QPixmapCache>
0016 #include <QQuickWindow>
0017 #include <QStringBuilder>
0018 #include <QStyle>
0019 #include <QStyleFactory>
0020 #include <qsgninepatchnode.h>
0021 #include <qstyleoption.h>
0022 
0023 #include <KConfigGroup>
0024 #include <ksharedconfig.h>
0025 
0026 #include <Kirigami/Platform/PlatformTheme>
0027 #include <Kirigami/Platform/TabletModeWatcher>
0028 
0029 std::unique_ptr<QStyle> KQuickStyleItem::s_style = nullptr;
0030 
0031 QStyle *KQuickStyleItem::style()
0032 {
0033     if (s_style) {
0034         return s_style.get();
0035     } else {
0036         return qApp->style();
0037     }
0038 }
0039 
0040 static bool isKeyFocusReason(Qt::FocusReason reason)
0041 {
0042     return reason == Qt::TabFocusReason || reason == Qt::BacktabFocusReason || reason == Qt::ShortcutFocusReason;
0043 }
0044 
0045 KQuickStyleItem::KQuickStyleItem(QQuickItem *parent)
0046     : QQuickItem(parent)
0047     , m_styleoption(nullptr)
0048     , m_itemType(Undefined)
0049     , m_sunken(false)
0050     , m_raised(false)
0051     , m_flat(false)
0052     , m_active(true)
0053     , m_selected(false)
0054     , m_focus(false)
0055     , m_hover(false)
0056     , m_on(false)
0057     , m_horizontal(true)
0058     , m_transient(false)
0059     , m_sharedWidget(false)
0060     , m_minimum(0)
0061     , m_maximum(100)
0062     , m_value(0)
0063     , m_step(0)
0064     , m_paintMargins(0)
0065     , m_contentWidth(0)
0066     , m_contentHeight(0)
0067     , m_textureWidth(0)
0068     , m_textureHeight(0)
0069     , m_focusReason(Qt::NoFocusReason)
0070 {
0071     // Check that we really are a QApplication before attempting to access the
0072     // application style.
0073     //
0074     // Functions used in this file which are safe to access through qApp are:
0075     //
0076     //   qApp->font() and qApp->fontChanged() - provided by QGuiApplication
0077     //   qApp->font("classname") - provided by QApplication but safe
0078     //   qApp->layoutDirection() - provided by QGuiApplication
0079     //   qApp->wheelScrollLines() - uses styleHints() provided by QGuiApplication
0080     //   qApp->testAttribute() and qApp->setAttribute() - provided by QCoreApplication
0081     //   qApp->devicePixelRatio() - provided by QGuiApplication
0082     //   qApp->palette("classname") - provided by QApplication but safe
0083     //
0084     // but any use of qApp->style(), even if only trying to test that it exists,
0085     // will assert.  Use KQuickStyleItem::style() as above.
0086     //
0087     // Any use of any other function provided by QApplication must either be checked
0088     // to ensure that it is safe to use if not a QApplication, or guarded.
0089 
0090     if (qobject_cast<QApplication *>(QCoreApplication::instance())) {
0091         // We are a QApplication.  Unfortunately there is no styleChanged signal
0092         // available, and it only sends QEvent::StyleChange events to all QWidgets.
0093         // So watch for the existing application style being destroyed, which means
0094         // that a new one is being applied.  See QApplication::setStyle().
0095         QStyle *style = qApp->style();
0096         if (style) {
0097             connect(style, &QObject::destroyed, this, &KQuickStyleItem::styleChanged);
0098         }
0099     } else if (!s_style) {
0100         // We are not a QApplication.  Create an internal copy of the configured
0101         // desktop style, to be used for metrics, options and painting.
0102         KSharedConfig::Ptr kdeglobals = KSharedConfig::openConfig();
0103         KConfigGroup cg(kdeglobals, QStringLiteral("KDE"));
0104         const QString defaultStyleName = QStringLiteral("Fusion");
0105         s_style.reset(QStyleFactory::create(cg.readEntry("widgetStyle", defaultStyleName)));
0106         if (!s_style) {
0107             s_style.reset(QStyleFactory::create(defaultStyleName));
0108             // Prevent inevitable crashes on nullptr dereference
0109             if (!s_style) {
0110                 qWarning() << "org.kde.desktop: Could not find any QStyle such as Breeze or Fusion";
0111                 ::exit(EXIT_FAILURE);
0112             }
0113         }
0114     }
0115 
0116     m_font = qApp->font();
0117     setFlag(QQuickItem::ItemHasContents, true);
0118     setSmooth(false);
0119 
0120     qGuiApp->installEventFilter(this);
0121 
0122     Kirigami::Platform::TabletModeWatcher::self()->addWatcher(this);
0123 }
0124 
0125 KQuickStyleItem::~KQuickStyleItem()
0126 {
0127     if (const QStyleOptionButton *aux = qstyleoption_cast<const QStyleOptionButton *>(m_styleoption)) {
0128         delete aux;
0129     } else if (const QStyleOptionViewItem *aux = qstyleoption_cast<const QStyleOptionViewItem *>(m_styleoption)) {
0130         delete aux;
0131     } else if (const QStyleOptionHeader *aux = qstyleoption_cast<const QStyleOptionHeader *>(m_styleoption)) {
0132         delete aux;
0133     } else if (const QStyleOptionToolButton *aux = qstyleoption_cast<const QStyleOptionToolButton *>(m_styleoption)) {
0134         delete aux;
0135     } else if (const QStyleOptionToolBar *aux = qstyleoption_cast<const QStyleOptionToolBar *>(m_styleoption)) {
0136         delete aux;
0137     } else if (const QStyleOptionTab *aux = qstyleoption_cast<const QStyleOptionTab *>(m_styleoption)) {
0138         delete aux;
0139     } else if (const QStyleOptionFrame *aux = qstyleoption_cast<const QStyleOptionFrame *>(m_styleoption)) {
0140         delete aux;
0141     } else if (const QStyleOptionFocusRect *aux = qstyleoption_cast<const QStyleOptionFocusRect *>(m_styleoption)) {
0142         delete aux;
0143     } else if (const QStyleOptionTabWidgetFrame *aux = qstyleoption_cast<const QStyleOptionTabWidgetFrame *>(m_styleoption)) {
0144         delete aux;
0145     } else if (const QStyleOptionMenuItem *aux = qstyleoption_cast<const QStyleOptionMenuItem *>(m_styleoption)) {
0146         delete aux;
0147     } else if (const QStyleOptionComboBox *aux = qstyleoption_cast<const QStyleOptionComboBox *>(m_styleoption)) {
0148         delete aux;
0149     } else if (const QStyleOptionSpinBox *aux = qstyleoption_cast<const QStyleOptionSpinBox *>(m_styleoption)) {
0150         delete aux;
0151     } else if (const QStyleOptionSlider *aux = qstyleoption_cast<const QStyleOptionSlider *>(m_styleoption)) {
0152         delete aux;
0153     } else if (const QStyleOptionProgressBar *aux = qstyleoption_cast<const QStyleOptionProgressBar *>(m_styleoption)) {
0154         delete aux;
0155     } else if (const QStyleOptionGroupBox *aux = qstyleoption_cast<const QStyleOptionGroupBox *>(m_styleoption)) {
0156         delete aux;
0157     } else {
0158         delete m_styleoption;
0159     }
0160 
0161     m_styleoption = nullptr;
0162     Kirigami::Platform::TabletModeWatcher::self()->removeWatcher(this);
0163 }
0164 
0165 void KQuickStyleItem::initStyleOption()
0166 {
0167     if (!m_theme) {
0168         m_theme = static_cast<Kirigami::Platform::PlatformTheme *>(qmlAttachedPropertiesObject<Kirigami::Platform::PlatformTheme>(this, true));
0169         Q_ASSERT(m_theme);
0170 
0171         connect(m_theme, &Kirigami::Platform::PlatformTheme::colorsChanged, this, [this]() {
0172             // we need to reset the palette event if Qt::AA_SetPalette attribute has been set
0173             m_styleoption->palette = m_theme->palette();
0174             polish();
0175         });
0176     }
0177     Q_ASSERT(m_theme);
0178 
0179     if (m_styleoption) {
0180         m_styleoption->state = {};
0181     }
0182 
0183     QString sizeHint = m_hints.value(QStringLiteral("size")).toString();
0184 
0185     bool needsResolvePalette = true;
0186     bool preventMirroring = false;
0187 
0188     switch (m_itemType) {
0189     case Button: {
0190         if (!m_styleoption) {
0191             m_styleoption = new QStyleOptionButton();
0192         }
0193 
0194         QStyleOptionButton *opt = qstyleoption_cast<QStyleOptionButton *>(m_styleoption);
0195         opt->text = text();
0196 
0197         if (m_iconDirty || opt->icon.isNull()) {
0198             opt->icon = iconFromIconProperty();
0199             m_iconDirty = false;
0200         }
0201 
0202         auto iconSize = QSize(m_properties[QStringLiteral("iconWidth")].toInt(), m_properties[QStringLiteral("iconHeight")].toInt());
0203         if (iconSize.isEmpty()) {
0204             int e = KQuickStyleItem::style()->pixelMetric(QStyle::PM_ButtonIconSize, m_styleoption, nullptr);
0205             if (iconSize.width() <= 0) {
0206                 iconSize.setWidth(e);
0207             }
0208             if (iconSize.height() <= 0) {
0209                 iconSize.setHeight(e);
0210             }
0211         }
0212         opt->iconSize = iconSize;
0213         opt->features = activeControl() == QLatin1String("default") ? QStyleOptionButton::DefaultButton : QStyleOptionButton::None;
0214         if (m_flat) {
0215             opt->features |= QStyleOptionButton::Flat;
0216         }
0217         const QFont font = qApp->font("QPushButton");
0218         opt->fontMetrics = QFontMetrics(font);
0219         bool hasMenu = m_properties[QStringLiteral("menu")].toBool();
0220         if (hasMenu) {
0221             opt->features |= QStyleOptionButton::HasMenu;
0222         }
0223         break;
0224     }
0225     case ItemRow: {
0226         if (!m_styleoption) {
0227             m_styleoption = new QStyleOptionViewItem();
0228         }
0229 
0230         QStyleOptionViewItem *opt = qstyleoption_cast<QStyleOptionViewItem *>(m_styleoption);
0231         opt->features = {};
0232         if (activeControl() == QLatin1String("alternate")) {
0233             opt->features |= QStyleOptionViewItem::Alternate;
0234         }
0235         break;
0236     }
0237 
0238     case Splitter: {
0239         if (!m_styleoption) {
0240             m_styleoption = new QStyleOption;
0241         }
0242         break;
0243     }
0244 
0245     case Item: {
0246         if (!m_styleoption) {
0247             m_styleoption = new QStyleOptionViewItem();
0248         }
0249         QStyleOptionViewItem *opt = qstyleoption_cast<QStyleOptionViewItem *>(m_styleoption);
0250         opt->features = QStyleOptionViewItem::HasDisplay;
0251         opt->text = text();
0252         opt->textElideMode = Qt::ElideRight;
0253         opt->displayAlignment = Qt::AlignLeft | Qt::AlignVCenter;
0254         opt->decorationAlignment = Qt::AlignCenter;
0255         resolvePalette();
0256         needsResolvePalette = false;
0257         QPalette pal = m_styleoption->palette;
0258         pal.setBrush(QPalette::Base, Qt::NoBrush);
0259         m_styleoption->palette = pal;
0260         const QFont font = qApp->font("QAbstractItemView");
0261         opt->font = font;
0262         opt->fontMetrics = QFontMetrics(font);
0263         break;
0264     }
0265     case ItemBranchIndicator: {
0266         if (!m_styleoption) {
0267             m_styleoption = new QStyleOption;
0268         }
0269 
0270         if (m_properties.value(QStringLiteral("isItem")).toBool()) {
0271             m_styleoption->state = QStyle::State_Item;
0272         }
0273         if (m_properties.value(QStringLiteral("hasChildren")).toBool()) {
0274             m_styleoption->state |= QStyle::State_Children;
0275         }
0276         if (m_properties.value(QStringLiteral("hasSibling")).toBool()) { // Even this one could go away
0277             m_styleoption->state |= QStyle::State_Sibling;
0278         }
0279         if (m_on) {
0280             m_styleoption->state |= QStyle::State_Open;
0281         }
0282         break;
0283     }
0284     case Header: {
0285         if (!m_styleoption) {
0286             m_styleoption = new QStyleOptionHeader();
0287         }
0288 
0289         QStyleOptionHeader *opt = qstyleoption_cast<QStyleOptionHeader *>(m_styleoption);
0290         opt->text = text();
0291         opt->textAlignment = static_cast<Qt::AlignmentFlag>(m_properties.value(QStringLiteral("textalignment")).toInt());
0292         opt->sortIndicator = activeControl() == QLatin1String("down") ? QStyleOptionHeader::SortDown
0293             : activeControl() == QLatin1String("up")                  ? QStyleOptionHeader::SortUp
0294                                                                       : QStyleOptionHeader::None;
0295         QString headerpos = m_properties.value(QStringLiteral("headerpos")).toString();
0296         if (headerpos == QLatin1String("beginning")) {
0297             opt->position = QStyleOptionHeader::Beginning;
0298         } else if (headerpos == QLatin1String("end")) {
0299             opt->position = QStyleOptionHeader::End;
0300         } else if (headerpos == QLatin1String("only")) {
0301             opt->position = QStyleOptionHeader::OnlyOneSection;
0302         } else {
0303             opt->position = QStyleOptionHeader::Middle;
0304         }
0305         opt->orientation = m_properties.value(QStringLiteral("orientation")).value<Qt::Orientation>();
0306         if (opt->orientation == Qt::Orientation(0)) {
0307             opt->orientation = Qt::Horizontal;
0308         }
0309         const QFont font = qApp->font("QHeaderView");
0310         opt->fontMetrics = QFontMetrics(font);
0311         break;
0312     }
0313     case DelayButton:
0314     case ToolButton: {
0315         if (!m_styleoption) {
0316             m_styleoption = new QStyleOptionToolButton();
0317         }
0318 
0319         QStyleOptionToolButton *opt = qstyleoption_cast<QStyleOptionToolButton *>(m_styleoption);
0320         opt->subControls = QStyle::SC_ToolButton;
0321 
0322         if (m_flat) {
0323             opt->state |= QStyle::State_AutoRaise;
0324         }
0325 
0326         opt->activeSubControls = QStyle::SC_ToolButton;
0327         opt->text = text();
0328 
0329         if (m_iconDirty || opt->icon.isNull()) {
0330             opt->icon = iconFromIconProperty();
0331             m_iconDirty = false;
0332         }
0333 
0334         auto iconSize = QSize(m_properties[QStringLiteral("iconWidth")].toInt(), m_properties[QStringLiteral("iconHeight")].toInt());
0335         if (iconSize.isEmpty()) {
0336             const auto metric = m_flat ? QStyle::PM_ToolBarIconSize : QStyle::PM_ButtonIconSize;
0337             int e = KQuickStyleItem::style()->pixelMetric(metric, m_styleoption, nullptr);
0338             if (iconSize.width() <= 0) {
0339                 iconSize.setWidth(e);
0340             }
0341             if (iconSize.height() <= 0) {
0342                 iconSize.setHeight(e);
0343             }
0344         }
0345         opt->iconSize = iconSize;
0346 
0347         if (m_properties.value(QStringLiteral("menu")).toBool()) {
0348             opt->features |= QStyleOptionToolButton::HasMenu;
0349         }
0350 
0351         const int toolButtonStyle = m_properties.value(QStringLiteral("toolButtonStyle")).toInt();
0352 
0353         switch (toolButtonStyle) {
0354         case Qt::ToolButtonIconOnly:
0355         case Qt::ToolButtonTextOnly:
0356         case Qt::ToolButtonTextBesideIcon:
0357         case Qt::ToolButtonTextUnderIcon:
0358         case Qt::ToolButtonFollowStyle:
0359             opt->toolButtonStyle = (Qt::ToolButtonStyle)toolButtonStyle;
0360             break;
0361         default:
0362             opt->toolButtonStyle = Qt::ToolButtonFollowStyle;
0363         }
0364 
0365         const QFont font = qApp->font("QToolButton");
0366         opt->font = font;
0367         opt->fontMetrics = QFontMetrics(font);
0368         break;
0369     }
0370     case ToolBar: {
0371         if (!m_styleoption) {
0372             m_styleoption = new QStyleOptionToolBar();
0373         }
0374         break;
0375     }
0376     case Tab: {
0377         if (!m_styleoption) {
0378             m_styleoption = new QStyleOptionTab();
0379         }
0380 
0381         QStyleOptionTab *opt = qstyleoption_cast<QStyleOptionTab *>(m_styleoption);
0382         opt->text = text();
0383 
0384         if (m_iconDirty || opt->icon.isNull()) {
0385             opt->icon = iconFromIconProperty();
0386             m_iconDirty = false;
0387         }
0388 
0389         auto iconSize = QSize(m_properties[QStringLiteral("iconWidth")].toInt(), m_properties[QStringLiteral("iconHeight")].toInt());
0390         if (iconSize.isEmpty()) {
0391             int e = KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarIconSize, m_styleoption, nullptr);
0392             if (iconSize.width() <= 0) {
0393                 iconSize.setWidth(e);
0394             }
0395             if (iconSize.height() <= 0) {
0396                 iconSize.setHeight(e);
0397             }
0398         }
0399         opt->iconSize = iconSize;
0400 
0401         if (m_properties.value(QStringLiteral("hasFrame")).toBool()) {
0402             opt->features |= QStyleOptionTab::HasFrame;
0403         }
0404 
0405         QString orientation = m_properties.value(QStringLiteral("orientation")).toString();
0406         QString position = m_properties.value(QStringLiteral("tabpos")).toString();
0407         QString selectedPosition = m_properties.value(QStringLiteral("selectedpos")).toString();
0408 
0409         opt->shape = orientation == QLatin1String("Bottom") ? QTabBar::RoundedSouth : QTabBar::RoundedNorth;
0410         if (position == QLatin1String("beginning")) {
0411             opt->position = QStyleOptionTab::Beginning;
0412         } else if (position == QLatin1String("end")) {
0413             opt->position = QStyleOptionTab::End;
0414         } else if (position == QLatin1String("only")) {
0415             opt->position = QStyleOptionTab::OnlyOneTab;
0416         } else {
0417             opt->position = QStyleOptionTab::Middle;
0418         }
0419 
0420         if (selectedPosition == QLatin1String("next")) {
0421             opt->selectedPosition = QStyleOptionTab::NextIsSelected;
0422         } else if (selectedPosition == QLatin1String("previous")) {
0423             opt->selectedPosition = QStyleOptionTab::PreviousIsSelected;
0424         } else {
0425             opt->selectedPosition = QStyleOptionTab::NotAdjacent;
0426         }
0427 
0428         break;
0429     }
0430 
0431     case Frame: {
0432         if (!m_styleoption) {
0433             m_styleoption = new QStyleOptionFrame();
0434         }
0435 
0436         QStyleOptionFrame *opt = qstyleoption_cast<QStyleOptionFrame *>(m_styleoption);
0437         opt->frameShape = QFrame::StyledPanel;
0438         opt->lineWidth = KQuickStyleItem::style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption, nullptr);
0439         opt->midLineWidth = opt->lineWidth;
0440         break;
0441     }
0442     case FocusRect: {
0443         if (!m_styleoption) {
0444             m_styleoption = new QStyleOptionFocusRect();
0445         }
0446         // Needed on windows
0447         m_styleoption->state |= QStyle::State_KeyboardFocusChange;
0448         break;
0449     }
0450     case TabFrame: {
0451         if (!m_styleoption) {
0452             m_styleoption = new QStyleOptionTabWidgetFrame();
0453         }
0454         QStyleOptionTabWidgetFrame *opt = qstyleoption_cast<QStyleOptionTabWidgetFrame *>(m_styleoption);
0455 
0456         opt->selectedTabRect = m_properties[QStringLiteral("selectedTabRect")].toRect();
0457         opt->shape = m_properties[QStringLiteral("orientation")] == Qt::BottomEdge ? QTabBar::RoundedSouth : QTabBar::RoundedNorth;
0458         if (minimum()) {
0459             opt->selectedTabRect = QRect(value(), 0, minimum(), height());
0460         }
0461         opt->tabBarSize = QSize(minimum(), height());
0462         // oxygen style needs this hack
0463         opt->leftCornerWidgetSize = QSize(value(), 0);
0464         break;
0465     }
0466     case MenuBar:
0467         if (!m_styleoption) {
0468             QStyleOptionMenuItem *menuOpt = new QStyleOptionMenuItem();
0469             menuOpt->menuItemType = QStyleOptionMenuItem::EmptyArea;
0470             m_styleoption = menuOpt;
0471         }
0472 
0473         break;
0474     case MenuBarItem: {
0475         if (!m_styleoption) {
0476             m_styleoption = new QStyleOptionMenuItem();
0477         }
0478 
0479         QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem *>(m_styleoption);
0480         opt->text = text();
0481         opt->menuItemType = QStyleOptionMenuItem::Normal;
0482         setProperty("_q_showUnderlined", m_hints[QStringLiteral("showUnderlined")].toBool());
0483 
0484         const QFont font = qApp->font("QMenuBar");
0485         opt->font = font;
0486         opt->fontMetrics = QFontMetrics(font);
0487         m_font = opt->font;
0488         break;
0489     }
0490     case Menu: {
0491         if (!m_styleoption) {
0492             m_styleoption = new QStyleOptionMenuItem();
0493         }
0494         break;
0495     }
0496     case MenuItem:
0497     case ComboBoxItem: {
0498         if (!m_styleoption) {
0499             m_styleoption = new QStyleOptionMenuItem();
0500         }
0501 
0502         QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem *>(m_styleoption);
0503         // For GTK style. See below, in setElementType()
0504         setProperty("_q_isComboBoxPopupItem", m_itemType == ComboBoxItem);
0505 
0506         KQuickStyleItem::MenuItemType type = static_cast<KQuickStyleItem::MenuItemType>(m_properties[QStringLiteral("type")].toInt());
0507         if (type == KQuickStyleItem::ScrollIndicatorType) {
0508             int scrollerDirection = m_properties[QStringLiteral("scrollerDirection")].toInt();
0509             opt->menuItemType = QStyleOptionMenuItem::Scroller;
0510             opt->state |= scrollerDirection == Qt::UpArrow ? QStyle::State_UpArrow : QStyle::State_DownArrow;
0511         } else if (type == KQuickStyleItem::SeparatorType) {
0512             opt->menuItemType = QStyleOptionMenuItem::Separator;
0513         } else {
0514             opt->text = text();
0515 
0516             if (type == KQuickStyleItem::MenuType) {
0517                 opt->menuItemType = QStyleOptionMenuItem::SubMenu;
0518             } else {
0519                 opt->menuItemType = QStyleOptionMenuItem::Normal;
0520 
0521                 QString shortcut = m_properties[QStringLiteral("shortcut")].toString();
0522                 if (!shortcut.isEmpty()) {
0523                     opt->text += QLatin1Char('\t') + shortcut;
0524                     opt->reservedShortcutWidth = qMax(opt->reservedShortcutWidth, qRound(textWidth(shortcut)));
0525                 }
0526 
0527                 if (m_properties[QStringLiteral("checkable")].toBool()) {
0528                     opt->checked = on();
0529                     QVariant exclusive = m_properties[QStringLiteral("exclusive")];
0530                     opt->checkType = exclusive.toBool() ? QStyleOptionMenuItem::Exclusive : QStyleOptionMenuItem::NonExclusive;
0531                 }
0532             }
0533 
0534             if (m_iconDirty || opt->icon.isNull()) {
0535                 opt->icon = iconFromIconProperty();
0536                 m_iconDirty = false;
0537             }
0538 
0539             setProperty("_q_showUnderlined", m_hints[QStringLiteral("showUnderlined")].toBool());
0540 
0541             const QFont font = qApp->font(m_itemType == ComboBoxItem ? "QComboMenuItem" : "QMenu");
0542             opt->font = font;
0543             opt->fontMetrics = QFontMetrics(font);
0544             m_font = opt->font;
0545         }
0546         break;
0547     }
0548     case CheckBox:
0549     case RadioButton: {
0550         if (!m_styleoption) {
0551             m_styleoption = new QStyleOptionButton();
0552         }
0553 
0554         QStyleOptionButton *opt = qstyleoption_cast<QStyleOptionButton *>(m_styleoption);
0555         if (!on()) {
0556             opt->state |= QStyle::State_Off;
0557         }
0558         if (m_properties.value(QStringLiteral("partiallyChecked")).toBool()) {
0559             opt->state |= QStyle::State_NoChange;
0560         }
0561         opt->text = text();
0562 
0563         if (m_iconDirty || opt->icon.isNull()) {
0564             opt->icon = iconFromIconProperty();
0565             m_iconDirty = false;
0566         }
0567 
0568         auto iconSize = QSize(m_properties[QStringLiteral("iconWidth")].toInt(), m_properties[QStringLiteral("iconHeight")].toInt());
0569         if (iconSize.isEmpty()) {
0570             int e = KQuickStyleItem::style()->pixelMetric(QStyle::PM_ButtonIconSize, m_styleoption, nullptr);
0571             if (iconSize.width() <= 0) {
0572                 iconSize.setWidth(e);
0573             }
0574             if (iconSize.height() <= 0) {
0575                 iconSize.setHeight(e);
0576             }
0577         }
0578         opt->iconSize = iconSize;
0579         break;
0580     }
0581     case Edit: {
0582         if (!m_styleoption) {
0583             m_styleoption = new QStyleOptionFrame();
0584         }
0585 
0586         QStyleOptionFrame *opt = qstyleoption_cast<QStyleOptionFrame *>(m_styleoption);
0587         opt->lineWidth = qMax(1, KQuickStyleItem::style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption, nullptr)); // this must be non zero
0588         break;
0589     }
0590     case ComboBox: {
0591         if (!m_styleoption) {
0592             m_styleoption = new QStyleOptionComboBox();
0593         }
0594 
0595         QStyleOptionComboBox *opt = qstyleoption_cast<QStyleOptionComboBox *>(m_styleoption);
0596 
0597         const QFont font = qApp->font("QPushButton"); // DAVE - QQC1 code does this, but if you look at QComboBox this doesn't make sense
0598         opt->fontMetrics = QFontMetrics(font);
0599         opt->currentText = text();
0600         opt->editable = m_properties[QStringLiteral("editable")].toBool();
0601 
0602         const QVariant icon = m_properties[QStringLiteral("currentIcon")];
0603         if (icon.canConvert<QIcon>()) {
0604             opt->currentIcon = icon.value<QIcon>();
0605         } else if (icon.canConvert<QString>()) {
0606             opt->currentIcon = m_theme->iconFromTheme(icon.value<QString>(), m_properties[QStringLiteral("iconColor")].value<QColor>());
0607         }
0608         auto iconSize = QSize(m_properties[QStringLiteral("iconWidth")].toInt(), m_properties[QStringLiteral("iconHeight")].toInt());
0609         if (iconSize.isEmpty()) {
0610             int e = KQuickStyleItem::style()->pixelMetric(QStyle::PM_ButtonIconSize, m_styleoption, nullptr);
0611             if (iconSize.width() <= 0) {
0612                 iconSize.setWidth(e);
0613             }
0614             if (iconSize.height() <= 0) {
0615                 iconSize.setHeight(e);
0616             }
0617         }
0618         opt->iconSize = iconSize;
0619         opt->frame = !m_flat;
0620 
0621         break;
0622     }
0623     case SpinBox: {
0624         if (!m_styleoption) {
0625             m_styleoption = new QStyleOptionSpinBox();
0626         }
0627 
0628         QStyleOptionSpinBox *opt = qstyleoption_cast<QStyleOptionSpinBox *>(m_styleoption);
0629         opt->frame = true;
0630         if (value() & 0x1) {
0631             opt->activeSubControls = QStyle::SC_SpinBoxUp;
0632         } else if (value() & (1 << 1)) {
0633             opt->activeSubControls = QStyle::SC_SpinBoxDown;
0634         } else {
0635             opt->activeSubControls = QStyle::SC_None;
0636         }
0637         opt->subControls = QStyle::SC_All;
0638         opt->stepEnabled = {};
0639         if (value() & (1 << 2)) {
0640             opt->stepEnabled |= QAbstractSpinBox::StepUpEnabled;
0641         }
0642         if (value() & (1 << 3)) {
0643             opt->stepEnabled |= QAbstractSpinBox::StepDownEnabled;
0644         }
0645         break;
0646     }
0647     case Slider:
0648     case Dial: {
0649         if (!m_styleoption) {
0650             m_styleoption = new QStyleOptionSlider();
0651         }
0652 
0653         QStyleOptionSlider *opt = qstyleoption_cast<QStyleOptionSlider *>(m_styleoption);
0654         opt->orientation = horizontal() ? Qt::Horizontal : Qt::Vertical;
0655         opt->upsideDown = !horizontal();
0656 
0657         int min = minimum();
0658         int max = std::max(min, maximum());
0659 
0660         opt->minimum = min;
0661         opt->maximum = max;
0662         opt->sliderPosition = value();
0663         opt->singleStep = step();
0664 
0665         if (opt->singleStep) {
0666             qreal numOfSteps = (opt->maximum - opt->minimum) / opt->singleStep;
0667             // at least 5 pixels between tick marks
0668             qreal extent = horizontal() ? width() : height();
0669             if (numOfSteps && (extent / numOfSteps < 5)) {
0670                 opt->tickInterval = qRound((5 * numOfSteps / extent) + 0.5) * step();
0671             } else {
0672                 opt->tickInterval = opt->singleStep;
0673             }
0674 
0675         } else { // default Qt-components implementation
0676             opt->tickInterval = opt->maximum != opt->minimum ? 1200 / (opt->maximum - opt->minimum) : 0;
0677         }
0678 
0679         opt->sliderValue = value();
0680         opt->subControls = QStyle::SC_SliderGroove | QStyle::SC_SliderHandle;
0681         opt->tickPosition = activeControl() == QLatin1String("ticks") ? QSlider::TicksBelow : QSlider::NoTicks;
0682         if (opt->tickPosition != QSlider::NoTicks) {
0683             opt->subControls |= QStyle::SC_SliderTickmarks;
0684         }
0685 
0686         opt->activeSubControls = QStyle::SC_SliderHandle;
0687         break;
0688     }
0689     case ProgressBar: {
0690         if (!m_styleoption) {
0691             m_styleoption = new QStyleOptionProgressBar();
0692         }
0693 
0694         QStyleOptionProgressBar *opt = qstyleoption_cast<QStyleOptionProgressBar *>(m_styleoption);
0695         if (horizontal()) {
0696             opt->state |= QStyle::State_Horizontal;
0697         } else {
0698             opt->state &= ~QStyle::State_Horizontal;
0699         }
0700         opt->minimum = qMax(0, minimum());
0701         opt->maximum = qMax(0, maximum());
0702         opt->progress = value();
0703         break;
0704     }
0705     case GroupBox: {
0706         if (!m_styleoption) {
0707             m_styleoption = new QStyleOptionGroupBox();
0708         }
0709 
0710         QStyleOptionGroupBox *opt = qstyleoption_cast<QStyleOptionGroupBox *>(m_styleoption);
0711         opt->text = text();
0712         opt->lineWidth = KQuickStyleItem::style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption, nullptr);
0713         opt->subControls = QStyle::SC_GroupBoxLabel;
0714         opt->features = {};
0715         if (m_properties[QStringLiteral("sunken")].toBool()) { // Qt draws an ugly line here so I ignore it
0716             opt->subControls |= QStyle::SC_GroupBoxFrame;
0717         } else {
0718             opt->features |= QStyleOptionFrame::Flat;
0719         }
0720         if (m_properties[QStringLiteral("checkable")].toBool()) {
0721             opt->subControls |= QStyle::SC_GroupBoxCheckBox;
0722         }
0723 
0724         break;
0725     }
0726     case ScrollBar: {
0727         if (!m_styleoption) {
0728             m_styleoption = new QStyleOptionSlider();
0729         }
0730 
0731         QStyleOptionSlider *opt = qstyleoption_cast<QStyleOptionSlider *>(m_styleoption);
0732         opt->minimum = qMax(0, minimum());
0733         opt->maximum = qMax(0, maximum());
0734         opt->pageStep = qMax(0, int(horizontal() ? width() : height()));
0735         opt->orientation = horizontal() ? Qt::Horizontal : Qt::Vertical;
0736         if (horizontal()) {
0737             // mirrored horizontal scrollbars are not something you want to interact with
0738             preventMirroring = true;
0739         }
0740         opt->sliderPosition = value();
0741         opt->sliderValue = value();
0742         opt->activeSubControls = (activeControl() == QLatin1String("up")) ? QStyle::SC_ScrollBarSubLine
0743             : (activeControl() == QLatin1String("down"))                  ? QStyle::SC_ScrollBarAddLine
0744             : (activeControl() == QLatin1String("handle"))                ? QStyle::SC_ScrollBarSlider
0745             : hover()                                                     ? QStyle::SC_ScrollBarGroove
0746                                                                           : QStyle::SC_None;
0747         if (raised()) {
0748             opt->state |= QStyle::State_On;
0749         }
0750 
0751         opt->subControls = QStyle::SC_All;
0752 
0753         setTransient(KQuickStyleItem::style()->styleHint(QStyle::SH_ScrollBar_Transient, m_styleoption));
0754         break;
0755     }
0756     default:
0757         break;
0758     }
0759 
0760     if (!m_styleoption) {
0761         m_styleoption = new QStyleOption();
0762     }
0763 
0764     if (needsResolvePalette) {
0765         resolvePalette();
0766     }
0767 
0768     m_styleoption->styleObject = this;
0769     const auto mirror = m_control == nullptr ? qApp->layoutDirection() == Qt::RightToLeft : m_control->property("mirrored").toBool();
0770     m_styleoption->direction = (mirror && !preventMirroring) ? Qt::RightToLeft : Qt::LeftToRight;
0771 
0772     int w = m_textureWidth > 0 ? m_textureWidth : width();
0773     int h = m_textureHeight > 0 ? m_textureHeight : height();
0774 
0775     m_styleoption->rect = QRect(m_paintMargins, 0, w - 2 * m_paintMargins, h);
0776 
0777     if (isEnabled()) {
0778         m_styleoption->state |= QStyle::State_Enabled;
0779         m_styleoption->palette.setCurrentColorGroup(QPalette::Active);
0780     } else {
0781         m_styleoption->palette.setCurrentColorGroup(QPalette::Disabled);
0782     }
0783 
0784     if (m_active) {
0785         m_styleoption->state |= QStyle::State_Active;
0786     } else {
0787         m_styleoption->palette.setCurrentColorGroup(QPalette::Inactive);
0788     }
0789 
0790     if (m_sunken) {
0791         m_styleoption->state |= QStyle::State_Sunken;
0792     }
0793     if (!m_sunken || m_raised) {
0794         m_styleoption->state |= QStyle::State_Raised;
0795     }
0796     if (m_selected) {
0797         m_styleoption->state |= QStyle::State_Selected;
0798     }
0799     if (m_focus) {
0800         m_styleoption->state |= QStyle::State_HasFocus;
0801     }
0802     if (m_on) {
0803         m_styleoption->state |= QStyle::State_On;
0804     }
0805     if (m_hover) {
0806         m_styleoption->state |= QStyle::State_MouseOver;
0807     }
0808     if (m_horizontal) {
0809         m_styleoption->state |= QStyle::State_Horizontal;
0810     }
0811 
0812     // some styles don't draw a focus rectangle if
0813     // QStyle::State_KeyboardFocusChange is not set
0814     if (window()) {
0815         if (isKeyFocusReason(m_focusReason)) {
0816             m_styleoption->state |= QStyle::State_KeyboardFocusChange;
0817         }
0818     }
0819 
0820     if (sizeHint == QLatin1String("mini")) {
0821         m_styleoption->state |= QStyle::State_Mini;
0822     } else if (sizeHint == QLatin1String("small")) {
0823         m_styleoption->state |= QStyle::State_Small;
0824     }
0825 
0826 }
0827 
0828 QIcon KQuickStyleItem::iconFromIconProperty() const
0829 {
0830     QIcon icon;
0831     const QVariant iconProperty = m_properties[QStringLiteral("icon")];
0832     switch (iconProperty.userType()) {
0833     case QMetaType::QIcon:
0834         icon = iconProperty.value<QIcon>();
0835         break;
0836     case QMetaType::QUrl:
0837     case QMetaType::QString: {
0838         QString iconSource = iconProperty.toString();
0839         if (iconSource.startsWith(QLatin1String("qrc:/"))) {
0840             iconSource = iconSource.mid(3);
0841         } else if (iconSource.startsWith(QLatin1String("file:/"))) {
0842             iconSource = QUrl(iconSource).toLocalFile();
0843         }
0844         if (iconSource.contains(QLatin1String("/"))) {
0845             icon = QIcon(iconSource);
0846         } else {
0847             icon = m_theme->iconFromTheme(iconSource, m_properties[QStringLiteral("iconColor")].value<QColor>());
0848         }
0849         break;
0850     }
0851     default:
0852         break;
0853     }
0854     return icon;
0855 }
0856 
0857 const char *KQuickStyleItem::classNameForItem() const
0858 {
0859     switch (m_itemType) {
0860     case Button:
0861         return "QPushButton";
0862     case RadioButton:
0863         return "QRadioButton";
0864     case CheckBox:
0865         return "QCheckBox";
0866     case ComboBox:
0867         return "QComboBox";
0868     case ComboBoxItem:
0869         return "QComboMenuItem";
0870     case ToolBar:
0871         return "";
0872     case DelayButton:
0873     case ToolButton:
0874         return "QToolButton";
0875     case Tab:
0876         return "QTabButton";
0877     case TabFrame:
0878         return "QTabBar";
0879     case Edit:
0880         return "QTextEdit";
0881     case GroupBox:
0882         return "QGroupBox";
0883     case Header:
0884         return "QHeaderView";
0885     case Item:
0886     case ItemRow:
0887         return "QAbstractItemView";
0888     case Menu:
0889     case MenuItem:
0890         return "QMenu";
0891     case MenuBar:
0892     case MenuBarItem:
0893         return "QMenuBar";
0894     default:
0895         return "";
0896     }
0897     Q_UNREACHABLE();
0898 }
0899 
0900 void KQuickStyleItem::resolvePalette()
0901 {
0902     if (QCoreApplication::testAttribute(Qt::AA_SetPalette)) {
0903         return;
0904     }
0905 
0906     const QVariant controlPalette = m_control ? m_control->property("palette") : QVariant();
0907     if (controlPalette.isValid()) {
0908         m_styleoption->palette = controlPalette.value<QPalette>();
0909     } else {
0910         m_styleoption->palette = m_theme->palette();
0911     }
0912 }
0913 
0914 int KQuickStyleItem::topPadding() const
0915 {
0916     return padding(Qt::TopEdge);
0917 }
0918 
0919 int KQuickStyleItem::leftPadding() const
0920 {
0921     return padding(Qt::LeftEdge);
0922 }
0923 
0924 int KQuickStyleItem::rightPadding() const
0925 {
0926     return padding(Qt::RightEdge);
0927 }
0928 
0929 int KQuickStyleItem::bottomPadding() const
0930 {
0931     return padding(Qt::BottomEdge);
0932 }
0933 
0934 int KQuickStyleItem::padding(Qt::Edge edge) const
0935 {
0936     if (m_itemType == Frame) {
0937         const QRect cr = KQuickStyleItem::style()->subElementRect(QStyle::SE_ShapedFrameContents, m_styleoption);
0938         switch (edge) {
0939         case Qt::TopEdge:
0940             return cr.top() - m_styleoption->rect.top();
0941         case Qt::LeftEdge:
0942             return cr.left() - m_styleoption->rect.left();
0943         case Qt::RightEdge:
0944             return m_styleoption->rect.right() - cr.right();
0945         case Qt::BottomEdge:
0946             return m_styleoption->rect.bottom() - cr.bottom();
0947         }
0948     }
0949     return 0;
0950 }
0951 
0952 /*
0953  *   Property style
0954  *
0955  *   Returns a simplified style name.
0956  *
0957  *   QMacStyle = "mac"
0958  *   QWindowsXPStyle = "windowsxp"
0959  *   QFusionStyle = "fusion"
0960  */
0961 
0962 QString KQuickStyleItem::styleName() const
0963 {
0964     const QString fullName = QString::fromLatin1(KQuickStyleItem::style()->metaObject()->className());
0965     QStringView shortName = fullName;
0966     if (shortName.startsWith(QLatin1Char('q'), Qt::CaseInsensitive)) {
0967         shortName = shortName.sliced(1);
0968     }
0969     const QLatin1String suffix("style");
0970     if (shortName.endsWith(suffix, Qt::CaseInsensitive)) {
0971         shortName.chop(suffix.length());
0972     }
0973     return shortName.toString().toLower();
0974 }
0975 
0976 QString KQuickStyleItem::hitTest(int px, int py)
0977 {
0978     QStyle::SubControl subcontrol = QStyle::SC_All;
0979     switch (m_itemType) {
0980     case SpinBox: {
0981         subcontrol = KQuickStyleItem::style()->hitTestComplexControl(QStyle::CC_SpinBox,
0982                                                                      qstyleoption_cast<QStyleOptionComplex *>(m_styleoption),
0983                                                                      QPoint(px, py),
0984                                                                      nullptr);
0985         if (subcontrol == QStyle::SC_SpinBoxUp) {
0986             return QStringLiteral("up");
0987         } else if (subcontrol == QStyle::SC_SpinBoxDown) {
0988             return QStringLiteral("down");
0989         }
0990         break;
0991     }
0992 
0993     case Slider: {
0994         subcontrol = KQuickStyleItem::style()->hitTestComplexControl(QStyle::CC_Slider,
0995                                                                      qstyleoption_cast<QStyleOptionComplex *>(m_styleoption),
0996                                                                      QPoint(px, py),
0997                                                                      nullptr);
0998         if (subcontrol == QStyle::SC_SliderHandle) {
0999             return QStringLiteral("handle");
1000         }
1001         break;
1002     }
1003 
1004     case ScrollBar: {
1005         subcontrol = KQuickStyleItem::style()->hitTestComplexControl(QStyle::CC_ScrollBar,
1006                                                                      qstyleoption_cast<QStyleOptionComplex *>(m_styleoption),
1007                                                                      QPoint(px, py),
1008                                                                      nullptr);
1009         switch (subcontrol) {
1010         case QStyle::SC_ScrollBarSlider:
1011             return QStringLiteral("handle");
1012 
1013         case QStyle::SC_ScrollBarSubLine:
1014             return QStringLiteral("up");
1015 
1016         case QStyle::SC_ScrollBarSubPage:
1017             return QStringLiteral("upPage");
1018 
1019         case QStyle::SC_ScrollBarAddLine:
1020             return QStringLiteral("down");
1021 
1022         case QStyle::SC_ScrollBarAddPage:
1023             return QStringLiteral("downPage");
1024 
1025         default:
1026             break;
1027         }
1028         break;
1029     }
1030 
1031     default:
1032         break;
1033     }
1034     return QStringLiteral("none");
1035 }
1036 
1037 QRect KQuickStyleItem::computeBoundingRect(const QList<QRect> &rects)
1038 {
1039     QRegion r;
1040 
1041     for (const auto& rect : rects) {
1042         r = r.united(rect);
1043     }
1044 
1045     return r.boundingRect();
1046 }
1047 
1048 QSize KQuickStyleItem::sizeFromContents(int width, int height)
1049 {
1050     initStyleOption();
1051 
1052     QSize size;
1053     switch (m_itemType) {
1054     case RadioButton:
1055     case CheckBox: {
1056         auto contentType = (m_itemType == RadioButton) ? QStyle::CT_RadioButton : QStyle::CT_CheckBox;
1057         QStyleOptionButton *btn = qstyleoption_cast<QStyleOptionButton *>(m_styleoption);
1058         QSize contentSize = btn->fontMetrics.size(Qt::TextShowMnemonic, btn->text);
1059         if (!btn->icon.isNull()) {
1060             contentSize.setWidth(contentSize.width() + btn->iconSize.width());
1061             contentSize.setHeight(std::max(contentSize.height(), btn->iconSize.height()));
1062         }
1063         size = KQuickStyleItem::style()->sizeFromContents(contentType, m_styleoption, contentSize);
1064         break;
1065     }
1066     case ToolBar:
1067         size = QSize(200, styleName().contains(QLatin1String("windows")) ? 30 : 42);
1068         break;
1069     case DelayButton:
1070     case ToolButton: {
1071         QStyleOptionToolButton *btn = qstyleoption_cast<QStyleOptionToolButton *>(m_styleoption);
1072         int w = 0;
1073         int h = 0;
1074         if (btn->toolButtonStyle != Qt::ToolButtonTextOnly) {
1075             QSize icon = btn->iconSize;
1076             if (btn->toolButtonStyle == Qt::ToolButtonIconOnly || !btn->icon.isNull()) {
1077                 w = icon.width();
1078                 h = icon.height();
1079             }
1080         }
1081         if (btn->toolButtonStyle != Qt::ToolButtonIconOnly) {
1082             QSize textSize = btn->fontMetrics.size(Qt::TextShowMnemonic, btn->text);
1083             textSize.setWidth(textSize.width() + btn->fontMetrics.horizontalAdvance(QLatin1Char(' ')) * 2);
1084             if (btn->toolButtonStyle == Qt::ToolButtonTextUnderIcon) {
1085                 h += 4 + textSize.height();
1086                 if (textSize.width() > w) {
1087                     w = textSize.width();
1088                 }
1089             } else if (btn->toolButtonStyle == Qt::ToolButtonTextBesideIcon) {
1090                 w += 4 + textSize.width();
1091                 if (textSize.height() > h) {
1092                     h = textSize.height();
1093                 }
1094             } else { // TextOnly
1095                 w = textSize.width();
1096                 h = textSize.height();
1097             }
1098         }
1099         btn->rect.setSize(QSize(w, h));
1100         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_ToolButton, m_styleoption, QSize(w, h));
1101         break;
1102     }
1103     case Button: {
1104         QStyleOptionButton *btn = qstyleoption_cast<QStyleOptionButton *>(m_styleoption);
1105 
1106         int contentWidth = btn->fontMetrics.boundingRect(btn->text).width();
1107         int contentHeight = btn->fontMetrics.height();
1108 
1109         if (!btn->icon.isNull()) {
1110             //+4 matches a hardcoded value in QStyle and acts as a margin between the icon and the text.
1111             contentWidth += btn->iconSize.width() + 4;
1112             contentHeight = qMax(btn->fontMetrics.height(), btn->iconSize.height());
1113         }
1114 
1115         int newWidth = qMax(width, contentWidth);
1116         int newHeight = qMax(height, contentHeight);
1117         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_PushButton, m_styleoption, QSize(newWidth, newHeight));
1118         break;
1119     }
1120     case ComboBox: {
1121         QStyleOptionComboBox *opt = qstyleoption_cast<QStyleOptionComboBox *>(m_styleoption);
1122         int newWidth = qMax(width, m_contentWidth) + (opt->currentIcon.isNull() ? 0 : opt->iconSize.width());
1123         int newHeight = qMax(height, opt->fontMetrics.height());
1124         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_ComboBox, m_styleoption, QSize(newWidth, newHeight));
1125         break;
1126     }
1127     case Tab: {
1128         QStyleOptionTab *tab = qstyleoption_cast<QStyleOptionTab *>(m_styleoption);
1129 
1130         int contentWidth = tab->fontMetrics.boundingRect(tab->text).width();
1131         int contentHeight = tab->fontMetrics.height();
1132 
1133         if (!tab->icon.isNull()) {
1134             //+4 matches a hardcoded value in QStyle and acts as a margin between the icon and the text.
1135             contentWidth += tab->iconSize.width() + 4;
1136             contentHeight = qMax(contentHeight, tab->iconSize.height());
1137         }
1138 
1139         contentWidth += KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabHSpace, tab);
1140         contentHeight += KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabVSpace, tab);
1141 
1142         const int newWidth = qMax(width, contentWidth);
1143         const int newHeight = qMax(height, contentHeight);
1144 
1145         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_TabBarTab, m_styleoption, QSize(newWidth, newHeight));
1146 
1147         break;
1148     }
1149     case Slider: {
1150         const auto opt = qstyleoption_cast<const QStyleOptionSlider *>(m_styleoption);
1151         const auto tickPosition = opt->tickPosition;
1152 
1153         // Copied from QSlider
1154         const int SliderLength = 84, TickSpace = 5;
1155         int thick = style()->pixelMetric(QStyle::PM_SliderThickness, m_styleoption, nullptr);
1156         if (tickPosition & QSlider::TicksAbove) {
1157             thick += TickSpace;
1158         }
1159         if (tickPosition & QSlider::TicksBelow) {
1160             thick += TickSpace;
1161         }
1162         int w = thick;
1163         int h = SliderLength;
1164         if (opt->orientation == Qt::Horizontal) {
1165             w = SliderLength;
1166             h = thick;
1167         }
1168         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_Slider, m_styleoption, QSize(w, h));
1169         break;
1170     }
1171     case ProgressBar:
1172         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_ProgressBar, m_styleoption, QSize(width, height));
1173         break;
1174 
1175     case ScrollBar: {
1176         const auto opt = qstyleoption_cast<const QStyleOptionSlider *>(m_styleoption);
1177 
1178         // Copied from QScrollBar
1179         const int scrollBarExtent = KQuickStyleItem::style()->pixelMetric(QStyle::PM_ScrollBarExtent, opt, nullptr);
1180         const int scrollBarSliderMin = KQuickStyleItem::style()->pixelMetric(QStyle::PM_ScrollBarSliderMin, opt, nullptr);
1181         if (opt->orientation == Qt::Horizontal) {
1182             size = QSize(scrollBarExtent * 2 + scrollBarSliderMin, scrollBarExtent);
1183         } else {
1184             size = QSize(scrollBarExtent, scrollBarExtent * 2 + scrollBarSliderMin);
1185         }
1186         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_ScrollBar, opt, size);
1187         break;
1188     }
1189     case SpinBox:
1190     case Edit: {
1191         // We have to create a new style option since we might be calling with a QStyleOptionSpinBox
1192         QStyleOptionFrame frame;
1193         //+2 to be consistent with the hardcoded verticalmargin in QLineEdit
1194         int contentHeight = frame.fontMetrics.height() + 2;
1195 
1196         frame.state = m_styleoption->state | QStyle::State_Sunken;
1197         frame.lineWidth = KQuickStyleItem::style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption, nullptr);
1198         frame.rect = m_styleoption->rect;
1199         frame.styleObject = this;
1200 
1201         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_LineEdit, &frame, QSize(width, qMax(height, contentHeight)));
1202         if (m_itemType == SpinBox) {
1203             size.setWidth(KQuickStyleItem::style()->sizeFromContents(QStyle::CT_SpinBox, m_styleoption, QSize(width + 2, height)).width());
1204         }
1205         break;
1206     }
1207     case GroupBox: {
1208         QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox *>(m_styleoption);
1209         QFontMetrics metrics(box->fontMetrics);
1210         int baseWidth = metrics.boundingRect(box->text + QLatin1Char(' ')).width();
1211         int baseHeight = metrics.height() + m_contentHeight;
1212         if (box->subControls & QStyle::SC_GroupBoxCheckBox) {
1213             baseWidth += KQuickStyleItem::style()->pixelMetric(QStyle::PM_IndicatorWidth);
1214             baseWidth += KQuickStyleItem::style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing);
1215             baseHeight = qMax(baseHeight, KQuickStyleItem::style()->pixelMetric(QStyle::PM_IndicatorHeight));
1216         }
1217         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_GroupBox, m_styleoption, QSize(qMax(baseWidth, m_contentWidth), baseHeight));
1218         break;
1219     }
1220     case Header:
1221         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_HeaderSection, m_styleoption, QSize(width, height));
1222         break;
1223     case ItemRow:
1224     case Item: // fall through
1225         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_ItemViewItem, m_styleoption, QSize(width, height));
1226         break;
1227     case MenuBarItem:
1228         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_MenuBarItem, m_styleoption, QSize(width, height));
1229         break;
1230     case MenuBar:
1231         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_MenuBar, m_styleoption, QSize(width, height));
1232         break;
1233     case Menu:
1234         size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_Menu, m_styleoption, QSize(width, height));
1235         break;
1236     case MenuItem:
1237     case ComboBoxItem:
1238         if (static_cast<QStyleOptionMenuItem *>(m_styleoption)->menuItemType == QStyleOptionMenuItem::Scroller) {
1239             size.setHeight(KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuScrollerHeight, nullptr, nullptr));
1240         } else {
1241             size = KQuickStyleItem::style()->sizeFromContents(QStyle::CT_MenuItem, m_styleoption, QSize(width, height));
1242         }
1243         break;
1244     default:
1245         break;
1246     }
1247     return size.expandedTo(QSize(m_contentWidth, m_contentHeight));
1248 }
1249 
1250 qreal KQuickStyleItem::baselineOffset()
1251 {
1252     QRect r;
1253     bool ceilResult = true; // By default baseline offset rounding is done upwards
1254     switch (m_itemType) {
1255     case RadioButton:
1256         r = KQuickStyleItem::style()->subElementRect(QStyle::SE_RadioButtonContents, m_styleoption);
1257         break;
1258     case Button:
1259         r = KQuickStyleItem::style()->subElementRect(QStyle::SE_PushButtonContents, m_styleoption);
1260         break;
1261     case CheckBox:
1262         r = KQuickStyleItem::style()->subElementRect(QStyle::SE_CheckBoxContents, m_styleoption);
1263         break;
1264     case Edit:
1265         r = KQuickStyleItem::style()->subElementRect(QStyle::SE_LineEditContents, m_styleoption);
1266         break;
1267     case ComboBox:
1268         if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(m_styleoption)) {
1269             r = KQuickStyleItem::style()->subControlRect(QStyle::CC_ComboBox, combo, QStyle::SC_ComboBoxEditField);
1270             if (styleName() != QLatin1String("mac")) {
1271                 r.adjust(0, 0, 0, 1);
1272             }
1273         }
1274         break;
1275     case SpinBox:
1276         if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(m_styleoption)) {
1277             r = KQuickStyleItem::style()->subControlRect(QStyle::CC_SpinBox, spinbox, QStyle::SC_SpinBoxEditField);
1278             ceilResult = false;
1279         }
1280         break;
1281     default:
1282         break;
1283     }
1284     if (r.height() > 0) {
1285         const QFontMetrics &fm = m_styleoption->fontMetrics;
1286         int surplus = r.height() - fm.height();
1287         if ((surplus & 1) && ceilResult) {
1288             surplus++;
1289         }
1290         int result = r.top() + surplus / 2 + fm.ascent();
1291         return result;
1292     }
1293 
1294     return 0.;
1295 }
1296 
1297 void KQuickStyleItem::updateBaselineOffset()
1298 {
1299     const qreal baseline = baselineOffset();
1300     if (baseline > 0) {
1301         setBaselineOffset(baseline);
1302     }
1303 }
1304 
1305 void KQuickStyleItem::setContentWidth(int arg)
1306 {
1307     if (m_contentWidth != arg) {
1308         m_contentWidth = arg;
1309         updateSizeHint();
1310         Q_EMIT contentWidthChanged(arg);
1311     }
1312 }
1313 
1314 void KQuickStyleItem::setContentHeight(int arg)
1315 {
1316     if (m_contentHeight != arg) {
1317         m_contentHeight = arg;
1318         updateSizeHint();
1319         updateBaselineOffset();
1320         Q_EMIT contentHeightChanged(arg);
1321     }
1322 }
1323 
1324 void KQuickStyleItem::updateSizeHint()
1325 {
1326     QSize implicitSize = sizeFromContents(m_contentWidth, m_contentHeight);
1327     setImplicitSize(implicitSize.width(), implicitSize.height());
1328 }
1329 
1330 void KQuickStyleItem::updateRect()
1331 {
1332     initStyleOption();
1333     m_styleoption->rect.setWidth(width());
1334     m_styleoption->rect.setHeight(height());
1335 }
1336 
1337 int KQuickStyleItem::pixelMetric(const QString &metric)
1338 {
1339     if (metric == QLatin1String("scrollbarExtent")) {
1340         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_ScrollBarExtent, nullptr);
1341     } else if (metric == QLatin1String("defaultframewidth")) {
1342         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption);
1343     } else if (metric == QLatin1String("taboverlap")) {
1344         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabOverlap, nullptr);
1345     } else if (metric == QLatin1String("tabbaseoverlap")) {
1346         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarBaseOverlap, m_styleoption);
1347     } else if (metric == QLatin1String("tabhspace")) {
1348         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabHSpace, nullptr);
1349     } else if (metric == QLatin1String("indicatorwidth")) {
1350         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_IndicatorWidth, nullptr);
1351     } else if (metric == QLatin1String("exclusiveindicatorwidth")) {
1352         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_ExclusiveIndicatorWidth, nullptr);
1353     } else if (metric == QLatin1String("checkboxlabelspacing")) {
1354         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing, nullptr);
1355     } else if (metric == QLatin1String("radiobuttonlabelspacing")) {
1356         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_RadioButtonLabelSpacing, nullptr);
1357     } else if (metric == QLatin1String("tabvspace")) {
1358         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabVSpace, nullptr);
1359     } else if (metric == QLatin1String("tabbaseheight")) {
1360         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarBaseHeight, nullptr);
1361     } else if (metric == QLatin1String("tabvshift")) {
1362         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TabBarTabShiftVertical, nullptr);
1363     } else if (metric == QLatin1String("menubarhmargin")) {
1364         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuBarHMargin, nullptr);
1365     } else if (metric == QLatin1String("menubarvmargin")) {
1366         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuBarVMargin, nullptr);
1367     } else if (metric == QLatin1String("menubarpanelwidth")) {
1368         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, nullptr);
1369     } else if (metric == QLatin1String("menubaritemspacing")) {
1370         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuBarItemSpacing, nullptr);
1371     } else if (metric == QLatin1String("spacebelowmenubar")) {
1372         return KQuickStyleItem::style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, m_styleoption);
1373     } else if (metric == QLatin1String("menuhmargin")) {
1374         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuHMargin, nullptr);
1375     } else if (metric == QLatin1String("menuvmargin")) {
1376         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuVMargin, nullptr);
1377     } else if (metric == QLatin1String("menupanelwidth")) {
1378         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuPanelWidth, nullptr);
1379     } else if (metric == QLatin1String("submenuoverlap")) {
1380         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_SubMenuOverlap, nullptr);
1381     } else if (metric == QLatin1String("splitterwidth")) {
1382         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_SplitterWidth, nullptr);
1383     } else if (metric == QLatin1String("scrollbarspacing")) {
1384         return abs(KQuickStyleItem::style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing, nullptr));
1385     } else if (metric == QLatin1String("treeviewindentation")) {
1386         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_TreeViewIndentation, nullptr);
1387     } else if (metric == QLatin1String("layouthorizontalspacing")) {
1388         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutHorizontalSpacing, nullptr);
1389     } else if (metric == QLatin1String("layoutverticalspacing")) {
1390         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutVerticalSpacing, nullptr);
1391     } else if (metric == QLatin1String("layoutleftmargin")) {
1392         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutLeftMargin, nullptr);
1393     } else if (metric == QLatin1String("layouttopmargin")) {
1394         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutTopMargin, nullptr);
1395     } else if (metric == QLatin1String("layoutrightmargin")) {
1396         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutRightMargin, nullptr);
1397     } else if (metric == QLatin1String("layoutbottommargin")) {
1398         return KQuickStyleItem::style()->pixelMetric(QStyle::PM_LayoutBottomMargin, nullptr);
1399     }
1400     return 0;
1401 }
1402 
1403 QVariant KQuickStyleItem::styleHint(const QString &metric)
1404 {
1405     initStyleOption();
1406     if (metric == QLatin1String("comboboxpopup")) {
1407         return KQuickStyleItem::style()->styleHint(QStyle::SH_ComboBox_Popup, m_styleoption);
1408     } else if (metric == QLatin1String("highlightedTextColor")) {
1409         return m_styleoption->palette.highlightedText().color().name();
1410     } else if (metric == QLatin1String("textColor")) {
1411         QPalette pal = m_styleoption->palette;
1412         pal.setCurrentColorGroup(active() ? QPalette::Active : QPalette::Inactive);
1413         return pal.text().color().name();
1414     } else if (metric == QLatin1String("focuswidget")) {
1415         return KQuickStyleItem::style()->styleHint(QStyle::SH_FocusFrame_AboveWidget);
1416     } else if (metric == QLatin1String("tabbaralignment")) {
1417         int result = KQuickStyleItem::style()->styleHint(QStyle::SH_TabBar_Alignment);
1418         if (result == Qt::AlignCenter) {
1419             return QStringLiteral("center");
1420         }
1421         return QStringLiteral("left");
1422     } else if (metric == QLatin1String("externalScrollBars")) {
1423         return KQuickStyleItem::style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents);
1424     } else if (metric == QLatin1String("scrollToClickPosition")) {
1425         return KQuickStyleItem::style()->styleHint(QStyle::SH_ScrollBar_LeftClickAbsolutePosition);
1426     } else if (metric == QLatin1String("activateItemOnSingleClick")) {
1427         return KQuickStyleItem::style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick);
1428     } else if (metric == QLatin1String("submenupopupdelay")) {
1429         return KQuickStyleItem::style()->styleHint(QStyle::SH_Menu_SubMenuPopupDelay, m_styleoption);
1430     } else if (metric == QLatin1String("wheelScrollLines")) {
1431         return qApp->wheelScrollLines();
1432     }
1433     return 0;
1434 
1435     // Add SH_Menu_SpaceActivatesItem
1436 }
1437 
1438 void KQuickStyleItem::setHints(const QVariantMap &hints)
1439 {
1440     if (m_hints != hints) {
1441         m_hints = hints;
1442         initStyleOption();
1443         updateSizeHint();
1444         polish();
1445         if (m_styleoption->state & QStyle::State_Mini) {
1446             m_font.setPointSize(9.);
1447             Q_EMIT fontChanged();
1448         } else if (m_styleoption->state & QStyle::State_Small) {
1449             m_font.setPointSize(11.);
1450             Q_EMIT fontChanged();
1451         } else {
1452             Q_EMIT hintChanged();
1453         }
1454     }
1455 }
1456 
1457 void KQuickStyleItem::resetHints()
1458 {
1459     m_hints.clear();
1460 }
1461 
1462 void KQuickStyleItem::setElementType(const QString &str)
1463 {
1464     if (m_type == str) {
1465         return;
1466     }
1467 
1468     m_type = str;
1469 
1470     Q_EMIT elementTypeChanged();
1471     if (m_styleoption) {
1472         delete m_styleoption;
1473         m_styleoption = nullptr;
1474     }
1475 
1476     // Only enable visible if the widget can animate
1477     if (str == QLatin1String("menu")) {
1478         m_itemType = Menu;
1479     } else if (str == QLatin1String("menuitem")) {
1480         m_itemType = MenuItem;
1481     } else if (str == QLatin1String("item") || str == QLatin1String("itemrow") || str == QLatin1String("header")) {
1482         if (str == QLatin1String("header")) {
1483             m_itemType = Header;
1484         } else {
1485             m_itemType = str == QLatin1String("item") ? Item : ItemRow;
1486         }
1487     } else if (str == QLatin1String("itembranchindicator")) {
1488         m_itemType = ItemBranchIndicator;
1489     } else if (str == QLatin1String("groupbox")) {
1490         m_itemType = GroupBox;
1491     } else if (str == QLatin1String("tab")) {
1492         m_itemType = Tab;
1493     } else if (str == QLatin1String("tabframe")) {
1494         m_itemType = TabFrame;
1495     } else if (str == QLatin1String("comboboxitem")) {
1496         // Gtk uses qobject cast, hence we need to separate this from menuitem
1497         // On macOS, we temporarily use the menu item because it has more accurate
1498         // palette.
1499         m_itemType = ComboBoxItem;
1500     } else if (str == QLatin1String("toolbar")) {
1501         m_itemType = ToolBar;
1502     } else if (str == QLatin1String("toolbutton")) {
1503         m_itemType = ToolButton;
1504     } else if (str == QLatin1String("slider")) {
1505         m_itemType = Slider;
1506     } else if (str == QLatin1String("frame")) {
1507         m_itemType = Frame;
1508     } else if (str == QLatin1String("combobox")) {
1509         m_itemType = ComboBox;
1510     } else if (str == QLatin1String("splitter")) {
1511         m_itemType = Splitter;
1512     } else if (str == QLatin1String("progressbar")) {
1513         m_itemType = ProgressBar;
1514     } else if (str == QLatin1String("button")) {
1515         m_itemType = Button;
1516     } else if (str == QLatin1String("checkbox")) {
1517         m_itemType = CheckBox;
1518     } else if (str == QLatin1String("radiobutton")) {
1519         m_itemType = RadioButton;
1520     } else if (str == QLatin1String("edit")) {
1521         m_itemType = Edit;
1522     } else if (str == QLatin1String("spinbox")) {
1523         m_itemType = SpinBox;
1524     } else if (str == QLatin1String("scrollbar")) {
1525         m_itemType = ScrollBar;
1526     } else if (str == QLatin1String("widget")) {
1527         m_itemType = Widget;
1528     } else if (str == QLatin1String("focusframe")) {
1529         m_itemType = FocusFrame;
1530     } else if (str == QLatin1String("focusrect")) {
1531         m_itemType = FocusRect;
1532     } else if (str == QLatin1String("dial")) {
1533         m_itemType = Dial;
1534     } else if (str == QLatin1String("statusbar")) {
1535         m_itemType = StatusBar;
1536     } else if (str == QLatin1String("machelpbutton")) {
1537         m_itemType = MacHelpButton;
1538     } else if (str == QLatin1String("scrollareacorner")) {
1539         m_itemType = ScrollAreaCorner;
1540     } else if (str == QLatin1String("menubar")) {
1541         m_itemType = MenuBar;
1542     } else if (str == QLatin1String("menubaritem")) {
1543         m_itemType = MenuBarItem;
1544     } else if (str == QLatin1String("delaybutton")) {
1545         m_itemType = DelayButton;
1546     } else {
1547         m_itemType = Undefined;
1548     }
1549     Q_EMIT leftPaddingChanged();
1550     Q_EMIT rightPaddingChanged();
1551     Q_EMIT topPaddingChanged();
1552     Q_EMIT bottomPaddingChanged();
1553     updateSizeHint();
1554     polish();
1555 }
1556 
1557 QRectF KQuickStyleItem::subControlRect(const QString &subcontrolString)
1558 {
1559     QStyle::SubControl subcontrol = QStyle::SC_None;
1560     initStyleOption();
1561     switch (m_itemType) {
1562     case SpinBox: {
1563         QStyle::ComplexControl control = QStyle::CC_SpinBox;
1564         if (subcontrolString == QLatin1String("down")) {
1565             subcontrol = QStyle::SC_SpinBoxDown;
1566         } else if (subcontrolString == QLatin1String("up")) {
1567             subcontrol = QStyle::SC_SpinBoxUp;
1568         } else if (subcontrolString == QLatin1String("edit")) {
1569             subcontrol = QStyle::SC_SpinBoxEditField;
1570         }
1571         return KQuickStyleItem::style()->subControlRect(control, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), subcontrol);
1572 
1573         break;
1574     }
1575     case Slider: {
1576         QStyle::ComplexControl control = QStyle::CC_Slider;
1577         if (subcontrolString == QLatin1String("handle")) {
1578             subcontrol = QStyle::SC_SliderHandle;
1579         } else if (subcontrolString == QLatin1String("groove")) {
1580             subcontrol = QStyle::SC_SliderGroove;
1581         }
1582         return KQuickStyleItem::style()->subControlRect(control, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), subcontrol);
1583 
1584         break;
1585     }
1586     case ScrollBar: {
1587         QStyle::ComplexControl control = QStyle::CC_ScrollBar;
1588         if (subcontrolString == QLatin1String("slider")) {
1589             subcontrol = QStyle::SC_ScrollBarSlider;
1590         } else if (subcontrolString == QLatin1String("groove")) {
1591             subcontrol = QStyle::SC_ScrollBarGroove;
1592         } else if (subcontrolString == QLatin1String("handle")) {
1593             subcontrol = QStyle::SC_ScrollBarSlider;
1594         } else if (subcontrolString == QLatin1String("add")) {
1595             subcontrol = QStyle::SC_ScrollBarAddPage;
1596         } else if (subcontrolString == QLatin1String("sub")) {
1597             subcontrol = QStyle::SC_ScrollBarSubPage;
1598         }
1599         return KQuickStyleItem::style()->subControlRect(control, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), subcontrol);
1600         break;
1601     }
1602     case ItemBranchIndicator: {
1603         QStyleOption opt;
1604         opt.rect = QRect(0, 0, implicitWidth(), implicitHeight());
1605         return KQuickStyleItem::style()->subElementRect(QStyle::SE_TreeViewDisclosureItem, &opt, nullptr);
1606     }
1607     default:
1608         break;
1609     }
1610     return QRectF();
1611 }
1612 
1613 void KQuickStyleItem::paint(QPainter *painter)
1614 {
1615     initStyleOption();
1616     if (QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem *>(m_styleoption)) {
1617         painter->setFont(opt->font);
1618     } else {
1619         QFont font;
1620         if (m_styleoption->state & QStyle::State_Mini) {
1621             font = qApp->font("QMiniFont");
1622         } else if (m_styleoption->state & QStyle::State_Small) {
1623             font = qApp->font("QSmallFont");
1624         } else {
1625             font = QApplication::font(classNameForItem());
1626         }
1627         painter->setFont(font);
1628     }
1629 
1630     switch (m_itemType) {
1631     case Button:
1632         KQuickStyleItem::style()->drawControl(QStyle::CE_PushButton, m_styleoption, painter);
1633         break;
1634     case ItemRow: {
1635         QPixmap pixmap;
1636         // Only draw through style once
1637         const QString pmKey = QLatin1String("itemrow") % QString::number(m_styleoption->state, 16) % activeControl();
1638         if (!QPixmapCache::find(pmKey, &pixmap) || pixmap.width() < width() || height() != pixmap.height()) {
1639             int newSize = width();
1640             pixmap = QPixmap(newSize, height());
1641             pixmap.fill(Qt::transparent);
1642             QPainter pixpainter(&pixmap);
1643             KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelItemViewRow, m_styleoption, &pixpainter);
1644             if ((styleName() == QLatin1String("mac") || !KQuickStyleItem::style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected)) && selected()) {
1645                 QPalette pal = QApplication::palette("QAbstractItemView");
1646                 pal.setCurrentColorGroup(m_styleoption->palette.currentColorGroup());
1647                 pixpainter.fillRect(m_styleoption->rect, pal.highlight());
1648             }
1649             QPixmapCache::insert(pmKey, pixmap);
1650         }
1651         painter->drawPixmap(0, 0, pixmap);
1652         break;
1653     }
1654     case Item:
1655         KQuickStyleItem::style()->drawControl(QStyle::CE_ItemViewItem, m_styleoption, painter);
1656         break;
1657     case ItemBranchIndicator:
1658         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_IndicatorBranch, m_styleoption, painter);
1659         break;
1660     case Header:
1661         KQuickStyleItem::style()->drawControl(QStyle::CE_Header, m_styleoption, painter);
1662         break;
1663     case ToolButton:
1664         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_ToolButton, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1665         break;
1666     case Tab: {
1667         if (!isKeyFocusReason(m_focusReason)) {
1668             m_styleoption->state &= ~QStyle::State_HasFocus;
1669         }
1670         KQuickStyleItem::style()->drawControl(QStyle::CE_TabBarTab, m_styleoption, painter);
1671         break;
1672     }
1673     case Frame:
1674         m_styleoption->state |= QStyle::State_Sunken;
1675         m_styleoption->state &= ~QStyle::State_Raised;
1676         KQuickStyleItem::style()->drawControl(QStyle::CE_ShapedFrame, m_styleoption, painter);
1677         break;
1678     case FocusFrame:
1679         KQuickStyleItem::style()->drawControl(QStyle::CE_FocusFrame, m_styleoption, painter);
1680         break;
1681     case FocusRect:
1682         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_FrameFocusRect, m_styleoption, painter);
1683         break;
1684     case TabFrame:
1685         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_FrameTabWidget, m_styleoption, painter);
1686         break;
1687     case MenuBar:
1688         KQuickStyleItem::style()->drawControl(QStyle::CE_MenuBarEmptyArea, m_styleoption, painter);
1689         break;
1690     case MenuBarItem:
1691         KQuickStyleItem::style()->drawControl(QStyle::CE_MenuBarItem, m_styleoption, painter);
1692         break;
1693     case MenuItem:
1694     case ComboBoxItem: { // fall through
1695         QStyle::ControlElement menuElement =
1696             static_cast<QStyleOptionMenuItem *>(m_styleoption)->menuItemType == QStyleOptionMenuItem::Scroller ? QStyle::CE_MenuScroller : QStyle::CE_MenuItem;
1697         KQuickStyleItem::style()->drawControl(menuElement, m_styleoption, painter);
1698         break;
1699     }
1700     case CheckBox:
1701         KQuickStyleItem::style()->drawControl(QStyle::CE_CheckBox, m_styleoption, painter);
1702         break;
1703     case RadioButton:
1704         KQuickStyleItem::style()->drawControl(QStyle::CE_RadioButton, m_styleoption, painter);
1705         break;
1706     case Edit:
1707         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelLineEdit, m_styleoption, painter);
1708         break;
1709     case MacHelpButton:
1710         // Not managed as mac is not supported
1711         break;
1712     case Widget:
1713         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_Widget, m_styleoption, painter);
1714         break;
1715     case ScrollAreaCorner:
1716         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelScrollAreaCorner, m_styleoption, painter);
1717         break;
1718     case Splitter:
1719         if (m_styleoption->rect.width() == 1) {
1720             painter->fillRect(0, 0, width(), height(), m_styleoption->palette.dark().color());
1721         } else {
1722             KQuickStyleItem::style()->drawControl(QStyle::CE_Splitter, m_styleoption, painter);
1723         }
1724         break;
1725     case ComboBox: {
1726         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_ComboBox, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1727         // This is needed on macOS as it will use the painter color and ignore the palette
1728         QPen pen = painter->pen();
1729         painter->setPen(m_styleoption->palette.text().color());
1730         KQuickStyleItem::style()->drawControl(QStyle::CE_ComboBoxLabel, m_styleoption, painter);
1731         painter->setPen(pen);
1732         break;
1733     }
1734     case SpinBox:
1735 #ifdef Q_OS_MAC
1736         // macstyle depends on the embedded qlineedit to fill the editfield background
1737         if (styleName() == QLatin1String("mac")) {
1738             QRect editRect = KQuickStyleItem::style()->subControlRect(QStyle::CC_SpinBox,
1739                                                                       qstyleoption_cast<QStyleOptionComplex *>(m_styleoption),
1740                                                                       QStyle::SC_SpinBoxEditField);
1741             painter->fillRect(editRect.adjusted(-1, -1, 1, 1), m_styleoption->palette.base());
1742         }
1743 #endif
1744         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_SpinBox, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1745         break;
1746     case Slider:
1747         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_Slider, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1748         break;
1749     case Dial:
1750         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_Dial, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1751         break;
1752     case ProgressBar:
1753         KQuickStyleItem::style()->drawControl(QStyle::CE_ProgressBar, m_styleoption, painter);
1754         break;
1755     case ToolBar:
1756         painter->fillRect(m_styleoption->rect, m_styleoption->palette.window().color());
1757         KQuickStyleItem::style()->drawControl(QStyle::CE_ToolBar, m_styleoption, painter);
1758         painter->save();
1759         painter->setPen(styleName() != QLatin1String("fusion") ? m_styleoption->palette.dark().color().darker(120)
1760                                                                : m_styleoption->palette.window().color().lighter(107));
1761         painter->drawLine(m_styleoption->rect.bottomLeft(), m_styleoption->rect.bottomRight());
1762         painter->restore();
1763         break;
1764     case StatusBar: {
1765         painter->fillRect(m_styleoption->rect, m_styleoption->palette.window().color());
1766         painter->setPen(m_styleoption->palette.dark().color().darker(120));
1767         painter->drawLine(m_styleoption->rect.topLeft(), m_styleoption->rect.topRight());
1768         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelStatusBar, m_styleoption, painter);
1769         break;
1770     }
1771     case GroupBox:
1772         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_GroupBox, qstyleoption_cast<QStyleOptionComplex *>(m_styleoption), painter);
1773         break;
1774     case ScrollBar:
1775         KQuickStyleItem::style()->drawComplexControl(QStyle::CC_ScrollBar, qstyleoption_cast<QStyleOptionSlider *>(m_styleoption), painter);
1776         break;
1777     case Menu: {
1778         QStyleHintReturnMask val;
1779         KQuickStyleItem::style()->styleHint(QStyle::SH_Menu_Mask, m_styleoption, nullptr, &val);
1780         painter->save();
1781         painter->setClipRegion(val.region);
1782         painter->fillRect(m_styleoption->rect, m_styleoption->palette.window());
1783         painter->restore();
1784         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelMenu, m_styleoption, painter);
1785 
1786         if (int fw = KQuickStyleItem::style()->pixelMetric(QStyle::PM_MenuPanelWidth)) {
1787             QStyleOptionFrame frame;
1788             frame.state = QStyle::State_None;
1789             frame.lineWidth = fw;
1790             frame.midLineWidth = 0;
1791             frame.rect = m_styleoption->rect;
1792             frame.styleObject = this;
1793             frame.palette = m_styleoption->palette;
1794             KQuickStyleItem::style()->drawPrimitive(QStyle::PE_FrameMenu, &frame, painter);
1795         }
1796         break;
1797     }
1798     case DelayButton: { // Adapted from Spectacle's ProgressButton made by David Redondo.
1799         // Draw Button without text and icon, note the missing text and icon in options
1800         QStyleOption baseStyleOptions = *m_styleoption;
1801         baseStyleOptions.state.setFlag(QStyle::State_Enabled, !baseStyleOptions.state.testFlag(QStyle::State_Sunken));
1802         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelButtonTool, &baseStyleOptions, painter);
1803         qreal progress = qreal(value()) / qreal(maximum());
1804         if (!qFuzzyIsNull(progress)) {
1805             // Draw overlay
1806             QStyleOption overlayOption;
1807             overlayOption.palette = m_styleoption->palette;
1808             overlayOption.palette.setBrush(QPalette::Button, m_styleoption->palette.highlight());
1809             overlayOption.rect = m_styleoption->direction == Qt::LeftToRight ?
1810                 QRect(0, 0, m_styleoption->rect.width() * progress, m_styleoption->rect.height())
1811                 : QRect(QPoint(m_styleoption->rect.width() * (1 - progress), 0), m_styleoption->rect.size());
1812             overlayOption.state.setFlag(QStyle::State_Sunken, m_styleoption->state.testFlag(QStyle::State_Sunken));
1813             painter->setCompositionMode(QPainter::CompositionMode_SourceAtop);
1814             painter->setOpacity(0.5);
1815             KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelButtonTool, &overlayOption, painter);
1816         }
1817         // Finally draw text and icon and outline
1818         painter->setOpacity(1);
1819         KQuickStyleItem::style()->drawControl(QStyle::CE_ToolButtonLabel, m_styleoption, painter);
1820         break;
1821     }
1822     default:
1823         break;
1824     }
1825 }
1826 
1827 qreal KQuickStyleItem::textWidth(const QString &text)
1828 {
1829     QFontMetricsF fm = QFontMetricsF(m_styleoption->fontMetrics);
1830     return fm.boundingRect(text).width();
1831 }
1832 
1833 qreal KQuickStyleItem::textHeight(const QString &text)
1834 {
1835     QFontMetricsF fm = QFontMetricsF(m_styleoption->fontMetrics);
1836     return text.isEmpty() ? fm.height() : fm.boundingRect(text).height();
1837 }
1838 
1839 QString KQuickStyleItem::elidedText(const QString &text, int elideMode, int width)
1840 {
1841     return m_styleoption->fontMetrics.elidedText(text, Qt::TextElideMode(elideMode), width);
1842 }
1843 
1844 bool KQuickStyleItem::hasThemeIcon(const QString &icon) const
1845 {
1846     return QIcon::hasThemeIcon(icon);
1847 }
1848 
1849 void KQuickStyleItem::updateFocusReason()
1850 {
1851     if (m_control) {
1852         auto reason = m_focusReasonProperty.read(m_control).value<Qt::FocusReason>();
1853         if (m_focusReason != reason) {
1854             m_focusReason = reason;
1855             polish();
1856         }
1857     }
1858 }
1859 
1860 bool KQuickStyleItem::event(QEvent *ev)
1861 {
1862     if (ev->type() == QEvent::StyleAnimationUpdate) {
1863         if (isVisible()) {
1864             ev->accept();
1865             polish();
1866         }
1867         return true;
1868     } else if (ev->type() == Kirigami::Platform::TabletModeChangedEvent::type) {
1869         Q_EMIT leftPaddingChanged();
1870         Q_EMIT rightPaddingChanged();
1871         Q_EMIT topPaddingChanged();
1872         Q_EMIT bottomPaddingChanged();
1873         updateSizeHint();
1874         polish();
1875         return true;
1876     }
1877 
1878     return QQuickItem::event(ev);
1879 }
1880 
1881 void KQuickStyleItem::setTextureWidth(int w)
1882 {
1883     if (m_textureWidth == w) {
1884         return;
1885     }
1886     m_textureWidth = w;
1887     Q_EMIT textureWidthChanged(m_textureWidth);
1888     update();
1889 }
1890 
1891 void KQuickStyleItem::setTextureHeight(int h)
1892 {
1893     if (m_textureHeight == h) {
1894         return;
1895     }
1896     m_textureHeight = h;
1897     Q_EMIT textureHeightChanged(m_textureHeight);
1898     update();
1899 }
1900 
1901 QQuickItem *KQuickStyleItem::control() const
1902 {
1903     return m_control;
1904 }
1905 
1906 void KQuickStyleItem::setControl(QQuickItem *control)
1907 {
1908     if (control == m_control) {
1909         return;
1910     }
1911 
1912     if (m_control) {
1913         m_control->removeEventFilter(this);
1914         disconnect(m_control, nullptr, this, nullptr);
1915     }
1916 
1917     m_control = control;
1918     m_focusReasonProperty = {};
1919     m_focusReason = Qt::NoFocusReason;
1920 
1921     if (m_control) {
1922         // focusReasonChanged is a signal of QQuickControl class which is not exposed.
1923         const auto mo = m_control->metaObject();
1924         m_focusReasonProperty = mo->property(mo->indexOfProperty("focusReason"));
1925         if (m_focusReasonProperty.isValid()) {
1926             // wish there was something like QMetaMethod::fromSignal but for slots
1927             const auto slot = metaObject()->method(metaObject()->indexOfSlot("updateFocusReason()"));
1928             // also wish there was a way to connect QMetaMethod to arbitrary member function
1929             connect(m_control, m_focusReasonProperty.notifySignal(), this, slot);
1930             updateFocusReason();
1931         }
1932 
1933         m_control->installEventFilter(this);
1934 
1935         if (m_control->window()) {
1936             m_window = m_control->window();
1937             m_window->installEventFilter(this);
1938         }
1939         connect(m_control, &QQuickItem::windowChanged, this, [this](QQuickWindow *window) {
1940             if (m_window) {
1941                 m_window->removeEventFilter(this);
1942             }
1943             m_window = window;
1944             if (m_window) {
1945                 m_window->installEventFilter(this);
1946             }
1947         });
1948     }
1949 
1950     Q_EMIT controlChanged();
1951 }
1952 
1953 QSGNode *KQuickStyleItem::updatePaintNode(QSGNode *node, UpdatePaintNodeData *)
1954 {
1955     if (m_image.isNull()) {
1956         delete node;
1957         return nullptr;
1958     }
1959 
1960     QSGNinePatchNode *styleNode = static_cast<QSGNinePatchNode *>(node);
1961     if (!styleNode) {
1962         styleNode = window()->createNinePatchNode();
1963     }
1964 
1965 #ifdef QSG_RUNTIME_DESCRIPTION
1966     qsgnode_set_description(styleNode, QString::fromLatin1("%1:%2, '%3'").arg(styleName(), elementType(), text()));
1967 #endif
1968 
1969     styleNode->setTexture(window()->createTextureFromImage(m_image, QQuickWindow::TextureCanUseAtlas));
1970 
1971     auto scale = window()->effectiveDevicePixelRatio();
1972     QRectF bounds = QRectF(boundingRect().topLeft(), QSizeF{m_image.width() / scale, m_image.height() / scale});
1973 
1974     QPointF globalPixelPos = mapToScene(bounds.topLeft()) * scale;
1975     QPointF posAdjust = QPointF(globalPixelPos.x() - std::round(globalPixelPos.x()), globalPixelPos.y() - std::round(globalPixelPos.y()))
1976         / scale;
1977     bounds.moveTopLeft(bounds.topLeft() - posAdjust);
1978 
1979     styleNode->setBounds(bounds);
1980     styleNode->setDevicePixelRatio(scale);
1981     styleNode->setPadding(m_border.left(), m_border.top(), m_border.right(), m_border.bottom());
1982     styleNode->update();
1983 
1984     return styleNode;
1985 }
1986 
1987 void KQuickStyleItem::updatePolish()
1988 {
1989     if (isVisible() && width() >= 1 && height() >= 1) { // Note these are reals so 1 pixel is minimum
1990         const qreal devicePixelRatio = window() ? window()->effectiveDevicePixelRatio() : qApp->devicePixelRatio();
1991         const QSize size = QSize(m_textureWidth > 0 ? m_textureWidth : width(), m_textureHeight > 0 ? m_textureHeight : height()) * devicePixelRatio;
1992 
1993         if (m_image.size() != size) {
1994             m_image = QImage(size, QImage::Format_ARGB32_Premultiplied);
1995         }
1996         m_image.setDevicePixelRatio(devicePixelRatio);
1997         m_image.fill(Qt::transparent);
1998         QPainter painter(&m_image);
1999         painter.setLayoutDirection(qApp->layoutDirection());
2000         paint(&painter);
2001         QQuickItem::update();
2002     } else if (!m_image.isNull()) {
2003         m_image = QImage();
2004         QQuickItem::update();
2005     }
2006 }
2007 
2008 bool KQuickStyleItem::eventFilter(QObject *watched, QEvent *event)
2009 {
2010     if (watched == m_control) {
2011         // Page accepts mouse events without doing anything with them (for a workaround wrt dragging from empty areas of flickables) when the interaction is
2012         // pure mouse, steal events from them, so a parent handler can initiate a window drag from empty areas, either Kirigami.ApplicationWindow or the breeze
2013         // style from a QQwuickwidget
2014         if (event->type() == QEvent::MouseButtonPress) {
2015             QMouseEvent *me = static_cast<QMouseEvent *>(event);
2016             if (me->source() == Qt::MouseEventNotSynthesized && watched->inherits("QQuickPage")) {
2017                 event->setAccepted(false);
2018                 return true;
2019             }
2020         }
2021     } else if (watched == m_window.data()) {
2022         if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
2023             QKeyEvent *ke = static_cast<QKeyEvent *>(event);
2024             if (ke->key() == Qt::Key_Alt) {
2025                 polish();
2026             }
2027         }
2028     } else if (watched == qGuiApp) {
2029         if (event->type() == QEvent::ApplicationFontChange) {
2030             QMetaObject::invokeMethod(this, &KQuickStyleItem::updateSizeHint, Qt::QueuedConnection);
2031         }
2032     }
2033 
2034     return QQuickItem::eventFilter(watched, event);
2035 }
2036 
2037 void KQuickStyleItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
2038 {
2039     if (change == QQuickItem::ItemVisibleHasChanged || change == QQuickItem::ItemEnabledHasChanged || change == QQuickItem::ItemDevicePixelRatioHasChanged) {
2040         polish();
2041     }
2042 
2043     QQuickItem::itemChange(change, value);
2044 }
2045 
2046 void KQuickStyleItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
2047 {
2048     QQuickItem::geometryChange(newGeometry, oldGeometry);
2049 
2050     if (!newGeometry.isEmpty() && newGeometry != oldGeometry) {
2051         polish();
2052         updateRect();
2053 
2054         if (newGeometry.height() != oldGeometry.height()) {
2055             updateBaselineOffset();
2056         }
2057     }
2058 }
2059 
2060 void KQuickStyleItem::styleChanged()
2061 {
2062     // It should be safe to use qApp->style() unguarded here, because the signal
2063     // will only have been connected if qApp is a QApplication.
2064     Q_ASSERT(qobject_cast<QApplication *>(QCoreApplication::instance()));
2065     auto *style = qApp->style();
2066     if (!style || QCoreApplication::closingDown()) {
2067         return;
2068     }
2069 
2070     Q_ASSERT(style != sender());
2071 
2072     connect(style, &QObject::destroyed, this, &KQuickStyleItem::styleChanged);
2073 
2074     updateSizeHint();
2075     polish();
2076     Q_EMIT styleNameChanged();
2077 }
2078 
2079 QPixmap QQuickTableRowImageProvider1::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize)
2080 {
2081     Q_UNUSED(requestedSize);
2082     int width = 16;
2083     int height = 16;
2084     if (size) {
2085         *size = QSize(width, height);
2086     }
2087 
2088     QPixmap pixmap(width, height);
2089 
2090     QStyleOptionViewItem opt;
2091     opt.state |= QStyle::State_Enabled;
2092     opt.rect = QRect(0, 0, width, height);
2093     QString style = QString::fromLatin1(KQuickStyleItem::style()->metaObject()->className());
2094     opt.features = {};
2095 
2096     if (id.contains(QLatin1String("selected"))) {
2097         opt.state |= QStyle::State_Selected;
2098     }
2099 
2100     if (id.contains(QLatin1String("active"))) {
2101         opt.state |= QStyle::State_Active;
2102         opt.palette.setCurrentColorGroup(QPalette::Active);
2103     } else {
2104         opt.palette.setCurrentColorGroup(QPalette::Inactive);
2105     }
2106 
2107     if (id.contains(QLatin1String("alternate"))) {
2108         opt.features |= QStyleOptionViewItem::Alternate;
2109     }
2110 
2111     QPalette pal = QApplication::palette("QAbstractItemView");
2112     if (opt.state & QStyle::State_Selected
2113         && (style.contains(QLatin1String("Mac")) || !KQuickStyleItem::style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected))) {
2114         pal.setCurrentColorGroup(opt.palette.currentColorGroup());
2115         pixmap.fill(pal.highlight().color());
2116     } else {
2117         pixmap.fill(pal.base().color());
2118         QPainter pixpainter(&pixmap);
2119         KQuickStyleItem::style()->drawPrimitive(QStyle::PE_PanelItemViewRow, &opt, &pixpainter);
2120     }
2121     return pixmap;
2122 }
2123 
2124 #include "moc_kquickpadding_p.cpp"
2125 #include "moc_kquickstyleitem_p.cpp"