chore: support Qt6.8

from qt6-base_6.8.0+dfsg.orig.tar.gz

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/qxcbglintegration.h

@@ -0,0 +1,41 @@
+// 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
+
+#ifndef QXCBGLINTEGRATION_H
+
+#include "qxcbexport.h"
+#include "qxcbwindow.h"
+
+#include <QtCore/QLoggingCategory>
+
+QT_BEGIN_NAMESPACE
+
+class QPlatformOffscreenSurface;
+class QOffscreenSurface;
+class QXcbNativeInterfaceHandler;
+
+Q_DECLARE_EXPORTED_LOGGING_CATEGORY(lcQpaGl, Q_XCB_EXPORT)
+
+class Q_XCB_EXPORT QXcbGlIntegration
+{
+public:
+    QXcbGlIntegration();
+    virtual ~QXcbGlIntegration();
+    virtual bool initialize(QXcbConnection *connection) = 0;
+
+    virtual bool supportsThreadedOpenGL() const { return false; }
+    virtual bool supportsSwitchableWidgetComposition()  const { return true; }
+    virtual bool handleXcbEvent(xcb_generic_event_t *event, uint responseType);
+
+    virtual QXcbWindow *createWindow(QWindow *window) const = 0;
+#ifndef QT_NO_OPENGL
+    virtual QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const = 0;
+#endif
+    virtual QPlatformOffscreenSurface *createPlatformOffscreenSurface(QOffscreenSurface *surface) const = 0;
+
+    virtual QXcbNativeInterfaceHandler *nativeInterfaceHandler() const  { return nullptr; }
+};
+
+QT_END_NAMESPACE
+
+#endif //QXCBGLINTEGRATION_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/qxcbglintegrationfactory.h

@@ -0,0 +1,22 @@
+// 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
+
+#ifndef QXCBGLINTEGRATIONFACTORY_H
+#define QXCBGLINTEGRATIONFACTORY_H
+
+#include <QtCore/qstringlist.h>
+
+QT_BEGIN_NAMESPACE
+
+class QXcbGlIntegration;
+
+class QXcbGlIntegrationFactory
+{
+public:
+    static QXcbGlIntegration *create(const QString &name);
+};
+
+QT_END_NAMESPACE
+
+#endif //QXCBGLINTEGRATIONFACTORY_H
+

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/qxcbglintegrationplugin.h

@@ -0,0 +1,32 @@
+// 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
+
+#ifndef QXCBGLINTEGRATIONPLUGIN_H
+#define QXCBGLINTEGRATIONPLUGIN_H
+
+#include "qxcbexport.h"
+#include <QtCore/qplugin.h>
+#include <QtCore/qfactoryinterface.h>
+
+QT_BEGIN_NAMESPACE
+
+#define QXcbGlIntegrationFactoryInterface_iid "org.qt-project.Qt.QPA.Xcb.QXcbGlIntegrationFactoryInterface.5.5"
+
+class QXcbGlIntegration;
+
+class Q_XCB_EXPORT QXcbGlIntegrationPlugin : public QObject
+{
+    Q_OBJECT
+public:
+        explicit QXcbGlIntegrationPlugin(QObject *parent = nullptr)
+            : QObject(parent)
+        { }
+
+        virtual QXcbGlIntegration *create() = 0;
+    // the pattern expected by qLoadPlugin calls for a QString argument.
+    // we don't need it, so don't bother subclasses with it:
+    QXcbGlIntegration *create(const QString &) { return create(); }
+};
+QT_END_NAMESPACE
+
+#endif //QXCBGLINTEGRATIONPLUGIN_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/qxcbnativeinterfacehandler.h

@@ -0,0 +1,34 @@
+// 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
+
+#ifndef QXCBNATIVEINTERFACEHANDLER_H
+#define QXCBNATIVEINTERFACEHANDLER_H
+
+#include <QtCore/QByteArray>
+#include <QtGui/qpa/qplatformnativeinterface.h>
+
+#include "qxcbexport.h"
+
+QT_BEGIN_NAMESPACE
+
+class QXcbNativeInterface;
+class Q_XCB_EXPORT QXcbNativeInterfaceHandler
+{
+public:
+    QXcbNativeInterfaceHandler(QXcbNativeInterface *nativeInterface);
+    virtual ~QXcbNativeInterfaceHandler();
+
+    virtual QPlatformNativeInterface::NativeResourceForIntegrationFunction nativeResourceFunctionForIntegration(const QByteArray &resource) const;
+    virtual QPlatformNativeInterface::NativeResourceForContextFunction nativeResourceFunctionForContext(const QByteArray &resource) const;
+    virtual QPlatformNativeInterface::NativeResourceForScreenFunction nativeResourceFunctionForScreen(const QByteArray &resource) const;
+    virtual QPlatformNativeInterface::NativeResourceForWindowFunction nativeResourceFunctionForWindow(const QByteArray &resource) const;
+    virtual QPlatformNativeInterface::NativeResourceForBackingStoreFunction nativeResourceFunctionForBackingStore(const QByteArray &resource) const;
+
+    virtual QFunctionPointer platformFunction(const QByteArray &function) const;
+protected:
+    QXcbNativeInterface *m_native_interface;
+};
+
+QT_END_NAMESPACE
+
+#endif //QXCBNATIVEINTERFACEHANDLER_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/xcb_egl/qxcbeglcontext.h

@@ -0,0 +1,56 @@
+// 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
+
+#ifndef QXCBEGLCONTEXT_H
+#define QXCBEGLCONTEXT_H
+
+#include "qxcbeglwindow.h"
+#include <QtGui/private/qeglplatformcontext_p.h>
+#include <QtGui/private/qeglpbuffer_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QXcbEglContext : public QEGLPlatformContext
+{
+public:
+    using QEGLPlatformContext::QEGLPlatformContext;
+    QXcbEglContext(const QSurfaceFormat &glFormat, QPlatformOpenGLContext *share, EGLDisplay display)
+        : QEGLPlatformContext(glFormat, share, display, nullptr)
+    {
+    }
+
+    void swapBuffers(QPlatformSurface *surface) override
+    {
+        QEGLPlatformContext::swapBuffers(surface);
+        if (surface->surface()->surfaceClass() == QSurface::Window) {
+            QXcbWindow *platformWindow = static_cast<QXcbWindow *>(surface);
+            // OpenGL context might be bound to a non-gui thread use QueuedConnection to sync
+            // the window from the platformWindow's thread as QXcbWindow is no QObject, an
+            // event is sent to QXcbConnection. (this is faster than a metacall)
+            if (platformWindow->needsSync())
+                platformWindow->postSyncWindowRequest();
+        }
+    }
+
+    bool makeCurrent(QPlatformSurface *surface) override
+    {
+        return QEGLPlatformContext::makeCurrent(surface);
+    }
+
+    void doneCurrent() override
+    {
+        QEGLPlatformContext::doneCurrent();
+    }
+
+    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) override
+    {
+        if (surface->surface()->surfaceClass() == QSurface::Window)
+            return static_cast<QXcbEglWindow *>(surface)->eglSurface();
+        else
+            return static_cast<QEGLPbuffer *>(surface)->pbuffer();
+    }
+};
+
+QT_END_NAMESPACE
+#endif //QXCBEGLCONTEXT_H
+

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/xcb_egl/qxcbeglinclude.h

@@ -0,0 +1,18 @@
+// 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
+
+#ifndef QXCBINCLUDE_H
+#define QXCBINCLUDE_H
+
+#include <QtGui/QPalette>
+#include <QtCore/QTextStream>
+#include <QtGui/private/qmath_p.h>
+#include <QtGui/private/qtextengine_p.h>
+
+#include <QtGui/private/qt_egl_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QT_END_NAMESPACE
+
+#endif //QXCBINCLUDE_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/xcb_egl/qxcbeglintegration.h

@@ -0,0 +1,54 @@
+// 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
+
+#ifndef QXCBEGLINTEGRATION_H
+#define QXCBEGLINTEGRATION_H
+
+#include "qxcbglintegration.h"
+
+#include "qxcbeglwindow.h"
+
+#include <QtGui/QOpenGLContext>
+#include <qpa/qplatformopenglcontext.h>
+#include <QtGui/qpa/qplatformscreen.h>
+#include <QtGui/QScreen>
+
+#include "qxcbscreen.h"
+
+#include "qxcbeglinclude.h"
+
+QT_BEGIN_NAMESPACE
+
+class QXcbEglNativeInterfaceHandler;
+
+class QXcbEglIntegration : public QXcbGlIntegration
+                         , public QNativeInterface::Private::QEGLIntegration
+{
+public:
+    QXcbEglIntegration();
+    ~QXcbEglIntegration();
+
+    bool initialize(QXcbConnection *connection) override;
+
+    QXcbWindow *createWindow(QWindow *window) const override;
+    QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const override;
+    QOpenGLContext *createOpenGLContext(EGLContext context, EGLDisplay display, QOpenGLContext *shareContext) const override;
+    QPlatformOffscreenSurface *createPlatformOffscreenSurface(QOffscreenSurface *surface) const override;
+
+    bool supportsThreadedOpenGL() const override { return true; }
+
+    EGLDisplay eglDisplay() const { return m_egl_display; }
+
+    bool usingPlatformDisplay() const { return m_using_platform_display; }
+
+    xcb_visualid_t getCompatibleVisualId(xcb_screen_t *screen, EGLConfig config) const;
+private:
+    QXcbConnection *m_connection;
+    EGLDisplay m_egl_display;
+    bool m_using_platform_display;
+
+    QScopedPointer<QXcbEglNativeInterfaceHandler> m_native_interface_handler;
+};
+
+QT_END_NAMESPACE
+#endif //QXCBEGLINTEGRATION_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/xcb_egl/qxcbeglnativeinterfacehandler.h

@@ -0,0 +1,34 @@
+// 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
+
+#ifndef QXCBEGLNATIVEINTERFACEHANDLER_H
+#define QXCBEGLNATIVEINTERFACEHANDLER_H
+
+#include "qxcbnativeinterfacehandler.h"
+
+QT_BEGIN_NAMESPACE
+
+class QXcbEglNativeInterfaceHandler : public QXcbNativeInterfaceHandler
+{
+public:
+    enum ResourceType {
+        EglDisplay,
+        EglContext,
+        EglConfig
+    };
+
+    QXcbEglNativeInterfaceHandler(QXcbNativeInterface *nativeInterface);
+
+    QPlatformNativeInterface::NativeResourceForIntegrationFunction nativeResourceFunctionForIntegration(const QByteArray &resource) const override;
+    QPlatformNativeInterface::NativeResourceForContextFunction nativeResourceFunctionForContext(const QByteArray &resource) const override;
+    QPlatformNativeInterface::NativeResourceForWindowFunction nativeResourceFunctionForWindow(const QByteArray &resource) const override;
+private:
+    static void *eglDisplay();
+    static void *eglDisplayForWindow(QWindow *window);
+    static void *eglContextForContext(QOpenGLContext *context);
+    static void *eglConfigForContext(QOpenGLContext *context);
+};
+
+QT_END_NAMESPACE
+
+#endif //QXCBEGLNATIVEINTERFACEHANDLER_H

xcb/libqt6xcbqpa-dev/6.8.0/gl_integrations/xcb_egl/qxcbeglwindow.h

@@ -0,0 +1,37 @@
+// 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
+
+#ifndef QXCBEGLWINDOW_H
+#define QXCBEGLWINDOW_H
+
+#include "qxcbwindow.h"
+
+#include "qxcbeglinclude.h"
+
+QT_BEGIN_NAMESPACE
+
+class QXcbEglIntegration;
+
+class QXcbEglWindow : public QXcbWindow
+{
+public:
+    QXcbEglWindow(QWindow *window, QXcbEglIntegration *glIntegration);
+    ~QXcbEglWindow();
+
+    EGLSurface eglSurface() const { return m_surface; }
+
+    QXcbEglIntegration *glIntegration() const { return m_glIntegration; }
+
+protected:
+    void create() override;
+    void resolveFormat(const QSurfaceFormat &format) override;
+    const xcb_visualtype_t *createVisual() override;
+
+private:
+    QXcbEglIntegration *m_glIntegration;
+    EGLConfig m_config;
+    EGLSurface m_surface;
+};
+
+QT_END_NAMESPACE
+#endif //QXCBEGLWINDOW_H