Public Functions
void	cleanup ()

bool	isValid ()

	QX11GLSharedContexts ()

	~QX11GLSharedContexts ()

Public Variables
QEglContext *	argbContext

QEglContext *	rgbContext

QGLContext *	sharedQGLContext

Properties
QPixmap *	sharePixmap

bool	valid

Detailed Description

Definition at line 65 of file qpixmapdata_x11gl_egl.cpp.

Constructors and Destructors

◆ QX11GLSharedContexts()

QX11GLSharedContexts::QX11GLSharedContexts ( )

inline

Definition at line 68 of file qpixmapdata_x11gl_egl.cpp.

         : rgbContext(0)
         , argbContext(0)
         , sharedQGLContext(0)
         , sharePixmap(0)
     {
         EGLint rgbConfigId;
         EGLint argbConfigId;
 
         do {
             EGLConfig rgbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL, QEgl::Renderable);
             EGLConfig argbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL,
                                                        QEgl::Renderable | QEgl::Translucent);
 
             eglGetConfigAttrib(QEgl::display(), rgbConfig, EGL_CONFIG_ID, &rgbConfigId);
             eglGetConfigAttrib(QEgl::display(), argbConfig, EGL_CONFIG_ID, &argbConfigId);
 
             rgbContext = new QEglContext;
             rgbContext->setConfig(rgbConfig);
             rgbContext->createContext();
 
             if (!rgbContext->isValid())
                 break;
 
             // If the RGB & ARGB configs are the same, use the same egl context for both:
             if (rgbConfig == argbConfig)
                 argbContext = rgbContext;
 
             // Otherwise, create a separate context to be used for ARGB pixmaps:
             if (!argbContext) {
                 argbContext = new QEglContext;
                 argbContext->setConfig(argbConfig);
                 bool success = argbContext->createContext(rgbContext);
                 if (!success) {
                     qWarning("QX11GLPixmapData - RGB & ARGB contexts aren't shared");
                     success = argbContext->createContext();
                     if (!success)
                         argbContext = rgbContext; // Might work, worth a shot at least.
                 }
             }
 
             if (!argbContext->isValid())
                 break;
 
             // Create the pixmap which will be used to create the egl surface for the share QGLContext
             QX11PixmapData *rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
             rgbPixmapData->resize(8, 8);
             rgbPixmapData->fill(Qt::red);
             sharePixmap = new QPixmap(rgbPixmapData);
             EGLSurface sharePixmapSurface = QEgl::createSurface(sharePixmap, rgbConfig);
             rgbPixmapData->gl_surface = (void*)sharePixmapSurface;
 
             // Create the actual QGLContext which will be used for sharing
             sharedQGLContext = new QGLContext(QX11GLPixmapData::glFormat());
             sharedQGLContext->d_func()->eglContext = rgbContext;
             sharedQGLContext->d_func()->eglSurface = sharePixmapSurface;
             sharedQGLContext->d_func()->valid = true;
             qt_glformat_from_eglconfig(sharedQGLContext->d_func()->glFormat, rgbConfig);
 
 
             valid = rgbContext->makeCurrent(sharePixmapSurface);
 
             // If the ARGB & RGB configs are different, check ARGB works too:
             if (argbConfig != rgbConfig) {
                 QX11PixmapData *argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
                 argbPixmapData->resize(8, 8);
                 argbPixmapData->fill(Qt::transparent); // Force ARGB
                 QPixmap argbPixmap(argbPixmapData); // destroys pixmap data when goes out of scope
                 EGLSurface argbPixmapSurface = QEgl::createSurface(&argbPixmap, argbConfig);
                 valid = argbContext->makeCurrent(argbPixmapSurface);
                 argbContext->doneCurrent();
                 eglDestroySurface(QEgl::display(), argbPixmapSurface);
                 argbPixmapData->gl_surface = 0;
             }
 
             if (!valid) {
                 qWarning() << "Unable to make pixmap surface current:" << QEgl::errorString();
                 break;
             }
 
             // The pixmap surface destruction hooks are installed by QGLTextureCache, so we
             // must make sure this is instanciated:
             QGLTextureCache::instance();
         } while(0);
 
         if (!valid)
             cleanup();
         else
             qDebug("Using QX11GLPixmapData with EGL config %d for ARGB and config %d for RGB", argbConfigId, rgbConfigId);
 
     }

◆ ~QX11GLSharedContexts()

QX11GLSharedContexts::~QX11GLSharedContexts ( )

inline

Definition at line 160 of file qpixmapdata_x11gl_egl.cpp.

                             {
         cleanup();
     }

Functions

◆ cleanup()

void QX11GLSharedContexts::cleanup ( )

inline

Definition at line 164 of file qpixmapdata_x11gl_egl.cpp.

Referenced by QX11GLSharedContexts(), and ~QX11GLSharedContexts().

                    {
         if (sharedQGLContext) {
             delete sharedQGLContext;
             sharedQGLContext = 0;
         }
         if (argbContext && argbContext != rgbContext)
             delete argbContext;
         argbContext = 0;
 
         if (rgbContext) {
             delete rgbContext;
             rgbContext = 0;
         }
 
         // Deleting the QPixmap will fire the pixmap destruction cleanup hooks which in turn
         // will destroy the egl surface:
         if (sharePixmap) {
             delete sharePixmap;
             sharePixmap = 0;
         }
     }