diff -r 000000000000 -r 1918ee327afb src/opengl/qgl_egl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/opengl/qgl_egl.cpp Mon Jan 11 14:00:40 2010 +0000 @@ -0,0 +1,233 @@ +/**************************************************************************** +** +** Copyright (C) 2009 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 +#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) { + if (d->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 (d->paintDevice->devType() == QInternal::Widget) { + QGLWidget* w = static_cast(d->paintDevice); + + if (w->d_func()->eglSurfaceWindowId == w->winId()) + eglDestroySurface(d->eglContext->display(), d->eglSurface); + } else +#endif + eglDestroySurface(d->eglContext->display(), d->eglSurface); + } + 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; + qgl_share_reg()->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 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(proc.toLatin1().data())); +} + +bool QGLWidgetPrivate::renderCxPm(QPixmap*) +{ + return false; +} + +QT_END_NAMESPACE