FCL/sf/mw/qt: comparison src/gui/egl/qegl.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
 **
 // If a background thread modifies the value, the worst that will
 // happen is a redundant eglMakeCurrent() in the foreground thread.
 static QEglContext * volatile currentGLContext = 0;
 static QEglContext * volatile currentVGContext = 0;
+EGLDisplay QEglContext::dpy = EGL_NO_DISPLAY;
 QEglContext::QEglContext()
 : apiType(QEgl::OpenGL)
-, dpy(EGL_NO_DISPLAY)
 , ctx(EGL_NO_CONTEXT)
 , cfg(0)
 , currentSurface(EGL_NO_SURFACE)
 , current(false)
 , ownsContext(true)
 {
 }
 QEglContext::~QEglContext()
 {
-destroy();
+destroyContext();
 if (currentGLContext == this)
 currentGLContext = 0;
 if (currentVGContext == this)
 currentVGContext = 0;
 bool QEglContext::isCurrent() const
 {
 return current;
 }
-// Open the EGL display associated with "device".
-bool QEglContext::openDisplay(QPaintDevice *device)
-{
-if (dpy == EGL_NO_DISPLAY)
-dpy = defaultDisplay(device);
-return (dpy != EGL_NO_DISPLAY);
-}
 // Choose a configuration that matches "properties".
 bool QEglContext::chooseConfig
 (const QEglProperties& properties, QEgl::PixelFormatMatch match)
 {
 QEglProperties props(properties);
 do {
 // Get the number of matching configurations for this set of properties.
 EGLint matching = 0;
-if (!eglChooseConfig(dpy, props.properties(), 0, 0, &matching) || !matching)
+if (!eglChooseConfig(display(), props.properties(), 0, 0, &matching) || !matching)
 continue;
 // If we want the best pixel format, then return the first
 // matching configuration.
 if (match == QEgl::BestPixelFormat) {
-eglChooseConfig(dpy, props.properties(), &cfg, 1, &matching);
+eglChooseConfig(display(), props.properties(), &cfg, 1, &matching);
 if (matching < 1)
 continue;
 return true;
 }
 // Fetch all of the matching configurations and find the
 // first that matches the pixel format we wanted.
 EGLint size = matching;
 EGLConfig *configs = new EGLConfig [size];
-eglChooseConfig(dpy, props.properties(), configs, size, &matching);
+eglChooseConfig(display(), props.properties(), configs, size, &matching);
 for (EGLint index = 0; index < size; ++index) {
 EGLint red, green, blue, alpha;
-eglGetConfigAttrib(dpy, configs[index], EGL_RED_SIZE, &red);
+eglGetConfigAttrib(display(), configs[index], EGL_RED_SIZE, &red);
-eglGetConfigAttrib(dpy, configs[index], EGL_GREEN_SIZE, &green);
+eglGetConfigAttrib(display(), configs[index], EGL_GREEN_SIZE, &green);
-eglGetConfigAttrib(dpy, configs[index], EGL_BLUE_SIZE, &blue);
+eglGetConfigAttrib(display(), configs[index], EGL_BLUE_SIZE, &blue);
-eglGetConfigAttrib(dpy, configs[index], EGL_ALPHA_SIZE, &alpha);
+eglGetConfigAttrib(display(), configs[index], EGL_ALPHA_SIZE, &alpha);
 if (red == props.value(EGL_RED_SIZE) &&
 green == props.value(EGL_GREEN_SIZE) &&
 blue == props.value(EGL_BLUE_SIZE) &&
 (props.value(EGL_ALPHA_SIZE) == 0 ||
 alpha == props.value(EGL_ALPHA_SIZE))) {
 #endif
 sharing = false;
 if (shareContext && shareContext->ctx == EGL_NO_CONTEXT)
 shareContext = 0;
 if (shareContext) {
-ctx = eglCreateContext(dpy, cfg, shareContext->ctx, contextProps.properties());
+ctx = eglCreateContext(display(), cfg, shareContext->ctx, contextProps.properties());
 if (ctx == EGL_NO_CONTEXT) {
 qWarning() << "QEglContext::createContext(): Could not share context:" << errorString(eglGetError());
 shareContext = 0;
 } else {
 sharing = true;
 }
 }
 if (ctx == EGL_NO_CONTEXT) {
-ctx = eglCreateContext(dpy, cfg, 0, contextProps.properties());
+ctx = eglCreateContext(display(), cfg, 0, contextProps.properties());
 if (ctx == EGL_NO_CONTEXT) {
 qWarning() << "QEglContext::createContext(): Unable to create EGL context:" << errorString(eglGetError());
 return false;
 }
 }
 void QEglContext::destroySurface(EGLSurface surface)
 {
 if (surface != EGL_NO_SURFACE) {
 if (surface == currentSurface)
 doneCurrent();
-eglDestroySurface(dpy, surface);
+eglDestroySurface(display(), surface);
 }
 }
 // Destroy the context.  Note: this does not destroy the surface.
-void QEglContext::destroy()
+void QEglContext::destroyContext()
 {
 if (ctx != EGL_NO_CONTEXT && ownsContext)
-eglDestroyContext(dpy, ctx);
+eglDestroyContext(display(), ctx);
-dpy = EGL_NO_DISPLAY;
 ctx = EGL_NO_CONTEXT;
 cfg = 0;
 }
 bool QEglContext::makeCurrent(EGLSurface surface)
 #ifdef EGL_OPENVG_API
 if (apiType == QEgl::OpenVG)
 eglBindAPI(EGL_OPENVG_API);
 #endif
-bool ok = eglMakeCurrent(dpy, surface, surface, ctx);
+bool ok = eglMakeCurrent(display(), surface, surface, ctx);
 if (!ok)
 qWarning() << "QEglContext::makeCurrent():" << errorString(eglGetError());
 return ok;
 }
 #ifdef EGL_OPENVG_API
 if (apiType == QEgl::OpenVG)
 eglBindAPI(EGL_OPENVG_API);
 #endif
-bool ok = eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+bool ok = eglMakeCurrent(display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 if (!ok)
 qWarning() << "QEglContext::doneCurrent():" << errorString(eglGetError());
 return ok;
 }
 bool QEglContext::swapBuffers(EGLSurface surface)
 {
 if(ctx == EGL_NO_CONTEXT)
 return false;
-bool ok = eglSwapBuffers(dpy, surface);
+bool ok = eglSwapBuffers(display(), surface);
 if (!ok)
 qWarning() << "QEglContext::swapBuffers():" << errorString(eglGetError());
 return ok;
 }
 }
 // Query the value of a configuration attribute.
 bool QEglContext::configAttrib(int name, EGLint *value) const
 {
-return eglGetConfigAttrib(dpy, cfg, name, value);
+return eglGetConfigAttrib(display(), cfg, name, value);
 }
 // Retrieve all of the properties on "cfg".  If zero, return
 // the context's configuration.
 QEglProperties QEglContext::configProperties(EGLConfig cfg) const
 if (!cfg)
 cfg = config();
 QEglProperties props;
 for (int name = 0x3020; name <= 0x304F; ++name) {
 EGLint value;
-if (name != EGL_NONE && eglGetConfigAttrib(dpy, cfg, name, &value))
+if (name != EGL_NONE && eglGetConfigAttrib(display(), cfg, name, &value))
 props.setValue(name, value);
 }
 eglGetError();  // Clear the error state.
 return props;
 }
-// Initialize and return the default display.
+EGLDisplay QEglContext::display()
-EGLDisplay QEglContext::defaultDisplay(QPaintDevice *device)
+{
-{
+static bool openedDisplay = false;
-static EGLDisplay dpy = EGL_NO_DISPLAY;
-if (dpy == EGL_NO_DISPLAY) {
+if (!openedDisplay) {
-dpy = getDisplay(device);
+dpy = eglGetDisplay(nativeDisplay());
+openedDisplay = true;
 if (dpy == EGL_NO_DISPLAY) {
-qWarning() << "QEglContext::defaultDisplay(): Cannot open EGL display";
+qWarning("QEglContext::display(): Falling back to EGL_DEFAULT_DISPLAY");
+dpy = eglGetDisplay(EGLNativeDisplayType(EGL_DEFAULT_DISPLAY));
+}
+if (dpy == EGL_NO_DISPLAY) {
+qWarning("QEglContext::display(): Can't even open the default display");
 return EGL_NO_DISPLAY;
 }
 if (!eglInitialize(dpy, NULL, NULL)) {
-qWarning() << "QEglContext::defaultDisplay(): Cannot initialize EGL display:" << errorString(eglGetError());
+qWarning() << "QEglContext::display(): Cannot initialize EGL display:" << errorString(eglGetError());
 return EGL_NO_DISPLAY;
 }
-#ifdef EGL_OPENGL_ES_API
+}
-eglBindAPI(EGL_OPENGL_ES_API);
-#endif
-}
 return dpy;
 }
+#if !defined(Q_WS_X11) && !defined(Q_WS_WINCE) // WinCE & X11 implement this properly
+EGLNativeDisplayType QEglContext::nativeDisplay()
+{
+return EGL_DEFAULT_DISPLAY;
+}
+#endif
 // Return the error string associated with a specific code.
 QString QEglContext::errorString(EGLint code)
 {
 static const char * const errors[] = {
 // Dump all of the EGL configurations supported by the system.
 void QEglContext::dumpAllConfigs()
 {
 QEglProperties props;
 EGLint count = 0;
-if (!eglGetConfigs(dpy, 0, 0, &count) || count < 1)
+if (!eglGetConfigs(display(), 0, 0, &count) || count < 1)
 return;
 EGLConfig *configs = new EGLConfig [count];
-eglGetConfigs(dpy, configs, count, &count);
+eglGetConfigs(display(), configs, count, &count);
 for (EGLint index = 0; index < count; ++index) {
 props = configProperties(configs[index]);
 qWarning() << props.toString();
 }
 delete [] configs;
 }
 QString QEglContext::extensions()
 {
-const char* exts = eglQueryString(QEglContext::defaultDisplay(0), EGL_EXTENSIONS);
+const char* exts = eglQueryString(QEglContext::display(), EGL_EXTENSIONS);
 return QString(QLatin1String(exts));
 }
 bool QEglContext::hasExtension(const char* extensionName)
 {
 QList<QByteArray> extensions =
 QByteArray(reinterpret_cast<const char *>
-(eglQueryString(QEglContext::defaultDisplay(0), EGL_EXTENSIONS))).split(' ');
+(eglQueryString(QEglContext::display(), EGL_EXTENSIONS))).split(' ');
 return extensions.contains(extensionName);
 }
 QEglContext *QEglContext::currentContext(QEgl::API api)
 {

changeset 7	f7bc934e204c
parent 3	41300fa6a67c
child 23	89e065397ea6