Revision control
Copy as Markdown
// 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
#ifndef QHIGHDPISCALING_P_H
#define QHIGHDPISCALING_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtGui/private/qtguiglobal_p.h>
#include <QtCore/qlist.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmargins.h>
#include <QtCore/qmath.h>
#include <QtCore/qrect.h>
#include <QtGui/qregion.h>
#include <QtGui/qscreen.h>
#include <QtGui/qvector2d.h>
#include <QtGui/qwindow.h>
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(lcHighDpi);
class QScreen;
class QPlatformScreen;
typedef std::pair<qreal, qreal> QDpi;
#ifndef QT_NO_HIGHDPISCALING
class Q_GUI_EXPORT QHighDpiScaling {
Q_GADGET
public:
enum class DpiAdjustmentPolicy {
Unset,
Enabled,
Disabled,
UpOnly
};
Q_ENUM(DpiAdjustmentPolicy)
QHighDpiScaling() = delete;
~QHighDpiScaling() = delete;
QHighDpiScaling(const QHighDpiScaling &) = delete;
QHighDpiScaling &operator=(const QHighDpiScaling &) = delete;
QHighDpiScaling(QHighDpiScaling &&) = delete;
QHighDpiScaling &operator=(QHighDpiScaling &&) = delete;
static void initHighDpiScaling();
static void updateHighDpiScaling();
static void setGlobalFactor(qreal factor);
static void setScreenFactor(QScreen *screen, qreal factor);
static bool isActive() { return m_active; }
struct Point {
enum Kind {
Invalid,
DeviceIndependent,
Native
};
Kind kind;
QPoint point;
};
struct ScaleAndOrigin
{
qreal factor;
QPoint origin;
};
static ScaleAndOrigin scaleAndOrigin(const QPlatformScreen *platformScreen, Point position = Point{ Point::Invalid, QPoint() });
static ScaleAndOrigin scaleAndOrigin(const QScreen *screen, Point position = Point{ Point::Invalid, QPoint() });
static ScaleAndOrigin scaleAndOrigin(const QWindow *platformScreen, Point position = Point{ Point::Invalid, QPoint() });
template<typename C>
static qreal factor(C *context) {
return scaleAndOrigin(context).factor;
}
static QPoint mapPositionFromNative(const QPoint &pos, const QPlatformScreen *platformScreen);
static QPoint mapPositionToNative(const QPoint &pos, const QPlatformScreen *platformScreen);
static QDpi logicalDpi(const QScreen *screen);
static qreal roundScaleFactor(qreal rawFactor);
private:
struct ScreenFactor {
ScreenFactor(QString name, qreal factor)
:name(name), factor(factor) { }
QString name;
qreal factor;
};
static qreal rawScaleFactor(const QPlatformScreen *screen);
static QDpi effectiveLogicalDpi(const QPlatformScreen *screen, qreal rawFactor, qreal roundedFactor);
static qreal screenSubfactor(const QPlatformScreen *screen);
static QScreen *screenForPosition(Point position, QScreen *guess);
static QList<QHighDpiScaling::ScreenFactor> parseScreenScaleFactorsSpec(QStringView screenScaleFactors);
static qreal m_factor;
static bool m_active;
static bool m_usePlatformPluginDpi;
static bool m_platformPluginDpiScalingActive;
static bool m_globalScalingActive;
static bool m_screenFactorSet;
static bool m_usePhysicalDpi;
static QVector<ScreenFactor> m_screenFactors;
static DpiAdjustmentPolicy m_dpiAdjustmentPolicy;
static QHash<QString, qreal> m_namedScreenScaleFactors;
#ifndef QT_NO_DEBUG_STREAM
friend Q_GUI_EXPORT QDebug operator<<(QDebug, const ScreenFactor &);
#endif
};
namespace QHighDpi {
inline qreal scale(qreal value, qreal scaleFactor, QPointF /* origin */ = QPointF(0, 0))
{
return value * scaleFactor;
}
inline QSize scale(const QSize &value, qreal scaleFactor, QPointF /* origin */ = QPointF(0, 0))
{
return value * scaleFactor;
}
inline QSizeF scale(const QSizeF &value, qreal scaleFactor, QPointF /* origin */ = QPointF(0, 0))
{
return value * scaleFactor;
}
inline QVector2D scale(const QVector2D &value, qreal scaleFactor, QPointF /* origin */ = QPointF(0, 0))
{
return value * float(scaleFactor);
}
inline QPointF scale(const QPointF &pos, qreal scaleFactor, QPointF origin = QPointF(0, 0))
{
return (pos - origin) * scaleFactor + origin;
}
inline QPoint scale(const QPoint &pos, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
return (pos - origin) * scaleFactor + origin;
}
inline QRect scale(const QRect &rect, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
return QRect(scale(rect.topLeft(), scaleFactor, origin), scale(rect.size(), scaleFactor));
}
inline QRectF scale(const QRectF &rect, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
return QRectF(scale(rect.topLeft(), scaleFactor, origin), scale(rect.size(), scaleFactor));
}
inline QMargins scale(const QMargins &margins, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
Q_UNUSED(origin);
return QMargins(qRound(qreal(margins.left()) * scaleFactor), qRound(qreal(margins.top()) * scaleFactor),
qRound(qreal(margins.right()) * scaleFactor), qRound(qreal(margins.bottom()) * scaleFactor));
}
template<typename T>
QList<T> scale(const QList<T> &list, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
if (qFuzzyCompare(scaleFactor, qreal(1)))
return list;
QList<T> scaled;
scaled.reserve(list.size());
for (const T &item : list)
scaled.append(scale(item, scaleFactor, origin));
return scaled;
}
inline QRegion scale(const QRegion ®ion, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
if (qFuzzyCompare(scaleFactor, qreal(1)))
return region;
QRegion scaled = region.translated(-origin);
scaled = QTransform::fromScale(scaleFactor, scaleFactor).map(scaled);
return scaled.translated(origin);
}
template <typename T>
inline QHighDpiScaling::Point position(T, QHighDpiScaling::Point::Kind) {
return QHighDpiScaling::Point{ QHighDpiScaling::Point::Invalid, QPoint() };
}
inline QHighDpiScaling::Point position(QPoint point, QHighDpiScaling::Point::Kind kind) {
return QHighDpiScaling::Point{ kind, point };
}
inline QHighDpiScaling::Point position(QPointF point, QHighDpiScaling::Point::Kind kind) {
return QHighDpiScaling::Point{ kind, point.toPoint() };
}
inline QHighDpiScaling::Point position(QRect rect, QHighDpiScaling::Point::Kind kind) {
return QHighDpiScaling::Point{ kind, rect.topLeft() };
}
inline QHighDpiScaling::Point position(QRectF rect, QHighDpiScaling::Point::Kind kind) {
return QHighDpiScaling::Point{ kind, rect.topLeft().toPoint() };
}
template <typename T, typename C>
T fromNativePixels(const T &value, const C *context)
{
QHighDpiScaling::ScaleAndOrigin so = QHighDpiScaling::scaleAndOrigin(context);
return scale(value, qreal(1) / so.factor, so.origin);
}
template <typename T, typename C>
T toNativePixels(const T &value, const C *context)
{
QHighDpiScaling::ScaleAndOrigin so = QHighDpiScaling::scaleAndOrigin(context);
return scale(value, so.factor, so.origin);
}
template <typename T, typename C>
T fromNativeLocalPosition(const T &value, const C *context)
{
return scale(value, qreal(1) / QHighDpiScaling::factor(context));
}
template <typename T, typename C>
T toNativeLocalPosition(const T &value, const C *context)
{
return scale(value, QHighDpiScaling::factor(context));
}
template <typename T, typename C>
T fromNativeGlobalPosition(const T &value, const C *context)
{
QHighDpiScaling::ScaleAndOrigin so =
QHighDpiScaling::scaleAndOrigin(context, position(value, QHighDpiScaling::Point::Native));
return scale(value, qreal(1) / so.factor, so.origin);
}
template <typename T, typename C>
T toNativeGlobalPosition(const T &value, const C *context)
{
QHighDpiScaling::ScaleAndOrigin so =
QHighDpiScaling::scaleAndOrigin(context, position(value, QHighDpiScaling::Point::DeviceIndependent));
return scale(value, so.factor, so.origin);
}
template <typename T>
T fromNativeWindowGeometry(const T &value, const QWindow *context)
{
QHighDpiScaling::ScaleAndOrigin so = QHighDpiScaling::scaleAndOrigin(context);
QPoint effectiveOrigin = (context && context->isTopLevel()) ? so.origin : QPoint(0,0);
return scale(value, qreal(1) / so.factor, effectiveOrigin);
}
template <typename T>
T toNativeWindowGeometry(const T &value, const QWindow *context)
{
QHighDpiScaling::ScaleAndOrigin so = QHighDpiScaling::scaleAndOrigin(context);
QPoint effectiveOrigin = (context && context->isTopLevel()) ? so.origin : QPoint(0,0);
return scale(value, so.factor, effectiveOrigin);
}
template <typename T>
inline T fromNative(const T &value, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
return scale(value, qreal(1) / scaleFactor, origin);
}
template <typename T>
inline T toNative(const T &value, qreal scaleFactor, QPoint origin = QPoint(0, 0))
{
return scale(value, scaleFactor, origin);
}
inline QRect fromNative(const QRect &rect, const QScreen *screen, const QPoint &screenOrigin)
{
return scale(rect, qreal(1) / QHighDpiScaling::factor(screen), screenOrigin);
}
inline QRect fromNativeScreenGeometry(const QRect &nativeScreenGeometry, const QScreen *screen)
{
return QRect(nativeScreenGeometry.topLeft(),
scale(nativeScreenGeometry.size(), qreal(1) / QHighDpiScaling::factor(screen)));
}
inline QRegion fromNativeLocalRegion(const QRegion &pixelRegion, const QWindow *window)
{
return scale(pixelRegion, qreal(1) / QHighDpiScaling::factor(window));
}
// When mapping expose events to Qt rects: round top/left towards the origin and
// bottom/right away from the origin, making sure that we cover the whole window.
inline QRegion fromNativeLocalExposedRegion(const QRegion &pixelRegion, const QWindow *window)
{
if (!QHighDpiScaling::isActive())
return pixelRegion;
const qreal scaleFactor = QHighDpiScaling::factor(window);
QRegion pointRegion;
for (const QRectF rect: pixelRegion)
pointRegion += QRectF(rect.topLeft() / scaleFactor, rect.size() / scaleFactor).toAlignedRect();
return pointRegion;
}
inline QRegion toNativeLocalRegion(const QRegion &pointRegion, const QWindow *window)
{
return scale(pointRegion, QHighDpiScaling::factor(window));
}
} // namespace QHighDpi
#else // QT_NO_HIGHDPISCALING
class Q_GUI_EXPORT QHighDpiScaling {
public:
static inline void initHighDpiScaling() {}
static inline void updateHighDpiScaling() {}
static inline void setGlobalFactor(qreal) {}
static inline void setScreenFactor(QScreen *, qreal) {}
struct ScaleAndOrigin
{
qreal factor;
QPoint origin;
};
static ScaleAndOrigin scaleAndOrigin(const QPlatformScreen *platformScreen, QPoint *nativePosition = nullptr);
static ScaleAndOrigin scaleAndOrigin(const QScreen *screen, QPoint *nativePosition = nullptr);
static ScaleAndOrigin scaleAndOrigin(const QWindow *platformScreen, QPoint *nativePosition = nullptr);
static inline bool isActive() { return false; }
static inline qreal factor(const QWindow *) { return 1.0; }
static inline qreal factor(const QScreen *) { return 1.0; }
static inline qreal factor(const QPlatformScreen *) { return 1.0; }
static inline QPoint origin(const QScreen *) { return QPoint(); }
static inline QPoint origin(const QPlatformScreen *) { return QPoint(); }
static inline QPoint mapPositionFromNative(const QPoint &pos, const QPlatformScreen *) { return pos; }
static inline QPoint mapPositionToNative(const QPoint &pos, const QPlatformScreen *) { return pos; }
static inline QPointF mapPositionToGlobal(const QPointF &pos, const QPoint &, const QWindow *) { return pos; }
static inline QPointF mapPositionFromGlobal(const QPointF &pos, const QPoint &, const QWindow *) { return pos; }
static inline QDpi logicalDpi(const QScreen *) { return QDpi(-1,-1); }
static inline qreal roundScaleFactor(qreal) { return 1.0; }
};
namespace QHighDpi {
template <typename T> inline
T scale(const T &value, ...) { return value; }
template <typename T> inline
T toNative(const T &value, ...) { return value; }
template <typename T> inline
T fromNative(const T &value, ...) { return value; }
template <typename T> inline
T fromNativeLocalPosition(const T &value, ...) { return value; }
template <typename T> inline
T toNativeLocalPosition(const T &value, ...) { return value; }
template <typename T, typename C> inline
T fromNativeGlobalPosition(const T &value, const C *) { return value; }
template <typename T, typename C> inline
T toNativeGlobalPosition(const T &value, const C *) { return value; }
template <typename T, typename C> inline
T fromNativeWindowGeometry(const T &value, const C *) { return value; }
template <typename T, typename C> inline
T toNativeWindowGeometry(const T &value, const C *) { return value; }
template <typename T> inline
T fromNativeLocalRegion(const T &value, ...) { return value; }
template <typename T> inline
T fromNativeLocalExposedRegion(const T &value, ...) { return value; }
template <typename T> inline
T toNativeLocalRegion(const T &value, ...) { return value; }
template <typename T> inline
T fromNativeScreenGeometry(const T &value, ...) { return value; }
template <typename T, typename U> inline
T toNativePixels(const T &value, const U*) {return value;}
template <typename T, typename U> inline
T fromNativePixels(const T &value, const U*) {return value;}
}
#endif // QT_NO_HIGHDPISCALING
QT_END_NAMESPACE
#endif // QHIGHDPISCALING_P_H