/****************************************************************************+
−
**+
−
** 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 QtOpenGL module of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
#include "qgl.h"+
−
#include <private/qt_x11_p.h>+
−
#include <private/qpixmap_x11_p.h>+
−
#include <private/qimagepixmapcleanuphooks_p.h>+
−
#include <private/qgl_p.h>+
−
#include <private/qpaintengine_opengl_p.h>+
−
#include "qgl_egl_p.h"+
−
#include "qcolormap.h"+
−
#include <QDebug>+
−
+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
+
−
bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,+
−
                             const QX11Info &x11Info, bool useArgbVisual);+
−
+
−
/*+
−
    QGLTemporaryContext implementation+
−
*/+
−
+
−
class QGLTemporaryContextPrivate+
−
{+
−
public:+
−
    bool initialized;+
−
    Window window;+
−
    EGLContext context;+
−
    EGLSurface surface;+
−
    EGLDisplay display;+
−
};+
−
+
−
QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)+
−
    : d(new QGLTemporaryContextPrivate)+
−
{+
−
    d->initialized = false;+
−
    d->window = 0;+
−
    d->context = 0;+
−
    d->surface = 0;+
−
    int screen = 0;+
−
+
−
    d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));+
−
+
−
    if (!eglInitialize(d->display, NULL, NULL)) {+
−
        qWarning("QGLTemporaryContext: Unable to initialize EGL display.");+
−
        return;+
−
    }+
−
+
−
    EGLConfig config;+
−
    int numConfigs = 0;+
−
    EGLint attribs[] = {+
−
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,+
−
#ifdef QT_OPENGL_ES_2+
−
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,+
−
#endif+
−
        EGL_NONE+
−
    };+
−
+
−
    eglChooseConfig(d->display, attribs, &config, 1, &numConfigs);+
−
    if (!numConfigs) {+
−
        qWarning("QGLTemporaryContext: No EGL configurations available.");+
−
        return;+
−
    }+
−
+
−
    XVisualInfo visualInfo;+
−
    XVisualInfo *vi;+
−
    int numVisuals;+
−
    EGLint id = 0;+
−
+
−
    eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);+
−
    if (id == 0) {+
−
        // EGL_NATIVE_VISUAL_ID is optional and might not be supported+
−
        // on some implementations - we'll have to do it the hard way+
−
        QX11Info xinfo;+
−
        qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);+
−
    } else {+
−
        visualInfo.visualid = id;+
−
    }+
−
    vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);+
−
    if (!vi || numVisuals < 1) {+
−
        qWarning("QGLTemporaryContext: Unable to get X11 visual info id.");+
−
        return;+
−
    }+
−
+
−
    d->window = XCreateWindow(X11->display, RootWindow(X11->display, screen),+
−
                              0, 0, 1, 1, 0,+
−
                              vi->depth, InputOutput, vi->visual,+
−
                              0, 0);+
−
+
−
    d->surface = eglCreateWindowSurface(d->display, config, (EGLNativeWindowType) d->window, NULL);+
−
+
−
    if (d->surface == EGL_NO_SURFACE) {+
−
        qWarning("QGLTemporaryContext: Error creating EGL surface.");+
−
        XFree(vi);+
−
        XDestroyWindow(X11->display, d->window);+
−
        return;+
−
    }+
−
+
−
    EGLint contextAttribs[] = {+
−
#ifdef QT_OPENGL_ES_2+
−
        EGL_CONTEXT_CLIENT_VERSION, 2,+
−
#endif+
−
        EGL_NONE+
−
    };+
−
    d->context = eglCreateContext(d->display, config, 0, contextAttribs);+
−
    if (d->context != EGL_NO_CONTEXT+
−
        && eglMakeCurrent(d->display, d->surface, d->surface, d->context))+
−
    {+
−
        d->initialized = true;+
−
    } else {+
−
        qWarning("QGLTemporaryContext: Error creating EGL context.");+
−
        eglDestroySurface(d->display, d->surface);+
−
        XDestroyWindow(X11->display, d->window);+
−
    }+
−
    XFree(vi);+
−
}+
−
+
−
QGLTemporaryContext::~QGLTemporaryContext()+
−
{+
−
    if (d->initialized) {+
−
        eglMakeCurrent(d->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);+
−
        eglDestroyContext(d->display, d->context);+
−
        eglDestroySurface(d->display, d->surface);+
−
        XDestroyWindow(X11->display, d->window);+
−
    }+
−
}+
−
+
−
bool QGLFormat::hasOpenGLOverlays()+
−
{+
−
    return false;+
−
}+
−
+
−
void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)+
−
{+
−
    if (device->devType() == QInternal::Image)+
−
        props.setPixelFormat(static_cast<QImage *>(device)->format());+
−
}+
−
+
−
// Chooses the EGL config and creates the EGL context+
−
bool QGLContext::chooseContext(const QGLContext* shareContext)+
−
{+
−
    Q_D(QGLContext);+
−
+
−
    if (!device())+
−
        return false;+
−
+
−
    int devType = device()->devType();+
−
+
−
    // Get the display and initialize it.+
−
    if (d->eglContext == 0) {+
−
        d->eglContext = new QEglContext();+
−
        d->eglContext->setApi(QEgl::OpenGL);+
−
+
−
        // Construct the configuration we need for this surface.+
−
        QEglProperties configProps;+
−
        qt_egl_set_format(configProps, devType, d->glFormat);+
−
        qt_egl_add_platform_config(configProps, device());+
−
        configProps.setRenderableType(QEgl::OpenGL);+
−
+
−
#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE+
−
        if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) {+
−
            qDebug("Setting EGL_BUFFER_SIZE to 16");+
−
            configProps.setValue(EGL_BUFFER_SIZE, 16);+
−
            configProps.setValue(EGL_ALPHA_SIZE, 0);+
−
        }+
−
+
−
        if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {+
−
            delete d->eglContext;+
−
            d->eglContext = 0;+
−
            return false;+
−
        }+
−
#else+
−
        QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;+
−
        if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) {+
−
            configProps.setValue(EGL_RED_SIZE, 5);+
−
            configProps.setValue(EGL_GREEN_SIZE, 6);+
−
            configProps.setValue(EGL_BLUE_SIZE, 5);+
−
            configProps.setValue(EGL_ALPHA_SIZE, 0);+
−
            matchType = QEgl::ExactPixelFormat;+
−
        }+
−
+
−
        // Search for a matching configuration, reducing the complexity+
−
        // each time until we get something that matches.+
−
        if (!d->eglContext->chooseConfig(configProps, matchType)) {+
−
            delete d->eglContext;+
−
            d->eglContext = 0;+
−
            return false;+
−
        }+
−
#endif+
−
+
−
//        qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config());+
−
//        qDebug() << QEglProperties(d->eglContext->config()).toString();+
−
+
−
        // Create a new context for the configuration.+
−
        if (!d->eglContext->createContext+
−
                (shareContext ? shareContext->d_func()->eglContext : 0)) {+
−
            delete d->eglContext;+
−
            d->eglContext = 0;+
−
            return false;+
−
        }+
−
        d->sharing = d->eglContext->isSharing();+
−
        if (d->sharing && shareContext)+
−
            const_cast<QGLContext *>(shareContext)->d_func()->sharing = true;+
−
+
−
#if defined(EGL_VERSION_1_1)+
−
        if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)+
−
            eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());+
−
#endif+
−
    }+
−
+
−
    // Inform the higher layers about the actual format properties.+
−
    qt_egl_update_format(*(d->eglContext), d->glFormat);+
−
+
−
    return true;+
−
}+
−
+
−
void QGLWidget::resizeEvent(QResizeEvent *)+
−
{+
−
    Q_D(QGLWidget);+
−
    if (!isValid())+
−
        return;+
−
    makeCurrent();+
−
    if (!d->glcx->initialized())+
−
        glInit();+
−
    resizeGL(width(), height());+
−
    //handle overlay+
−
}+
−
+
−
const QGLContext* QGLWidget::overlayContext() const+
−
{+
−
    return 0;+
−
}+
−
+
−
void QGLWidget::makeOverlayCurrent()+
−
{+
−
    //handle overlay+
−
}+
−
+
−
void QGLWidget::updateOverlayGL()+
−
{+
−
    //handle overlay+
−
}+
−
+
−
//#define QT_DEBUG_X11_VISUAL_SELECTION 1+
−
+
−
bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config, const QX11Info &x11Info, bool useArgbVisual)+
−
{+
−
    bool foundVisualIsArgb = useArgbVisual;+
−
+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
    qDebug("qt_egl_setup_x11_visual() - useArgbVisual=%d", useArgbVisual);+
−
#endif+
−
+
−
    memset(&vi, 0, sizeof(XVisualInfo));+
−
+
−
    EGLint eglConfigColorSize;+
−
    eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize);+
−
+
−
    // Check to see if EGL is suggesting an appropriate visual id:+
−
    EGLint nativeVisualId;+
−
    eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId);+
−
    vi.visualid = nativeVisualId;+
−
+
−
    if (vi.visualid) {+
−
        // EGL has suggested a visual id, so get the rest of the visual info for that id:+
−
        XVisualInfo *chosenVisualInfo;+
−
        int matchingCount = 0;+
−
        chosenVisualInfo = XGetVisualInfo(x11Info.display(), VisualIDMask, &vi, &matchingCount);+
−
        if (chosenVisualInfo) {+
−
#if !defined(QT_NO_XRENDER)+
−
            if (useArgbVisual) {+
−
                // Check to make sure the visual provided by EGL is ARGB+
−
                XRenderPictFormat *format;+
−
                format = XRenderFindVisualFormat(x11Info.display(), chosenVisualInfo->visual);+
−
                if (format->type == PictTypeDirect && format->direct.alphaMask) {+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
                    qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);+
−
#endif+
−
                    foundVisualIsArgb = true;+
−
                    vi = *chosenVisualInfo;+
−
                }+
−
                else {+
−
                    qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this is not ARGB",+
−
                             nativeVisualId, (int)config);+
−
                    vi.visualid = 0;+
−
                }+
−
            } else+
−
#endif+
−
            {+
−
                if (eglConfigColorSize == chosenVisualInfo->depth) {+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
                    qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);+
−
#endif+
−
                    vi = *chosenVisualInfo;+
−
                } else+
−
                    qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!",+
−
                             nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize);+
−
            }+
−
            XFree(chosenVisualInfo);+
−
        }+
−
        else {+
−
            qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this seems to be invalid!",+
−
                     nativeVisualId, (int)config);+
−
            vi.visualid = 0;+
−
        }+
−
    }+
−
+
−
    // If EGL does not know the visual ID, so try to select an appropriate one ourselves, first+
−
    // using XRender if we're supposed to have an alpha, then falling back to XGetVisualInfo+
−
+
−
#if !defined(QT_NO_XRENDER)+
−
    if (vi.visualid == 0 && useArgbVisual) {+
−
        // Try to use XRender to find an ARGB visual we can use+
−
        vi.screen  = x11Info.screen();+
−
        vi.depth   = 32; //### We might at some point (soon) get ARGB4444+
−
        vi.c_class = TrueColor;+
−
        XVisualInfo *matchingVisuals;+
−
        int matchingCount = 0;+
−
        matchingVisuals = XGetVisualInfo(x11Info.display(),+
−
                                         VisualScreenMask|VisualDepthMask|VisualClassMask,+
−
                                         &vi, &matchingCount);+
−
+
−
        for (int i = 0; i < matchingCount; ++i) {+
−
            XRenderPictFormat *format;+
−
            format = XRenderFindVisualFormat(x11Info.display(), matchingVisuals[i].visual);+
−
            if (format->type == PictTypeDirect && format->direct.alphaMask) {+
−
                vi = matchingVisuals[i];+
−
                foundVisualIsArgb = true;+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
                qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);+
−
#endif+
−
                break;+
−
            }+
−
        }+
−
        XFree(matchingVisuals);+
−
    }+
−
#endif+
−
+
−
    if (vi.visualid == 0) {+
−
        EGLint depth;+
−
        eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &depth);+
−
        int err;+
−
        err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);+
−
        if (err == 0) {+
−
            qWarning("Warning: Can't find an X visual which matches the EGL config(%d)'s depth (%d)!",+
−
                     (int)config, depth);+
−
            depth = x11Info.depth();+
−
            err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);+
−
            if (err == 0) {+
−
                qWarning("Error: Couldn't get any matching X visual!");+
−
                return false;+
−
            } else+
−
                qWarning("         - Falling back to X11 suggested depth (%d)", depth);+
−
        }+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
        else+
−
            qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);+
−
#endif+
−
+
−
        // Don't try to use ARGB now unless the visual is 32-bit - even then it might stil fail :-(+
−
        if (useArgbVisual)+
−
            foundVisualIsArgb = vi.depth == 32; //### We might at some point (soon) get ARGB4444+
−
    }+
−
+
−
#ifdef QT_DEBUG_X11_VISUAL_SELECTION+
−
    qDebug("Visual Info:");+
−
    qDebug("   bits_per_rgb=%d", vi.bits_per_rgb);+
−
    qDebug("   red_mask=0x%x", vi.red_mask);+
−
    qDebug("   green_mask=0x%x", vi.green_mask);+
−
    qDebug("   blue_mask=0x%x", vi.blue_mask);+
−
    qDebug("   colormap_size=%d", vi.colormap_size);+
−
    qDebug("   c_class=%d", vi.c_class);+
−
    qDebug("   depth=%d", vi.depth);+
−
    qDebug("   screen=%d", vi.screen);+
−
    qDebug("   visualid=%d", vi.visualid);+
−
#endif+
−
    return foundVisualIsArgb;+
−
}+
−
+
−
void QGLWidget::setContext(QGLContext *context, const QGLContext* shareContext, bool deleteOldContext)+
−
{+
−
    Q_D(QGLWidget);+
−
    if (context == 0) {+
−
        qWarning("QGLWidget::setContext: Cannot set null context");+
−
        return;+
−
    }+
−
    if (!context->deviceIsPixmap() && context->device() != this) {+
−
        qWarning("QGLWidget::setContext: Context must refer to this widget");+
−
        return;+
−
    }+
−
+
−
    if (d->glcx)+
−
        d->glcx->doneCurrent();+
−
    QGLContext* oldcx = d->glcx;+
−
    d->glcx = context;+
−
+
−
    if (parentWidget()) {+
−
        // force creation of delay-created widgets+
−
        parentWidget()->winId();+
−
        if (parentWidget()->x11Info().screen() != x11Info().screen())+
−
            d_func()->xinfo = parentWidget()->d_func()->xinfo;+
−
    }+
−
+
−
    // If the application has set WA_TranslucentBackground and not explicitly set+
−
    // the alpha buffer size to zero, modify the format so it have an alpha channel+
−
    QGLFormat& fmt = d->glcx->d_func()->glFormat;+
−
    const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha();+
−
    if (tryArgbVisual && fmt.alphaBufferSize() == -1)+
−
        fmt.setAlphaBufferSize(1);+
−
+
−
    bool createFailed = false;+
−
    if (!d->glcx->isValid()) {+
−
        // Create the QGLContext here, which in turn chooses the EGL config+
−
        // and creates the EGL context:+
−
        if (!d->glcx->create(shareContext ? shareContext : oldcx))+
−
            createFailed = true;+
−
    }+
−
    if (createFailed) {+
−
        if (deleteOldContext)+
−
            delete oldcx;+
−
        return;+
−
    }+
−
+
−
    if (d->glcx->windowCreated() || d->glcx->deviceIsPixmap()) {+
−
        if (deleteOldContext)+
−
            delete oldcx;+
−
        return;+
−
    }+
−
+
−
    bool visible = isVisible();+
−
    if (visible)+
−
        hide();+
−
+
−
    XVisualInfo vi;+
−
    QEglContext *eglContext = d->glcx->d_func()->eglContext;+
−
    bool usingArgbVisual = qt_egl_setup_x11_visual(vi, eglContext->display(), eglContext->config(),+
−
                                                   x11Info(), tryArgbVisual);+
−
+
−
    XSetWindowAttributes a;+
−
+
−
    Window p = RootWindow(x11Info().display(), x11Info().screen());+
−
    if (parentWidget())+
−
        p = parentWidget()->winId();+
−
+
−
    QColormap colmap = QColormap::instance(vi.screen);+
−
    a.background_pixel = colmap.pixel(palette().color(backgroundRole()));+
−
    a.border_pixel = colmap.pixel(Qt::black);+
−
+
−
    unsigned int valueMask = CWBackPixel|CWBorderPixel;+
−
    if (usingArgbVisual) {+
−
        a.colormap = XCreateColormap(x11Info().display(), p, vi.visual, AllocNone);+
−
        valueMask |= CWColormap;+
−
    }+
−
+
−
    Window w = XCreateWindow(x11Info().display(), p, x(), y(), width(), height(),+
−
                             0, vi.depth, InputOutput, vi.visual, valueMask, &a);+
−
+
−
    if (deleteOldContext)+
−
        delete oldcx;+
−
    oldcx = 0;+
−
+
−
    create(w); // Create with the ID of the window we've just created+
−
+
−
+
−
    // Create the EGL surface to draw into.+
−
    QGLContextPrivate *ctxpriv = d->glcx->d_func();+
−
    ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(this);+
−
    if (ctxpriv->eglSurface == EGL_NO_SURFACE) {+
−
        delete ctxpriv->eglContext;+
−
        ctxpriv->eglContext = 0;+
−
        return;+
−
    }+
−
+
−
    d->eglSurfaceWindowId = w; // Remember the window id we created the surface for+
−
+
−
    if (visible)+
−
        show();+
−
+
−
    XFlush(X11->display);+
−
    d->glcx->setWindowCreated(true);+
−
}+
−
+
−
void QGLWidgetPrivate::init(QGLContext *context, const QGLWidget* shareWidget)+
−
{+
−
    Q_Q(QGLWidget);+
−
+
−
    initContext(context, shareWidget);+
−
+
−
    if(q->isValid() && glcx->format().hasOverlay()) {+
−
        //no overlay+
−
        qWarning("QtOpenGL ES doesn't currently support overlays");+
−
    }+
−
}+
−
+
−
void QGLWidgetPrivate::cleanupColormaps()+
−
{+
−
}+
−
+
−
const QGLColormap & QGLWidget::colormap() const+
−
{+
−
    return d_func()->cmap;+
−
}+
−
+
−
void QGLWidget::setColormap(const QGLColormap &)+
−
{+
−
}+
−
+
−
// Re-creates the EGL surface if the window ID has changed or if force is true+
−
void QGLWidgetPrivate::recreateEglSurface(bool force)+
−
{+
−
    Q_Q(QGLWidget);+
−
+
−
    Window currentId = q->winId();+
−
+
−
    if ( force || (currentId != eglSurfaceWindowId) ) {+
−
        // The window id has changed so we need to re-create the EGL surface+
−
        QEglContext *ctx = glcx->d_func()->eglContext;+
−
        EGLSurface surface = glcx->d_func()->eglSurface;+
−
        if (surface != EGL_NO_SURFACE)+
−
            ctx->destroySurface(surface); // Will force doneCurrent() if nec.+
−
        surface = ctx->createSurface(q);+
−
        if (surface == EGL_NO_SURFACE)+
−
            qWarning("Error creating EGL window surface: 0x%x", eglGetError());+
−
        glcx->d_func()->eglSurface = surface;+
−
+
−
        eglSurfaceWindowId = currentId;+
−
    }+
−
}+
−
+
−
// Selects which configs should be used+
−
EGLConfig Q_OPENGL_EXPORT qt_chooseEGLConfigForPixmap(bool hasAlpha, bool readOnly)+
−
{+
−
    // Cache the configs we select as they wont change:+
−
    static EGLConfig roPixmapRGBConfig = 0;+
−
    static EGLConfig roPixmapRGBAConfig = 0;+
−
    static EGLConfig rwPixmapRGBConfig = 0;+
−
    static EGLConfig rwPixmapRGBAConfig = 0;+
−
+
−
    EGLConfig* targetConfig;+
−
+
−
    if (hasAlpha) {+
−
        if (readOnly)+
−
            targetConfig = &roPixmapRGBAConfig;+
−
        else+
−
            targetConfig = &rwPixmapRGBAConfig;+
−
    }+
−
    else {+
−
        if (readOnly)+
−
            targetConfig = &roPixmapRGBConfig;+
−
        else+
−
            targetConfig = &rwPixmapRGBConfig;+
−
    }+
−
+
−
    if (*targetConfig == 0) {+
−
        QEglProperties configAttribs;+
−
        configAttribs.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);+
−
        configAttribs.setRenderableType(QEgl::OpenGL);+
−
        if (hasAlpha)+
−
            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);+
−
        else+
−
            configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);+
−
+
−
        // If this is going to be a render target, it needs to have a depth, stencil & sample buffer+
−
        if (!readOnly) {+
−
            configAttribs.setValue(EGL_DEPTH_SIZE, 1);+
−
            configAttribs.setValue(EGL_STENCIL_SIZE, 1);+
−
            configAttribs.setValue(EGL_SAMPLE_BUFFERS, 1);+
−
        }+
−
+
−
        EGLint configCount = 0;+
−
        do {+
−
            eglChooseConfig(QEglContext::display(), configAttribs.properties(), targetConfig, 1, &configCount);+
−
            if (configCount > 0) {+
−
                // Got one+
−
                qDebug() << "Found an" << (hasAlpha ? "ARGB" : "RGB") << (readOnly ? "readonly" : "target" )+
−
                         << "config (" << int(*targetConfig) << ") to create a pixmap surface:";+
−
+
−
//                QEglProperties configProps(*targetConfig);+
−
//                qDebug() << configProps.toString();+
−
                break;+
−
            }+
−
            qWarning("choosePixmapConfig() - No suitible config found, reducing requirements");+
−
        } while (configAttribs.reduceConfiguration());+
−
    }+
−
+
−
    if (*targetConfig == 0)+
−
        qWarning("choosePixmapConfig() - Couldn't find a suitable config");+
−
+
−
    return *targetConfig;+
−
}+
−
+
−
bool Q_OPENGL_EXPORT qt_createEGLSurfaceForPixmap(QPixmapData* pmd, bool readOnly)+
−
{+
−
    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);+
−
    QX11PixmapData* pixmapData = static_cast<QX11PixmapData*>(pmd);+
−
+
−
    bool hasAlpha = pixmapData->hasAlphaChannel();+
−
+
−
    EGLConfig pixmapConfig = qt_chooseEGLConfigForPixmap(hasAlpha, readOnly);+
−
+
−
    QEglProperties pixmapAttribs;+
−
+
−
    // If the pixmap can't be bound to a texture, it's pretty useless+
−
    pixmapAttribs.setValue(EGL_TEXTURE_TARGET, EGL_TEXTURE_2D);+
−
    if (hasAlpha)+
−
        pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA);+
−
    else+
−
        pixmapAttribs.setValue(EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB);+
−
+
−
    EGLSurface pixmapSurface;+
−
    pixmapSurface = eglCreatePixmapSurface(QEglContext::display(),+
−
                                           pixmapConfig,+
−
                                           (EGLNativePixmapType) pixmapData->handle(),+
−
                                           pixmapAttribs.properties());+
−
//    qDebug("qt_createEGLSurfaceForPixmap() created surface 0x%x for pixmap 0x%x",+
−
//           pixmapSurface, pixmapData->handle());+
−
    if (pixmapSurface == EGL_NO_SURFACE) {+
−
        qWarning() << "Failed to create a pixmap surface using config" << (int)pixmapConfig+
−
                   << ":" << QEglContext::errorString(eglGetError());+
−
        return false;+
−
    }+
−
+
−
    static bool doneOnce = false;+
−
    if (!doneOnce) {+
−
        // Make sure QGLTextureCache is instanciated so it can install cleanup hooks+
−
        // which cleanup the EGL surface.+
−
        QGLTextureCache::instance();+
−
        doneOnce = true;+
−
    }+
−
+
−
    Q_ASSERT(sizeof(Qt::HANDLE) >= sizeof(EGLSurface)); // Just to make totally sure!+
−
    pixmapData->gl_surface = (Qt::HANDLE)pixmapSurface;+
−
    QImagePixmapCleanupHooks::enableCleanupHooks(pixmapData); // Make sure the cleanup hook gets called+
−
+
−
    return true;+
−
}+
−
+
−
+
−
QGLTexture *QGLContextPrivate::bindTextureFromNativePixmap(QPixmapData* pd, const qint64 key,+
−
                                                           QGLContext::BindOptions options)+
−
{+
−
    Q_Q(QGLContext);+
−
+
−
    // The EGL texture_from_pixmap has no facility to invert the y coordinate+
−
    if (!(options & QGLContext::CanFlipNativePixmapBindOption))+
−
        return 0;+
−
+
−
    Q_ASSERT(pd->classId() == QPixmapData::X11Class);+
−
+
−
    static bool checkedForTFP = false;+
−
    static bool haveTFP = false;+
−
+
−
    if (!checkedForTFP) {+
−
        // Check for texture_from_pixmap egl extension+
−
        checkedForTFP = true;+
−
        if (eglContext->hasExtension("EGL_NOKIA_texture_from_pixmap") ||+
−
            eglContext->hasExtension("EGL_EXT_texture_from_pixmap"))+
−
        {+
−
            qDebug("Found texture_from_pixmap EGL extension!");+
−
            haveTFP = true;+
−
        }+
−
    }+
−
+
−
    if (!haveTFP)+
−
        return 0;+
−
+
−
    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pd);+
−
+
−
    bool hasAlpha = pixmapData->hasAlphaChannel();+
−
+
−
    // Check to see if the surface is still valid+
−
    if (pixmapData->gl_surface &&+
−
        hasAlpha != (pixmapData->flags & QX11PixmapData::GlSurfaceCreatedWithAlpha))+
−
    {+
−
        // Surface is invalid!+
−
        destroyGlSurfaceForPixmap(pixmapData);+
−
    }+
−
+
−
    if (pixmapData->gl_surface == 0) {+
−
        bool success = qt_createEGLSurfaceForPixmap(pixmapData, true);+
−
        if (!success) {+
−
            haveTFP = false;+
−
            return 0;+
−
        }+
−
    }+
−
+
−
    Q_ASSERT(pixmapData->gl_surface);+
−
+
−
    GLuint textureId;+
−
    glGenTextures(1, &textureId);+
−
    glBindTexture(GL_TEXTURE_2D, textureId);+
−
+
−
    // bind the egl pixmap surface to a texture+
−
    EGLBoolean success;+
−
    success = eglBindTexImage(eglContext->display(), (EGLSurface)pixmapData->gl_surface, EGL_BACK_BUFFER);+
−
    if (success == EGL_FALSE) {+
−
        qWarning() << "eglBindTexImage() failed:" << eglContext->errorString(eglGetError());+
−
        eglDestroySurface(eglContext->display(), (EGLSurface)pixmapData->gl_surface);+
−
        pixmapData->gl_surface = (Qt::HANDLE)EGL_NO_SURFACE;+
−
        haveTFP = false;+
−
        return 0;+
−
    }+
−
+
−
    QGLTexture *texture = new QGLTexture(q, textureId, GL_TEXTURE_2D, options);+
−
    pixmapData->flags |= QX11PixmapData::InvertedWhenBoundToTexture;+
−
+
−
    // We assume the cost of bound pixmaps is zero+
−
    QGLTextureCache::instance()->insert(q, key, texture, 0);+
−
+
−
    glBindTexture(GL_TEXTURE_2D, textureId);+
−
    return texture;+
−
}+
−
+
−
void QGLContextPrivate::destroyGlSurfaceForPixmap(QPixmapData* pmd)+
−
{+
−
    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);+
−
    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);+
−
    if (pixmapData->gl_surface) {+
−
        EGLBoolean success;+
−
        success = eglDestroySurface(QEglContext::display(), (EGLSurface)pixmapData->gl_surface);+
−
        if (success == EGL_FALSE) {+
−
            qWarning() << "destroyGlSurfaceForPixmap() - Error deleting surface: "+
−
                       << QEglContext::errorString(eglGetError());+
−
        }+
−
        pixmapData->gl_surface = 0;+
−
    }+
−
}+
−
+
−
void QGLContextPrivate::unbindPixmapFromTexture(QPixmapData* pmd)+
−
{+
−
    Q_ASSERT(pmd->classId() == QPixmapData::X11Class);+
−
    QX11PixmapData *pixmapData = static_cast<QX11PixmapData*>(pmd);+
−
    if (pixmapData->gl_surface) {+
−
        EGLBoolean success;+
−
        success = eglReleaseTexImage(QEglContext::display(),+
−
                                     (EGLSurface)pixmapData->gl_surface,+
−
                                     EGL_BACK_BUFFER);+
−
        if (success == EGL_FALSE) {+
−
            qWarning() << "unbindPixmapFromTexture() - Unable to release bound texture: "+
−
                       << QEglContext::errorString(eglGetError());+
−
        }+
−
    }+
−
}+
−
+
−
QT_END_NAMESPACE+
−