source: trunk/src/opengl/qgl_egl.cpp@ 681

/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of the QtOpenGL module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QtOpenGL/qgl.h>
#include "qgl_p.h"
#include "qgl_egl_p.h"

QT_BEGIN_NAMESPACE

// Set device configuration attributes from a QGLFormat instance.
void qt_egl_set_format(QEglProperties& props, int deviceType, const QGLFormat& f)
{
    if (deviceType == QInternal::Pixmap || deviceType == QInternal::Image)
        props.setValue(EGL_SURFACE_TYPE, EGL_PIXMAP_BIT);
    else if (deviceType == QInternal::Pbuffer)
        props.setValue(EGL_SURFACE_TYPE, EGL_PBUFFER_BIT);
    else
        props.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT);

    // Set the pixel format to that contained in the QGLFormat
    // if the system hasn't already chosen a fixed format to
    // match the pixmap, widget, etc.
    if (props.value(EGL_RED_SIZE) == 0 || f.redBufferSize() != -1)
        props.setValue(EGL_RED_SIZE, f.redBufferSize() == -1 ? 1 : f.redBufferSize());
    if (props.value(EGL_GREEN_SIZE) == 0 || f.greenBufferSize() != -1)
        props.setValue(EGL_GREEN_SIZE, f.greenBufferSize() == -1 ? 1 : f.greenBufferSize());
    if (props.value(EGL_BLUE_SIZE) == 0 || f.blueBufferSize() != -1)
        props.setValue(EGL_BLUE_SIZE, f.blueBufferSize() == -1 ? 1 : f.blueBufferSize());
    if (f.alpha()) {
        if (props.value(EGL_ALPHA_SIZE) == 0 || f.alphaBufferSize() != -1)
            props.setValue(EGL_ALPHA_SIZE, f.alphaBufferSize() == -1 ? 1 : f.alphaBufferSize());
    }

    if (f.depth())
        props.setValue(EGL_DEPTH_SIZE, f.depthBufferSize() == -1 ? 1 : f.depthBufferSize());
    if (f.stencil())
        props.setValue(EGL_STENCIL_SIZE, f.stencilBufferSize() == -1 ? 1 : f.stencilBufferSize());
    if (f.sampleBuffers()) {
        props.setValue(EGL_SAMPLE_BUFFERS, 1);
        props.setValue(EGL_SAMPLES, f.samples() == -1 ? 1 : f.samples());
    } else {
        props.setValue(EGL_SAMPLE_BUFFERS, 0);
    }
    if (deviceType == QInternal::Widget)
        props.setValue(EGL_LEVEL, f.plane());
}

// Updates "format" with the parameters of the selected configuration.
void qt_egl_update_format(const QEglContext& context, QGLFormat& format)
{
    EGLint value = 0;

    if (context.configAttrib(EGL_RED_SIZE, &value))
        format.setRedBufferSize(value);
    if (context.configAttrib(EGL_GREEN_SIZE, &value))
        format.setGreenBufferSize(value);
    if (context.configAttrib(EGL_BLUE_SIZE, &value))
        format.setBlueBufferSize(value);
    if (context.configAttrib(EGL_ALPHA_SIZE, &value)) {
        format.setAlpha(value != 0);
        if (format.alpha())
            format.setAlphaBufferSize(value);
    }

    if (context.configAttrib(EGL_DEPTH_SIZE, &value)) {
        format.setDepth(value != 0);
        if (format.depth())
            format.setDepthBufferSize(value);
    }

    if (context.configAttrib(EGL_LEVEL, &value))
        format.setPlane(value);

    if (context.configAttrib(EGL_SAMPLE_BUFFERS, &value)) {
        format.setSampleBuffers(value != 0);
        if (format.sampleBuffers()) {
            context.configAttrib(EGL_SAMPLES, &value);
            format.setSamples(value);
        }
    }

    if (context.configAttrib(EGL_STENCIL_SIZE, &value)) {
        format.setStencil(value != 0);
        if (format.stencil())
            format.setStencilBufferSize(value);
    }

    // Clear the EGL error state because some of the above may
    // have errored out because the attribute is not applicable
    // to the surface type.  Such errors don't matter.
    context.clearError();
}

bool QGLFormat::hasOpenGL()
{
    return true;
}

void QGLContext::reset()
{
    Q_D(QGLContext);
    if (!d->valid)
        return;
    d->cleanup();
    doneCurrent();
    if (d->eglContext) {
        d->destroyEglSurfaceForDevice();
        delete d->eglContext;
    }
    d->eglContext = 0;
    d->eglSurface = EGL_NO_SURFACE;
    d->crWin = false;
    d->sharing = false;
    d->valid = false;
    d->transpColor = QColor();
    d->initDone = false;
    QGLContextGroup::removeShare(this);
}

void QGLContext::makeCurrent()
{
    Q_D(QGLContext);
    if (!d->valid || !d->eglContext || d->eglSurface == EGL_NO_SURFACE) {
        qWarning("QGLContext::makeCurrent(): Cannot make invalid context current");
        return;
    }

    if (d->eglContext->makeCurrent(d->eglSurface))
        QGLContextPrivate::setCurrentContext(this);
}

void QGLContext::doneCurrent()
{
    Q_D(QGLContext);
    if (d->eglContext)
        d->eglContext->doneCurrent();

    QGLContextPrivate::setCurrentContext(0);
}


void QGLContext::swapBuffers() const
{
    Q_D(const QGLContext);
    if (!d->valid || !d->eglContext)
        return;

    d->eglContext->swapBuffers(d->eglSurface);
}

void QGLContextPrivate::destroyEglSurfaceForDevice()
{
    if (eglSurface != EGL_NO_SURFACE) {
#ifdef Q_WS_X11
        // Make sure we don't call eglDestroySurface on a surface which
        // was created for a different winId:
        if (paintDevice->devType() == QInternal::Widget) {
            QGLWidget* w = static_cast<QGLWidget*>(paintDevice);

            if (w->d_func()->eglSurfaceWindowId == w->winId())
                eglDestroySurface(eglContext->display(), eglSurface);
            else
                qWarning("WARNING: Potential EGL surface leak!");
        } else
#endif
            eglDestroySurface(eglContext->display(), eglSurface);
        eglSurface = EGL_NO_SURFACE;
    }
}

void QGLWidget::setMouseTracking(bool enable)
{
    QWidget::setMouseTracking(enable);
}

QColor QGLContext::overlayTransparentColor() const
{
    return d_func()->transpColor;
}

uint QGLContext::colorIndex(const QColor &c) const
{
    Q_UNUSED(c);
    return 0;
}

void QGLContext::generateFontDisplayLists(const QFont & fnt, int listBase)
{
    Q_UNUSED(fnt);
    Q_UNUSED(listBase);
}

void *QGLContext::getProcAddress(const QString &proc) const
{
    return (void*)eglGetProcAddress(reinterpret_cast<const char *>(proc.toLatin1().data()));
}

bool QGLWidgetPrivate::renderCxPm(QPixmap*)
{
    return false;
}

QT_END_NAMESPACE