eglfs: Move remaining sources to under api

Move platform integration, context and offscreensurface to under 'api'.
This allows accessing these from out-of-tree eglfs backends as well.

For instance, the upcoming eglfs_emu backend for the Qt Simulator may need
access to QEglFSIntegration.

Clean up the project files and remove out-of-date comments (the private
module QtEglFSDeviceIntegration is not really header-less since 5.7).

Change-Id: If96dd5780a6bd33a1cf29164364df9bf921c4d01
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

10 files changed, 927 insertions, 4 deletions

diff --git a/src/plugins/platforms/eglfs/api/api.pri b/src/plugins/platforms/eglfs/api/api.pri
index 957dee554c..bd792dae7f 100644
--- a/src/plugins/platforms/eglfs/api/api.pri
+++ b/src/plugins/platforms/eglfs/api/api.pri
@@ -3,13 +3,19 @@ SOURCES +=  $$PWD/qeglfswindow.cpp \
             $$PWD/qeglfsscreen.cpp \
             $$PWD/qeglfscursor.cpp \
             $$PWD/qeglfshooks.cpp \
-            $$PWD/qeglfsdeviceintegration.cpp
+            $$PWD/qeglfsdeviceintegration.cpp \
+            $$PWD/qeglfsintegration.cpp \
+            $$PWD/qeglfscontext.cpp \
+            $$PWD/qeglfsoffscreenwindow.cpp
 
 HEADERS +=  $$PWD/qeglfswindow_p.h \
             $$PWD/qeglfsscreen_p.h \
             $$PWD/qeglfscursor_p.h \
             $$PWD/qeglfshooks_p.h \
             $$PWD/qeglfsdeviceintegration_p.h \
+            $$PWD/qeglfsintegration_p.h \
+            $$PWD/qeglfscontext_p.h \
+            $$PWD/qeglfsoffscreenwindow_p.h \
             $$PWD/qeglfsglobal.h
 
 INCLUDEPATH += $$PWD
diff --git a/src/plugins/platforms/eglfs/api/qeglfscontext.cpp b/src/plugins/platforms/eglfs/api/qeglfscontext.cpp
new file mode 100644
index 0000000000..8e44b3e93e
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfscontext.cpp
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeglfsglobal.h"
+#include <QtGui/QSurface>
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
+#include <QtPlatformSupport/private/qeglpbuffer_p.h>
+
+#include "qeglfscontext_p.h"
+#include "qeglfswindow_p.h"
+#include "qeglfshooks_p.h"
+#include "qeglfscursor_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QEglFSContext::QEglFSContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
+                             EGLConfig *config, const QVariant &nativeHandle)
+    : QEGLPlatformContext(format, share, display, config, nativeHandle,
+                          qt_egl_device_integration()->supportsSurfacelessContexts() ? Flags(0) : QEGLPlatformContext::NoSurfaceless),
+      m_tempWindow(0)
+{
+}
+
+EGLSurface QEglFSContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
+{
+    if (surface->surface()->surfaceClass() == QSurface::Window)
+        return static_cast<QEglFSWindow *>(surface)->surface();
+    else
+        return static_cast<QEGLPbuffer *>(surface)->pbuffer();
+}
+
+EGLSurface QEglFSContext::createTemporaryOffscreenSurface()
+{
+    if (qt_egl_device_integration()->supportsPBuffers())
+        return QEGLPlatformContext::createTemporaryOffscreenSurface();
+
+    if (!m_tempWindow) {
+        m_tempWindow = qt_egl_device_integration()->createNativeOffscreenWindow(format());
+        if (!m_tempWindow) {
+            qWarning("QEglFSContext: Failed to create temporary native window");
+            return EGL_NO_SURFACE;
+        }
+    }
+    EGLConfig config = q_configFromGLFormat(eglDisplay(), format());
+    return eglCreateWindowSurface(eglDisplay(), config, m_tempWindow, 0);
+}
+
+void QEglFSContext::destroyTemporaryOffscreenSurface(EGLSurface surface)
+{
+    if (qt_egl_device_integration()->supportsPBuffers()) {
+        QEGLPlatformContext::destroyTemporaryOffscreenSurface(surface);
+    } else {
+        eglDestroySurface(eglDisplay(), surface);
+        qt_egl_device_integration()->destroyNativeWindow(m_tempWindow);
+        m_tempWindow = 0;
+    }
+}
+
+void QEglFSContext::runGLChecks()
+{
+    // Note that even though there is an EGL context current here,
+    // QOpenGLContext and QOpenGLFunctions are not yet usable at this stage.
+    const char *renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
+    // Be nice and warn about a common source of confusion.
+    if (renderer && strstr(renderer, "llvmpipe"))
+        qWarning("Running on a software rasterizer (LLVMpipe), expect limited performance.");
+}
+
+void QEglFSContext::swapBuffers(QPlatformSurface *surface)
+{
+    // draw the cursor
+    if (surface->surface()->surfaceClass() == QSurface::Window) {
+        QPlatformWindow *window = static_cast<QPlatformWindow *>(surface);
+        if (QEglFSCursor *cursor = qobject_cast<QEglFSCursor *>(window->screen()->cursor()))
+            cursor->paintOnScreen();
+    }
+
+    qt_egl_device_integration()->waitForVSync(surface);
+    QEGLPlatformContext::swapBuffers(surface);
+    qt_egl_device_integration()->presentBuffer(surface);
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/platforms/eglfs/api/qeglfscontext_p.h b/src/plugins/platforms/eglfs/api/qeglfscontext_p.h
new file mode 100644
index 0000000000..2274e488ff
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfscontext_p.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEGLFSCONTEXT_H
+#define QEGLFSCONTEXT_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 "qeglfsglobal.h"
+#include <QtPlatformSupport/private/qeglplatformcontext_p.h>
+#include <QtCore/QVariant>
+
+QT_BEGIN_NAMESPACE
+
+class Q_EGLFS_EXPORT QEglFSContext : public QEGLPlatformContext
+{
+public:
+    QEglFSContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
+                  EGLConfig *config, const QVariant &nativeHandle);
+    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) Q_DECL_OVERRIDE;
+    EGLSurface createTemporaryOffscreenSurface() Q_DECL_OVERRIDE;
+    void destroyTemporaryOffscreenSurface(EGLSurface surface) Q_DECL_OVERRIDE;
+    void runGLChecks() Q_DECL_OVERRIDE;
+    void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE;
+
+private:
+    EGLNativeWindowType m_tempWindow;
+};
+
+QT_END_NAMESPACE
+
+#endif // QEGLFSCONTEXT_H
diff --git a/src/plugins/platforms/eglfs/api/qeglfscursor.cpp b/src/plugins/platforms/eglfs/api/qeglfscursor.cpp
index 0040ecd59d..1b3446c4ac 100644
--- a/src/plugins/platforms/eglfs/api/qeglfscursor.cpp
+++ b/src/plugins/platforms/eglfs/api/qeglfscursor.cpp
@@ -38,7 +38,7 @@
 ****************************************************************************/
 
 #include "qeglfscursor_p.h"
-#include "qeglfsintegration.h"
+#include "qeglfsintegration_p.h"
 #include "qeglfsscreen_p.h"
 
 #include <qpa/qwindowsysteminterface.h>
diff --git a/src/plugins/platforms/eglfs/api/qeglfsdeviceintegration.cpp b/src/plugins/platforms/eglfs/api/qeglfsdeviceintegration.cpp
index 6f65929913..9f05767366 100644
--- a/src/plugins/platforms/eglfs/api/qeglfsdeviceintegration.cpp
+++ b/src/plugins/platforms/eglfs/api/qeglfsdeviceintegration.cpp
@@ -38,7 +38,7 @@
 ****************************************************************************/
 
 #include "qeglfsdeviceintegration_p.h"
-#include "qeglfsintegration.h"
+#include "qeglfsintegration_p.h"
 #include "qeglfscursor_p.h"
 #include "qeglfswindow_p.h"
 #include "qeglfsscreen_p.h"
diff --git a/src/plugins/platforms/eglfs/api/qeglfsintegration.cpp b/src/plugins/platforms/eglfs/api/qeglfsintegration.cpp
new file mode 100644
index 0000000000..4974499e0a
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfsintegration.cpp
@@ -0,0 +1,439 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qtextstream.h>
+#include <QtGui/private/qguiapplication_p.h>
+
+#include <qpa/qplatformwindow.h>
+#include <QtGui/QSurfaceFormat>
+#include <QtGui/QOpenGLContext>
+#include <QtGui/QScreen>
+#include <QtGui/QOffscreenSurface>
+#include <QtGui/QWindow>
+#include <QtCore/QLoggingCategory>
+#include <qpa/qwindowsysteminterface.h>
+#include <qpa/qplatforminputcontextfactory_p.h>
+#include <private/qgenericunixthemes_p.h>
+
+#include "qeglfsintegration_p.h"
+#include "qeglfswindow_p.h"
+#include "qeglfshooks_p.h"
+#include "qeglfscontext_p.h"
+#include "qeglfsoffscreenwindow_p.h"
+#include "qeglfscursor_p.h"
+
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
+#include <QtPlatformSupport/private/qeglplatformcontext_p.h>
+#include <QtPlatformSupport/private/qeglpbuffer_p.h>
+
+#include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>
+#include <QtPlatformSupport/private/qgenericunixservices_p.h>
+#include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>
+#include <QtPlatformSupport/private/qfbvthandler_p.h>
+#include <QtPlatformSupport/private/qopenglcompositorbackingstore_p.h>
+
+#include <QtPlatformHeaders/QEGLNativeContext>
+
+#if QT_CONFIG(libinput)
+#include <QtPlatformSupport/private/qlibinputhandler_p.h>
+#endif
+
+#if QT_CONFIG(evdev)
+#include <QtPlatformSupport/private/qevdevmousemanager_p.h>
+#include <QtPlatformSupport/private/qevdevkeyboardmanager_p.h>
+#include <QtPlatformSupport/private/qevdevtouchmanager_p.h>
+#endif
+
+#if QT_CONFIG(tslib)
+#include <QtPlatformSupport/private/qtslib_p.h>
+#endif
+
+#include <QtPlatformHeaders/qeglfsfunctions.h>
+
+static void initResources()
+{
+#ifndef QT_NO_CURSOR
+    Q_INIT_RESOURCE(cursor);
+#endif
+}
+
+QT_BEGIN_NAMESPACE
+
+QEglFSIntegration::QEglFSIntegration()
+    : m_display(EGL_NO_DISPLAY),
+      m_inputContext(0),
+      m_fontDb(new QGenericUnixFontDatabase),
+      m_services(new QGenericUnixServices),
+      m_kbdMgr(0),
+      m_disableInputHandlers(false)
+{
+    m_disableInputHandlers = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DISABLE_INPUT");
+
+    initResources();
+}
+
+void QEglFSIntegration::addScreen(QPlatformScreen *screen)
+{
+    screenAdded(screen);
+}
+
+void QEglFSIntegration::removeScreen(QPlatformScreen *screen)
+{
+    destroyScreen(screen);
+}
+
+void QEglFSIntegration::initialize()
+{
+    qt_egl_device_integration()->platformInit();
+
+    m_display = qt_egl_device_integration()->createDisplay(nativeDisplay());
+    if (Q_UNLIKELY(m_display == EGL_NO_DISPLAY))
+        qFatal("Could not open egl display");
+
+    EGLint major, minor;
+    if (Q_UNLIKELY(!eglInitialize(m_display, &major, &minor)))
+        qFatal("Could not initialize egl display");
+
+    m_inputContext = QPlatformInputContextFactory::create();
+
+    m_vtHandler.reset(new QFbVtHandler);
+
+    if (qt_egl_device_integration()->usesDefaultScreen())
+        addScreen(new QEglFSScreen(display()));
+    else
+        qt_egl_device_integration()->screenInit();
+
+    // Input code may rely on the screens, so do it only after the screen init.
+    if (!m_disableInputHandlers)
+        createInputHandlers();
+}
+
+void QEglFSIntegration::destroy()
+{
+    foreach (QWindow *w, qGuiApp->topLevelWindows())
+        w->destroy();
+
+    qt_egl_device_integration()->screenDestroy();
+
+    if (m_display != EGL_NO_DISPLAY)
+        eglTerminate(m_display);
+
+    qt_egl_device_integration()->platformDestroy();
+}
+
+QAbstractEventDispatcher *QEglFSIntegration::createEventDispatcher() const
+{
+    return createUnixEventDispatcher();
+}
+
+QPlatformServices *QEglFSIntegration::services() const
+{
+    return m_services.data();
+}
+
+QPlatformFontDatabase *QEglFSIntegration::fontDatabase() const
+{
+    return m_fontDb.data();
+}
+
+QPlatformTheme *QEglFSIntegration::createPlatformTheme(const QString &name) const
+{
+    return QGenericUnixTheme::createUnixTheme(name);
+}
+
+QPlatformBackingStore *QEglFSIntegration::createPlatformBackingStore(QWindow *window) const
+{
+    QOpenGLCompositorBackingStore *bs = new QOpenGLCompositorBackingStore(window);
+    if (!window->handle())
+        window->create();
+    static_cast<QEglFSWindow *>(window->handle())->setBackingStore(bs);
+    return bs;
+}
+
+QPlatformWindow *QEglFSIntegration::createPlatformWindow(QWindow *window) const
+{
+    QWindowSystemInterface::flushWindowSystemEvents();
+    QEglFSWindow *w = qt_egl_device_integration()->createWindow(window);
+    w->create();
+    if (window->type() != Qt::ToolTip)
+        w->requestActivateWindow();
+    return w;
+}
+
+QPlatformOpenGLContext *QEglFSIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
+{
+    EGLDisplay dpy = context->screen() ? static_cast<QEglFSScreen *>(context->screen()->handle())->display() : display();
+    QPlatformOpenGLContext *share = context->shareHandle();
+    QVariant nativeHandle = context->nativeHandle();
+
+    QEglFSContext *ctx;
+    QSurfaceFormat adjustedFormat = qt_egl_device_integration()->surfaceFormatFor(context->format());
+    if (nativeHandle.isNull()) {
+        EGLConfig config = QEglFSDeviceIntegration::chooseConfig(dpy, adjustedFormat);
+        ctx = new QEglFSContext(adjustedFormat, share, dpy, &config, QVariant());
+    } else {
+        ctx = new QEglFSContext(adjustedFormat, share, dpy, 0, nativeHandle);
+    }
+    nativeHandle = QVariant::fromValue<QEGLNativeContext>(QEGLNativeContext(ctx->eglContext(), dpy));
+
+    context->setNativeHandle(nativeHandle);
+    return ctx;
+}
+
+QPlatformOffscreenSurface *QEglFSIntegration::createPlatformOffscreenSurface(QOffscreenSurface *surface) const
+{
+    EGLDisplay dpy = surface->screen() ? static_cast<QEglFSScreen *>(surface->screen()->handle())->display() : display();
+    QSurfaceFormat fmt = qt_egl_device_integration()->surfaceFormatFor(surface->requestedFormat());
+    if (qt_egl_device_integration()->supportsPBuffers()) {
+        QEGLPlatformContext::Flags flags = 0;
+        if (!qt_egl_device_integration()->supportsSurfacelessContexts())
+            flags |= QEGLPlatformContext::NoSurfaceless;
+        return new QEGLPbuffer(dpy, fmt, surface, flags);
+    } else {
+        return new QEglFSOffscreenWindow(dpy, fmt, surface);
+    }
+    // Never return null. Multiple QWindows are not supported by this plugin.
+}
+
+bool QEglFSIntegration::hasCapability(QPlatformIntegration::Capability cap) const
+{
+    // We assume that devices will have more and not less capabilities
+    if (qt_egl_device_integration()->hasCapability(cap))
+        return true;
+
+    switch (cap) {
+    case ThreadedPixmaps: return true;
+    case OpenGL: return true;
+    case ThreadedOpenGL: return true;
+    case WindowManagement: return false;
+    case RasterGLSurface: return true;
+    default: return QPlatformIntegration::hasCapability(cap);
+    }
+}
+
+QPlatformNativeInterface *QEglFSIntegration::nativeInterface() const
+{
+    return const_cast<QEglFSIntegration *>(this);
+}
+
+enum ResourceType {
+    EglDisplay,
+    EglWindow,
+    EglContext,
+    EglConfig,
+    NativeDisplay,
+    XlibDisplay,
+    WaylandDisplay
+};
+
+static int resourceType(const QByteArray &key)
+{
+    static const QByteArray names[] = { // match ResourceType
+        QByteArrayLiteral("egldisplay"),
+        QByteArrayLiteral("eglwindow"),
+        QByteArrayLiteral("eglcontext"),
+        QByteArrayLiteral("eglconfig"),
+        QByteArrayLiteral("nativedisplay"),
+        QByteArrayLiteral("display"),
+        QByteArrayLiteral("server_wl_display")
+    };
+    const QByteArray *end = names + sizeof(names) / sizeof(names[0]);
+    const QByteArray *result = std::find(names, end, key);
+    if (result == end)
+        result = std::find(names, end, key.toLower());
+    return int(result - names);
+}
+
+void *QEglFSIntegration::nativeResourceForIntegration(const QByteArray &resource)
+{
+    void *result = 0;
+
+    switch (resourceType(resource)) {
+    case EglDisplay:
+        result = display();
+        break;
+    case NativeDisplay:
+        result = reinterpret_cast<void*>(nativeDisplay());
+        break;
+    case WaylandDisplay:
+        result = qt_egl_device_integration()->wlDisplay();
+        break;
+    default:
+        break;
+    }
+
+    return result;
+}
+
+void *QEglFSIntegration::nativeResourceForScreen(const QByteArray &resource, QScreen *)
+{
+    void *result = 0;
+
+    switch (resourceType(resource)) {
+    case XlibDisplay:
+        // Play nice when using the x11 hooks: Be compatible with xcb that allows querying
+        // the X Display pointer, which is nothing but our native display.
+        result = reinterpret_cast<void*>(nativeDisplay());
+        break;
+    default:
+        break;
+    }
+
+    return result;
+}
+
+void *QEglFSIntegration::nativeResourceForWindow(const QByteArray &resource, QWindow *window)
+{
+    void *result = 0;
+
+    switch (resourceType(resource)) {
+    case EglDisplay:
+        if (window && window->handle())
+            result = static_cast<QEglFSScreen *>(window->handle()->screen())->display();
+        else
+            result = display();
+        break;
+    case EglWindow:
+        if (window && window->handle())
+            result = reinterpret_cast<void*>(static_cast<QEglFSWindow *>(window->handle())->eglWindow());
+        break;
+    default:
+        break;
+    }
+
+    return result;
+}
+
+void *QEglFSIntegration::nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context)
+{
+    void *result = 0;
+
+    switch (resourceType(resource)) {
+    case EglContext:
+        if (context->handle())
+            result = static_cast<QEglFSContext *>(context->handle())->eglContext();
+        break;
+    case EglConfig:
+        if (context->handle())
+            result = static_cast<QEglFSContext *>(context->handle())->eglConfig();
+        break;
+    case EglDisplay:
+        if (context->handle())
+            result = static_cast<QEglFSContext *>(context->handle())->eglDisplay();
+        break;
+    default:
+        break;
+    }
+
+    return result;
+}
+
+static void *eglContextForContext(QOpenGLContext *context)
+{
+    Q_ASSERT(context);
+
+    QEglFSContext *handle = static_cast<QEglFSContext *>(context->handle());
+    if (!handle)
+        return 0;
+
+    return handle->eglContext();
+}
+
+QPlatformNativeInterface::NativeResourceForContextFunction QEglFSIntegration::nativeResourceFunctionForContext(const QByteArray &resource)
+{
+    QByteArray lowerCaseResource = resource.toLower();
+    if (lowerCaseResource == "get_egl_context")
+        return NativeResourceForContextFunction(eglContextForContext);
+
+    return 0;
+}
+
+QFunctionPointer QEglFSIntegration::platformFunction(const QByteArray &function) const
+{
+#if QT_CONFIG(evdev)
+    if (function == QEglFSFunctions::loadKeymapTypeIdentifier())
+        return QFunctionPointer(loadKeymapStatic);
+#else
+    Q_UNUSED(function)
+#endif
+
+    return 0;
+}
+
+void QEglFSIntegration::loadKeymapStatic(const QString &filename)
+{
+#if QT_CONFIG(evdev)
+    QEglFSIntegration *self = static_cast<QEglFSIntegration *>(QGuiApplicationPrivate::platformIntegration());
+    if (self->m_kbdMgr)
+        self->m_kbdMgr->loadKeymap(filename);
+    else
+        qWarning("QEglFSIntegration: Cannot load keymap, no keyboard handler found");
+#else
+    Q_UNUSED(filename);
+#endif
+}
+
+void QEglFSIntegration::createInputHandlers()
+{
+#if QT_CONFIG(libinput)
+    if (!qEnvironmentVariableIntValue("QT_QPA_EGLFS_NO_LIBINPUT")) {
+        new QLibInputHandler(QLatin1String("libinput"), QString());
+        return;
+    }
+#endif
+
+#if QT_CONFIG(evdev)
+    m_kbdMgr = new QEvdevKeyboardManager(QLatin1String("EvdevKeyboard"), QString() /* spec */, this);
+    new QEvdevMouseManager(QLatin1String("EvdevMouse"), QString() /* spec */, this);
+#if QT_CONFIG(tslib)
+    const bool useTslib = qEnvironmentVariableIntValue("QT_QPA_EGLFS_TSLIB");
+    if (useTslib)
+        new QTsLibMouseHandler(QLatin1String("TsLib"), QString() /* spec */);
+    else
+#endif
+        new QEvdevTouchManager(QLatin1String("EvdevTouch"), QString() /* spec */, this);
+#endif
+}
+
+EGLNativeDisplayType QEglFSIntegration::nativeDisplay() const
+{
+    return qt_egl_device_integration()->platformDisplay();
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/platforms/eglfs/api/qeglfsintegration_p.h b/src/plugins/platforms/eglfs/api/qeglfsintegration_p.h
new file mode 100644
index 0000000000..861a11e578
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfsintegration_p.h
@@ -0,0 +1,122 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEGLFSINTEGRATION_H
+#define QEGLFSINTEGRATION_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 "qeglfsglobal.h"
+#include <QtCore/QVariant>
+#include <qpa/qplatformintegration.h>
+#include <qpa/qplatformnativeinterface.h>
+#include <qpa/qplatformscreen.h>
+
+QT_BEGIN_NAMESPACE
+
+class QEglFSWindow;
+class QEglFSContext;
+class QFbVtHandler;
+class QEvdevKeyboardManager;
+
+class Q_EGLFS_EXPORT QEglFSIntegration : public QPlatformIntegration, public QPlatformNativeInterface
+{
+public:
+    QEglFSIntegration();
+
+    void initialize() Q_DECL_OVERRIDE;
+    void destroy() Q_DECL_OVERRIDE;
+
+    EGLDisplay display() const { return m_display; }
+
+    QAbstractEventDispatcher *createEventDispatcher() const Q_DECL_OVERRIDE;
+    QPlatformFontDatabase *fontDatabase() const Q_DECL_OVERRIDE;
+    QPlatformServices *services() const Q_DECL_OVERRIDE;
+    QPlatformInputContext *inputContext() const Q_DECL_OVERRIDE { return m_inputContext; }
+    QPlatformTheme *createPlatformTheme(const QString &name) const Q_DECL_OVERRIDE;
+
+    QPlatformWindow *createPlatformWindow(QWindow *window) const Q_DECL_OVERRIDE;
+    QPlatformBackingStore *createPlatformBackingStore(QWindow *window) const Q_DECL_OVERRIDE;
+    QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const Q_DECL_OVERRIDE;
+    QPlatformOffscreenSurface *createPlatformOffscreenSurface(QOffscreenSurface *surface) const Q_DECL_OVERRIDE;
+
+    bool hasCapability(QPlatformIntegration::Capability cap) const Q_DECL_OVERRIDE;
+
+    QPlatformNativeInterface *nativeInterface() const Q_DECL_OVERRIDE;
+
+    // QPlatformNativeInterface
+    void *nativeResourceForIntegration(const QByteArray &resource) Q_DECL_OVERRIDE;
+    void *nativeResourceForScreen(const QByteArray &resource, QScreen *screen) Q_DECL_OVERRIDE;
+    void *nativeResourceForWindow(const QByteArray &resource, QWindow *window) Q_DECL_OVERRIDE;
+    void *nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context) Q_DECL_OVERRIDE;
+    NativeResourceForContextFunction nativeResourceFunctionForContext(const QByteArray &resource) Q_DECL_OVERRIDE;
+
+    QFunctionPointer platformFunction(const QByteArray &function) const Q_DECL_OVERRIDE;
+
+    QFbVtHandler *vtHandler() { return m_vtHandler.data(); }
+
+    void addScreen(QPlatformScreen *screen);
+    void removeScreen(QPlatformScreen *screen);
+
+private:
+    EGLNativeDisplayType nativeDisplay() const;
+    void createInputHandlers();
+    static void loadKeymapStatic(const QString &filename);
+
+    EGLDisplay m_display;
+    QPlatformInputContext *m_inputContext;
+    QScopedPointer<QPlatformFontDatabase> m_fontDb;
+    QScopedPointer<QPlatformServices> m_services;
+    QScopedPointer<QFbVtHandler> m_vtHandler;
+    QEvdevKeyboardManager *m_kbdMgr;
+    bool m_disableInputHandlers;
+};
+
+QT_END_NAMESPACE
+
+#endif // QEGLFSINTEGRATION_H
diff --git a/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow.cpp b/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow.cpp
new file mode 100644
index 0000000000..7de5379ae3
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow.cpp
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeglfsoffscreenwindow_p.h"
+#include "qeglfshooks_p.h"
+#include <QtGui/QOffscreenSurface>
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
+
+QT_BEGIN_NAMESPACE
+
+/*
+    In some cases pbuffers are not available. Triggering QtGui's built-in
+    fallback for a hidden QWindow is not suitable for eglfs since this would be
+    treated as an attempt to create multiple top-level, native windows.
+
+    Therefore this class is provided as an alternative to QEGLPbuffer.
+
+    This class requires the hooks to implement createNativeOffscreenWindow().
+*/
+
+QEglFSOffscreenWindow::QEglFSOffscreenWindow(EGLDisplay display, const QSurfaceFormat &format, QOffscreenSurface *offscreenSurface)
+    : QPlatformOffscreenSurface(offscreenSurface)
+    , m_format(format)
+    , m_display(display)
+    , m_surface(EGL_NO_SURFACE)
+    , m_window(0)
+{
+    m_window = qt_egl_device_integration()->createNativeOffscreenWindow(format);
+    if (!m_window) {
+        qWarning("QEglFSOffscreenWindow: Failed to create native window");
+        return;
+    }
+    EGLConfig config = q_configFromGLFormat(m_display, m_format);
+    m_surface = eglCreateWindowSurface(m_display, config, m_window, 0);
+    if (m_surface != EGL_NO_SURFACE)
+        m_format = q_glFormatFromConfig(m_display, config);
+}
+
+QEglFSOffscreenWindow::~QEglFSOffscreenWindow()
+{
+    if (m_surface != EGL_NO_SURFACE)
+        eglDestroySurface(m_display, m_surface);
+    if (m_window)
+        qt_egl_device_integration()->destroyNativeWindow(m_window);
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow_p.h b/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow_p.h
new file mode 100644
index 0000000000..da9d9b0fd6
--- /dev/null
+++ b/src/plugins/platforms/eglfs/api/qeglfsoffscreenwindow_p.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEGLFSOFFSCREENWINDOW_H
+#define QEGLFSOFFSCREENWINDOW_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 "qeglfsglobal.h"
+#include <qpa/qplatformoffscreensurface.h>
+
+QT_BEGIN_NAMESPACE
+
+class Q_EGLFS_EXPORT QEglFSOffscreenWindow : public QPlatformOffscreenSurface
+{
+public:
+    QEglFSOffscreenWindow(EGLDisplay display, const QSurfaceFormat &format, QOffscreenSurface *offscreenSurface);
+    ~QEglFSOffscreenWindow();
+
+    QSurfaceFormat format() const Q_DECL_OVERRIDE { return m_format; }
+    bool isValid() const Q_DECL_OVERRIDE { return m_surface != EGL_NO_SURFACE; }
+
+private:
+    QSurfaceFormat m_format;
+    EGLDisplay m_display;
+    EGLSurface m_surface;
+    EGLNativeWindowType m_window;
+};
+
+QT_END_NAMESPACE
+
+#endif // QEGLFSOFFSCREENWINDOW_H
diff --git a/src/plugins/platforms/eglfs/api/qeglfswindow_p.h b/src/plugins/platforms/eglfs/api/qeglfswindow_p.h
index aea4ed4806..dd1d2d6fc7 100644
--- a/src/plugins/platforms/eglfs/api/qeglfswindow_p.h
+++ b/src/plugins/platforms/eglfs/api/qeglfswindow_p.h
@@ -52,7 +52,7 @@
 //
 
 #include "qeglfsglobal.h"
-#include "qeglfsintegration.h"
+#include "qeglfsintegration_p.h"
 #include "qeglfsscreen_p.h"
 
 #include <qpa/qplatformwindow.h>