1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make use of our egl convenience code for QNX QPA

Browse Source 
This fixes various problems that occur because the current egl context
assumes OpenGL ES 2.0 and does not support newer versions of ES.

Task-number: QTBUG-64306
Change-Id: I81466ba5cf028b47ca5a2ebcdc702167aff655a2
Reviewed-by: James McDonnell <jmcdonnell@blackberry.com>
This commit is contained in:
Adam Treat 2017-12-02 10:36:12 -05:00
parent ce8e72d040
commit 36171af399
9 changed files with 162 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/platforms/qnx/qnx.pro
View File

@ -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) {

130
src/plugins/platforms/qnx/qqnxeglwindow.cpp
View File

@ -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");

16
src/plugins/platforms/qnx/qqnxeglwindow.h
View File

@ -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

212
src/plugins/platforms/qnx/qqnxglcontext.cpp
View File

@ -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);
}
EGLSurface QQnxGLContext::eglSurfaceForPlatformSurface(QPlatformSurface *surface)
{
QQnxEglWindow *window = static_cast<QQnxEglWindow *>(surface);
window->ensureInitialized(this);
return window->surface();
}
bool QQnxGLContext::makeCurrent(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);
}
void QQnxGLContext::doneCurrent()
{
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();
QEGLPlatformContext::swapBuffers(surface);
QQnxEglWindow *platformWindow = static_cast<QQnxEglWindow*>(surface);
platformWindow->windowPosted();
}
QFunctionPointer QQnxGLContext::getProcAddress(const char *procName)
void QQnxGLContext::doneCurrent()
{
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());
// 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;
}
EGLint *QQnxGLContext::contextAttrs(const QSurfaceFormat &format)
{
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

30
src/plugins/platforms/qnx/qqnxglcontext.h
View File

@ -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;
void doneCurrent() override;
virtual QSurfaceFormat format() const override { return m_windowFormat; }
bool isSharing() const 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

53
src/plugins/platforms/qnx/qqnxintegration.cpp
View File

@ -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

2
src/plugins/platforms/qnx/qqnxnativeinterface.cpp
View File

@ -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;
}

10
src/plugins/platforms/qnx/qqnxscreen.h
View File

@ -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;

3
src/plugins/platforms/qnx/qqnxwindow.h
View File

@ -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;