| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2016 The Qt Company Ltd. | |
| ** Contact: https://www.qt.io/licensing/ | |
| ** | |
| ** This file is part of the Qt Quick Controls module of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** Commercial License Usage | |
| ** Licensees holding valid commercial Qt licenses may use this file in | |
| ** accordance with the commercial license agreement provided with the | |
| ** Software or, alternatively, in accordance with the terms contained in | |
| ** a written agreement between you and The Qt Company. For licensing terms | |
| ** and conditions see https://www.qt.io/terms-conditions. For further | |
| ** information use the contact form at https://www.qt.io/contact-us. | |
| ** | |
| ** GNU Lesser General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU Lesser | |
| ** General Public License version 3 as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the | |
| ** packaging of this file. Please review the following information to | |
| ** ensure the GNU Lesser General Public License version 3 requirements | |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU | |
| ** General Public License version 2.0 or (at your option) the GNU General | |
| ** Public license version 3 or any later version approved by the KDE Free | |
| ** Qt Foundation. The licenses are as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 | |
| ** included in the packaging of this file. Please review the following | |
| ** information to ensure the GNU General Public License requirements will | |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and | |
| ** https://www.gnu.org/licenses/gpl-3.0.html. | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| #include "qquickstyleitem_p.h" | |
| #include <qstringbuilder.h> | |
| #include <qpainter.h> | |
| #include <qpixmapcache.h> | |
| #include <qstyle.h> | |
| #include <qstyleoption.h> | |
| #include <qapplication.h> | |
| #include <qquickwindow.h> | |
| #include "private/qguiapplication_p.h" | |
| #include <QtQuick/private/qquickwindow_p.h> | |
| #include <QtQuick/private/qquickitem_p.h> | |
| #include <QtGui/qpa/qplatformtheme.h> | |
| #include <QtQuick/qsgninepatchnode.h> | |
| #include "../qquickmenuitem_p.h" | |
| QT_BEGIN_NAMESPACE | |
| #ifdef Q_OS_OSX | |
| #include <Carbon/Carbon.h> | |
| static inline HIRect qt_hirectForQRect(const QRect &convertRect, const QRect &rect = QRect()) | |
| { | |
| return CGRectMake(convertRect.x() + rect.x(), convertRect.y() + rect.y(), | |
| convertRect.width() - rect.width(), convertRect.height() - rect.height()); | |
| } | |
| /*! \internal | |
| Returns the CoreGraphics CGContextRef of the paint device. 0 is | |
| returned if it can't be obtained. It is the caller's responsibility to | |
| CGContextRelease the context when finished using it. | |
| \warning This function is only available on \macos. | |
| \warning This function is duplicated in qmacstyle_mac.mm | |
| */ | |
| CGContextRef qt_mac_cg_context(const QPaintDevice *pdev) | |
| { | |
| if (pdev->devType() == QInternal::Image) { | |
| const QImage *i = static_cast<const QImage*>(pdev); | |
| QImage *image = const_cast< QImage*>(i); | |
| CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); | |
| uint flags = kCGImageAlphaPremultipliedFirst; | |
| flags |= kCGBitmapByteOrder32Host; | |
| CGContextRef ret = 0; | |
| ret = CGBitmapContextCreate(image->bits(), image->width(), image->height(), | |
| 8, image->bytesPerLine(), colorspace, flags); | |
| CGContextTranslateCTM(ret, 0, image->height()); | |
| CGContextScaleCTM(ret, 1, -1); | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| #endif | |
| QQuickStyleItem1::QQuickStyleItem1(QQuickItem *parent) | |
| : QQuickItem(parent), | |
| m_styleoption(0), | |
| m_itemType(Undefined), | |
| m_sunken(false), | |
| m_raised(false), | |
| m_active(true), | |
| m_selected(false), | |
| m_focus(false), | |
| m_hover(false), | |
| m_on(false), | |
| m_horizontal(true), | |
| m_transient(false), | |
| m_sharedWidget(false), | |
| m_minimum(0), | |
| m_maximum(100), | |
| m_value(0), | |
| m_step(0), | |
| m_paintMargins(0), | |
| m_contentWidth(0), | |
| m_contentHeight(0), | |
| m_textureWidth(0), | |
| m_textureHeight(0) | |
| { | |
| m_font = qApp->font(); | |
| setFlag(QQuickItem::ItemHasContents, true); | |
| setSmooth(false); | |
| connect(this, SIGNAL(visibleChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(widthChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(heightChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(enabledChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(infoChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(onChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(selectedChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(activeChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(textChanged()), this, SLOT(updateSizeHint())); | |
| connect(this, SIGNAL(textChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(activeChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(raisedChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(sunkenChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(hoverChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(maximumChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(minimumChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(valueChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(horizontalChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(transientChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(activeControlChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(hasFocusChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(activeControlChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(hintChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(propertiesChanged()), this, SLOT(updateSizeHint())); | |
| connect(this, SIGNAL(propertiesChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(elementTypeChanged()), this, SLOT(updateItem())); | |
| connect(this, SIGNAL(contentWidthChanged(int)), this, SLOT(updateSizeHint())); | |
| connect(this, SIGNAL(contentHeightChanged(int)), this, SLOT(updateSizeHint())); | |
| connect(this, SIGNAL(widthChanged()), this, SLOT(updateRect())); | |
| connect(this, SIGNAL(heightChanged()), this, SLOT(updateRect())); | |
| connect(this, SIGNAL(heightChanged()), this, SLOT(updateBaselineOffset())); | |
| connect(this, SIGNAL(contentHeightChanged(int)), this, SLOT(updateBaselineOffset())); | |
| } | |
| QQuickStyleItem1::~QQuickStyleItem1() | |
| { | |
| if (const QStyleOptionButton *aux = qstyleoption_cast<const QStyleOptionButton*>(m_styleoption)) | |
| delete aux; | |
| #if QT_CONFIG(itemviews) | |
| else if (const QStyleOptionViewItem *aux = qstyleoption_cast<const QStyleOptionViewItem*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| else if (const QStyleOptionHeader *aux = qstyleoption_cast<const QStyleOptionHeader*>(m_styleoption)) | |
| delete aux; | |
| else if (const QStyleOptionToolButton *aux = qstyleoption_cast<const QStyleOptionToolButton*>(m_styleoption)) | |
| delete aux; | |
| #if QT_CONFIG(toolbar) | |
| else if (const QStyleOptionToolBar *aux = qstyleoption_cast<const QStyleOptionToolBar*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| #if QT_CONFIG(tabbar) | |
| else if (const QStyleOptionTab *aux = qstyleoption_cast<const QStyleOptionTab*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| else if (const QStyleOptionFrame *aux = qstyleoption_cast<const QStyleOptionFrame*>(m_styleoption)) | |
| delete aux; | |
| else if (const QStyleOptionFocusRect *aux = qstyleoption_cast<const QStyleOptionFocusRect*>(m_styleoption)) | |
| delete aux; | |
| #if QT_CONFIG(tabwidget) | |
| else if (const QStyleOptionTabWidgetFrame *aux = qstyleoption_cast<const QStyleOptionTabWidgetFrame*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| else if (const QStyleOptionMenuItem *aux = qstyleoption_cast<const QStyleOptionMenuItem*>(m_styleoption)) | |
| delete aux; | |
| else if (const QStyleOptionComboBox *aux = qstyleoption_cast<const QStyleOptionComboBox*>(m_styleoption)) | |
| delete aux; | |
| #if QT_CONFIG(spinbox) | |
| else if (const QStyleOptionSpinBox *aux = qstyleoption_cast<const QStyleOptionSpinBox*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| #if QT_CONFIG(slider) | |
| else if (const QStyleOptionSlider *aux = qstyleoption_cast<const QStyleOptionSlider*>(m_styleoption)) | |
| delete aux; | |
| #endif | |
| else if (const QStyleOptionProgressBar *aux = qstyleoption_cast<const QStyleOptionProgressBar*>(m_styleoption)) | |
| delete aux; | |
| else if (const QStyleOptionGroupBox *aux = qstyleoption_cast<const QStyleOptionGroupBox*>(m_styleoption)) | |
| delete aux; | |
| else | |
| delete m_styleoption; | |
| m_styleoption = 0; | |
| } | |
| void QQuickStyleItem1::initStyleOption() | |
| { | |
| if (m_styleoption) | |
| m_styleoption->state = {}; | |
| QString sizeHint = m_hints.value(QStringLiteral("size")).toString(); | |
| QPlatformTheme::Font platformFont = (sizeHint == QLatin1String("mini")) ? QPlatformTheme::MiniFont : | |
| (sizeHint == QLatin1String("small")) ? QPlatformTheme::SmallFont : | |
| QPlatformTheme::SystemFont; | |
| bool needsResolvePalette = true; | |
| switch (m_itemType) { | |
| case Button: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionButton(); | |
| QStyleOptionButton *opt = qstyleoption_cast<QStyleOptionButton*>(m_styleoption); | |
| opt->text = text(); | |
| opt->icon = m_properties[QStringLiteral("icon")].value<QIcon>(); | |
| int e = qApp->style()->pixelMetric(QStyle::PM_ButtonIconSize, m_styleoption, 0); | |
| opt->iconSize = QSize(e, e); | |
| opt->features = activeControl() == QLatin1String("default") ? | |
| QStyleOptionButton::DefaultButton : | |
| QStyleOptionButton::None; | |
| if (platformFont == QPlatformTheme::SystemFont) | |
| platformFont = QPlatformTheme::PushButtonFont; | |
| const QFont *font = QGuiApplicationPrivate::platformTheme()->font(platformFont); | |
| if (font) | |
| opt->fontMetrics = QFontMetrics(*font); | |
| QObject * menu = m_properties[QStringLiteral("menu")].value<QObject *>(); | |
| if (menu) { | |
| opt->features |= QStyleOptionButton::HasMenu; | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| if (platformFont == QPlatformTheme::PushButtonFont) | |
| menu->setProperty("__xOffset", 12); | |
| else | |
| menu->setProperty("__xOffset", 11); | |
| if (platformFont == QPlatformTheme::MiniFont) | |
| menu->setProperty("__yOffset", 5); | |
| else if (platformFont == QPlatformTheme::SmallFont) | |
| menu->setProperty("__yOffset", 6); | |
| else | |
| menu->setProperty("__yOffset", 3); | |
| if (font) | |
| menu->setProperty("__font", *font); | |
| } | |
| #endif | |
| } | |
| } | |
| break; | |
| #if QT_CONFIG(itemviews) | |
| case ItemRow: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionViewItem(); | |
| QStyleOptionViewItem *opt = qstyleoption_cast<QStyleOptionViewItem*>(m_styleoption); | |
| opt->features = {}; | |
| if (activeControl() == QLatin1String("alternate")) | |
| opt->features |= QStyleOptionViewItem::Alternate; | |
| } | |
| break; | |
| #endif // QT_CONFIG(itemviews) | |
| case Splitter: { | |
| if (!m_styleoption) { | |
| m_styleoption = new QStyleOption; | |
| } | |
| } | |
| break; | |
| #if QT_CONFIG(itemviews) | |
| case Item: { | |
| if (!m_styleoption) { | |
| m_styleoption = new QStyleOptionViewItem(); | |
| } | |
| QStyleOptionViewItem *opt = qstyleoption_cast<QStyleOptionViewItem*>(m_styleoption); | |
| opt->features = QStyleOptionViewItem::HasDisplay; | |
| opt->text = text(); | |
| opt->textElideMode = Qt::ElideRight; | |
| opt->displayAlignment = Qt::AlignLeft | Qt::AlignVCenter; | |
| opt->decorationAlignment = Qt::AlignCenter; | |
| resolvePalette(); | |
| needsResolvePalette = false; | |
| QPalette pal = m_styleoption->palette; | |
| pal.setBrush(QPalette::Base, Qt::NoBrush); | |
| m_styleoption->palette = pal; | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(QPlatformTheme::ItemViewFont)) { | |
| opt->fontMetrics = QFontMetrics(*font); | |
| opt->font = *font; | |
| } | |
| } | |
| break; | |
| #endif // QT_CONFIG(itemviews) | |
| case ItemBranchIndicator: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOption; | |
| m_styleoption->state = QStyle::State_Item; // We don't want to fully support Win 95 | |
| if (m_properties.value(QStringLiteral("hasChildren")).toBool()) | |
| m_styleoption->state |= QStyle::State_Children; | |
| if (m_properties.value(QStringLiteral("hasSibling")).toBool()) // Even this one could go away | |
| m_styleoption->state |= QStyle::State_Sibling; | |
| if (m_on) | |
| m_styleoption->state |= QStyle::State_Open; | |
| } | |
| break; | |
| case Header: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionHeader(); | |
| QStyleOptionHeader *opt = qstyleoption_cast<QStyleOptionHeader*>(m_styleoption); | |
| opt->text = text(); | |
| opt->textAlignment = static_cast<Qt::AlignmentFlag>(m_properties.value(QStringLiteral("textalignment")).toInt()); | |
| opt->sortIndicator = activeControl() == QLatin1String("down") ? | |
| QStyleOptionHeader::SortDown | |
| : activeControl() == QLatin1String("up") ? | |
| QStyleOptionHeader::SortUp : QStyleOptionHeader::None; | |
| QString headerpos = m_properties.value(QStringLiteral("headerpos")).toString(); | |
| if (headerpos == QLatin1String("beginning")) | |
| opt->position = QStyleOptionHeader::Beginning; | |
| else if (headerpos == QLatin1String("end")) | |
| opt->position = QStyleOptionHeader::End; | |
| else if (headerpos == QLatin1String("only")) | |
| opt->position = QStyleOptionHeader::OnlyOneSection; | |
| else | |
| opt->position = QStyleOptionHeader::Middle; | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(QPlatformTheme::HeaderViewFont)) | |
| opt->fontMetrics = QFontMetrics(*font); | |
| } | |
| break; | |
| case ToolButton: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionToolButton(); | |
| QStyleOptionToolButton *opt = | |
| qstyleoption_cast<QStyleOptionToolButton*>(m_styleoption); | |
| opt->subControls = QStyle::SC_ToolButton; | |
| opt->state |= QStyle::State_AutoRaise; | |
| opt->activeSubControls = QStyle::SC_ToolButton; | |
| opt->text = text(); | |
| opt->icon = m_properties[QStringLiteral("icon")].value<QIcon>(); | |
| if (m_properties.value(QStringLiteral("menu")).toBool()) { | |
| opt->subControls |= QStyle::SC_ToolButtonMenu; | |
| opt->features = QStyleOptionToolButton::HasMenu; | |
| } | |
| // For now icon only is displayed by default. | |
| opt->toolButtonStyle = Qt::ToolButtonIconOnly; | |
| if (opt->icon.isNull() && !opt->text.isEmpty()) | |
| opt->toolButtonStyle = Qt::ToolButtonTextOnly; | |
| int e = qApp->style()->pixelMetric(QStyle::PM_ToolBarIconSize, m_styleoption, 0); | |
| opt->iconSize = QSize(e, e); | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(QPlatformTheme::ToolButtonFont)) { | |
| opt->fontMetrics = QFontMetrics(*font); | |
| opt->font = *font; | |
| } | |
| } | |
| break; | |
| #if QT_CONFIG(toolbar) | |
| case ToolBar: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionToolBar(); | |
| } | |
| break; | |
| #endif | |
| #if QT_CONFIG(tabbar) | |
| case Tab: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionTab(); | |
| QStyleOptionTab *opt = qstyleoption_cast<QStyleOptionTab*>(m_styleoption); | |
| opt->text = text(); | |
| if (m_properties.value(QStringLiteral("hasFrame")).toBool()) | |
| opt->features |= QStyleOptionTab::HasFrame; | |
| QString orientation = m_properties.value(QStringLiteral("orientation")).toString(); | |
| QString position = m_properties.value(QStringLiteral("tabpos")).toString(); | |
| QString selectedPosition = m_properties.value(QStringLiteral("selectedpos")).toString(); | |
| opt->shape = orientation == QLatin1String("Bottom") ? QTabBar::RoundedSouth : QTabBar::RoundedNorth; | |
| if (position == QLatin1String("beginning")) | |
| opt->position = QStyleOptionTab::Beginning; | |
| else if (position == QLatin1String("end")) | |
| opt->position = QStyleOptionTab::End; | |
| else if (position == QLatin1String("only")) | |
| opt->position = QStyleOptionTab::OnlyOneTab; | |
| else | |
| opt->position = QStyleOptionTab::Middle; | |
| if (selectedPosition == QLatin1String("next")) | |
| opt->selectedPosition = QStyleOptionTab::NextIsSelected; | |
| else if (selectedPosition == QLatin1String("previous")) | |
| opt->selectedPosition = QStyleOptionTab::PreviousIsSelected; | |
| else | |
| opt->selectedPosition = QStyleOptionTab::NotAdjacent; | |
| } break; | |
| #endif // QT_CONFIG(tabbar) | |
| case Frame: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionFrame(); | |
| QStyleOptionFrame *opt = qstyleoption_cast<QStyleOptionFrame*>(m_styleoption); | |
| opt->frameShape = QFrame::StyledPanel; | |
| opt->lineWidth = 1; | |
| opt->midLineWidth = 1; | |
| } | |
| break; | |
| case FocusRect: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionFocusRect(); | |
| // Needed on windows | |
| m_styleoption->state |= QStyle::State_KeyboardFocusChange; | |
| } | |
| break; | |
| #if QT_CONFIG(tabwidget) | |
| case TabFrame: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionTabWidgetFrame(); | |
| QStyleOptionTabWidgetFrame *opt = qstyleoption_cast<QStyleOptionTabWidgetFrame*>(m_styleoption); | |
| opt->selectedTabRect = m_properties[QStringLiteral("selectedTabRect")].toRect(); | |
| opt->shape = m_properties[QStringLiteral("orientation")] == Qt::BottomEdge ? QTabBar::RoundedSouth : QTabBar::RoundedNorth; | |
| if (minimum()) | |
| opt->selectedTabRect = QRect(value(), 0, minimum(), height()); | |
| opt->tabBarSize = QSize(minimum() , height()); | |
| // oxygen style needs this hack | |
| opt->leftCornerWidgetSize = QSize(value(), 0); | |
| } | |
| break; | |
| #endif // QT_CONFIG(tabwidget) | |
| case MenuBar: | |
| if (!m_styleoption) { | |
| QStyleOptionMenuItem *menuOpt = new QStyleOptionMenuItem(); | |
| menuOpt->menuItemType = QStyleOptionMenuItem::EmptyArea; | |
| m_styleoption = menuOpt; | |
| } | |
| break; | |
| case MenuBarItem: | |
| { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionMenuItem(); | |
| QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem*>(m_styleoption); | |
| opt->text = text(); | |
| opt->menuItemType = QStyleOptionMenuItem::Normal; | |
| setProperty("_q_showUnderlined", m_hints[QStringLiteral("showUnderlined")].toBool()); | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(QPlatformTheme::MenuBarFont)) { | |
| opt->font = *font; | |
| opt->fontMetrics = QFontMetrics(opt->font); | |
| m_font = opt->font; | |
| } | |
| } | |
| break; | |
| case Menu: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionMenuItem(); | |
| } | |
| break; | |
| case MenuItem: | |
| case ComboBoxItem: | |
| { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionMenuItem(); | |
| QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem*>(m_styleoption); | |
| // For GTK style. See below, in setElementType() | |
| setProperty("_q_isComboBoxPopupItem", m_itemType == ComboBoxItem); | |
| QQuickMenuItemType1::MenuItemType type = | |
| static_cast<QQuickMenuItemType1::MenuItemType>(m_properties[QStringLiteral("type")].toInt()); | |
| if (type == QQuickMenuItemType1::ScrollIndicator) { | |
| int scrollerDirection = m_properties[QStringLiteral("scrollerDirection")].toInt(); | |
| opt->menuItemType = QStyleOptionMenuItem::Scroller; | |
| opt->state |= scrollerDirection == Qt::UpArrow ? | |
| QStyle::State_UpArrow : QStyle::State_DownArrow; | |
| } else if (type == QQuickMenuItemType1::Separator) { | |
| opt->menuItemType = QStyleOptionMenuItem::Separator; | |
| } else { | |
| opt->text = text(); | |
| if (type == QQuickMenuItemType1::Menu) { | |
| opt->menuItemType = QStyleOptionMenuItem::SubMenu; | |
| } else { | |
| opt->menuItemType = QStyleOptionMenuItem::Normal; | |
| QString shortcut = m_properties[QStringLiteral("shortcut")].toString(); | |
| if (!shortcut.isEmpty()) { | |
| opt->text += QLatin1Char('\t') + shortcut; | |
| opt->tabWidth = qMax(opt->tabWidth, qRound(textWidth(shortcut))); | |
| } | |
| if (m_properties[QStringLiteral("checkable")].toBool()) { | |
| opt->checked = on(); | |
| QVariant exclusive = m_properties[QStringLiteral("exclusive")]; | |
| opt->checkType = exclusive.toBool() ? QStyleOptionMenuItem::Exclusive : | |
| QStyleOptionMenuItem::NonExclusive; | |
| } | |
| } | |
| if (m_properties[QStringLiteral("icon")].canConvert<QIcon>()) | |
| opt->icon = m_properties[QStringLiteral("icon")].value<QIcon>(); | |
| setProperty("_q_showUnderlined", m_hints["showUnderlined"].toBool()); | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(m_itemType == ComboBoxItem ? QPlatformTheme::ComboMenuItemFont : QPlatformTheme::MenuFont)) { | |
| opt->font = *font; | |
| opt->fontMetrics = QFontMetrics(opt->font); | |
| m_font = opt->font; | |
| } | |
| } | |
| } | |
| break; | |
| case CheckBox: | |
| case RadioButton: | |
| { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionButton(); | |
| QStyleOptionButton *opt = qstyleoption_cast<QStyleOptionButton*>(m_styleoption); | |
| if (!on()) | |
| opt->state |= QStyle::State_Off; | |
| if (m_properties.value(QStringLiteral("partiallyChecked")).toBool()) | |
| opt->state |= QStyle::State_NoChange; | |
| opt->text = text(); | |
| } | |
| break; | |
| case Edit: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionFrame(); | |
| QStyleOptionFrame *opt = qstyleoption_cast<QStyleOptionFrame*>(m_styleoption); | |
| opt->lineWidth = 1; // this must be non-zero | |
| } | |
| break; | |
| case ComboBox :{ | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionComboBox(); | |
| QStyleOptionComboBox *opt = qstyleoption_cast<QStyleOptionComboBox*>(m_styleoption); | |
| if (platformFont == QPlatformTheme::SystemFont) | |
| platformFont = QPlatformTheme::PushButtonFont; | |
| const QFont *font = QGuiApplicationPrivate::platformTheme()->font(platformFont); | |
| if (font) | |
| opt->fontMetrics = QFontMetrics(*font); | |
| opt->currentText = text(); | |
| opt->editable = m_properties[QStringLiteral("editable")].toBool(); | |
| #ifdef Q_OS_OSX | |
| if (m_properties[QStringLiteral("popup")].canConvert<QObject *>() | |
| && style() == QLatin1String("mac")) { | |
| QObject *popup = m_properties[QStringLiteral("popup")].value<QObject *>(); | |
| if (platformFont == QPlatformTheme::MiniFont) { | |
| popup->setProperty("__xOffset", -2); | |
| popup->setProperty("__yOffset", 5); | |
| } else { | |
| if (platformFont == QPlatformTheme::SmallFont) | |
| popup->setProperty("__xOffset", -1); | |
| popup->setProperty("__yOffset", 6); | |
| } | |
| if (font) | |
| popup->setProperty("__font", *font); | |
| } | |
| #endif | |
| } | |
| break; | |
| #if QT_CONFIG(spinbox) | |
| case SpinBox: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionSpinBox(); | |
| QStyleOptionSpinBox *opt = qstyleoption_cast<QStyleOptionSpinBox*>(m_styleoption); | |
| opt->frame = true; | |
| opt->subControls = QStyle::SC_SpinBoxFrame | QStyle::SC_SpinBoxEditField; | |
| if (value() & 0x1) | |
| opt->activeSubControls = QStyle::SC_SpinBoxUp; | |
| else if (value() & (1<<1)) | |
| opt->activeSubControls = QStyle::SC_SpinBoxDown; | |
| opt->subControls = QStyle::SC_All; | |
| opt->stepEnabled = {}; | |
| if (value() & (1<<2)) | |
| opt->stepEnabled |= QAbstractSpinBox::StepUpEnabled; | |
| if (value() & (1<<3)) | |
| opt->stepEnabled |= QAbstractSpinBox::StepDownEnabled; | |
| } | |
| break; | |
| #endif // QT_CONFIG(spinbox) | |
| #if QT_CONFIG(slider) | |
| case Slider: | |
| case Dial: | |
| { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionSlider(); | |
| QStyleOptionSlider *opt = qstyleoption_cast<QStyleOptionSlider*>(m_styleoption); | |
| opt->orientation = horizontal() ? Qt::Horizontal : Qt::Vertical; | |
| opt->upsideDown = !horizontal(); | |
| opt->minimum = minimum(); | |
| opt->maximum = maximum(); | |
| opt->sliderPosition = value(); | |
| opt->singleStep = step(); | |
| if (opt->singleStep) { | |
| qreal numOfSteps = (opt->maximum - opt->minimum) / opt->singleStep; | |
| // at least 5 pixels between tick marks | |
| qreal extent = horizontal() ? width() : height(); | |
| if (numOfSteps && (extent / numOfSteps < 5)) | |
| opt->tickInterval = qRound((5 * numOfSteps / extent) + 0.5) * step(); | |
| else | |
| opt->tickInterval = opt->singleStep; | |
| } else // default Qt-components implementation | |
| opt->tickInterval = opt->maximum != opt->minimum ? 1200 / (opt->maximum - opt->minimum) : 0; | |
| opt->sliderValue = value(); | |
| opt->subControls = QStyle::SC_SliderGroove | QStyle::SC_SliderHandle; | |
| opt->tickPosition = activeControl() == QLatin1String("ticks") ? | |
| QSlider::TicksBelow : QSlider::NoTicks; | |
| if (opt->tickPosition != QSlider::NoTicks) | |
| opt->subControls |= QStyle::SC_SliderTickmarks; | |
| opt->activeSubControls = QStyle::SC_SliderHandle; | |
| } | |
| break; | |
| #endif // QT_CONFIG(slider) | |
| case ProgressBar: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionProgressBar(); | |
| QStyleOptionProgressBar *opt = qstyleoption_cast<QStyleOptionProgressBar*>(m_styleoption); | |
| opt->orientation = horizontal() ? Qt::Horizontal : Qt::Vertical; | |
| opt->minimum = minimum(); | |
| opt->maximum = maximum(); | |
| opt->progress = value(); | |
| } | |
| break; | |
| case GroupBox: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionGroupBox(); | |
| QStyleOptionGroupBox *opt = qstyleoption_cast<QStyleOptionGroupBox*>(m_styleoption); | |
| opt->text = text(); | |
| opt->lineWidth = 1; | |
| opt->subControls = QStyle::SC_GroupBoxLabel; | |
| opt->features = {}; | |
| if (m_properties[QStringLiteral("sunken")].toBool()) { // Qt draws an ugly line here so I ignore it | |
| opt->subControls |= QStyle::SC_GroupBoxFrame; | |
| } else { | |
| opt->features |= QStyleOptionFrame::Flat; | |
| } | |
| if (m_properties[QStringLiteral("checkable")].toBool()) | |
| opt->subControls |= QStyle::SC_GroupBoxCheckBox; | |
| } | |
| break; | |
| #if QT_CONFIG(slider) | |
| case ScrollBar: { | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOptionSlider(); | |
| QStyleOptionSlider *opt = qstyleoption_cast<QStyleOptionSlider*>(m_styleoption); | |
| opt->minimum = minimum(); | |
| opt->maximum = maximum(); | |
| opt->pageStep = qMax(0, int(horizontal() ? width() : height())); | |
| opt->orientation = horizontal() ? Qt::Horizontal : Qt::Vertical; | |
| opt->sliderPosition = value(); | |
| opt->sliderValue = value(); | |
| opt->activeSubControls = (activeControl() == QLatin1String("up")) | |
| ? QStyle::SC_ScrollBarSubLine : (activeControl() == QLatin1String("down")) ? | |
| QStyle::SC_ScrollBarAddLine : | |
| (activeControl() == QLatin1String("handle")) ? | |
| QStyle::SC_ScrollBarSlider : hover() ? QStyle::SC_ScrollBarGroove : QStyle::SC_None; | |
| if (raised()) | |
| opt->state |= QStyle::State_On; | |
| opt->sliderValue = value(); | |
| opt->subControls = QStyle::SC_All; | |
| setTransient(qApp->style()->styleHint(QStyle::SH_ScrollBar_Transient, m_styleoption)); | |
| break; | |
| } | |
| #endif // QT_CONFIG(slider) | |
| default: | |
| break; | |
| } | |
| if (!m_styleoption) | |
| m_styleoption = new QStyleOption(); | |
| if (needsResolvePalette) | |
| resolvePalette(); | |
| m_styleoption->styleObject = this; | |
| m_styleoption->direction = qApp->layoutDirection(); | |
| int w = m_textureWidth > 0 ? m_textureWidth : width(); | |
| int h = m_textureHeight > 0 ? m_textureHeight : height(); | |
| m_styleoption->rect = QRect(m_paintMargins, 0, w - 2* m_paintMargins, h); | |
| if (isEnabled()) { | |
| m_styleoption->state |= QStyle::State_Enabled; | |
| m_styleoption->palette.setCurrentColorGroup(QPalette::Active); | |
| } else { | |
| m_styleoption->palette.setCurrentColorGroup(QPalette::Disabled); | |
| } | |
| if (m_active) | |
| m_styleoption->state |= QStyle::State_Active; | |
| else | |
| m_styleoption->palette.setCurrentColorGroup(QPalette::Inactive); | |
| if (m_sunken) | |
| m_styleoption->state |= QStyle::State_Sunken; | |
| if (m_raised) | |
| m_styleoption->state |= QStyle::State_Raised; | |
| if (m_selected) | |
| m_styleoption->state |= QStyle::State_Selected; | |
| if (m_focus) | |
| m_styleoption->state |= QStyle::State_HasFocus; | |
| if (m_on) | |
| m_styleoption->state |= QStyle::State_On; | |
| if (m_hover) | |
| m_styleoption->state |= QStyle::State_MouseOver; | |
| if (m_horizontal) | |
| m_styleoption->state |= QStyle::State_Horizontal; | |
| // some styles don't draw a focus rectangle if | |
| // QStyle::State_KeyboardFocusChange is not set | |
| if (window()) { | |
| Qt::FocusReason lastFocusReason = QQuickWindowPrivate::get(window())->lastFocusReason; | |
| if (lastFocusReason == Qt::TabFocusReason || lastFocusReason == Qt::BacktabFocusReason) { | |
| m_styleoption->state |= QStyle::State_KeyboardFocusChange; | |
| } | |
| } | |
| if (sizeHint == QLatin1String("mini")) { | |
| m_styleoption->state |= QStyle::State_Mini; | |
| } else if (sizeHint == QLatin1String("small")) { | |
| m_styleoption->state |= QStyle::State_Small; | |
| } | |
| } | |
| void QQuickStyleItem1::resolvePalette() | |
| { | |
| if (QCoreApplication::testAttribute(Qt::AA_SetPalette)) | |
| return; | |
| QPlatformTheme::Palette paletteType = QPlatformTheme::SystemPalette; | |
| switch (m_itemType) { | |
| case Button: | |
| paletteType = QPlatformTheme::ButtonPalette; | |
| break; | |
| case RadioButton: | |
| paletteType = QPlatformTheme::RadioButtonPalette; | |
| break; | |
| case CheckBox: | |
| paletteType = QPlatformTheme::CheckBoxPalette; | |
| break; | |
| case ComboBox: | |
| case ComboBoxItem: | |
| paletteType = QPlatformTheme::ComboBoxPalette; | |
| break; | |
| case ToolBar: | |
| case ToolButton: | |
| paletteType = QPlatformTheme::ToolButtonPalette; | |
| break; | |
| case Tab: | |
| case TabFrame: | |
| paletteType = QPlatformTheme::TabBarPalette; | |
| break; | |
| case Edit: | |
| paletteType = QPlatformTheme::TextEditPalette; | |
| break; | |
| case GroupBox: | |
| paletteType = QPlatformTheme::GroupBoxPalette; | |
| break; | |
| case Header: | |
| paletteType = QPlatformTheme::HeaderPalette; | |
| break; | |
| case Item: | |
| case ItemRow: | |
| paletteType = QPlatformTheme::ItemViewPalette; | |
| break; | |
| case Menu: | |
| case MenuItem: | |
| paletteType = QPlatformTheme::MenuPalette; | |
| break; | |
| case MenuBar: | |
| case MenuBarItem: | |
| paletteType = QPlatformTheme::MenuBarPalette; | |
| break; | |
| default: | |
| break; | |
| } | |
| const QPalette *platformPalette = QGuiApplicationPrivate::platformTheme()->palette(paletteType); | |
| if (platformPalette) | |
| m_styleoption->palette = *platformPalette; | |
| // Defaults to SystemPalette otherwise | |
| } | |
| /* | |
| * Property style | |
| * | |
| * Returns a simplified style name. | |
| * | |
| * QMacStyle = "mac" | |
| * QWindowsXPStyle = "windowsxp" | |
| * QFusionStyle = "fusion" | |
| */ | |
| QString QQuickStyleItem1::style() const | |
| { | |
| QString style = qApp->style()->metaObject()->className(); | |
| style = style.toLower(); | |
| if (style.startsWith(QLatin1Char('q'))) | |
| style = style.right(style.length() - 1); | |
| if (style.endsWith(QLatin1String("style"))) | |
| style = style.left(style.length() - 5); | |
| return style; | |
| } | |
| QString QQuickStyleItem1::hitTest(int px, int py) | |
| { | |
| QStyle::SubControl subcontrol = QStyle::SC_All; | |
| switch (m_itemType) { | |
| case SpinBox :{ | |
| subcontrol = qApp->style()->hitTestComplexControl(QStyle::CC_SpinBox, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| QPoint(px,py), 0); | |
| if (subcontrol == QStyle::SC_SpinBoxUp) | |
| return QStringLiteral("up"); | |
| else if (subcontrol == QStyle::SC_SpinBoxDown) | |
| return QStringLiteral("down"); | |
| } | |
| break; | |
| case Slider: { | |
| subcontrol = qApp->style()->hitTestComplexControl(QStyle::CC_Slider, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| QPoint(px,py), 0); | |
| if (subcontrol == QStyle::SC_SliderHandle) | |
| return QStringLiteral("handle"); | |
| } | |
| break; | |
| case ScrollBar: { | |
| subcontrol = qApp->style()->hitTestComplexControl(QStyle::CC_ScrollBar, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| QPoint(px,py), 0); | |
| switch (subcontrol) { | |
| case QStyle::SC_ScrollBarSlider: | |
| return QStringLiteral("handle"); | |
| case QStyle::SC_ScrollBarSubLine: | |
| return QStringLiteral("up"); | |
| case QStyle::SC_ScrollBarSubPage: | |
| return QStringLiteral("upPage"); | |
| case QStyle::SC_ScrollBarAddLine: | |
| return QStringLiteral("down"); | |
| case QStyle::SC_ScrollBarAddPage: | |
| return QStringLiteral("downPage"); | |
| default: | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| return QStringLiteral("none"); | |
| } | |
| QSize QQuickStyleItem1::sizeFromContents(int width, int height) | |
| { | |
| initStyleOption(); | |
| QSize size; | |
| switch (m_itemType) { | |
| case RadioButton: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_RadioButton, m_styleoption, QSize(width,height)); | |
| break; | |
| case CheckBox: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_CheckBox, m_styleoption, QSize(width,height)); | |
| break; | |
| case ToolBar: | |
| size = QSize(200, style().contains(QLatin1String("windows")) ? 30 : 42); | |
| break; | |
| case ToolButton: { | |
| QStyleOptionToolButton *btn = qstyleoption_cast<QStyleOptionToolButton*>(m_styleoption); | |
| int w = 0; | |
| int h = 0; | |
| if (btn->toolButtonStyle != Qt::ToolButtonTextOnly) { | |
| QSize icon = btn->iconSize; | |
| w = icon.width(); | |
| h = icon.height(); | |
| } | |
| if (btn->toolButtonStyle != Qt::ToolButtonIconOnly) { | |
| QSize textSize = btn->fontMetrics.size(Qt::TextShowMnemonic, btn->text); | |
| textSize.setWidth(textSize.width() + btn->fontMetrics.horizontalAdvance(QLatin1Char(' '))*2); | |
| if (btn->toolButtonStyle == Qt::ToolButtonTextUnderIcon) { | |
| h += 4 + textSize.height(); | |
| if (textSize.width() > w) | |
| w = textSize.width(); | |
| } else if (btn->toolButtonStyle == Qt::ToolButtonTextBesideIcon) { | |
| w += 4 + textSize.width(); | |
| if (textSize.height() > h) | |
| h = textSize.height(); | |
| } else { // TextOnly | |
| w = textSize.width(); | |
| h = textSize.height(); | |
| } | |
| } | |
| btn->rect.setSize(QSize(w, h)); | |
| size = qApp->style()->sizeFromContents(QStyle::CT_ToolButton, m_styleoption, QSize(w, h)); } | |
| break; | |
| case Button: { | |
| QStyleOptionButton *btn = qstyleoption_cast<QStyleOptionButton*>(m_styleoption); | |
| int contentWidth = btn->fontMetrics.horizontalAdvance(btn->text); | |
| int contentHeight = btn->fontMetrics.height(); | |
| if (!btn->icon.isNull()) { | |
| //+4 matches a hardcoded value in QStyle and acts as a margin between the icon and the text. | |
| contentWidth += btn->iconSize.width() + 4; | |
| contentHeight = qMax(btn->fontMetrics.height(), btn->iconSize.height()); | |
| } | |
| int newWidth = qMax(width, contentWidth); | |
| int newHeight = qMax(height, contentHeight); | |
| size = qApp->style()->sizeFromContents(QStyle::CT_PushButton, m_styleoption, QSize(newWidth, newHeight)); } | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| // Cancel out QMacStylePrivate::PushButton*Offset, or part of it | |
| size -= QSize(7, 6); | |
| } | |
| #endif | |
| break; | |
| case ComboBox: { | |
| QStyleOptionComboBox *btn = qstyleoption_cast<QStyleOptionComboBox*>(m_styleoption); | |
| int newWidth = qMax(width, btn->fontMetrics.horizontalAdvance(btn->currentText)); | |
| int newHeight = qMax(height, btn->fontMetrics.height()); | |
| size = qApp->style()->sizeFromContents(QStyle::CT_ComboBox, m_styleoption, QSize(newWidth, newHeight)); } | |
| break; | |
| case Tab: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_TabBarTab, m_styleoption, QSize(width,height)); | |
| break; | |
| case Slider: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_Slider, m_styleoption, QSize(width,height)); | |
| break; | |
| case ProgressBar: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_ProgressBar, m_styleoption, QSize(width,height)); | |
| break; | |
| case SpinBox: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| size = qApp->style()->sizeFromContents(QStyle::CT_SpinBox, m_styleoption, QSize(width, height + 5)); | |
| break; | |
| } | |
| #endif // fall through if not mac | |
| case Edit: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| QString sizeHint = m_hints.value(QStringLiteral("size")).toString(); | |
| if (sizeHint == QLatin1String("small") || sizeHint == QLatin1String("mini")) | |
| size = QSize(width, 19); | |
| else | |
| size = QSize(width, 22); | |
| if (hints().value(QStringLiteral("rounded")).toBool()) | |
| size += QSize(4, 4); | |
| } else | |
| #endif | |
| { | |
| // We have to create a new style option since we might be calling with a QStyleOptionSpinBox | |
| QStyleOptionFrame frame; | |
| frame.state = m_styleoption->state; | |
| frame.lineWidth = qApp->style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption, 0); | |
| frame.rect = m_styleoption->rect; | |
| frame.styleObject = this; | |
| size = qApp->style()->sizeFromContents(QStyle::CT_LineEdit, &frame, QSize(width, height)); | |
| if (m_itemType == SpinBox) | |
| size.setWidth(qApp->style()->sizeFromContents(QStyle::CT_SpinBox, | |
| m_styleoption, QSize(width + 2, height)).width()); | |
| } | |
| break; | |
| case GroupBox: { | |
| QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox*>(m_styleoption); | |
| QFontMetrics metrics(box->fontMetrics); | |
| int baseWidth = metrics.horizontalAdvance(box->text) | |
| + metrics.horizontalAdvance(QLatin1Char(' ')); | |
| int baseHeight = metrics.height() + m_contentHeight; | |
| if (box->subControls & QStyle::SC_GroupBoxCheckBox) { | |
| baseWidth += qApp->style()->pixelMetric(QStyle::PM_IndicatorWidth); | |
| baseWidth += qApp->style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing); | |
| baseHeight = qMax(baseHeight, qApp->style()->pixelMetric(QStyle::PM_IndicatorHeight)); | |
| } | |
| size = qApp->style()->sizeFromContents(QStyle::CT_GroupBox, m_styleoption, QSize(qMax(baseWidth, m_contentWidth), baseHeight)); | |
| } | |
| break; | |
| case Header: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_HeaderSection, m_styleoption, QSize(width,height)); | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) | |
| size.setHeight(15); | |
| #endif | |
| break; | |
| case ItemRow: | |
| case Item: //fall through | |
| size = qApp->style()->sizeFromContents(QStyle::CT_ItemViewItem, m_styleoption, QSize(width,height)); | |
| break; | |
| case MenuBarItem: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_MenuBarItem, m_styleoption, QSize(width,height)); | |
| break; | |
| case MenuBar: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_MenuBar, m_styleoption, QSize(width,height)); | |
| break; | |
| case Menu: | |
| size = qApp->style()->sizeFromContents(QStyle::CT_Menu, m_styleoption, QSize(width,height)); | |
| break; | |
| case MenuItem: | |
| case ComboBoxItem: | |
| if (static_cast<QStyleOptionMenuItem *>(m_styleoption)->menuItemType == QStyleOptionMenuItem::Scroller) { | |
| size.setHeight(qMax(QApplication::globalStrut().height(), | |
| qApp->style()->pixelMetric(QStyle::PM_MenuScrollerHeight, 0, 0))); | |
| } else { | |
| size = qApp->style()->sizeFromContents(QStyle::CT_MenuItem, m_styleoption, QSize(width,height)); | |
| } | |
| break; | |
| default: | |
| break; | |
| } return size; | |
| } | |
| qreal QQuickStyleItem1::baselineOffset() | |
| { | |
| QRect r; | |
| bool ceilResult = true; // By default baseline offset rounding is done upwards | |
| switch (m_itemType) { | |
| case RadioButton: | |
| r = qApp->style()->subElementRect(QStyle::SE_RadioButtonContents, m_styleoption); | |
| break; | |
| case Button: | |
| r = qApp->style()->subElementRect(QStyle::SE_PushButtonContents, m_styleoption); | |
| break; | |
| case CheckBox: | |
| r = qApp->style()->subElementRect(QStyle::SE_CheckBoxContents, m_styleoption); | |
| break; | |
| case Edit: | |
| r = qApp->style()->subElementRect(QStyle::SE_LineEditContents, m_styleoption); | |
| break; | |
| case ComboBox: | |
| if (const QStyleOptionComboBox *combo = qstyleoption_cast<const QStyleOptionComboBox *>(m_styleoption)) { | |
| r = qApp->style()->subControlRect(QStyle::CC_ComboBox, combo, QStyle::SC_ComboBoxEditField); | |
| if (style() != QLatin1String("mac")) | |
| r.adjust(0,0,0,1); | |
| } | |
| break; | |
| #if QT_CONFIG(spinbox) | |
| case SpinBox: | |
| if (const QStyleOptionSpinBox *spinbox = qstyleoption_cast<const QStyleOptionSpinBox *>(m_styleoption)) { | |
| r = qApp->style()->subControlRect(QStyle::CC_SpinBox, spinbox, QStyle::SC_SpinBoxEditField); | |
| ceilResult = false; | |
| } | |
| break; | |
| #endif | |
| default: | |
| break; | |
| } | |
| if (r.height() > 0) { | |
| const QFontMetrics &fm = m_styleoption->fontMetrics; | |
| int surplus = r.height() - fm.height(); | |
| if ((surplus & 1) && ceilResult) | |
| surplus++; | |
| int result = r.top() + surplus/2 + fm.ascent(); | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| switch (m_itemType) { | |
| case Button: | |
| case Edit: | |
| result -= 1; | |
| break; | |
| case ComboBox: | |
| // adjust back the adjustments done in drawControl(CE_ComboBoxLabel) | |
| result += 1; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| #endif | |
| return result; | |
| } | |
| return 0.; | |
| } | |
| void QQuickStyleItem1::updateBaselineOffset() | |
| { | |
| const qreal baseline = baselineOffset(); | |
| if (baseline > 0) | |
| setBaselineOffset(baseline); | |
| } | |
| void QQuickStyleItem1::setContentWidth(int arg) | |
| { | |
| if (m_contentWidth != arg) { | |
| m_contentWidth = arg; | |
| emit contentWidthChanged(arg); | |
| } | |
| } | |
| void QQuickStyleItem1::setContentHeight(int arg) | |
| { | |
| if (m_contentHeight != arg) { | |
| m_contentHeight = arg; | |
| emit contentHeightChanged(arg); | |
| } | |
| } | |
| void QQuickStyleItem1::updateSizeHint() | |
| { | |
| QSize implicitSize = sizeFromContents(m_contentWidth, m_contentHeight); | |
| setImplicitSize(implicitSize.width(), implicitSize.height()); | |
| } | |
| void QQuickStyleItem1::updateRect() | |
| { | |
| initStyleOption(); | |
| m_styleoption->rect.setWidth(width()); | |
| m_styleoption->rect.setHeight(height()); | |
| } | |
| int QQuickStyleItem1::pixelMetric(const QString &metric) | |
| { | |
| if (metric == QLatin1String("scrollbarExtent")) | |
| return qApp->style()->pixelMetric(QStyle::PM_ScrollBarExtent, 0 ); | |
| else if (metric == QLatin1String("defaultframewidth")) | |
| return qApp->style()->pixelMetric(QStyle::PM_DefaultFrameWidth, m_styleoption); | |
| else if (metric == QLatin1String("taboverlap")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarTabOverlap, 0 ); | |
| else if (metric == QLatin1String("tabbaseoverlap")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarBaseOverlap, m_styleoption ); | |
| else if (metric == QLatin1String("tabhspace")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarTabHSpace, 0 ); | |
| else if (metric == QLatin1String("indicatorwidth")) | |
| return qApp->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorWidth, 0 ); | |
| else if (metric == QLatin1String("tabvspace")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarTabVSpace, 0 ); | |
| else if (metric == QLatin1String("tabbaseheight")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarBaseHeight, 0 ); | |
| else if (metric == QLatin1String("tabvshift")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TabBarTabShiftVertical, 0 ); | |
| else if (metric == QLatin1String("menubarhmargin")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuBarHMargin, 0 ); | |
| else if (metric == QLatin1String("menubarvmargin")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0 ); | |
| else if (metric == QLatin1String("menubarpanelwidth")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0 ); | |
| else if (metric == QLatin1String("menubaritemspacing")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuBarItemSpacing, 0 ); | |
| else if (metric == QLatin1String("spacebelowmenubar")) | |
| return qApp->style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, m_styleoption); | |
| else if (metric == QLatin1String("menuhmargin")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuHMargin, 0 ); | |
| else if (metric == QLatin1String("menuvmargin")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuVMargin, 0 ); | |
| else if (metric == QLatin1String("menupanelwidth")) | |
| return qApp->style()->pixelMetric(QStyle::PM_MenuPanelWidth, 0 ); | |
| else if (metric == QLatin1String("submenuoverlap")) | |
| return qApp->style()->pixelMetric(QStyle::PM_SubMenuOverlap, 0 ); | |
| else if (metric == QLatin1String("splitterwidth")) | |
| return qApp->style()->pixelMetric(QStyle::PM_SplitterWidth, 0 ); | |
| else if (metric == QLatin1String("scrollbarspacing")) | |
| return abs(qApp->style()->pixelMetric(QStyle::PM_ScrollView_ScrollBarSpacing, 0 )); | |
| else if (metric == QLatin1String("treeviewindentation")) | |
| return qApp->style()->pixelMetric(QStyle::PM_TreeViewIndentation, 0 ); | |
| return 0; | |
| } | |
| QVariant QQuickStyleItem1::styleHint(const QString &metric) | |
| { | |
| initStyleOption(); | |
| if (metric == QLatin1String("comboboxpopup")) { | |
| return qApp->style()->styleHint(QStyle::SH_ComboBox_Popup, m_styleoption); | |
| } else if (metric == QLatin1String("highlightedTextColor")) { | |
| return m_styleoption->palette.highlightedText().color().name(); | |
| } else if (metric == QLatin1String("textColor")) { | |
| QPalette pal = m_styleoption->palette; | |
| pal.setCurrentColorGroup(active()? QPalette::Active : QPalette::Inactive); | |
| return pal.text().color().name(); | |
| } else if (metric == QLatin1String("focuswidget")) { | |
| return qApp->style()->styleHint(QStyle::SH_FocusFrame_AboveWidget); | |
| } else if (metric == QLatin1String("tabbaralignment")) { | |
| int result = qApp->style()->styleHint(QStyle::SH_TabBar_Alignment); | |
| if (result == Qt::AlignCenter) | |
| return QStringLiteral("center"); | |
| return QStringLiteral("left"); | |
| } else if (metric == QLatin1String("externalScrollBars")) { | |
| return qApp->style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents); | |
| } else if (metric == QLatin1String("scrollToClickPosition")) | |
| return qApp->style()->styleHint(QStyle::SH_ScrollBar_LeftClickAbsolutePosition); | |
| else if (metric == QLatin1String("activateItemOnSingleClick")) | |
| return qApp->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick); | |
| else if (metric == QLatin1String("submenupopupdelay")) | |
| return qApp->style()->styleHint(QStyle::SH_Menu_SubMenuPopupDelay, m_styleoption); | |
| #if QT_CONFIG(wheelevent) | |
| else if (metric == QLatin1String("wheelScrollLines")) | |
| return qApp->wheelScrollLines(); | |
| #endif | |
| return 0; | |
| // Add SH_Menu_SpaceActivatesItem | |
| } | |
| void QQuickStyleItem1::setHints(const QVariantMap &str) | |
| { | |
| if (m_hints != str) { | |
| m_hints = str; | |
| initStyleOption(); | |
| updateSizeHint(); | |
| if (m_styleoption->state & QStyle::State_Mini) { | |
| m_font.setPointSize(9.); | |
| emit fontChanged(); | |
| } else if (m_styleoption->state & QStyle::State_Small) { | |
| m_font.setPointSize(11.); | |
| emit fontChanged(); | |
| } else { | |
| emit hintChanged(); | |
| } | |
| } | |
| } | |
| void QQuickStyleItem1::resetHints() | |
| { | |
| m_hints.clear(); | |
| } | |
| void QQuickStyleItem1::setElementType(const QString &str) | |
| { | |
| if (m_type == str) | |
| return; | |
| m_type = str; | |
| emit elementTypeChanged(); | |
| if (m_styleoption) { | |
| delete m_styleoption; | |
| m_styleoption = 0; | |
| } | |
| // Only enable visible if the widget can animate | |
| if (str == QLatin1String("menu")) { | |
| m_itemType = Menu; | |
| } else if (str == QLatin1String("menuitem")) { | |
| m_itemType = MenuItem; | |
| } else if (str == QLatin1String("item") || str == QLatin1String("itemrow") || str == QLatin1String("header")) { | |
| #ifdef Q_OS_OSX | |
| m_font.setPointSize(11.0); | |
| emit fontChanged(); | |
| #endif | |
| if (str == QLatin1String("header")) { | |
| m_itemType = Header; | |
| } else { | |
| m_itemType = str == QLatin1String("item") ? Item : ItemRow; | |
| } | |
| } else if (str == QLatin1String("itembranchindicator")) { | |
| m_itemType = ItemBranchIndicator; | |
| } else if (str == QLatin1String("groupbox")) { | |
| m_itemType = GroupBox; | |
| } else if (str == QLatin1String("tab")) { | |
| m_itemType = Tab; | |
| } else if (str == QLatin1String("tabframe")) { | |
| m_itemType = TabFrame; | |
| } else if (str == QLatin1String("comboboxitem")) { | |
| // Gtk uses qobject cast, hence we need to separate this from menuitem | |
| // On mac, we temporarily use the menu item because it has more accurate | |
| // palette. | |
| m_itemType = ComboBoxItem; | |
| } else if (str == QLatin1String("toolbar")) { | |
| m_itemType = ToolBar; | |
| } else if (str == QLatin1String("toolbutton")) { | |
| m_itemType = ToolButton; | |
| } else if (str == QLatin1String("slider")) { | |
| m_itemType = Slider; | |
| } else if (str == QLatin1String("frame")) { | |
| m_itemType = Frame; | |
| } else if (str == QLatin1String("combobox")) { | |
| m_itemType = ComboBox; | |
| } else if (str == QLatin1String("splitter")) { | |
| m_itemType = Splitter; | |
| } else if (str == QLatin1String("progressbar")) { | |
| m_itemType = ProgressBar; | |
| } else if (str == QLatin1String("button")) { | |
| m_itemType = Button; | |
| } else if (str == QLatin1String("checkbox")) { | |
| m_itemType = CheckBox; | |
| } else if (str == QLatin1String("radiobutton")) { | |
| m_itemType = RadioButton; | |
| } else if (str == QLatin1String("edit")) { | |
| m_itemType = Edit; | |
| } else if (str == QLatin1String("spinbox")) { | |
| m_itemType = SpinBox; | |
| } else if (str == QLatin1String("scrollbar")) { | |
| m_itemType = ScrollBar; | |
| } else if (str == QLatin1String("widget")) { | |
| m_itemType = Widget; | |
| } else if (str == QLatin1String("focusframe")) { | |
| m_itemType = FocusFrame; | |
| } else if (str == QLatin1String("focusrect")) { | |
| m_itemType = FocusRect; | |
| } else if (str == QLatin1String("dial")) { | |
| m_itemType = Dial; | |
| } else if (str == QLatin1String("statusbar")) { | |
| m_itemType = StatusBar; | |
| } else if (str == QLatin1String("machelpbutton")) { | |
| m_itemType = MacHelpButton; | |
| } else if (str == QLatin1String("scrollareacorner")) { | |
| m_itemType = ScrollAreaCorner; | |
| } else if (str == QLatin1String("menubar")) { | |
| m_itemType = MenuBar; | |
| } else if (str == QLatin1String("menubaritem")) { | |
| m_itemType = MenuBarItem; | |
| } else { | |
| m_itemType = Undefined; | |
| } | |
| updateSizeHint(); | |
| } | |
| QRectF QQuickStyleItem1::subControlRect(const QString &subcontrolString) | |
| { | |
| QStyle::SubControl subcontrol = QStyle::SC_None; | |
| initStyleOption(); | |
| switch (m_itemType) { | |
| case SpinBox: | |
| { | |
| QStyle::ComplexControl control = QStyle::CC_SpinBox; | |
| if (subcontrolString == QLatin1String("down")) | |
| subcontrol = QStyle::SC_SpinBoxDown; | |
| else if (subcontrolString == QLatin1String("up")) | |
| subcontrol = QStyle::SC_SpinBoxUp; | |
| else if (subcontrolString == QLatin1String("edit")){ | |
| subcontrol = QStyle::SC_SpinBoxEditField; | |
| } | |
| return qApp->style()->subControlRect(control, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| subcontrol); | |
| } | |
| break; | |
| case Slider: | |
| { | |
| QStyle::ComplexControl control = QStyle::CC_Slider; | |
| if (subcontrolString == QLatin1String("handle")) | |
| subcontrol = QStyle::SC_SliderHandle; | |
| else if (subcontrolString == QLatin1String("groove")) | |
| subcontrol = QStyle::SC_SliderGroove; | |
| return qApp->style()->subControlRect(control, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| subcontrol); | |
| } | |
| break; | |
| case ScrollBar: | |
| { | |
| QStyle::ComplexControl control = QStyle::CC_ScrollBar; | |
| if (subcontrolString == QLatin1String("slider")) | |
| subcontrol = QStyle::SC_ScrollBarSlider; | |
| if (subcontrolString == QLatin1String("groove")) | |
| subcontrol = QStyle::SC_ScrollBarGroove; | |
| else if (subcontrolString == QLatin1String("handle")) | |
| subcontrol = QStyle::SC_ScrollBarSlider; | |
| else if (subcontrolString == QLatin1String("add")) | |
| subcontrol = QStyle::SC_ScrollBarAddPage; | |
| else if (subcontrolString == QLatin1String("sub")) | |
| subcontrol = QStyle::SC_ScrollBarSubPage; | |
| return qApp->style()->subControlRect(control, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| subcontrol); | |
| } | |
| break; | |
| case ItemBranchIndicator: { | |
| QStyleOption opt; | |
| opt.rect = QRect(0, 0, implicitWidth(), implicitHeight()); | |
| return qApp->style()->subElementRect(QStyle::SE_TreeViewDisclosureItem, &opt, 0); | |
| } | |
| default: | |
| break; | |
| } | |
| return QRectF(); | |
| } | |
| namespace { | |
| class QHighDpiPixmapsEnabler1 { | |
| public: | |
| QHighDpiPixmapsEnabler1() | |
| :wasEnabled(false) | |
| { | |
| if (!qApp->testAttribute(Qt::AA_UseHighDpiPixmaps)) { | |
| qApp->setAttribute(Qt::AA_UseHighDpiPixmaps); | |
| wasEnabled = true; | |
| } | |
| } | |
| ~QHighDpiPixmapsEnabler1() | |
| { | |
| if (wasEnabled) | |
| qApp->setAttribute(Qt::AA_UseHighDpiPixmaps, false); | |
| } | |
| private: | |
| bool wasEnabled; | |
| }; | |
| } | |
| void QQuickStyleItem1::paint(QPainter *painter) | |
| { | |
| initStyleOption(); | |
| if (QStyleOptionMenuItem *opt = qstyleoption_cast<QStyleOptionMenuItem*>(m_styleoption)) | |
| painter->setFont(opt->font); | |
| else { | |
| QPlatformTheme::Font platformFont = (m_styleoption->state & QStyle::State_Mini) ? QPlatformTheme::MiniFont : | |
| (m_styleoption->state & QStyle::State_Small) ? QPlatformTheme::SmallFont : | |
| QPlatformTheme::NFonts; | |
| if (platformFont != QPlatformTheme::NFonts) | |
| if (const QFont *font = QGuiApplicationPrivate::platformTheme()->font(platformFont)) | |
| painter->setFont(*font); | |
| } | |
| // Set AA_UseHighDpiPixmaps when calling style code to make QIcon return | |
| // "retina" pixmaps. The flag is controlled by the application so we can't | |
| // set it unconditinally. | |
| QHighDpiPixmapsEnabler1 enabler; | |
| switch (m_itemType) { | |
| case Button: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| // Add back what was substracted in sizeFromContents() | |
| m_styleoption->rect.adjust(-4, -2, 3, 4); | |
| } | |
| #endif | |
| qApp->style()->drawControl(QStyle::CE_PushButton, m_styleoption, painter); | |
| break; | |
| case ItemRow :{ | |
| QPixmap pixmap; | |
| // Only draw through style once | |
| const QString pmKey = QLatin1String("itemrow") % QString::number(m_styleoption->state,16) % activeControl(); | |
| if (!QPixmapCache::find(pmKey, &pixmap) || pixmap.width() < width() || height() != pixmap.height()) { | |
| int newSize = width(); | |
| pixmap = QPixmap(newSize, height()); | |
| pixmap.fill(Qt::transparent); | |
| QPainter pixpainter(&pixmap); | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelItemViewRow, m_styleoption, &pixpainter); | |
| if ((style() == QLatin1String("mac") || !qApp->style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected)) && selected()) { | |
| QPalette pal = QApplication::palette("QAbstractItemView"); | |
| pal.setCurrentColorGroup(m_styleoption->palette.currentColorGroup()); | |
| pixpainter.fillRect(m_styleoption->rect, pal.highlight()); | |
| } | |
| QPixmapCache::insert(pmKey, pixmap); | |
| } | |
| painter->drawPixmap(0, 0, pixmap); | |
| } | |
| break; | |
| case Item: | |
| qApp->style()->drawControl(QStyle::CE_ItemViewItem, m_styleoption, painter); | |
| break; | |
| case ItemBranchIndicator: | |
| qApp->style()->drawPrimitive(QStyle::PE_IndicatorBranch, m_styleoption, painter); | |
| break; | |
| case Header: | |
| qApp->style()->drawControl(QStyle::CE_Header, m_styleoption, painter); | |
| break; | |
| case ToolButton: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac") && hints().value(QStringLiteral("segmented")).toBool()) { | |
| const QPaintDevice *target = painter->device(); | |
| HIThemeSegmentDrawInfo sgi; | |
| sgi.version = 0; | |
| sgi.state = isEnabled() ? kThemeStateActive : kThemeStateDisabled; | |
| if (sunken()) sgi.state |= kThemeStatePressed; | |
| sgi.size = kHIThemeSegmentSizeNormal; | |
| sgi.kind = kHIThemeSegmentKindTextured; | |
| sgi.value = on() && !sunken() ? kThemeButtonOn : kThemeButtonOff; | |
| sgi.adornment |= kHIThemeSegmentAdornmentLeadingSeparator; | |
| if (sunken()) { | |
| sgi.adornment |= kHIThemeSegmentAdornmentTrailingSeparator; | |
| } | |
| SInt32 button_height; | |
| GetThemeMetric(kThemeMetricButtonRoundedHeight, &button_height); | |
| QString buttonPos = m_properties.value(QStringLiteral("position")).toString(); | |
| sgi.position = buttonPos == QLatin1String("leftmost") ? kHIThemeSegmentPositionFirst : | |
| buttonPos == QLatin1String("rightmost") ? kHIThemeSegmentPositionLast : | |
| buttonPos == QLatin1String("h_middle") ? kHIThemeSegmentPositionMiddle : | |
| kHIThemeSegmentPositionOnly; | |
| QRect centered = m_styleoption->rect; | |
| centered.setHeight(button_height); | |
| centered.moveCenter(m_styleoption->rect.center()); | |
| HIRect hirect = qt_hirectForQRect(centered.translated(0, -1), QRect(0, 0, 0, 0)); | |
| HIThemeDrawSegment(&hirect, &sgi, qt_mac_cg_context(target), kHIThemeOrientationNormal); | |
| } else | |
| #endif | |
| qApp->style()->drawComplexControl(QStyle::CC_ToolButton, qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), painter); | |
| break; | |
| case Tab: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| m_styleoption->rect.translate(0, 1); // Unhack QMacStyle's hack | |
| qApp->style()->drawControl(QStyle::CE_TabBarTabShape, m_styleoption, painter); | |
| m_styleoption->rect.translate(0, -1); | |
| qApp->style()->drawControl(QStyle::CE_TabBarTabLabel, m_styleoption, painter); | |
| } else | |
| #endif | |
| { | |
| qApp->style()->drawControl(QStyle::CE_TabBarTab, m_styleoption, painter); | |
| } | |
| break; | |
| case Frame: | |
| qApp->style()->drawControl(QStyle::CE_ShapedFrame, m_styleoption, painter); | |
| break; | |
| case FocusFrame: | |
| qApp->style()->drawControl(QStyle::CE_FocusFrame, m_styleoption, painter); | |
| break; | |
| case FocusRect: | |
| qApp->style()->drawPrimitive(QStyle::PE_FrameFocusRect, m_styleoption, painter); | |
| break; | |
| case TabFrame: | |
| qApp->style()->drawPrimitive(QStyle::PE_FrameTabWidget, m_styleoption, painter); | |
| break; | |
| case MenuBar: | |
| qApp->style()->drawControl(QStyle::CE_MenuBarEmptyArea, m_styleoption, painter); | |
| break; | |
| case MenuBarItem: | |
| qApp->style()->drawControl(QStyle::CE_MenuBarItem, m_styleoption, painter); | |
| break; | |
| case MenuItem: | |
| case ComboBoxItem: { // fall through | |
| QStyle::ControlElement menuElement = | |
| static_cast<QStyleOptionMenuItem *>(m_styleoption)->menuItemType == QStyleOptionMenuItem::Scroller ? | |
| QStyle::CE_MenuScroller : QStyle::CE_MenuItem; | |
| qApp->style()->drawControl(menuElement, m_styleoption, painter); | |
| } | |
| break; | |
| case CheckBox: | |
| qApp->style()->drawControl(QStyle::CE_CheckBox, m_styleoption, painter); | |
| break; | |
| case RadioButton: | |
| qApp->style()->drawControl(QStyle::CE_RadioButton, m_styleoption, painter); | |
| break; | |
| case Edit: { | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac") && hints().value(QStringLiteral("rounded")).toBool()) { | |
| const QPaintDevice *target = painter->device(); | |
| HIThemeFrameDrawInfo fdi; | |
| fdi.version = 0; | |
| fdi.state = kThemeStateActive; | |
| SInt32 frame_size; | |
| GetThemeMetric(kThemeMetricEditTextFrameOutset, &frame_size); | |
| fdi.kind = kHIThemeFrameTextFieldRound; | |
| if ((m_styleoption->state & QStyle::State_ReadOnly) || !(m_styleoption->state & QStyle::State_Enabled)) | |
| fdi.state = kThemeStateInactive; | |
| fdi.isFocused = hasFocus(); | |
| HIRect hirect = qt_hirectForQRect(m_styleoption->rect.adjusted(2, 2, -2, 2), QRect(0, 0, 0, 0)); | |
| HIThemeDrawFrame(&hirect, &fdi, qt_mac_cg_context(target), kHIThemeOrientationNormal); | |
| } else | |
| #endif | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelLineEdit, m_styleoption, painter); | |
| } | |
| break; | |
| case MacHelpButton: | |
| #ifdef Q_OS_OSX | |
| { | |
| const QPaintDevice *target = painter->device(); | |
| HIThemeButtonDrawInfo fdi; | |
| fdi.kind = kThemeRoundButtonHelp; | |
| fdi.version = 0; | |
| fdi.adornment = 0; | |
| fdi.state = sunken() ? kThemeStatePressed : kThemeStateActive; | |
| HIRect hirect = qt_hirectForQRect(m_styleoption->rect,QRect(0, 0, 0, 0)); | |
| HIThemeDrawButton(&hirect, &fdi, qt_mac_cg_context(target), kHIThemeOrientationNormal, NULL); | |
| } | |
| #endif | |
| break; | |
| case Widget: | |
| qApp->style()->drawPrimitive(QStyle::PE_Widget, m_styleoption, painter); | |
| break; | |
| case ScrollAreaCorner: | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelScrollAreaCorner, m_styleoption, painter); | |
| break; | |
| case Splitter: | |
| if (m_styleoption->rect.width() == 1) | |
| painter->fillRect(0, 0, width(), height(), m_styleoption->palette.dark().color()); | |
| else | |
| qApp->style()->drawControl(QStyle::CE_Splitter, m_styleoption, painter); | |
| break; | |
| case ComboBox: | |
| { | |
| qApp->style()->drawComplexControl(QStyle::CC_ComboBox, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| painter); | |
| // This is needed on mac as it will use the painter color and ignore the palette | |
| QPen pen = painter->pen(); | |
| painter->setPen(m_styleoption->palette.text().color()); | |
| qApp->style()->drawControl(QStyle::CE_ComboBoxLabel, m_styleoption, painter); | |
| painter->setPen(pen); | |
| } break; | |
| case SpinBox: | |
| #ifdef Q_OS_MAC | |
| // macstyle depends on the embedded qlineedit to fill the editfield background | |
| if (style() == QLatin1String("mac")) { | |
| QRect editRect = qApp->style()->subControlRect(QStyle::CC_SpinBox, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| QStyle::SC_SpinBoxEditField); | |
| painter->fillRect(editRect.adjusted(-1, -1, 1, 1), m_styleoption->palette.base()); | |
| } | |
| #endif | |
| qApp->style()->drawComplexControl(QStyle::CC_SpinBox, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| painter); | |
| break; | |
| case Slider: | |
| qApp->style()->drawComplexControl(QStyle::CC_Slider, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| painter); | |
| break; | |
| case Dial: | |
| qApp->style()->drawComplexControl(QStyle::CC_Dial, | |
| qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), | |
| painter); | |
| break; | |
| case ProgressBar: | |
| qApp->style()->drawControl(QStyle::CE_ProgressBar, m_styleoption, painter); | |
| break; | |
| case ToolBar: | |
| painter->fillRect(m_styleoption->rect, m_styleoption->palette.window().color()); | |
| qApp->style()->drawControl(QStyle::CE_ToolBar, m_styleoption, painter); | |
| painter->save(); | |
| painter->setPen(style() != QLatin1String("fusion") ? m_styleoption->palette.dark().color().darker(120) : | |
| m_styleoption->palette.window().color().lighter(107)); | |
| painter->drawLine(m_styleoption->rect.bottomLeft(), m_styleoption->rect.bottomRight()); | |
| painter->restore(); | |
| break; | |
| case StatusBar: | |
| #ifdef Q_OS_OSX | |
| if (style() == QLatin1String("mac")) { | |
| qApp->style()->drawControl(QStyle::CE_ToolBar, m_styleoption, painter); | |
| painter->setPen(m_styleoption->palette.dark().color().darker(120)); | |
| painter->drawLine(m_styleoption->rect.topLeft(), m_styleoption->rect.topRight()); | |
| } else | |
| #endif | |
| { | |
| painter->fillRect(m_styleoption->rect, m_styleoption->palette.window().color()); | |
| painter->setPen(m_styleoption->palette.dark().color().darker(120)); | |
| painter->drawLine(m_styleoption->rect.topLeft(), m_styleoption->rect.topRight()); | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelStatusBar, m_styleoption, painter); | |
| } | |
| break; | |
| case GroupBox: | |
| qApp->style()->drawComplexControl(QStyle::CC_GroupBox, qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), painter); | |
| break; | |
| case ScrollBar: | |
| qApp->style()->drawComplexControl(QStyle::CC_ScrollBar, qstyleoption_cast<QStyleOptionComplex*>(m_styleoption), painter); | |
| break; | |
| case Menu: { | |
| QStyleHintReturnMask val; | |
| qApp->style()->styleHint(QStyle::SH_Menu_Mask, m_styleoption, 0, &val); | |
| painter->save(); | |
| painter->setClipRegion(val.region); | |
| painter->fillRect(m_styleoption->rect, m_styleoption->palette.window()); | |
| painter->restore(); | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelMenu, m_styleoption, painter); | |
| if (int fw = qApp->style()->pixelMetric(QStyle::PM_MenuPanelWidth)) { | |
| QStyleOptionFrame frame; | |
| frame.state = QStyle::State_None; | |
| frame.lineWidth = fw; | |
| frame.midLineWidth = 0; | |
| frame.rect = m_styleoption->rect; | |
| frame.styleObject = this; | |
| frame.palette = m_styleoption->palette; | |
| qApp->style()->drawPrimitive(QStyle::PE_FrameMenu, &frame, painter); | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| qreal QQuickStyleItem1::textWidth(const QString &text) | |
| { | |
| QFontMetricsF fm = QFontMetricsF(m_styleoption->fontMetrics); | |
| return fm.boundingRect(text).width(); | |
| } | |
| qreal QQuickStyleItem1::textHeight(const QString &text) | |
| { | |
| QFontMetricsF fm = QFontMetricsF(m_styleoption->fontMetrics); | |
| return text.isEmpty() ? fm.height() : | |
| fm.boundingRect(text).height(); | |
| } | |
| QString QQuickStyleItem1::elidedText(const QString &text, int elideMode, int width) | |
| { | |
| return m_styleoption->fontMetrics.elidedText(text, Qt::TextElideMode(elideMode), width); | |
| } | |
| bool QQuickStyleItem1::hasThemeIcon(const QString &icon) const | |
| { | |
| return QIcon::hasThemeIcon(icon); | |
| } | |
| bool QQuickStyleItem1::event(QEvent *ev) | |
| { | |
| if (ev->type() == QEvent::StyleAnimationUpdate) { | |
| if (isVisible()) { | |
| ev->accept(); | |
| polish(); | |
| } | |
| return true; | |
| } else if (ev->type() == QEvent::StyleChange) { | |
| if (m_itemType == ScrollBar) | |
| initStyleOption(); | |
| } | |
| return QQuickItem::event(ev); | |
| } | |
| void QQuickStyleItem1::setTextureWidth(int w) | |
| { | |
| if (m_textureWidth == w) | |
| return; | |
| m_textureWidth = w; | |
| emit textureWidthChanged(m_textureWidth); | |
| update(); | |
| } | |
| void QQuickStyleItem1::setTextureHeight(int h) | |
| { | |
| if (m_textureHeight == h) | |
| return; | |
| m_textureHeight = h; | |
| emit textureHeightChanged(m_textureHeight); | |
| update(); | |
| } | |
| QSGNode *QQuickStyleItem1::updatePaintNode(QSGNode *node, UpdatePaintNodeData *) | |
| { | |
| if (m_image.isNull()) { | |
| delete node; | |
| return 0; | |
| } | |
| QSGNinePatchNode *styleNode = static_cast<QSGNinePatchNode *>(node); | |
| if (!styleNode) | |
| styleNode = window()->createNinePatchNode(); | |
| #ifdef QSG_RUNTIME_DESCRIPTION | |
| qsgnode_set_description(styleNode, | |
| QString::fromLatin1("%1:%2, '%3'") | |
| .arg(style()) | |
| .arg(elementType()) | |
| .arg(text())); | |
| #endif | |
| styleNode->setTexture(window()->createTextureFromImage(m_image, QQuickWindow::TextureCanUseAtlas)); | |
| styleNode->setBounds(boundingRect()); | |
| styleNode->setDevicePixelRatio(window()->devicePixelRatio()); | |
| styleNode->setPadding(m_border.left(), m_border.top(), m_border.right(), m_border.bottom()); | |
| styleNode->update(); | |
| return styleNode; | |
| } | |
| void QQuickStyleItem1::updatePolish() | |
| { | |
| if (width() >= 1 && height() >= 1) { // Note these are reals so 1 pixel is minimum | |
| float devicePixelRatio = window() ? window()->devicePixelRatio() : qApp->devicePixelRatio(); | |
| int w = m_textureWidth > 0 ? m_textureWidth : width(); | |
| int h = m_textureHeight > 0 ? m_textureHeight : height(); | |
| m_image = QImage(w * devicePixelRatio, h * devicePixelRatio, QImage::Format_ARGB32_Premultiplied); | |
| m_image.setDevicePixelRatio(devicePixelRatio); | |
| m_image.fill(Qt::transparent); | |
| QPainter painter(&m_image); | |
| painter.setLayoutDirection(qApp->layoutDirection()); | |
| paint(&painter); | |
| QQuickItem::update(); | |
| } else if (!m_image.isNull()) { | |
| m_image = QImage(); | |
| QQuickItem::update(); | |
| } | |
| } | |
| QPixmap QQuickTableRowImageProvider1::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize) | |
| { | |
| Q_UNUSED (requestedSize); | |
| int width = 16; | |
| int height = 16; | |
| if (size) | |
| *size = QSize(width, height); | |
| QPixmap pixmap(width, height); | |
| #if QT_CONFIG(itemviews) | |
| QStyleOptionViewItem opt; | |
| opt.state |= QStyle::State_Enabled; | |
| opt.rect = QRect(0, 0, width, height); | |
| QString style = qApp->style()->metaObject()->className(); | |
| opt.features = {}; | |
| if (id.contains(QLatin1String("selected"))) | |
| opt.state |= QStyle::State_Selected; | |
| if (id.contains(QLatin1String("active"))) { | |
| opt.state |= QStyle::State_Active; | |
| opt.palette.setCurrentColorGroup(QPalette::Active); | |
| } else | |
| opt.palette.setCurrentColorGroup(QPalette::Inactive); | |
| if (id.contains(QLatin1String("alternate"))) | |
| opt.features |= QStyleOptionViewItem::Alternate; | |
| QPalette pal = QApplication::palette("QAbstractItemView"); | |
| if (opt.state & QStyle::State_Selected && (style.contains(QLatin1String("Mac")) || | |
| !qApp->style()->styleHint(QStyle::SH_ItemView_ShowDecorationSelected))) { | |
| pal.setCurrentColorGroup(opt.palette.currentColorGroup()); | |
| pixmap.fill(pal.highlight().color()); | |
| } else { | |
| pixmap.fill(pal.base().color()); | |
| QPainter pixpainter(&pixmap); | |
| qApp->style()->drawPrimitive(QStyle::PE_PanelItemViewRow, &opt, &pixpainter); | |
| } | |
| #else | |
| Q_UNUSED(id); | |
| #endif | |
| return pixmap; | |
| } | |
| QT_END_NAMESPACE |