QEgl Namespace Reference

Enumerations
enum	API { OpenGL, OpenVG }
enum	ConfigOption { NoOptions = 0, Translucent = 0x01, Renderable = 0x02 }
enum	PixelFormatMatch { ExactPixelFormat, BestPixelFormat }

Functions
Q_GUI_EXPORT EGLConfig	chooseConfig (const QEglProperties *configAttribs, QEgl::PixelFormatMatch match=QEgl::ExactPixelFormat)
Q_GUI_EXPORT EGLSurface	createSurface (QPaintDevice *device, EGLConfig cfg, const QEglProperties *surfaceAttribs=0)
Q_GUI_EXPORT EGLConfig	defaultConfig (int devType, API api, ConfigOptions options)
Q_GUI_EXPORT EGLDisplay	display ()
Q_GUI_EXPORT void	dumpAllConfigs ()
Q_GUI_EXPORT EGLImageKHR	eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
Q_GUI_EXPORT EGLBoolean	eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR img)
Q_GUI_EXPORT EGLBoolean	eglSwapBuffersRegion2NOK (EGLDisplay dpy, EGLSurface surface, EGLint count, const EGLint *rects)
Q_GUI_EXPORT QString	errorString (EGLint code=eglGetError())
Q_GUI_EXPORT QString	extensions ()
Q_GUI_EXPORT VisualID	getCompatibleVisualId (EGLConfig config)
Q_GUI_EXPORT bool	hasExtension (const char *extensionName)
Q_GUI_EXPORT EGLNativeDisplayType	nativeDisplay ()
Q_GUI_EXPORT EGLNativePixmapType	nativePixmap (QPixmap *)
Q_GUI_EXPORT EGLNativeWindowType	nativeWindow (QWidget *)

Enumeration Type Documentation

API

enum QEgl::API

Enumerator
OpenGL
OpenVG

Definition at line 190 of file qegl_p.h.

    {
        OpenGL,
        OpenVG
    };

ConfigOption

enum QEgl::ConfigOption

Enumerator
NoOptions
Translucent
Renderable

Definition at line 202 of file qegl_p.h.

    {
        NoOptions   = 0,
        Translucent = 0x01,
        Renderable  = 0x02  // Config will be compatable with the paint engines (VG or GL)
    };

PixelFormatMatch

enum QEgl::PixelFormatMatch

Enumerator
ExactPixelFormat
BestPixelFormat

Definition at line 196 of file qegl_p.h.

    {
        ExactPixelFormat,
        BestPixelFormat
    };

Function Documentation

chooseConfig()

EGLConfig QEgl::chooseConfig	(	const QEglProperties *	configAttribs,
		QEgl::PixelFormatMatch	match = QEgl::ExactPixelFormat
	)

Definition at line 288 of file qegl.cpp.

Referenced by QEglContext::chooseConfig(), and QEglContext::setApi().

{
    QEglProperties props(*properties);
    EGLConfig cfg = QEGL_NO_CONFIG;
    do {
        // Get the number of matching configurations for this set of properties.
        EGLint matching = 0;
        EGLDisplay dpy = QEgl::display();
        if (!eglChooseConfig(dpy, 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(display(), props.properties(), &cfg, 1, &matching);
            if (matching < 1)
                continue;
            return cfg;
        }

        // 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(display(), props.properties(), configs, size, &matching);
        for (EGLint index = 0; index < size; ++index) {
            EGLint red, green, blue, alpha;
            eglGetConfigAttrib(display(), configs[index], EGL_RED_SIZE, &red);
            eglGetConfigAttrib(display(), configs[index], EGL_GREEN_SIZE, &green);
            eglGetConfigAttrib(display(), configs[index], EGL_BLUE_SIZE, &blue);
            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))) {
                cfg = configs[index];
                delete [] configs;
                return cfg;
            }
        }
        delete [] configs;
    } while (props.reduceConfiguration());

#ifdef EGL_BIND_TO_TEXTURE_RGBA
    // Don't report an error just yet if we failed to get a pbuffer
    // configuration with texture rendering.  Only report failure if
    // we cannot get any pbuffer configurations at all.
    if (props.value(EGL_BIND_TO_TEXTURE_RGBA) == EGL_DONT_CARE &&
        props.value(EGL_BIND_TO_TEXTURE_RGB) == EGL_DONT_CARE)
#endif
    {
        qWarning() << "QEglContext::chooseConfig(): Could not find a suitable EGL configuration";
        qWarning() << "Requested:" << props.toString();
        qWarning() << "Available:";
        QEgl::dumpAllConfigs();
    }
    return QEGL_NO_CONFIG;
}

createSurface()

EGLSurface QEgl::createSurface	(	QPaintDevice *	device,
		EGLConfig	cfg,
		const QEglProperties *	surfaceAttribs = 0
	)

Definition at line 333 of file qegl_x11.cpp.

Referenced by QX11GLPixmapData::beginPaint(), QScreen::colorCount(), QEglContext::createSurface(), eglSwapBuffersRegion2NOK(), QMeeGoLivePixmapData::getSurfaceForBackingPixmap(), QX11GLSharedContexts::QX11GLSharedContexts(), QEglContext::setApi(), PvrEglScreen::setMode(), and QWSWindow::shuttingDown().

{
    int devType = device->devType();

    if (devType == QInternal::Pbuffer) {
        // TODO
        return EGL_NO_SURFACE;
    }

    QX11PixmapData *x11PixmapData = 0;
    if (devType == QInternal::Pixmap) {
        QPixmapData *pmd = static_cast<QPixmap*>(device)->data_ptr().data();
        if (pmd->classId() == QPixmapData::X11Class)
            x11PixmapData = static_cast<QX11PixmapData*>(pmd);
        else {
            // TODO: Replace the pixmap's data with a new QX11PixmapData
            qWarning("WARNING: Creating an EGL surface on a QPixmap is only supported for QX11PixmapData");
            return EGL_NO_SURFACE;
        }
    } else if ((devType != QInternal::Widget) && (devType != QInternal::Pbuffer)) {
        qWarning("WARNING: Creating an EGLSurface for device type %d isn't supported", devType);
        return EGL_NO_SURFACE;
    }

    VisualID visualId = QEgl::getCompatibleVisualId(config);
    EGLint alphaSize;
    eglGetConfigAttrib(QEgl::display(), config, EGL_ALPHA_SIZE, &alphaSize);

    if (devType == QInternal::Widget) {
        QWidget *widget = static_cast<QWidget*>(device);

        VisualID currentVisualId = 0;
        if (widget->testAttribute(Qt::WA_WState_Created))
            currentVisualId = XVisualIDFromVisual((Visual*)widget->x11Info().visual());

        if (currentVisualId != visualId) {
            // The window is either not created or has the wrong visual. Either way, we need
            // to create a window with the correct visual and call create() on the widget:

            bool visible = widget->isVisible();
            if (visible)
                widget->hide();

            XVisualInfo visualInfo;
            visualInfo.visualid = visualId;
            {
                XVisualInfo *visualInfoPtr;
                int matchingCount = 0;
                visualInfoPtr = XGetVisualInfo(widget->x11Info().display(), VisualIDMask,
                                               &visualInfo, &matchingCount);
                Q_ASSERT(visualInfoPtr); // visualId really should be valid!
                visualInfo = *visualInfoPtr;
                XFree(visualInfoPtr);
            }

            Window parentWindow = RootWindow(widget->x11Info().display(), widget->x11Info().screen());
            if (widget->parentWidget())
                parentWindow = widget->parentWidget()->winId();

            XSetWindowAttributes windowAttribs;
            QColormap colmap = QColormap::instance(widget->x11Info().screen());
            windowAttribs.background_pixel = colmap.pixel(widget->palette().color(widget->backgroundRole()));
            windowAttribs.border_pixel = colmap.pixel(Qt::black);

            unsigned int valueMask = CWBackPixel|CWBorderPixel;
            if (alphaSize > 0) {
                windowAttribs.colormap = XCreateColormap(widget->x11Info().display(), parentWindow,
                                                         visualInfo.visual, AllocNone);
                valueMask |= CWColormap;
            }

            Window window = XCreateWindow(widget->x11Info().display(), parentWindow,
                                          widget->x(), widget->y(), widget->width(), widget->height(),
                                          0, visualInfo.depth, InputOutput, visualInfo.visual,
                                          valueMask, &windowAttribs);

            // This is a nasty hack to get round the fact that we can't be a friend of QWidget:
            qt_set_winid_on_widget(widget, window);

            if (visible)
                widget->show();
        }

        // At this point, the widget's window should be created and have the correct visual. Now we
        // just need to create the EGL surface for it:
        const int *props;
        if (properties)
            props = properties->properties();
        else
            props = 0;
        EGLSurface surf = eglCreateWindowSurface(QEgl::display(), config, (EGLNativeWindowType)widget->winId(), props);
        if (surf == EGL_NO_SURFACE)
            qWarning("QEglContext::createSurface(): Unable to create EGL surface, error = 0x%x", eglGetError());
        return surf;
    }

    if (x11PixmapData) {
        // X11 Pixmaps are only created with a depth, so that's all we need to check
        EGLint configDepth;
        eglGetConfigAttrib(QEgl::display(), config, EGL_BUFFER_SIZE , &configDepth);
        if (x11PixmapData->depth() != configDepth) {
            // The bit depths are wrong which means the EGLConfig isn't compatable with
            // this pixmap. So we need to replace the pixmap's existing data with a new
            // one which is created with the correct depth:

#ifndef QT_NO_XRENDER
            if (configDepth == 32) {
                qWarning("Warning: EGLConfig's depth (32) != pixmap's depth (%d), converting to ARGB32",
                         x11PixmapData->depth());
                x11PixmapData->convertToARGB32(true);
            } else
#endif
            {
                qWarning("Warning: EGLConfig's depth (%d) != pixmap's depth (%d)",
                         configDepth, x11PixmapData->depth());
            }
        }

        QEglProperties surfaceAttribs;

        // If the pixmap can't be bound to a texture, it's pretty useless
        surfaceAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);
        if (alphaSize > 0)
            surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);
        else
            surfaceAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);

        EGLSurface surf = eglCreatePixmapSurface(QEgl::display(), config,
                                                 (EGLNativePixmapType) x11PixmapData->handle(),
                                                 surfaceAttribs.properties());
        x11PixmapData->gl_surface = (void*)surf;
        QImagePixmapCleanupHooks::enableCleanupHooks(x11PixmapData);
        return surf;
    }

    return EGL_NO_SURFACE;
}

defaultConfig()

EGLConfig QEgl::defaultConfig	(	int	devType,
		API	api,
		ConfigOptions	options
	)

Definition at line 126 of file qegl.cpp.

Referenced by QMeeGoLivePixmapData::getSurfaceForBackingPixmap(), and QX11GLSharedContexts::QX11GLSharedContexts().

{
    if ( (devType != QInternal::Pixmap) && ((options & Renderable) == 0))
        qWarning("QEgl::defaultConfig() - Only configs for pixmaps make sense to be read-only!");

    EGLConfig* targetConfig = 0;

    static EGLConfig defaultVGConfigs[] = {
        QEGL_NO_CONFIG, // 0    Window  Renderable  Translucent
        QEGL_NO_CONFIG, // 1    Window  Renderable  Opaque
        QEGL_NO_CONFIG, // 2    Pixmap  Renderable  Translucent
        QEGL_NO_CONFIG, // 3    Pixmap  Renderable  Opaque
        QEGL_NO_CONFIG, // 4    Pixmap  ReadOnly    Translucent
        QEGL_NO_CONFIG  // 5    Pixmap  ReadOnly    Opaque
    };
    if (api == OpenVG) {
        if (devType == QInternal::Widget) {
            if (options & Translucent)
                targetConfig = &(defaultVGConfigs[0]);
            else
                targetConfig = &(defaultVGConfigs[1]);
        } else if (devType == QInternal::Pixmap) {
            if (options & Renderable) {
                if (options & Translucent)
                    targetConfig = &(defaultVGConfigs[2]);
                else // Opaque
                    targetConfig = &(defaultVGConfigs[3]);
            } else { // Read-only
                if (options & Translucent)
                    targetConfig = &(defaultVGConfigs[4]);
                else // Opaque
                    targetConfig = &(defaultVGConfigs[5]);
            }
        }
    }


    static EGLConfig defaultGLConfigs[] = {
        QEGL_NO_CONFIG, // 0    Window  Renderable  Translucent
        QEGL_NO_CONFIG, // 1    Window  Renderable  Opaque
        QEGL_NO_CONFIG, // 2    PBuffer Renderable  Translucent
        QEGL_NO_CONFIG, // 3    PBuffer Renderable  Opaque
        QEGL_NO_CONFIG, // 4    Pixmap  Renderable  Translucent
        QEGL_NO_CONFIG, // 5    Pixmap  Renderable  Opaque
        QEGL_NO_CONFIG, // 6    Pixmap  ReadOnly    Translucent
        QEGL_NO_CONFIG  // 7    Pixmap  ReadOnly    Opaque
    };
    if (api == OpenGL) {
        if (devType == QInternal::Widget) {
            if (options & Translucent)
                targetConfig = &(defaultGLConfigs[0]);
            else // Opaque
                targetConfig = &(defaultGLConfigs[1]);
        } else if (devType == QInternal::Pbuffer) {
            if (options & Translucent)
                targetConfig = &(defaultGLConfigs[2]);
            else // Opaque
                targetConfig = &(defaultGLConfigs[3]);
        } else if (devType == QInternal::Pixmap) {
            if (options & Renderable) {
                if (options & Translucent)
                    targetConfig = &(defaultGLConfigs[4]);
                else // Opaque
                    targetConfig = &(defaultGLConfigs[5]);
            } else { // ReadOnly
                if (options & Translucent)
                    targetConfig = &(defaultGLConfigs[6]);
                else // Opaque
                    targetConfig = &(defaultGLConfigs[7]);
            }
        }
    }

    if (!targetConfig) {
        qWarning("QEgl::defaultConfig() - No default config for device/api/options combo");
        return QEGL_NO_CONFIG;
    }
    if (*targetConfig != QEGL_NO_CONFIG)
        return *targetConfig;


    // We haven't found an EGL config for the target config yet, so do it now:


    // Allow overriding from an environment variable:
    QByteArray configId;
    if (api == OpenVG)
        configId = qgetenv("QT_VG_EGL_CONFIG");
    else
        configId = qgetenv("QT_GL_EGL_CONFIG");
    if (!configId.isEmpty()) {
        // Overridden, so get the EGLConfig for the specified config ID:
        EGLint properties[] = {
            EGL_CONFIG_ID, (EGLint)configId.toInt(),
            EGL_NONE
        };
        EGLint configCount = 0;
        eglChooseConfig(display(), properties, targetConfig, 1, &configCount);
        if (configCount > 0)
            return *targetConfig;
        qWarning() << "QEgl::defaultConfig() -" << configId << "appears to be invalid";
    }

    QEglProperties configAttribs;
    configAttribs.setRenderableType(api);

    EGLint surfaceType;
    switch (devType) {
        case QInternal::Widget:
            surfaceType = EGL_WINDOW_BIT;
            break;
        case QInternal::Pixmap:
            surfaceType = EGL_PIXMAP_BIT;
            break;
        case QInternal::Pbuffer:
            surfaceType = EGL_PBUFFER_BIT;
            break;
        default:
            qWarning("QEgl::defaultConfig() - Can't create EGL surface for %d device type", devType);
            return QEGL_NO_CONFIG;
    };
#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
    // For OpenVG, we try to create a surface using a pre-multiplied format if
    // the surface needs to have an alpha channel:
    if (api == OpenVG && (options & Translucent))
        surfaceType |= EGL_VG_ALPHA_FORMAT_PRE_BIT;
#endif
    configAttribs.setValue(EGL_SURFACE_TYPE, surfaceType);

#ifdef EGL_BIND_TO_TEXTURE_RGBA
    if (devType == QInternal::Pixmap || devType == QInternal::Pbuffer) {
        if (options & Translucent)
            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
        else
            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
    }
#endif

    // Add paint engine requirements
    if (api == OpenVG) {
#if !defined(QVG_SCISSOR_CLIP) && defined(EGL_ALPHA_MASK_SIZE)
        configAttribs.setValue(EGL_ALPHA_MASK_SIZE, 1);
#endif
    } else {
        // Both OpenGL paint engines need to have stencil and sample buffers
        configAttribs.setValue(EGL_STENCIL_SIZE, 1);
        configAttribs.setValue(EGL_SAMPLE_BUFFERS, 1);
#ifndef QT_OPENGL_ES_2
        // Additionally, the GL1 engine likes to have a depth buffer for clipping
        configAttribs.setValue(EGL_DEPTH_SIZE, 1);
#endif
    }

    if (options & Translucent)
        configAttribs.setValue(EGL_ALPHA_SIZE, 1);

    *targetConfig = chooseConfig(&configAttribs, QEgl::BestPixelFormat);
    return *targetConfig;
}

display()

EGLDisplay QEgl::display

(

)

Definition at line 589 of file qegl.cpp.

Referenced by QSystemTrayIconSys::addToTray(), chooseConfig(), QX11Data::clipboardReadIncrementalProperty(), QXlibClipboard::clipboardReadProperty(), QX11Data::clipboardReadProperty(), QX11Data::clipboardWaitForEvent(), QEglContext::configAttrib(), QEglContext::createContext(), createContext(), QXlibCursor::createCursorBitmap(), QXlibCursor::createCursorShape(), QMeeGoGraphicsSystem::createFenceSync(), createSurface(), QTreeWidgetItem::data(), QEglContextTracker::deref(), QMeeGoPixmapData::destroyEGLSharedImage(), QMeeGoGraphicsSystem::destroyFenceSync(), QMeeGoLivePixmapData::destroySurfaceForPixmapData(), QX11EmbedContainer::discardClient(), QEglContext::display(), QItemDelegate::doLayout(), QEglContext::doneCurrent(), eglCreateImageKHR(), eglDestroyImageKHR(), eglSwapBuffersRegion2NOK(), QX11EmbedContainer::embedClient(), QX11EmbedWidget::embedInto(), QVGEGLWindowSurfaceDirect::ensureContext(), QX11EmbedWidget::event(), QX11EmbedContainer::event(), QX11EmbedWidget::eventFilter(), QX11EmbedContainer::eventFilter(), extensions(), QWSYellowSurface::flush(), QMeeGoPixmapData::fromEGLSharedImage(), getCompatibleVisualId(), QXlibClipboard::getDataInFormat(), QSystemTrayIconSys::getSysTrayVisualInfo(), QXcbWindow::glContext(), QXlibWindow::glContext(), QXlibClipboard::handleSelectionRequest(), hasExtension(), QGLPixelBuffer::hasOpenGLPbuffers(), QX11EmbedContainer::hideEvent(), QMeeGoPixmapData::imageToEGLSharedImage(), QMeeGoLivePixmapData::initializeThroughEGLImage(), QSystemTrayIconSys::locateSystemTray(), QMeeGoLivePixmapData::lock(), QEglContext::makeCurrent(), QXlibClipboard::mimeData(), QX11Data::motifdndEnable(), QBBScreen::newWindowCreated(), QBBIntegration::paintUsingOpenGL(), QDateTimeParser::parseFormat(), QDirectFbConvenience::pixelFomatHasAlpha(), QBBRootWindow::QBBRootWindow(), QEglProperties::QEglProperties(), QOpenKODEIntegration::QOpenKODEIntegration(), qt_glformat_from_eglconfig(), qt_init(), qt_mac_post_retranslateAppMenu(), qt_mac_unregister_widget(), qt_mac_updateContentBorderMetricts(), qt_vg_destroy_shared_context(), qt_vg_shared_surface(), query_colormap(), QVNCIntegration::QVNCIntegration(), QX11EmbedContainer::QX11EmbedContainer(), QX11EmbedWidget::QX11EmbedWidget(), QX11GLSharedContexts::QX11GLSharedContexts(), QMeeGoLivePixmapData::release(), QX11EmbedContainer::resizeEvent(), QBBIntegration::screenForWindow(), QXlibClipboard::sendSelection(), QXlibClipboard::sendTargetsSelection(), sendXEmbedMessage(), QWSConnectedEvent::setData(), QWidgetPrivate::setGeometry_sys(), QBBWindow::setScreen(), QMeeGoGraphicsSystem::setSurfaceScaling(), QX11EmbedContainer::showEvent(), QEglContext::swapBuffers(), QEglContext::swapBuffersRegion2NOK(), QXcbConnection::sync(), QSystemTrayIconSys::sysTrayTracker(), QGLWindowSurface::updateGeometry(), QCommonStylePrivate::viewItemLayout(), QVGEGLWindowSurfacePrivate::windowSurfaceSize(), QWSWindowSurface::winId(), QX11EmbedWidget::x11Event(), QX11EmbedContainer::x11Event(), QX11Data::xdndAtomToString(), QX11Data::xdndMimeAtomToString(), QX11Data::xdndMimeStringToAtom(), QX11Data::xdndStringToAtom(), QApplicationPrivate::~QApplicationPrivate(), QX11EmbedContainer::~QX11EmbedContainer(), and QX11EmbedWidget::~QX11EmbedWidget().

{
    static EGLDisplay dpy = EGL_NO_DISPLAY;
    if (!QEglContextTracker::displayOpened()) {
        dpy = eglGetDisplay(nativeDisplay());
        QEglContextTracker::setDisplayOpened();
        if (dpy == EGL_NO_DISPLAY) {
            qWarning("QEgl::display(): Falling back to EGL_DEFAULT_DISPLAY");
            dpy = eglGetDisplay(EGLNativeDisplayType(EGL_DEFAULT_DISPLAY));
        }
        if (dpy == EGL_NO_DISPLAY) {
            qWarning("QEgl::display(): Can't even open the default display");
            return EGL_NO_DISPLAY;
        }

        if (!eglInitialize(dpy, NULL, NULL)) {
            qWarning() << "QEgl::display(): Cannot initialize EGL display:" << QEgl::errorString();
            return EGL_NO_DISPLAY;
        }

        // Resolve the egl extension function pointers:
#if (defined(EGL_KHR_image) || defined(EGL_KHR_image_base)) && !defined(EGL_EGLEXT_PROTOTYPES)
        if (QEgl::hasExtension("EGL_KHR_image") || QEgl::hasExtension("EGL_KHR_image_base")) {
            qt_eglCreateImageKHR = (_eglCreateImageKHR) eglGetProcAddress("eglCreateImageKHR");
            qt_eglDestroyImageKHR = (_eglDestroyImageKHR) eglGetProcAddress("eglDestroyImageKHR");
        }
#endif

        if (QEgl::hasExtension("EGL_NOK_swap_region2")) {
            qt_eglSwapBuffersRegion2NOK = (_eglSwapBuffersRegion2NOK) eglGetProcAddress("eglSwapBuffersRegion2NOK");
        }
    }

    return dpy;
}

dumpAllConfigs()

void QEgl::dumpAllConfigs

(

)

Definition at line 770 of file qegl.cpp.

Referenced by chooseConfig().

{
    QEglProperties props;
    EGLint count = 0;
    if (!eglGetConfigs(display(), 0, 0, &count) || count < 1)
        return;
    EGLConfig *configs = new EGLConfig [count];
    eglGetConfigs(display(), configs, count, &count);
    for (EGLint index = 0; index < count; ++index) {
        props = QEglProperties(configs[index]);
        qWarning() << props.toString();
    }
    delete [] configs;
}

eglCreateImageKHR()

EGLImageKHR QEgl::eglCreateImageKHR	(	EGLDisplay	dpy,
		EGLContext	ctx,
		EGLenum	target,
		EGLClientBuffer	buffer,
		const EGLint *	attrib_list
	)

Definition at line 625 of file qegl.cpp.

Referenced by QMeeGoPixmapData::fromEGLSharedImage(), QMeeGoPixmapData::imageToEGLSharedImage(), QMeeGoLivePixmapData::initializeThroughEGLImage(), and QDri2Context::resize().

{
    if (qt_eglCreateImageKHR)
        return qt_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);

    QEgl::display(); // Initialises function pointers
    if (qt_eglCreateImageKHR)
        return qt_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);

    qWarning("QEgl::eglCreateImageKHR() called but EGL_KHR_image(_base) extension not present");
    return 0;
}

eglDestroyImageKHR()

EGLBoolean QEgl::eglDestroyImageKHR	(	EGLDisplay	dpy,
		EGLImageKHR	img
	)

Definition at line 638 of file qegl.cpp.

Referenced by QMeeGoPixmapData::fromEGLSharedImage(), QMeeGoPixmapData::imageToEGLSharedImage(), QMeeGoLivePixmapData::initializeThroughEGLImage(), and QDri2Context::resize().

{
    if (qt_eglDestroyImageKHR)
        return qt_eglDestroyImageKHR(dpy, img);

    QEgl::display(); // Initialises function pointers
    if (qt_eglDestroyImageKHR)
        return qt_eglDestroyImageKHR(dpy, img);

    qWarning("QEgl::eglDestroyImageKHR() called but EGL_KHR_image(_base) extension not present");
    return 0;
}

eglSwapBuffersRegion2NOK()

EGLBoolean QEgl::eglSwapBuffersRegion2NOK	(	EGLDisplay	dpy,
		EGLSurface	surface,
		EGLint	count,
		const EGLint *	rects
	)

Definition at line 651 of file qegl.cpp.

Referenced by QEglContext::swapBuffersRegion2NOK().

{
    if (qt_eglSwapBuffersRegion2NOK)
        return qt_eglSwapBuffersRegion2NOK(dpy, surface, count, rects);

    QEgl::display(); // Initialises function pointers
    if (qt_eglSwapBuffersRegion2NOK)
        return qt_eglSwapBuffersRegion2NOK(dpy, surface, count, rects);

    qWarning("QEgl::eglSwapBuffersRegion2NOK() called but EGL_NOK_swap_region2 extension not present");
    return 0;
}

errorString()

QString QEgl::errorString

(

EGLint

code = eglGetError()

)

Definition at line 743 of file qegl.cpp.

Referenced by QHttpNetworkConnectionChannel::_q_error(), QX11GLPixmapData::beginPaint(), QEglContext::createContext(), QUrlPrivate::createErrorString(), createPixmapDataSync(), display(), QEglContext::doneCurrent(), QHttpNetworkConnectionPrivate::errorDetail(), QNetworkAccessHttpBackend::httpError(), QGLPixelBufferPrivate::init(), QEglContext::makeCurrent(), QNetworkAccessHttpBackend::needsResetableUploadData(), QDeclarativeDataBlob::networkError(), QDeclarativePixmapReader::networkRequestDone(), QDeclarativeXmlListModelPrivate::notifyQueryStarted(), QRegExp::operator!=(), QSslError::operator!=(), QX11GLSharedContexts::QX11GLSharedContexts(), QDeclarativeTypeData::resolveTypes(), QNetworkSessionPrivate::setALREnabled(), QAbstractFileEngine::setError(), QUrl::swap(), QEglContext::swapBuffers(), QEglContext::swapBuffersRegion2NOK(), QIODevice::write(), QNetworkSessionPrivateImpl::~QNetworkSessionPrivateImpl(), QXmlContentHandler::~QXmlContentHandler(), QXmlDeclHandler::~QXmlDeclHandler(), QXmlDefaultHandler::~QXmlDefaultHandler(), QXmlDTDHandler::~QXmlDTDHandler(), QXmlEntityResolver::~QXmlEntityResolver(), QXmlErrorHandler::~QXmlErrorHandler(), and QXmlLexicalHandler::~QXmlLexicalHandler().

{
    static const char * const errors[] = {
        "Success (0x3000)",                 // No tr
        "Not initialized (0x3001)",         // No tr
        "Bad access (0x3002)",              // No tr
        "Bad alloc (0x3003)",               // No tr
        "Bad attribute (0x3004)",           // No tr
        "Bad config (0x3005)",              // No tr
        "Bad context (0x3006)",             // No tr
        "Bad current surface (0x3007)",     // No tr
        "Bad display (0x3008)",             // No tr
        "Bad match (0x3009)",               // No tr
        "Bad native pixmap (0x300A)",       // No tr
        "Bad native window (0x300B)",       // No tr
        "Bad parameter (0x300C)",           // No tr
        "Bad surface (0x300D)",             // No tr
        "Context lost (0x300E)"             // No tr
    };
    if (code >= 0x3000 && code <= 0x300E) {
        return QString::fromLatin1(errors[code - 0x3000]);
    } else {
        return QLatin1String("0x") + QString::number(int(code), 16);
    }
}

extensions()

QString QEgl::extensions

(

)

Definition at line 785 of file qegl.cpp.

Referenced by QGL2PaintEngineEx::begin(), buildSpec(), QSvgSwitch::draw(), hasExtension(), QImageReaderPrivate::initHandler(), QVGPaintEnginePrivate::initObjects(), parseCoreNode(), q_hasEglExtension(), qgl_use_font(), qglx_getProcAddress(), qt_format_to_attrib_list(), qt_gl_resolve_features(), qt_resolve_buffer_extensions(), QGtkStylePrivate::setupGtkFileChooser(), and QGLContext::tryVisual().

{
    const char* exts = eglQueryString(QEgl::display(), EGL_EXTENSIONS);
    return QString(QLatin1String(exts));
}

getCompatibleVisualId()

VisualID QEgl::getCompatibleVisualId

(

EGLConfig

config

)

defined(QT_NO_XRENDER)

Definition at line 133 of file qegl_x11.cpp.

Referenced by createSurface().

{
    VisualID    visualId = 0;
    EGLint      eglValue = 0;

    EGLint configRedSize = 0;
    eglGetConfigAttrib(display(), config, EGL_RED_SIZE, &configRedSize);

    EGLint configGreenSize = 0;
    eglGetConfigAttrib(display(), config, EGL_GREEN_SIZE, &configGreenSize);

    EGLint configBlueSize = 0;
    eglGetConfigAttrib(display(), config, EGL_BLUE_SIZE, &configBlueSize);

    EGLint configAlphaSize = 0;
    eglGetConfigAttrib(display(), config, EGL_ALPHA_SIZE, &configAlphaSize);

    eglGetConfigAttrib(display(), config, EGL_CONFIG_ID, &eglValue);
    int configId = eglValue;

    // See if EGL provided a valid VisualID:
    eglGetConfigAttrib(display(), config, EGL_NATIVE_VISUAL_ID, &eglValue);
    visualId = (VisualID)eglValue;
    if (visualId) {
        // EGL has suggested a visual id, so get the rest of the visual info for that id:
        XVisualInfo visualInfoTemplate;
        memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
        visualInfoTemplate.visualid = visualId;

        XVisualInfo *chosenVisualInfo;
        int matchingCount = 0;
        chosenVisualInfo = XGetVisualInfo(X11->display, VisualIDMask, &visualInfoTemplate, &matchingCount);
        if (chosenVisualInfo) {
            // Skip size checks if implementation supports non-matching visual
            // and config (http://bugreports.qt-project.org/browse/QTBUG-9444).
            if (QEgl::hasExtension("EGL_NV_post_convert_rounding")) {
                XFree(chosenVisualInfo);
                return visualId;
            }

            int visualRedSize = countBits(chosenVisualInfo->red_mask);
            int visualGreenSize = countBits(chosenVisualInfo->green_mask);
            int visualBlueSize = countBits(chosenVisualInfo->blue_mask);
            int visualAlphaSize = -1; // Need XRender to tell us the alpha channel size

#if !defined(QT_NO_XRENDER)
            if (X11->use_xrender) {
                // If we have XRender, actually check the visual supplied by EGL is ARGB
                XRenderPictFormat *format;
                format = XRenderFindVisualFormat(X11->display, chosenVisualInfo->visual);
                if (format && (format->type == PictTypeDirect))
                    visualAlphaSize = countBits(format->direct.alphaMask);
            }
#endif

            bool visualMatchesConfig = false;
            if ( visualRedSize == configRedSize &&
                 visualGreenSize == configGreenSize &&
                 visualBlueSize == configBlueSize )
            {
                // We need XRender to check the alpha channel size of the visual. If we don't have
                // the alpha size, we don't check it against the EGL config's alpha size.
                if (visualAlphaSize >= 0)
                    visualMatchesConfig = visualAlphaSize == configAlphaSize;
                else
                    visualMatchesConfig = true;
            }

            if (!visualMatchesConfig) {
                if (visualAlphaSize >= 0) {
                    qWarning("Warning: EGL suggested using X Visual ID %d (ARGB%d%d%d%d) for EGL config %d (ARGB%d%d%d%d), but this is incompatable",
                             (int)visualId, visualAlphaSize, visualRedSize, visualGreenSize, visualBlueSize,
                             configId, configAlphaSize, configRedSize, configGreenSize, configBlueSize);
                } else {
                    qWarning("Warning: EGL suggested using X Visual ID %d (RGB%d%d%d) for EGL config %d (RGB%d%d%d), but this is incompatable",
                             (int)visualId, visualRedSize, visualGreenSize, visualBlueSize,
                             configId, configRedSize, configGreenSize, configBlueSize);
                }
                visualId = 0;
            }
        } else {
            qWarning("Warning: EGL suggested using X Visual ID %d for EGL config %d, but that isn't a valid ID",
                     (int)visualId, configId);
            visualId = 0;
        }
        XFree(chosenVisualInfo);
    }
#ifdef QT_DEBUG_X11_VISUAL_SELECTION
    else
        qDebug("EGL did not suggest a VisualID (EGL_NATIVE_VISUAL_ID was zero) for EGLConfig %d", configId);
#endif

    if (visualId) {
#ifdef QT_DEBUG_X11_VISUAL_SELECTION
        if (configAlphaSize > 0)
            qDebug("Using ARGB Visual ID %d provided by EGL for config %d", (int)visualId, configId);
        else
            qDebug("Using Opaque Visual ID %d provided by EGL for config %d", (int)visualId, configId);
#endif
        return visualId;
    }


    // If EGL didn't give us a valid visual ID, try XRender
#if !defined(QT_NO_XRENDER)
    if (!visualId && X11->use_xrender) {
        XVisualInfo visualInfoTemplate;
        memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));

        visualInfoTemplate.c_class = TrueColor;

        XVisualInfo *matchingVisuals;
        int matchingCount = 0;
        matchingVisuals = XGetVisualInfo(X11->display,
                                         VisualClassMask,
                                         &visualInfoTemplate,
                                         &matchingCount);

        for (int i = 0; i < matchingCount; ++i) {
            XRenderPictFormat *format;
            format = XRenderFindVisualFormat(X11->display, matchingVisuals[i].visual);

            // Check the format for the visual matches the EGL config
            if ( (countBits(format->direct.redMask) == configRedSize) &&
                 (countBits(format->direct.greenMask) == configGreenSize) &&
                 (countBits(format->direct.blueMask) == configBlueSize) &&
                 (countBits(format->direct.alphaMask) == configAlphaSize) )
            {
                visualId = matchingVisuals[i].visualid;
                break;
            }
        }
        if (matchingVisuals)
            XFree(matchingVisuals);

    }
    if (visualId) {
# ifdef QT_DEBUG_X11_VISUAL_SELECTION
        if (configAlphaSize > 0)
            qDebug("Using ARGB Visual ID %d provided by XRender for EGL config %d", (int)visualId, configId);
        else
            qDebug("Using Opaque Visual ID %d provided by XRender for EGL config %d", (int)visualId, configId);
# endif // QT_DEBUG_X11_VISUAL_SELECTION
        return visualId;
    }
# ifdef QT_DEBUG_X11_VISUAL_SELECTION
    else
        qDebug("Failed to find an XVisual which matches EGL config %d using XRender", configId);
# endif // QT_DEBUG_X11_VISUAL_SELECTION

#endif 


    // Finally, if XRender also failed to find a visual (or isn't present), try to
    // use XGetVisualInfo and only use the bit depths to match on:
    if (!visualId) {
        XVisualInfo visualInfoTemplate;
        memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
        XVisualInfo *matchingVisuals;
        int matchingCount = 0;

        visualInfoTemplate.depth = configRedSize + configGreenSize + configBlueSize + configAlphaSize;
        matchingVisuals = XGetVisualInfo(X11->display,
                                         VisualDepthMask,
                                         &visualInfoTemplate,
                                         &matchingCount);
        if (!matchingVisuals) {
            // Try again without taking the alpha channel into account:
            visualInfoTemplate.depth = configRedSize + configGreenSize + configBlueSize;
            matchingVisuals = XGetVisualInfo(X11->display,
                                             VisualDepthMask,
                                             &visualInfoTemplate,
                                             &matchingCount);
        }

        if (matchingVisuals) {
            visualId = matchingVisuals[0].visualid;
            XFree(matchingVisuals);
        }
    }

    if (visualId) {
#ifdef QT_DEBUG_X11_VISUAL_SELECTION
        qDebug("Using Visual ID %d provided by XGetVisualInfo for EGL config %d", (int)visualId, configId);
#endif
        return visualId;
    }

    qWarning("Unable to find an X11 visual which matches EGL config %d", configId);
    return (VisualID)0;
}

hasExtension()

bool QEgl::hasExtension

(

const char *

extensionName

)

Definition at line 791 of file qegl.cpp.

Referenced by display(), getCompatibleVisualId(), QGLWindowSurface::hijackWindow(), QMeeGoExtensions::initialize(), and QGLContext::makeCurrent().

{
    QList<QByteArray> extensions =
        QByteArray(reinterpret_cast<const char *>
            (eglQueryString(QEgl::display(), EGL_EXTENSIONS))).split(' ');
    return extensions.contains(extensionName);
}

nativeDisplay()

EGLNativeDisplayType QEgl::nativeDisplay

(

)

Definition at line 55 of file qegl_qpa.cpp.

Referenced by QXlibClipboard::clipboardReadProperty(), QXlibCursor::createCursorBitmap(), QXlibCursor::createCursorShape(), QXlibScreen::defaultVisual(), display(), QXlibClipboard::getDataInFormat(), QBBScreenEventHandler::handleDisplayEvent(), QXlibClipboard::handleSelectionRequest(), QXlibClipboard::mimeData(), screenForDevice(), QXlibClipboard::sendSelection(), and QXlibClipboard::sendTargetsSelection().

{
    return EGLNativeDisplayType(EGL_DEFAULT_DISPLAY);
}

nativePixmap()

EGLNativePixmapType QEgl::nativePixmap

(

QPixmap *

pixmap

)

Definition at line 65 of file qegl_qpa.cpp.

Referenced by eglSwapBuffersRegion2NOK(), and screenForDevice().

{
    Q_UNUSED(pixmap);
    return 0;
}

nativeWindow()

EGLNativeWindowType QEgl::nativeWindow

(

QWidget *

widget

)

Definition at line 60 of file qegl_qpa.cpp.

Referenced by eglSwapBuffersRegion2NOK(), and screenForDevice().

{
    return (EGLNativeWindowType)(widget->winId());
}