Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qtpropertybrowserutils_p.h"
++
++ #include <QtWidgets/qapplication.h>
++ #include <QtWidgets/qboxlayout.h>
++ #include <QtWidgets/qcheckbox.h>
++ #include <QtWidgets/qlineedit.h>
++ #include <QtWidgets/qmenu.h>
++
++ #include <QtGui/qevent.h>
++ #include <QtGui/qpainter.h>
++ #include <QtGui/qpainterstateguard.h>
++
++ #include <QtCore/qhash.h>
++ #include <QtCore/qlocale.h>
++ #include <QtCore/qoperatingsystemversion.h>
++
++ #include <utility>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ // Make sure icons are removed as soon as QApplication is destroyed, otherwise,
++ // handles are leaked on X11.
++ static void clearCursorDatabase()
++ {
++ QtCursorDatabase::instance()->clear();
++ }
++
++ using ShapeNames = QHash<Qt::CursorShape, const char *>;
++
++ static const ShapeNames &shapeNames()
++ {
++ static const ShapeNames result =
++ {{Qt::ArrowCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Arrow")},
++ {Qt::UpArrowCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Up Arrow")},
++ {Qt::CrossCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Cross")},
++ {Qt::WaitCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Wait")},
++ {Qt::IBeamCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "IBeam")},
++ {Qt::SizeVerCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Size Vertical")},
++ {Qt::SizeHorCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Size Horizontal")},
++ {Qt::SizeFDiagCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Size Backslash")},
++ {Qt::SizeBDiagCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Size Slash")},
++ {Qt::SizeAllCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Size All")},
++ {Qt::BlankCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Blank")},
++ {Qt::SplitVCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Split Vertical")},
++ {Qt::SplitHCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Split Horizontal")},
++ {Qt::PointingHandCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Pointing Hand")},
++ {Qt::ForbiddenCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Forbidden")},
++ {Qt::OpenHandCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Open Hand")},
++ {Qt::ClosedHandCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Closed Hand")},
++ {Qt::WhatsThisCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "What's This")},
++ {Qt::BusyCursor, QT_TRANSLATE_NOOP("QtCursorDatabase", "Busy")}};
++ return result;
++ }
++
++ using CursorResource = std::pair<Qt::CursorShape, QLatin1StringView>;
++
++ static constexpr CursorResource cursorResources[] = {
++ {Qt::ArrowCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-arrow.png"_L1},
++ {Qt::UpArrowCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-uparrow.png"_L1},
++ {Qt::CrossCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-cross.png"_L1},
++ {Qt::WaitCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-wait.png"_L1},
++ {Qt::IBeamCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-ibeam.png"_L1},
++ {Qt::SizeVerCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-sizev.png"_L1},
++ {Qt::SizeHorCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-sizeh.png"_L1},
++ {Qt::SizeFDiagCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-sizef.png"_L1},
++ {Qt::SizeBDiagCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-sizeb.png"_L1},
++ {Qt::SizeAllCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-sizeall.png"_L1},
++ {Qt::SplitVCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-vsplit.png"_L1},
++ {Qt::SplitHCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-hsplit.png"_L1},
++ {Qt::PointingHandCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-hand.png"_L1},
++ {Qt::ForbiddenCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-forbidden.png"_L1},
++ {Qt::OpenHandCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-openhand.png"_L1},
++ {Qt::ClosedHandCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-closedhand.png"_L1},
++ {Qt::WhatsThisCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-whatsthis.png"_L1},
++ {Qt::BusyCursor, ":/qt-project.org/qtpropertybrowser/images/cursor-busy.png"_L1}
++ };
++
++ // A Pixmap icon engine for resource pixmaps that do not have a DPR set.
++ // It sets the DPR on the pixmaps and either scales it down or centers it.
++ class QtPixmapIconEngine : public QtPropertyIconEngine
++ {
++ public:
++ Q_DISABLE_COPY_MOVE(QtPixmapIconEngine)
++
++ explicit QtPixmapIconEngine(QPixmap p) : m_pixmap(std::move(p)) { }
++
++ QIconEngine *clone() const override
++ {
++ return new QtPixmapIconEngine(m_pixmap);
++ }
++
++ void paint(QPainter *painter, const QRect &rect, QIcon::Mode, QIcon::State) override
++ {
++ QPainterStateGuard psg(painter);
++ painter->setRenderHint(QPainter::Antialiasing, true);
++
++ const auto dpr = painter->device()->devicePixelRatioF();
++ m_pixmap.setDevicePixelRatio(dpr);
++ QSize dipSize =
++ qFuzzyCompare(dpr, 1) ? m_pixmap.size() : (QSizeF(m_pixmap.size()) / dpr).toSize();
++ const int dipWidth = dipSize.width();
++ const int dipHeight = dipSize.height();
++ if (dipWidth > rect.width() || dipHeight > rect.height()) {
++ painter->setRenderHint(QPainter::SmoothPixmapTransform);
++ painter->drawPixmap(rect, m_pixmap); // Too big: Let Qt scale down
++ } else {
++ QPoint point = rect.topLeft(); // center if needed
++ if (dipWidth < rect.width())
++ point.rx() += (rect.width() - dipWidth) / 2;
++ if (dipHeight < rect.height())
++ point.ry() += (rect.height() - dipHeight) / 2;
++ painter->drawPixmap(point, m_pixmap);
++ }
++ }
++
++ private:
++ QPixmap m_pixmap;
++ };
++
++ static inline QIcon getResourceCursorIcon(const QString &fn)
++ {
++ return QIcon{new QtPixmapIconEngine(QPixmap(fn))};
++ }
++
++ // Get an icon from the resources of the Windows QPA plugin. No scaling required.
++ [[maybe_unused]] static QIcon getWindowsCursorIcon(QLatin1StringView name)
++ {
++ static constexpr auto root = ":/qt-project.org/windows/cursors/images/"_L1;
++ static constexpr QLatin1StringView suffixes[] = {"_32.png"_L1, "_48.png"_L1, "_64.png"_L1};
++ QIcon result;
++ for (auto suffix : suffixes) {
++ const QString path = root + name + suffix;
++ QPixmap pixmap(path);
++ if (pixmap.isNull())
++ qWarning("%s: Failed to load \"%s\"", __FUNCTION__, qPrintable(path));
++ else
++ result.addPixmap(pixmap);
++ }
++ return result;
++ }
++
++ // Get a (small) icon from the resources of the Cocoa QPA plugin.
++ [[maybe_unused]] static QIcon getCocoaCursorIcon(QLatin1StringView name)
++ {
++ static constexpr auto root = ":/qt-project.org/mac/cursors/images/"_L1;
++ const QString path = root + name;
++ QPixmap pixmap(path);
++ if (pixmap.isNull()) {
++ qWarning("%s: Failed to load \"%s\"", __FUNCTION__, qPrintable(path));
++ return {};
++ }
++ return QIcon{new QtPixmapIconEngine(pixmap)};
++ }
++
++ QtCursorDatabase::QtCursorDatabase()
++ {
++ qAddPostRoutine(clearCursorDatabase);
++
++ if constexpr (QOperatingSystemVersion::currentType() == QOperatingSystemVersion::Windows) {
++ appendCursor(Qt::ClosedHandCursor, getWindowsCursorIcon("closedhandcursor"_L1));
++ appendCursor(Qt::OpenHandCursor, getWindowsCursorIcon("openhandcursor"_L1));
++ appendCursor(Qt::SplitHCursor, getWindowsCursorIcon("splithcursor"_L1));
++ appendCursor(Qt::SplitVCursor, getWindowsCursorIcon("splitvcursor"_L1));
++ }
++
++ if constexpr (QOperatingSystemVersion::currentType() == QOperatingSystemVersion::MacOS) {
++ appendCursor(Qt::BusyCursor, getCocoaCursorIcon("spincursor.png"_L1));
++ appendCursor(Qt::WaitCursor, getCocoaCursorIcon("waitcursor.png"_L1));
++ }
++
++ appendCursor(Qt::BlankCursor, QIcon{});
++
++ for (const auto &cursorResource : cursorResources) {
++ if (!hasCursor(cursorResource.first))
++ appendCursor(cursorResource.first, getResourceCursorIcon(cursorResource.second));
++ }
++ }
++
++ void QtCursorDatabase::clear()
++ {
++ m_cursorNames.clear();
++ m_cursorIcons.clear();
++ m_valueToCursorShape.clear();
++ m_cursorShapeToValue.clear();
++ }
++
++ void QtCursorDatabase::appendCursor(Qt::CursorShape shape, const QIcon &icon)
++ {
++ if (hasCursor(shape) || (shape != Qt::BlankCursor && icon.isNull()))
++ return;
++ const qsizetype value = m_cursorNames.size();
++ const char *name = shapeNames().value(shape, nullptr);
++ m_cursorNames.append(name ? QCoreApplication::translate("QtCursorDatabase", name) : QString{});
++ m_cursorIcons.insert(value, icon);
++ m_valueToCursorShape.insert(value, shape);
++ m_cursorShapeToValue.insert(shape, value);
++ }
++
++ QStringList QtCursorDatabase::cursorShapeNames() const
++ {
++ return m_cursorNames;
++ }
++
++ QMap<int, QIcon> QtCursorDatabase::cursorShapeIcons() const
++ {
++ return m_cursorIcons;
++ }
++
++ QString QtCursorDatabase::cursorToShapeName(const QCursor &cursor) const
++ {
++ int val = cursorToValue(cursor);
++ if (val >= 0)
++ return m_cursorNames.at(val);
++ return {};
++ }
++
++ QIcon QtCursorDatabase::cursorToShapeIcon(const QCursor &cursor) const
++ {
++ int val = cursorToValue(cursor);
++ return m_cursorIcons.value(val);
++ }
++
++ int QtCursorDatabase::cursorToValue(const QCursor &cursor) const
++ {
++ #ifndef QT_NO_CURSOR
++ return m_cursorShapeToValue.value(cursor.shape(), -1);
++ #endif
++ return -1;
++ }
++
++ #ifndef QT_NO_CURSOR
++ QCursor QtCursorDatabase::valueToCursor(int value) const
++ {
++ auto it = m_valueToCursorShape.constFind(value);
++ if (it != m_valueToCursorShape.cend())
++ return QCursor(it.value());
++ return {};
++ }
++ #endif
++
++ Q_GLOBAL_STATIC(QtCursorDatabase, cursorDatabase)
++
++ QtCursorDatabase *QtCursorDatabase::instance()
++ {
++ return cursorDatabase();
++ }
++
++ class QtPropertyBrushValueIconEngine : public QtPropertyIconEngine
++ {
++ public:
++ Q_DISABLE_COPY_MOVE(QtPropertyBrushValueIconEngine)
++
++ explicit QtPropertyBrushValueIconEngine(const QBrush &b) : m_brush(b) { }
++
++ QIconEngine *clone() const override
++ {
++ return new QtPropertyBrushValueIconEngine(m_brush);
++ }
++
++ void paint(QPainter *painter, const QRect &rect, QIcon::Mode, QIcon::State) override
++ {
++ QPainterStateGuard psg(painter);
++ painter->setCompositionMode(QPainter::CompositionMode_Source);
++ painter->fillRect(rect, m_brush);
++ QColor color = m_brush.color();
++ if (color.alpha() != 255) { // indicate alpha by an inset
++ QBrush opaqueBrush = m_brush;
++ color.setAlpha(255);
++ opaqueBrush.setColor(color);
++ const QPoint offset{rect.width() / 4, rect.height() / 4};
++ const QRect inset{rect.topLeft() + offset, rect.size() / 2};
++ painter->fillRect(inset, opaqueBrush);
++ }
++ }
++
++ private:
++ QBrush m_brush;
++ };
++
++ QPixmap QtPropertyBrowserUtils::brushValuePixmap(const QBrush &b, const QSize &size,
++ qreal devicePixelRatio)
++ {
++ QtPropertyBrushValueIconEngine engine(b);
++ return engine.drawPixmap(size, devicePixelRatio);
++ }
++
++ QIcon QtPropertyBrowserUtils::brushValueIcon(const QBrush &b)
++ {
++ return QIcon(new QtPropertyBrushValueIconEngine(b));
++ }
++
++ QString QtPropertyBrowserUtils::colorValueText(QColor c)
++ {
++ return QCoreApplication::translate("QtPropertyBrowserUtils", "[%1, %2, %3] (%4)")
++ .arg(c.red()).arg(c.green()).arg(c.blue()).arg(c.alpha());
++ }
++
++ class QtPropertyFontValueIconEngine : public QtPropertyIconEngine
++ {
++ public:
++ Q_DISABLE_COPY_MOVE(QtPropertyFontValueIconEngine)
++
++ explicit QtPropertyFontValueIconEngine(const QFont &f) : m_font(f) { }
++
++ QIconEngine *clone() const override
++ {
++ return new QtPropertyFontValueIconEngine(m_font);
++ }
++
++ void paint(QPainter *painter, const QRect &rect, QIcon::Mode, QIcon::State) override
++ {
++ QPainterStateGuard psg(painter);
++ const auto maxDimension = qMax(rect.width(), rect.height());
++ m_font.setPointSize(maxDimension - 3);
++ painter->setPen(QPen(Qt::black));
++ painter->setFont(m_font);
++ painter->setRenderHint(QPainter::TextAntialiasing, true);
++ painter->setRenderHint(QPainter::Antialiasing, true);
++ painter->drawText(rect, QString(u'A'), QTextOption(Qt::AlignCenter));
++ }
++
++ private:
++ QFont m_font;
++ };
++
++ QPixmap QtPropertyBrowserUtils::fontValuePixmap(const QFont &font, const QSize &size,
++ qreal devicePixelRatio)
++ {
++ QtPropertyFontValueIconEngine engine(font);
++ return engine.drawPixmap(size, devicePixelRatio);
++ }
++
++ QIcon QtPropertyBrowserUtils::fontValueIcon(const QFont &f)
++ {
++ return QIcon(new QtPropertyFontValueIconEngine(f));
++ }
++
++ QString QtPropertyBrowserUtils::fontValueText(const QFont &f)
++ {
++ return QCoreApplication::translate("QtPropertyBrowserUtils", "[%1, %2]")
++ .arg(f.family()).arg(f.pointSize());
++ }
++
++ QString QtPropertyBrowserUtils::dateFormat()
++ {
++ QLocale loc;
++ QString format = loc.dateFormat(QLocale::ShortFormat);
++ // Change dd.MM.yy, MM/dd/yy to 4 digit years
++ if (format.count(QLatin1Char('y')) == 2)
++ format.insert(format.indexOf(QLatin1Char('y')), "yy"_L1);
++ return format;
++ }
++
++ QString QtPropertyBrowserUtils::timeFormat()
++ {
++ QLocale loc;
++ // ShortFormat is missing seconds on UNIX.
++ return loc.timeFormat(QLocale::LongFormat);
++ }
++
++ QString QtPropertyBrowserUtils::dateTimeFormat()
++ {
++ QString format = dateFormat();
++ format += QLatin1Char(' ');
++ format += timeFormat();
++ return format;
++ }
++
++ QtBoolEdit::QtBoolEdit(QWidget *parent) :
++ QWidget(parent),
++ m_checkBox(new QCheckBox(this)),
++ m_textVisible(true)
++ {
++ auto *lt = new QHBoxLayout;
++ if (QApplication::layoutDirection() == Qt::LeftToRight)
++ lt->setContentsMargins(4, 0, 0, 0);
++ else
++ lt->setContentsMargins(0, 0, 4, 0);
++ lt->addWidget(m_checkBox);
++ setLayout(lt);
++ connect(m_checkBox, &QAbstractButton::toggled, this, &QtBoolEdit::toggled);
++ setFocusProxy(m_checkBox);
++ m_checkBox->setText(tr("True"));
++ }
++
++ void QtBoolEdit::setTextVisible(bool textVisible)
++ {
++ if (m_textVisible == textVisible)
++ return;
++
++ m_textVisible = textVisible;
++ if (m_textVisible)
++ m_checkBox->setText(isChecked() ? tr("True") : tr("False"));
++ else
++ m_checkBox->setText(QString());
++ }
++
++ Qt::CheckState QtBoolEdit::checkState() const
++ {
++ return m_checkBox->checkState();
++ }
++
++ void QtBoolEdit::setCheckState(Qt::CheckState state)
++ {
++ m_checkBox->setCheckState(state);
++ }
++
++ bool QtBoolEdit::isChecked() const
++ {
++ return m_checkBox->isChecked();
++ }
++
++ void QtBoolEdit::setChecked(bool c)
++ {
++ m_checkBox->setChecked(c);
++ if (!m_textVisible)
++ return;
++ m_checkBox->setText(isChecked() ? tr("True") : tr("False"));
++ }
++
++ bool QtBoolEdit::blockCheckBoxSignals(bool block)
++ {
++ return m_checkBox->blockSignals(block);
++ }
++
++ void QtBoolEdit::mousePressEvent(QMouseEvent *event)
++ {
++ if (event->buttons() == Qt::LeftButton) {
++ m_checkBox->click();
++ event->accept();
++ } else {
++ QWidget::mousePressEvent(event);
++ }
++ }
++
++ QPixmap QtPropertyIconEngine::createEmptyPixmap(const QSize &size, qreal devicePixelRatio)
++ {
++ QPixmap result(size * devicePixelRatio);
++ result.fill(Qt::transparent);
++ result.setDevicePixelRatio(devicePixelRatio);
++ return result;
++ }
++
++ QtPropertyIconEngine::QtPropertyIconEngine() = default;
++
++ // ### FIXME Qt 7: Remove? (reimplemented in Qt 6 since the default
++ // cannot be trusted to handle fractional dpr).
++ QPixmap QtPropertyIconEngine::scaledPixmap(const QSize &size, QIcon::Mode mode, QIcon::State state,
++ qreal scale)
++ {
++ QPixmap result = createEmptyPixmap(size, scale);
++ QPainter painter(&result);
++ paint(&painter, QRect(0, 0, size.width(), size.height()), mode, state);
++ painter.end();
++ return result;
++ }
++
++ QPixmap QtPropertyIconEngine::drawPixmap(const QSize &size, qreal devicePixelRatio)
++ {
++ return scaledPixmap(size, QIcon::Mode::Normal, QIcon::State::On, devicePixelRatio);
++ }
++
++ QT_END_NAMESPACE