Merge remote-tracking branch 'origin/5.9' into 5.11

 Conflicts:
	.qmake.conf
	src/corelib/animation/qvariantanimation.cpp
	src/corelib/global/qglobal.cpp
	src/corelib/global/qlogging.cpp
	src/corelib/io/qprocess_win.cpp
	src/corelib/json/qjsonarray.cpp
	src/corelib/tools/qsimd_p.h
	src/corelib/tools/qtimezoneprivate_p.h
	src/corelib/xml/qxmlstream_p.h
	src/gui/kernel/qsimpledrag.cpp
	src/gui/kernel/qsimpledrag_p.h
	src/plugins/generic/generic.pro
	src/plugins/platforms/cocoa/qcocoamenu.mm
	src/widgets/styles/qmacstyle_mac.mm
	tests/auto/concurrent/qtconcurrentmap/BLACKLIST
	tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
	tests/auto/corelib/tools/qdatetime/tst_qdatetime.cpp
	tests/auto/gui/kernel/qwindow/BLACKLIST
	tests/auto/widgets/dialogs/qmessagebox/BLACKLIST

Change-Id: I508d686cf20f7f8cc6a7119b9bc7c3bbb505c58e

9 files changed, 159 insertions, 295 deletions

diff --git a/src/plugins/platforms/qnx/qnx.pro b/src/plugins/platforms/qnx/qnx.pro
index 15d33200e5..96bfa1dd19 100644
--- a/src/plugins/platforms/qnx/qnx.pro
+++ b/src/plugins/platforms/qnx/qnx.pro
@@ -71,14 +71,14 @@ HEADERS =   main.h \
 
 LIBS += -lscreen
 
-qtConfig(opengles2) {
+qtConfig(egl) {
     SOURCES += qqnxglcontext.cpp \
                qqnxeglwindow.cpp
 
     HEADERS += qqnxglcontext.h \
                qqnxeglwindow.h
 
-    QMAKE_USE += opengl_es2 egl
+    QMAKE_USE += egl
 }
 
 qtConfig(qqnx_pps) {
diff --git a/src/plugins/platforms/qnx/qqnxeglwindow.cpp b/src/plugins/platforms/qnx/qqnxeglwindow.cpp
index 33ce0f924c..48766fc435 100644
--- a/src/plugins/platforms/qnx/qqnxeglwindow.cpp
+++ b/src/plugins/platforms/qnx/qqnxeglwindow.cpp
@@ -56,18 +56,12 @@ QT_BEGIN_NAMESPACE
 
 QQnxEglWindow::QQnxEglWindow(QWindow *window, screen_context_t context, bool needRootWindow) :
     QQnxWindow(window, context, needRootWindow),
-    m_platformOpenGLContext(0),
     m_newSurfaceRequested(true),
+    m_eglDisplay(EGL_NO_DISPLAY),
     m_eglSurface(EGL_NO_SURFACE)
 {
     initWindow();
 
-    // Set window usage
-    const int val = SCREEN_USAGE_OPENGL_ES2;
-    const int result = screen_set_window_property_iv(nativeHandle(), SCREEN_PROPERTY_USAGE, &val);
-    if (Q_UNLIKELY(result != 0))
-        qFatal("QQnxEglWindow: failed to set window alpha usage, errno=%d", errno);
-
     m_requestedBufferSize = shouldMakeFullScreen() ? screen()->geometry().size() : window->geometry().size();
 }
 
@@ -77,14 +71,58 @@ QQnxEglWindow::~QQnxEglWindow()
     destroyEGLSurface();
 }
 
-void QQnxEglWindow::createEGLSurface()
+bool QQnxEglWindow::isInitialized() const
 {
+    return m_eglSurface != EGL_NO_SURFACE;
+}
+
+void QQnxEglWindow::ensureInitialized(QQnxGLContext* context)
+{
+    if (m_newSurfaceRequested.testAndSetOrdered(true, false)) {
+        const QMutexLocker locker(&m_mutex); // Set geomety must not reset the requestedBufferSize till
+                                             // the surface is created
+
+        if (m_requestedBufferSize != bufferSize() || m_eglSurface == EGL_NO_SURFACE) {
+            if (m_eglSurface != EGL_NO_SURFACE) {
+                context->doneCurrent();
+                destroyEGLSurface();
+            }
+            createEGLSurface(context);
+        } else {
+            // Must've been a sequence of unprocessed changes returning us to the original size.
+            resetBuffers();
+        }
+    }
+}
+
+void QQnxEglWindow::createEGLSurface(QQnxGLContext *context)
+{
+    if (context->format().renderableType() != QSurfaceFormat::OpenGLES) {
+        qFatal("QQnxEglWindow: renderable type is not OpenGLES");
+        return;
+    }
+
+    // Set window usage
+    int usage = SCREEN_USAGE_OPENGL_ES2;
+#if _SCREEN_VERSION >= _SCREEN_MAKE_VERSION(1, 0, 0)
+    if (context->format().majorVersion() == 3)
+        usage |= SCREEN_USAGE_OPENGL_ES3;
+#endif
+
+    const int result = screen_set_window_property_iv(nativeHandle(), SCREEN_PROPERTY_USAGE, &usage);
+    if (Q_UNLIKELY(result != 0))
+        qFatal("QQnxEglWindow: failed to set window usage, errno=%d", errno);
+
     if (!m_requestedBufferSize.isValid()) {
         qWarning("QQNX: Trying to create 0 size EGL surface. "
                "Please set a valid window size before calling QOpenGLContext::makeCurrent()");
         return;
     }
 
+    m_eglDisplay = context->eglDisplay();
+    m_eglConfig = context->eglConfig();
+    m_format = context->format();
+
     // update the window's buffers before we create the EGL surface
     setBufferSize(m_requestedBufferSize);
 
@@ -94,24 +132,27 @@ void QQnxEglWindow::createEGLSurface()
         EGL_NONE
     };
 
-    qEglWindowDebug() << "Creating EGL surface" << platformOpenGLContext()->getEglDisplay()
-                   << platformOpenGLContext()->getEglConfig();
+    qEglWindowDebug() << "Creating EGL surface from" << this << context
+        << window()->surfaceType() << window()->type();
 
     // Create EGL surface
-    m_eglSurface = eglCreateWindowSurface(platformOpenGLContext()->getEglDisplay(),
-                                          platformOpenGLContext()->getEglConfig(),
-                                          (EGLNativeWindowType) nativeHandle(), eglSurfaceAttrs);
-    if (m_eglSurface == EGL_NO_SURFACE) {
-        const EGLenum error = QQnxGLContext::checkEGLError("eglCreateWindowSurface");
-        qWarning("QQNX: failed to create EGL surface, err=%d", error);
-    }
+    EGLSurface eglSurface = eglCreateWindowSurface(
+        m_eglDisplay,
+        m_eglConfig,
+        (EGLNativeWindowType) nativeHandle(),
+        eglSurfaceAttrs);
+
+    if (eglSurface == EGL_NO_SURFACE)
+        qWarning("QQNX: failed to create EGL surface, err=%d", eglGetError());
+
+    m_eglSurface = eglSurface;
 }
 
 void QQnxEglWindow::destroyEGLSurface()
 {
     // Destroy EGL surface if it exists
     if (m_eglSurface != EGL_NO_SURFACE) {
-        EGLBoolean eglResult = eglDestroySurface(platformOpenGLContext()->getEglDisplay(), m_eglSurface);
+        EGLBoolean eglResult = eglDestroySurface(m_eglDisplay, m_eglSurface);
         if (Q_UNLIKELY(eglResult != EGL_TRUE))
             qFatal("QQNX: failed to destroy EGL surface, err=%d", eglGetError());
     }
@@ -119,40 +160,8 @@ void QQnxEglWindow::destroyEGLSurface()
     m_eglSurface = EGL_NO_SURFACE;
 }
 
-void QQnxEglWindow::swapEGLBuffers()
+EGLSurface QQnxEglWindow::surface() const
 {
-    qEglWindowDebug();
-    // Set current rendering API
-    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());
-
-    // Post EGL surface to window
-    eglResult = eglSwapBuffers(m_platformOpenGLContext->getEglDisplay(), m_eglSurface);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to swap EGL buffers, err=%d", eglGetError());
-
-    windowPosted();
-}
-
-EGLSurface QQnxEglWindow::getSurface()
-{
-    if (m_newSurfaceRequested.testAndSetOrdered(true, false)) {
-        const QMutexLocker locker(&m_mutex); //Set geomety must not reset the requestedBufferSize till
-                                             //the surface is created
-
-        if ((m_requestedBufferSize != bufferSize()) || (m_eglSurface == EGL_NO_SURFACE)) {
-            if (m_eglSurface != EGL_NO_SURFACE) {
-                platformOpenGLContext()->doneCurrent();
-                destroyEGLSurface();
-            }
-            createEGLSurface();
-        } else {
-            // Must've been a sequence of unprocessed changes returning us to the original size.
-            resetBuffers();
-        }
-    }
-
     return m_eglSurface;
 }
 
@@ -169,35 +178,24 @@ void QQnxEglWindow::setGeometry(const QRect &rect)
         // that test.
         const QMutexLocker locker(&m_mutex);
         m_requestedBufferSize = newGeometry.size();
-        if (m_platformOpenGLContext != 0 && bufferSize() != newGeometry.size())
+        if (isInitialized() && bufferSize() != newGeometry.size())
             m_newSurfaceRequested.testAndSetRelease(false, true);
     }
     QQnxWindow::setGeometry(newGeometry);
 }
 
-void QQnxEglWindow::setPlatformOpenGLContext(QQnxGLContext *platformOpenGLContext)
-{
-    // This function does not take ownership of the platform gl context.
-    // It is owned by the frontend QOpenGLContext
-    m_platformOpenGLContext = platformOpenGLContext;
-}
-
 int QQnxEglWindow::pixelFormat() const
 {
-    if (!m_platformOpenGLContext) //The platform GL context was not set yet
-        return -1;
-
-    const QSurfaceFormat format = m_platformOpenGLContext->format();
     // Extract size of color channels from window format
-    const int redSize = format.redBufferSize();
+    const int redSize = m_format.redBufferSize();
     if (Q_UNLIKELY(redSize == -1))
         qFatal("QQnxWindow: red size not defined");
 
-    const int greenSize = format.greenBufferSize();
+    const int greenSize = m_format.greenBufferSize();
     if (Q_UNLIKELY(greenSize == -1))
         qFatal("QQnxWindow: green size not defined");
 
-    const int blueSize = format.blueBufferSize();
+    const int blueSize = m_format.blueBufferSize();
     if (Q_UNLIKELY(blueSize == -1))
         qFatal("QQnxWindow: blue size not defined");
 
diff --git a/src/plugins/platforms/qnx/qqnxeglwindow.h b/src/plugins/platforms/qnx/qqnxeglwindow.h
index 183be11ddc..3a3840f13c 100644
--- a/src/plugins/platforms/qnx/qqnxeglwindow.h
+++ b/src/plugins/platforms/qnx/qqnxeglwindow.h
@@ -53,13 +53,10 @@ public:
     QQnxEglWindow(QWindow *window, screen_context_t context, bool needRootWindow);
     ~QQnxEglWindow();
 
-    void createEGLSurface();
-    void destroyEGLSurface();
-    void swapEGLBuffers();
-    EGLSurface getSurface();
+    EGLSurface surface() const;
 
-    void setPlatformOpenGLContext(QQnxGLContext *platformOpenGLContext);
-    QQnxGLContext *platformOpenGLContext() const { return m_platformOpenGLContext; }
+    bool isInitialized() const;
+    void ensureInitialized(QQnxGLContext *context);
 
     void setGeometry(const QRect &rect) override;
 
@@ -68,6 +65,9 @@ protected:
     void resetBuffers() override;
 
 private:
+    void createEGLSurface(QQnxGLContext *context);
+    void destroyEGLSurface();
+
     QSize m_requestedBufferSize;
 
     // This mutex is used to protect access to the m_requestedBufferSize
@@ -78,9 +78,11 @@ private:
     // QQnxGLContext::makeCurrent()
     mutable QMutex m_mutex;
 
-    QQnxGLContext *m_platformOpenGLContext;
     QAtomicInt m_newSurfaceRequested;
+    EGLDisplay m_eglDisplay;
+    EGLConfig m_eglConfig;
     EGLSurface m_eglSurface;
+    QSurfaceFormat m_format;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxglcontext.cpp b/src/plugins/platforms/qnx/qqnxglcontext.cpp
index d35a4f0bba..d4493943e2 100644
--- a/src/plugins/platforms/qnx/qqnxglcontext.cpp
+++ b/src/plugins/platforms/qnx/qqnxglcontext.cpp
@@ -59,117 +59,13 @@ QT_BEGIN_NAMESPACE
 
 EGLDisplay QQnxGLContext::ms_eglDisplay = EGL_NO_DISPLAY;
 
-QQnxGLContext::QQnxGLContext(QOpenGLContext *glContext)
-    : QPlatformOpenGLContext(),
-      m_glContext(glContext),
-      m_currentEglSurface(EGL_NO_SURFACE)
+QQnxGLContext::QQnxGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share)
+    : QEGLPlatformContext(format, share, ms_eglDisplay)
 {
-    qGLContextDebug();
-    QSurfaceFormat format = m_glContext->format();
-
-    // Set current rendering API
-    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());
-
-    // Get colour channel sizes from window format
-    int alphaSize = format.alphaBufferSize();
-    int redSize = format.redBufferSize();
-    int greenSize = format.greenBufferSize();
-    int blueSize = format.blueBufferSize();
-
-    // Check if all channels are don't care
-    if (alphaSize == -1 && redSize == -1 && greenSize == -1 && blueSize == -1) {
-        // Set colour channels based on depth of window's screen
-        QQnxScreen *screen = static_cast<QQnxScreen*>(glContext->screen()->handle());
-        int depth = screen->depth();
-        if (depth == 32) {
-            // SCREEN_FORMAT_RGBA8888
-            alphaSize = 8;
-            redSize = 8;
-            greenSize = 8;
-            blueSize = 8;
-        } else {
-            // SCREEN_FORMAT_RGB565
-            alphaSize = 0;
-            redSize = 5;
-            greenSize = 6;
-            blueSize = 5;
-        }
-    } else {
-        // Choose best match based on supported pixel formats
-        if (alphaSize <= 0 && redSize <= 5 && greenSize <= 6 && blueSize <= 5) {
-            // SCREEN_FORMAT_RGB565
-            alphaSize = 0;
-            redSize = 5;
-            greenSize = 6;
-            blueSize = 5;
-        } else {
-            // SCREEN_FORMAT_RGBA8888
-            alphaSize = 8;
-            redSize = 8;
-            greenSize = 8;
-            blueSize = 8;
-        }
-    }
-
-    // Update colour channel sizes in window format
-    format.setAlphaBufferSize(alphaSize);
-    format.setRedBufferSize(redSize);
-    format.setGreenBufferSize(greenSize);
-    format.setBlueBufferSize(blueSize);
-
-    // Select EGL config based on requested window format
-    m_eglConfig = q_configFromGLFormat(ms_eglDisplay, format);
-    if (Q_UNLIKELY(m_eglConfig == 0))
-        qFatal("QQnxGLContext: failed to find EGL config");
-
-    QQnxGLContext *glShareContext = static_cast<QQnxGLContext*>(m_glContext->shareHandle());
-    m_eglShareContext = glShareContext ? glShareContext->m_eglContext : EGL_NO_CONTEXT;
-
-    m_eglContext = eglCreateContext(ms_eglDisplay, m_eglConfig, m_eglShareContext,
-                                    contextAttrs(format));
-    if (Q_UNLIKELY(m_eglContext == EGL_NO_CONTEXT)) {
-        checkEGLError("eglCreateContext");
-        qFatal("QQnxGLContext: failed to create EGL context, err=%d", eglGetError());
-    }
-
-    // Query/cache window format of selected EGL config
-    m_windowFormat = q_glFormatFromConfig(ms_eglDisplay, m_eglConfig);
 }
 
 QQnxGLContext::~QQnxGLContext()
 {
-    qGLContextDebug();
-
-    // Cleanup EGL context if it exists
-    if (m_eglContext != EGL_NO_CONTEXT)
-        eglDestroyContext(ms_eglDisplay, m_eglContext);
-}
-
-EGLenum QQnxGLContext::checkEGLError(const char *msg)
-{
-    static const char *errmsg[] =
-    {
-        "EGL function succeeded",
-        "EGL is not initialized, or could not be initialized, for the specified display",
-        "EGL cannot access a requested resource",
-        "EGL failed to allocate resources for the requested operation",
-        "EGL fail to access an unrecognized attribute or attribute value was passed in an attribute list",
-        "EGLConfig argument does not name a valid EGLConfig",
-        "EGLContext argument does not name a valid EGLContext",
-        "EGL current surface of the calling thread is no longer valid",
-        "EGLDisplay argument does not name a valid EGLDisplay",
-        "EGL arguments are inconsistent",
-        "EGLNativePixmapType argument does not refer to a valid native pixmap",
-        "EGLNativeWindowType argument does not refer to a valid native window",
-        "EGL one or more argument values are invalid",
-        "EGLSurface argument does not name a valid surface configured for rendering",
-        "EGL power management event has occurred",
-    };
-    EGLenum error = eglGetError();
-    fprintf(stderr, "%s: %s\n", msg, errmsg[error - EGL_SUCCESS]);
-    return error;
 }
 
 void QQnxGLContext::initializeContext()
@@ -178,16 +74,12 @@ void QQnxGLContext::initializeContext()
 
     // Initialize connection to EGL
     ms_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-    if (Q_UNLIKELY(ms_eglDisplay == EGL_NO_DISPLAY)) {
-        checkEGLError("eglGetDisplay");
-        qFatal("QQnxGLContext: failed to obtain EGL display");
-    }
+    if (Q_UNLIKELY(ms_eglDisplay == EGL_NO_DISPLAY))
+        qFatal("QQnxGLContext: failed to obtain EGL display: %x", eglGetError());
 
     EGLBoolean eglResult = eglInitialize(ms_eglDisplay, 0, 0);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE)) {
-        checkEGLError("eglInitialize");
+    if (Q_UNLIKELY(eglResult != EGL_TRUE))
         qFatal("QQnxGLContext: failed to initialize EGL display, err=%d", eglGetError());
-    }
 }
 
 void QQnxGLContext::shutdownContext()
@@ -198,98 +90,32 @@ void QQnxGLContext::shutdownContext()
     eglTerminate(ms_eglDisplay);
 }
 
-bool QQnxGLContext::makeCurrent(QPlatformSurface *surface)
+EGLSurface QQnxGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
 {
-    qGLContextDebug();
-
-    Q_ASSERT(surface->surface()->surfaceType() == QSurface::OpenGLSurface);
-
-    // Set current rendering API
-    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQnxGLContext: failed to set EGL API, err=%d", eglGetError());
-
-    QQnxEglWindow *platformWindow = dynamic_cast<QQnxEglWindow*>(surface);
-    if (!platformWindow)
-        return false;
-
-    platformWindow->setPlatformOpenGLContext(this);
-
-    if (m_currentEglSurface == EGL_NO_SURFACE || m_currentEglSurface != platformWindow->getSurface()) {
-        m_currentEglSurface = platformWindow->getSurface();
-        doneCurrent();
-    }
-
-    eglResult = eglMakeCurrent(ms_eglDisplay, m_currentEglSurface, m_currentEglSurface, m_eglContext);
-    if (eglResult != EGL_TRUE) {
-        checkEGLError("eglMakeCurrent");
-        qWarning("QQNX: failed to set current EGL context, err=%d", eglGetError());
-        return false;
-    }
-    return (eglResult == EGL_TRUE);
+    QQnxEglWindow *window = static_cast<QQnxEglWindow *>(surface);
+    window->ensureInitialized(this);
+    return window->surface();
 }
 
-void QQnxGLContext::doneCurrent()
+bool QQnxGLContext::makeCurrent(QPlatformSurface *surface)
 {
     qGLContextDebug();
-
-    // set current rendering API
-    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());
-
-    // clear curent EGL context and unbind EGL surface
-    eglResult = eglMakeCurrent(ms_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to clear current EGL context, err=%d", eglGetError());
+    return QEGLPlatformContext::makeCurrent(surface);
 }
 
 void QQnxGLContext::swapBuffers(QPlatformSurface *surface)
 {
     qGLContextDebug();
-    QQnxEglWindow *platformWindow = dynamic_cast<QQnxEglWindow*>(surface);
-    if (!platformWindow)
-        return;
-
-    platformWindow->swapEGLBuffers();
-}
 
-QFunctionPointer QQnxGLContext::getProcAddress(const char *procName)
-{
-    qGLContextDebug();
+    QEGLPlatformContext::swapBuffers(surface);
 
-    // Set current rendering API
-    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
-    if (Q_UNLIKELY(eglResult != EGL_TRUE))
-        qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());
-
-    // Lookup EGL extension function pointer
-    QFunctionPointer result = static_cast<QFunctionPointer>(eglGetProcAddress(procName));
-    if (!result)
-        result = reinterpret_cast<QFunctionPointer>(dlsym(RTLD_DEFAULT, procName));
-    return result;
-}
-
-bool QQnxGLContext::isSharing() const
-{
-    return m_eglShareContext != EGL_NO_CONTEXT;
-}
-
-EGLDisplay QQnxGLContext::getEglDisplay() {
-    return ms_eglDisplay;
+    QQnxEglWindow *platformWindow = static_cast<QQnxEglWindow*>(surface);
+    platformWindow->windowPosted();
 }
 
-EGLint *QQnxGLContext::contextAttrs(const QSurfaceFormat &format)
+void QQnxGLContext::doneCurrent()
 {
-    qGLContextDebug();
-
-    // Choose EGL settings based on OpenGL version
-#if defined(QT_OPENGL_ES_2)
-    static EGLint attrs[] = { EGL_CONTEXT_CLIENT_VERSION, format.version().first, EGL_NONE };
-    return attrs;
-#else
-    return 0;
-#endif
+    QEGLPlatformContext::doneCurrent();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxglcontext.h b/src/plugins/platforms/qnx/qqnxglcontext.h
index 6e5408e8bf..19179a80e2 100644
--- a/src/plugins/platforms/qnx/qqnxglcontext.h
+++ b/src/plugins/platforms/qnx/qqnxglcontext.h
@@ -46,49 +46,31 @@
 #include <QtCore/QSize>
 
 #include <EGL/egl.h>
+#include <QtEglSupport/private/qeglplatformcontext_p.h>
 
 QT_BEGIN_NAMESPACE
 
 class QQnxWindow;
 
-class QQnxGLContext : public QPlatformOpenGLContext
+class QQnxGLContext : public QEGLPlatformContext
 {
 public:
-    QQnxGLContext(QOpenGLContext *glContext);
+    QQnxGLContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share);
     virtual ~QQnxGLContext();
 
-    static EGLenum checkEGLError(const char *msg);
-
     static void initializeContext();
     static void shutdownContext();
 
-    void requestSurfaceChange();
-
     bool makeCurrent(QPlatformSurface *surface) override;
-    void doneCurrent() override;
     void swapBuffers(QPlatformSurface *surface) override;
-    QFunctionPointer getProcAddress(const char *procName) override;
-
-    virtual QSurfaceFormat format() const override { return m_windowFormat; }
-    bool isSharing() const override;
+    void doneCurrent() override;
 
-    static EGLDisplay getEglDisplay();
-    EGLConfig getEglConfig() const { return m_eglConfig;}
-    EGLContext getEglContext() const { return m_eglContext; }
+protected:
+    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) override;
 
 private:
     //Can be static because different displays returne the same handle
     static EGLDisplay ms_eglDisplay;
-
-    QSurfaceFormat m_windowFormat;
-    QOpenGLContext *m_glContext;
-
-    EGLConfig m_eglConfig;
-    EGLContext m_eglContext;
-    EGLContext m_eglShareContext;
-    EGLSurface m_currentEglSurface;
-
-    static EGLint *contextAttrs(const QSurfaceFormat &format);
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxintegration.cpp b/src/plugins/platforms/qnx/qqnxintegration.cpp
index 072510e052..bffe7ee34b 100644
--- a/src/plugins/platforms/qnx/qqnxintegration.cpp
+++ b/src/plugins/platforms/qnx/qqnxintegration.cpp
@@ -313,7 +313,58 @@ QPlatformBackingStore *QQnxIntegration::createPlatformBackingStore(QWindow *wind
 QPlatformOpenGLContext *QQnxIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
 {
     qIntegrationDebug();
-    return new QQnxGLContext(context);
+
+    // Get color channel sizes from window format
+    QSurfaceFormat format = context->format();
+    int alphaSize = format.alphaBufferSize();
+    int redSize = format.redBufferSize();
+    int greenSize = format.greenBufferSize();
+    int blueSize = format.blueBufferSize();
+
+    // Check if all channels are don't care
+    if (alphaSize == -1 && redSize == -1 && greenSize == -1 && blueSize == -1) {
+        // Set color channels based on depth of window's screen
+        QQnxScreen *screen = static_cast<QQnxScreen*>(context->screen()->handle());
+        int depth = screen->depth();
+        if (depth == 32) {
+            // SCREEN_FORMAT_RGBA8888
+            alphaSize = 8;
+            redSize = 8;
+            greenSize = 8;
+            blueSize = 8;
+        } else {
+            // SCREEN_FORMAT_RGB565
+            alphaSize = 0;
+            redSize = 5;
+            greenSize = 6;
+            blueSize = 5;
+        }
+    } else {
+        // Choose best match based on supported pixel formats
+        if (alphaSize <= 0 && redSize <= 5 && greenSize <= 6 && blueSize <= 5) {
+            // SCREEN_FORMAT_RGB565
+            alphaSize = 0;
+            redSize = 5;
+            greenSize = 6;
+            blueSize = 5;
+        } else {
+            // SCREEN_FORMAT_RGBA8888
+            alphaSize = 8;
+            redSize = 8;
+            greenSize = 8;
+            blueSize = 8;
+        }
+    }
+
+    // Update color channel sizes in window format
+    format.setAlphaBufferSize(alphaSize);
+    format.setRedBufferSize(redSize);
+    format.setGreenBufferSize(greenSize);
+    format.setBlueBufferSize(blueSize);
+    context->setFormat(format);
+
+    QQnxGLContext *ctx = new QQnxGLContext(context->format(), context->shareHandle());
+    return ctx;
 }
 #endif
 
diff --git a/src/plugins/platforms/qnx/qqnxnativeinterface.cpp b/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
index 468fe9cd91..3eebb9c742 100644
--- a/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
+++ b/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
@@ -98,7 +98,7 @@ void *QQnxNativeInterface::nativeResourceForIntegration(const QByteArray &resour
 void *QQnxNativeInterface::nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context)
 {
     if (resource == "eglcontext" && context)
-        return static_cast<QQnxGLContext*>(context->handle())->getEglContext();
+        return static_cast<QQnxGLContext*>(context->handle())->eglContext();
 
     return 0;
 }
diff --git a/src/plugins/platforms/qnx/qqnxscreen.h b/src/plugins/platforms/qnx/qqnxscreen.h
index 8a498434aa..a6d5623d04 100644
--- a/src/plugins/platforms/qnx/qqnxscreen.h
+++ b/src/plugins/platforms/qnx/qqnxscreen.h
@@ -49,10 +49,14 @@
 
 #include <screen/screen.h>
 
-// For pre-7.0 SDPs, map some screen property names to the old
+#if !defined(_SCREEN_VERSION)
+#define _SCREEN_MAKE_VERSION(major, minor, patch)  (((major) * 10000) + ((minor) * 100) + (patch))
+#define _SCREEN_VERSION _SCREEN_MAKE_VERSION(0, 0, 0)
+#endif
+
+// For pre-1.0.0 screen, map some screen property names to the old
 // names.
-#include <sys/neutrino.h>
-#if _NTO_VERSION < 700
+#if _SCREEN_VERSION < _SCREEN_MAKE_VERSION(1, 0, 0)
 const int SCREEN_PROPERTY_FLAGS = SCREEN_PROPERTY_KEY_FLAGS;
 const int SCREEN_PROPERTY_FOCUS = SCREEN_PROPERTY_KEYBOARD_FOCUS;
 const int SCREEN_PROPERTY_MODIFIERS = SCREEN_PROPERTY_KEY_MODIFIERS;
diff --git a/src/plugins/platforms/qnx/qqnxwindow.h b/src/plugins/platforms/qnx/qqnxwindow.h
index dfcca78f80..2895a547b1 100644
--- a/src/plugins/platforms/qnx/qqnxwindow.h
+++ b/src/plugins/platforms/qnx/qqnxwindow.h
@@ -112,12 +112,13 @@ public:
 
     bool shouldMakeFullScreen() const;
 
+    void windowPosted();
+
 protected:
     virtual int pixelFormat() const = 0;
     virtual void resetBuffers() = 0;
 
     void initWindow();
-    void windowPosted();
 
     screen_context_t m_screenContext;