qt 6.5.1 original

tests/auto/shared/highdpi.h

@@ -0,0 +1,84 @@
+// Copyright (C) 2019 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef HIGHDPI_H
+#define HIGHDPI_H
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qpoint.h>
+#include <QtCore/qrect.h>
+#include <QtCore/qsize.h>
+
+// Helpers for comparing geometries a that may go through scaling in the
+// platform plugin with fuzz (pass rounded-down device pixel ratios or
+// scaling factors). Error message for use with QVERIFY2() are also provided.
+
+class HighDpi
+{
+public:
+    HighDpi() = delete;
+    HighDpi(const HighDpi &) = delete;
+    HighDpi &operator=(const HighDpi &) = delete;
+    HighDpi(HighDpi &&) = delete;
+    HighDpi &operator=(HighDpi &&) = delete;
+    ~HighDpi() = delete;
+
+    static int manhattanDelta(const QPoint &p1, const QPoint p2)
+    {
+        return (p1 - p2).manhattanLength();
+    }
+
+    static bool fuzzyCompare(const QPoint &p1, const QPoint p2, int fuzz)
+    {
+        return manhattanDelta(p1, p2) <= fuzz;
+    }
+
+    static QByteArray msgPointMismatch(const QPoint &p1, const QPoint p2)
+    {
+        return QByteArray::number(p1.x()) + ',' + QByteArray::number(p1.y())
+                + " != " + QByteArray::number(p2.x()) + ',' + QByteArray::number(p2.y())
+                + ", manhattanLength=" + QByteArray::number(manhattanDelta(p1, p2));
+    }
+
+    // Compare a size that may go through scaling in the platform plugin with fuzz.
+
+    static inline int manhattanDelta(const QSize &s1, const QSize &s2)
+    {
+        return qAbs(s1.width() - s2.width()) + qAbs(s1.height() - s2.height());
+    }
+
+    static inline bool fuzzyCompare(const QSize &s1, const QSize &s2, int fuzz)
+    {
+        return manhattanDelta(s1, s2) <= fuzz;
+    }
+
+    static QByteArray msgSizeMismatch(const QSize &s1, const QSize &s2)
+    {
+        return QByteArray::number(s1.width()) + 'x' + QByteArray::number(s1.height())
+                + " != " + QByteArray::number(s2.width()) + 'x' + QByteArray::number(s2.height())
+                + ", manhattanLength=" + QByteArray::number(manhattanDelta(s1, s2));
+    }
+
+    // Compare a geometry that may go through scaling in the platform plugin with fuzz.
+
+    static inline bool fuzzyCompare(const QRect &r1, const QRect &r2, int fuzz)
+    {
+        return manhattanDelta(r1.topLeft(), r2.topLeft()) <= fuzz
+                && manhattanDelta(r1.size(), r2.size()) <= fuzz;
+    }
+
+    static QByteArray msgRectMismatch(const QRect &r1, const QRect &r2)
+    {
+        return formatRect(r1) + " != " + formatRect(r2);
+    }
+
+private:
+    static QByteArray formatRect(const QRect &r)
+    {
+        return QByteArray::number(r.width()) + 'x' + QByteArray::number(r.height())
+                + (r.left() < 0 ? '-' : '+') + QByteArray::number(r.left())
+                + (r.top() < 0 ? '-' : '+') + QByteArray::number(r.top());
+    }
+};
+
+#endif // HIGHDPI_H

tests/auto/shared/platformclipboard.h

@@ -0,0 +1,21 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#ifndef PLATFORMCLIPBOARD_H
+#define PLATFORMCLIPBOARD_H
+
+#include <qglobal.h>
+
+struct PlatformClipboard
+{
+    static inline bool isAvailable()
+    {
+#if defined(QT_NO_CLIPBOARD)
+        return false;
+#else
+        return true;
+#endif
+    }
+};
+
+#endif // PLATFORMCLIPBOARD_H

tests/auto/shared/platforminputcontext.h

@@ -0,0 +1,100 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <qpa/qplatforminputcontext.h>
+
+class PlatformInputContext : public QPlatformInputContext
+{
+public:
+    PlatformInputContext() :
+        m_animating(false),
+        m_visible(false),
+        m_updateCallCount(0),
+        m_resetCallCount(0),
+        m_commitCallCount(0),
+        m_localeCallCount(0),
+        m_inputDirectionCallCount(0),
+        m_lastQueries(Qt::ImhNone),
+        m_action(QInputMethod::Click),
+        m_cursorPosition(0),
+        m_lastEventType(QEvent::None),
+        m_setFocusObjectCallCount(0)
+    {}
+
+    virtual QRectF keyboardRect() const override { return m_keyboardRect; }
+    virtual bool isAnimating() const override { return m_animating; }
+    virtual void reset() override { m_resetCallCount++; }
+    virtual void commit() override
+    {
+        m_commitCallCount++;
+        if (m_commitString.isEmpty())
+            return;
+        QInputMethodEvent commitEvent;
+        commitEvent.setCommitString(m_commitString);
+        if (qGuiApp->focusObject())
+            qGuiApp->sendEvent(qGuiApp->focusObject(), &commitEvent);
+        else
+            qWarning("Test input context to commit without focused object");
+    }
+    void setCommitString(const QString &commitString)
+    {
+        m_commitString = commitString;
+    }
+
+    virtual void update(Qt::InputMethodQueries queries) override
+    {
+        m_updateCallCount++;
+        m_lastQueries = queries;
+    }
+    virtual void invokeAction(QInputMethod::Action action, int cursorPosition) override
+    {
+        m_action = action;
+        m_cursorPosition = cursorPosition;
+    }
+    virtual bool filterEvent(const QEvent *event) override
+    {
+        m_lastEventType = event->type(); return false;
+    }
+    virtual void showInputPanel() override
+    {
+        m_visible = true;
+    }
+    virtual void hideInputPanel() override
+    {
+        m_visible = false;
+    }
+    virtual bool isInputPanelVisible() const override
+    {
+        return m_visible;
+    }
+    virtual QLocale locale() const override
+    {
+        m_localeCallCount++;
+        return QLocale::c();
+    }
+    virtual Qt::LayoutDirection inputDirection() const override
+    {
+        m_inputDirectionCallCount++;
+        return Qt::LeftToRight;
+    }
+    virtual void setFocusObject(QObject *object) override
+    {
+        Q_UNUSED(object);
+        m_setFocusObjectCallCount++;
+    }
+
+    bool m_animating;
+    bool m_visible;
+    int m_updateCallCount;
+    int m_resetCallCount;
+    int m_commitCallCount;
+    QString m_commitString;
+    mutable int m_localeCallCount;
+    mutable int m_inputDirectionCallCount;
+    Qt::InputMethodQueries m_lastQueries;
+    QInputMethod::Action m_action;
+    int m_cursorPosition;
+    int m_lastEventType;
+    QRectF m_keyboardRect;
+    int m_setFocusObjectCallCount;
+};