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