Q_D(QGuiGLContext);
d->platformGLContext = QGuiApplicationPrivate::platformIntegration()->createPlatformGLContext(this);
+ d->platformGLContext->setContext(this);
return d->platformGLContext;
}
Reimplement this function in a subclass to indicate what format the glContext actually has.
*/
+
+struct QPlatformGLContextPrivate
+{
+ QGuiGLContext *context;
+};
+
+QPlatformGLContext::QPlatformGLContext()
+ : d_ptr(new QPlatformGLContextPrivate)
+{
+ Q_D(QPlatformGLContext);
+ d->context = 0;
+}
+
+QPlatformGLContext::~QPlatformGLContext()
+{
+}
+
+QGuiGLContext *QPlatformGLContext::context() const
+{
+ Q_D(const QPlatformGLContext);
+ return d->context;
+}
+
+void QPlatformGLContext::setContext(QGuiGLContext *context)
+{
+ Q_D(QPlatformGLContext);
+ d->context = context;
+}
friend class QPlatformWindow;
};
+class QPlatformGLContextPrivate;
+
class Q_GUI_EXPORT QPlatformGLContext
{
+ Q_DECLARE_PRIVATE(QPlatformGLContext)
public:
- virtual ~QPlatformGLContext() {}
+ QPlatformGLContext();
+ virtual ~QPlatformGLContext();
virtual QSurfaceFormat format() const = 0;
virtual void doneCurrent() = 0;
virtual void (*getProcAddress(const QByteArray &procName)) () = 0;
+
+ QGuiGLContext *context() const;
+
+private:
+ friend class QGuiGLContext;
+
+ QScopedPointer<QPlatformGLContextPrivate> d_ptr;
+
+ void setContext(QGuiGLContext *context);
+
+ Q_DISABLE_COPY(QPlatformGLContext)
};
QT_END_NAMESPACE
#include <QtGui/qwindowsysteminterface_qpa.h>
#include <QtGui/qwindow.h>
+#include <QtGui/qscreen.h>
class QPlatformWindowPrivate
{
}
/*!
+ Returns the platform screen handle corresponding to this platform window.
+*/
+QPlatformScreen *QPlatformWindow::screen() const
+{
+ Q_D(const QPlatformWindow);
+ return d->window->screen()->handle();
+}
+
+/*!
Returns the actual surface format of the window.
*/
QSurfaceFormat QPlatformWindow::format() const
QT_MODULE(Gui)
+class QPlatformScreen;
class QPlatformWindowPrivate;
class QWindow;
QWindow *window() const;
QPlatformWindow *parent() const;
+ QPlatformScreen *screen() const;
+
virtual QSurfaceFormat format() const;
virtual void setGeometry(const QRect &rect);
contains(QT_CONFIG,opengles2) {
+ CONFIG += opengl
HEADERS += \
$$PWD/qeglconvenience_p.h \
$$PWD/qeglplatformcontext_p.h
TEMPLATE = lib
CONFIG += plugin
-QT += opengl core-private gui-private opengl-private
+QT += opengl core-private gui-private opengl-private platformsupport-private widgets-private
DESTDIR = $$QT.gui.plugins/platforms
SOURCES = main.cpp \
qeglfsintegration.cpp \
- ../eglconvenience/qeglconvenience.cpp \
- ../eglconvenience/qeglplatformcontext.cpp \
qeglfswindow.cpp \
- qeglfswindowsurface.cpp \
+ qeglfsbackingstore.cpp \
qeglfsscreen.cpp
HEADERS = qeglfsintegration.h \
- ../eglconvenience/qeglconvenience.h \
- ../eglconvenience/qeglplatformcontext.h \
qeglfswindow.h \
- qeglfswindowsurface.h \
+ qeglfsbackingstore.h \
qeglfsscreen.h
load(qpa/fontdatabases/genericunix)
**
****************************************************************************/
-#include "qeglfswindowsurface.h"
+#include <QtOpenGL/private/qgl_p.h>
+
+#include "qeglfsbackingstore.h"
#include <QtGui/QPlatformGLContext>
+#include <QtGui/QScreen>
-#include <QtOpenGL/private/qgl_p.h>
#include <QtOpenGL/private/qglpaintdevice_p.h>
QT_BEGIN_NAMESPACE
class QEglFSPaintDevice : public QGLPaintDevice
{
public:
- QEglFSPaintDevice(QEglFSScreen *screen, QWidget *widget)
+ QEglFSPaintDevice(QEglFSScreen *screen)
:QGLPaintDevice(), m_screen(screen)
{
#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglPaintDevice %p, %p, %p",this, screen, widget);
+ qWarning("QEglPaintDevice %p, %p",this, screen);
#endif
}
QSize size() const { return m_screen->geometry().size(); }
- QGLContext* context() const { return QGLContext::fromPlatformGLContext(m_screen->platformContext());}
+ QGLContext* context() const { return QGLContext::fromGuiGLContext(m_screen->platformContext()->context()); }
QPaintEngine *paintEngine() const { return qt_qgl_paint_engine(); }
};
-QEglFSWindowSurface::QEglFSWindowSurface( QEglFSScreen *screen, QWidget *window )
- :QWindowSurface(window)
+QEglFSBackingStore::QEglFSBackingStore(QWindow *window)
+ : QPlatformBackingStore(window)
{
#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglWindowSurface %p, %p", window, screen);
+ qWarning("QEglBackingStore %p, %p", window, screen);
#endif
- m_paintDevice = new QEglFSPaintDevice(screen,window);
+ m_paintDevice = new QEglFSPaintDevice(static_cast<QEglFSScreen *>(window->screen()->handle()));
}
-void QEglFSWindowSurface::flush(QWidget *widget, const QRegion ®ion, const QPoint &offset)
+void QEglFSBackingStore::flush(QWindow *widget, const QRegion ®ion, const QPoint &offset)
{
Q_UNUSED(widget);
Q_UNUSED(region);
Q_UNUSED(offset);
#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglWindowSurface::flush %p",widget);
+ qWarning("QEglBackingStore::flush %p",widget);
#endif
- widget->platformWindow()->glContext()->swapBuffers();
+ static_cast<QEglFSPaintDevice *>(m_paintDevice)->context()->swapBuffers();
}
-void QEglFSWindowSurface::resize(const QSize &size)
+void QEglFSBackingStore::resize(const QSize &size, const QRegion &staticContents)
{
Q_UNUSED(size);
+ Q_UNUSED(staticContents);
}
QT_END_NAMESPACE
#include "qeglfsintegration.h"
#include "qeglfswindow.h"
-#include <QtGui/private/qwindowsurface_p.h>
+#include <QtGui/qplatformbackingstore_qpa.h>
QT_BEGIN_NAMESPACE
-class QEglFSWindowSurface : public QWindowSurface
+class QEglFSBackingStore : public QPlatformBackingStore
{
public:
- QEglFSWindowSurface(QEglFSScreen *screen, QWidget *window);
- ~QEglFSWindowSurface() {}
+ QEglFSBackingStore(QWindow *window);
+ ~QEglFSBackingStore() {}
QPaintDevice *paintDevice() { return m_paintDevice; }
- void flush(QWidget *widget, const QRegion ®ion, const QPoint &offset);
- void resize(const QSize &size);
+ void flush(QWindow *window, const QRegion ®ion, const QPoint &offset);
+ void resize(const QSize &size, const QRegion &staticContents);
+
private:
QPaintDevice *m_paintDevice;
};
#include "qeglfsintegration.h"
#include "qeglfswindow.h"
-#include "qeglfswindowsurface.h"
+#include "qeglfsbackingstore.h"
-#include "qgenericunixfontdatabase.h"
+#include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>
+#include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>
#include <QtGui/QPlatformWindow>
-#include <QtGui/QPlatformWindowFormat>
-#include <QtGui/private/qpixmap_raster_p.h>
+#include <QtGui/QSurfaceFormat>
+#include <QtGui/QGuiGLContext>
+#include <QtGui/QScreen>
#include <EGL/egl.h>
QEglFSIntegration::QEglFSIntegration()
: mFontDb(new QGenericUnixFontDatabase())
{
- m_primaryScreen = new QEglFSScreen(EGL_DEFAULT_DISPLAY);
+ screenAdded(new QEglFSScreen(EGL_DEFAULT_DISPLAY));
- mScreens.append(m_primaryScreen);
#ifdef QEGL_EXTRA_DEBUG
qWarning("QEglIntegration\n");
#endif
}
}
-QPlatformPixmap *QEglFSIntegration::createPlatformPixmap(QPlatformPixmap::PixelType type) const
+QPlatformWindow *QEglFSIntegration::createPlatformWindow(QWindow *window) const
{
#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglIntegration::createPlatformPixmap %d\n", type);
+ qWarning("QEglIntegration::createPlatformWindow %p\n",window);
#endif
- return new QRasterPlatformPixmap(type);
+ return new QEglFSWindow(window);
}
-QPlatformWindow *QEglFSIntegration::createPlatformWindow(QWidget *widget, WId winId) const
+
+QPlatformBackingStore *QEglFSIntegration::createPlatformBackingStore(QWindow *window) const
{
- Q_UNUSED(winId);
#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglIntegration::createPlatformWindow %p\n",widget);
+ qWarning("QEglIntegration::createWindowSurface %p\n",widget);
#endif
- return new QEglFSWindow(widget, m_primaryScreen);
+ return new QEglFSBackingStore(window);
}
-
-QWindowSurface *QEglFSIntegration::createWindowSurface(QWidget *widget, WId winId) const
+QPlatformGLContext *QEglFSIntegration::createPlatformGLContext(QGuiGLContext *context) const
{
- Q_UNUSED(winId);
-
-#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglIntegration::createWindowSurface %p\n",widget);
-#endif
- return new QEglFSWindowSurface(m_primaryScreen,widget);
+ return static_cast<QEglFSScreen *>(context->screen()->handle())->platformContext();
}
QPlatformFontDatabase *QEglFSIntegration::fontDatabase() const
return mFontDb;
}
+QAbstractEventDispatcher *QEglFSIntegration::createEventDispatcher() const
+{
+ return createUnixEventDispatcher();
+}
+
QT_END_NAMESPACE
QEglFSIntegration();
bool hasCapability(QPlatformIntegration::Capability cap) const;
- QPlatformPixmap *createPlatformPixmap(QPlatformPixmap::PixelType type) const;
- QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId) const;
- QWindowSurface *createWindowSurface(QWidget *widget, WId winId) const;
- QList<QPlatformScreen *> screens() const { return mScreens; }
+ QPlatformWindow *createPlatformWindow(QWindow *window) const;
+ QPlatformBackingStore *createPlatformBackingStore(QWindow *window) const;
+ QPlatformGLContext *createPlatformGLContext(QGuiGLContext *context) const;
QPlatformFontDatabase *fontDatabase() const;
+ QAbstractEventDispatcher *createEventDispatcher() const;
+
private:
QPlatformFontDatabase *mFontDb;
- QList<QPlatformScreen *> mScreens;
- QEglFSScreen *m_primaryScreen;
};
QT_END_NAMESPACE
****************************************************************************/
#include "qeglfsscreen.h"
+#include "qeglfswindow.h"
-#include "../eglconvenience/qeglconvenience.h"
-#include "../eglconvenience/qeglplatformcontext.h"
+#include <QtPlatformSupport/private/qeglconvenience_p.h>
+#include <QtPlatformSupport/private/qeglplatformcontext_p.h>
#ifdef Q_OPENKODE
#include <KD/kd.h>
{-1, 0}};
#endif //QEGL_EXTRA_DEBUG
+class QEglFSContext : public QEGLPlatformContext
+{
+public:
+ QEglFSContext(const QSurfaceFormat &format, QPlatformGLContext *share, EGLDisplay display,
+ EGLint eglClientVersion = 2, EGLenum eglApi = EGL_OPENGL_ES_API)
+ : QEGLPlatformContext(format, share, display, eglClientVersion, eglApi)
+ {
+ }
+
+ EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface)
+ {
+ QEglFSWindow *window = static_cast<QEglFSWindow *>(surface);
+ QEglFSScreen *screen = static_cast<QEglFSScreen *>(window->screen());
+ return screen->surface();
+ }
+};
+
QEglFSScreen::QEglFSScreen(EGLNativeDisplayType display)
: m_depth(32)
, m_format(QImage::Format_Invalid)
void QEglFSScreen::createAndSetPlatformContext()
{
- QPlatformWindowFormat platformFormat = QPlatformWindowFormat::defaultFormat();
-
- platformFormat.setWindowApi(QPlatformWindowFormat::OpenGL);
+ QSurfaceFormat platformFormat;
QByteArray depthString = qgetenv("QT_QPA_EGLFS_DEPTH");
if (depthString.toInt() == 16) {
- platformFormat.setDepth(16);
+ platformFormat.setDepthBufferSize(16);
platformFormat.setRedBufferSize(5);
platformFormat.setGreenBufferSize(6);
platformFormat.setBlueBufferSize(5);
m_depth = 16;
m_format = QImage::Format_RGB16;
} else {
- platformFormat.setDepth(32);
+ platformFormat.setDepthBufferSize(32);
platformFormat.setRedBufferSize(8);
platformFormat.setGreenBufferSize(8);
platformFormat.setBlueBufferSize(8);
m_depth = 32;
m_format = QImage::Format_RGB32;
}
- if (!qgetenv("QT_QPA_EGLFS_MULTISAMPLE").isEmpty()) {
- platformFormat.setSampleBuffers(true);
- }
+ if (!qgetenv("QT_QPA_EGLFS_MULTISAMPLE").isEmpty())
+ platformFormat.setSamples(4);
- EGLConfig config = q_configFromQPlatformWindowFormat(m_dpy, platformFormat);
+ EGLConfig config = q_configFromGLFormat(m_dpy, platformFormat);
EGLNativeWindowType eglWindow = 0;
#ifdef Q_OPENKODE
qWarning("\n");
#endif
- EGLint temp;
- EGLint attribList[32];
-
- temp = 0;
-
- attribList[temp++] = EGL_CONTEXT_CLIENT_VERSION;
- attribList[temp++] = 2; // GLES version 2
- attribList[temp++] = EGL_NONE;
-
- QEGLPlatformContext *platformContext = new QEGLPlatformContext(m_dpy,config,attribList,m_surface,EGL_OPENGL_ES_API);
+ QEGLPlatformContext *platformContext = new QEglFSContext(platformFormat, 0, m_dpy);
m_platformContext = platformContext;
EGLint w,h; // screen size detection
QPlatformGLContext *platformContext() const;
+ EGLSurface surface() const { return m_surface; }
+
private:
void createAndSetPlatformContext() const;
void createAndSetPlatformContext();
QT_BEGIN_NAMESPACE
-QEglFSWindow::QEglFSWindow(QWidget *w, QEglFSScreen *screen)
- : QPlatformWindow(w), m_screen(screen)
+QEglFSWindow::QEglFSWindow(QWindow *w)
+ : QPlatformWindow(w)
{
static int serialNo = 0;
m_winid = ++serialNo;
#endif
}
-
void QEglFSWindow::setGeometry(const QRect &)
{
// We only support full-screen windows
- QRect rect(m_screen->availableGeometry());
- QWindowSystemInterface::handleGeometryChange(this->widget(), rect);
-
- // Since toplevels are fullscreen, propegate the screen size back to the widget
- widget()->setGeometry(rect);
+ QRect rect(screen()->availableGeometry());
+ QWindowSystemInterface::handleGeometryChange(window(), rect);
QPlatformWindow::setGeometry(rect);
}
return m_winid;
}
-
-
-QPlatformGLContext *QEglFSWindow::glContext() const
-{
-#ifdef QEGL_EXTRA_DEBUG
- qWarning("QEglWindow::glContext %p\n", m_screen->platformContext());
-#endif
- Q_ASSERT(m_screen);
- return m_screen->platformContext();
-}
-
QT_END_NAMESPACE
class QEglFSWindow : public QPlatformWindow
{
public:
- QEglFSWindow(QWidget *w, QEglFSScreen *screen);
+ QEglFSWindow(QWindow *w);
void setGeometry(const QRect &);
WId winId() const;
- QPlatformGLContext *glContext() const;
-
private:
- QEglFSScreen *m_screen;
WId m_winid;
};
QT_END_NAMESPACE