FCL/sf/mw/qt: comparison src/opengl/qgl.cpp

equal deleted inserted replaced

--1:000000000000
+:1918ee327afb
+/****************************************************************************
+**
+** 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 "qapplication.h"
+#include "qplatformdefs.h"
+#include "qgl.h"
+#include <qdebug.h>
+#if defined(Q_WS_X11)
+#include "private/qt_x11_p.h"
+#include "private/qpixmap_x11_p.h"
+#define INT32 dummy_INT32
+#define INT8 dummy_INT8
+#if !defined(QT_OPENGL_ES)
+# include <GL/glx.h>
+#endif
+#undef INT32
+#undef INT8
+#include "qx11info_x11.h"
+#elif defined(Q_WS_MAC)
+# include <private/qt_mac_p.h>
+#endif
+#include <qdatetime.h>
+#include <stdlib.h> // malloc
+#include "qpixmap.h"
+#include "qimage.h"
+#include "qgl_p.h"
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#include "gl2paintengineex/qpaintengineex_opengl2_p.h"
+#endif
+#ifndef QT_OPENGL_ES_2
+#include <private/qpaintengine_opengl_p.h>
+#endif
+#ifdef Q_WS_QWS
+#include <private/qglwindowsurface_qws_p.h>
+#endif
+#include <qglpixelbuffer.h>
+#include <qglframebufferobject.h>
+#include <private/qimage_p.h>
+#include <private/qpixmapdata_p.h>
+#include <private/qpixmapdata_gl_p.h>
+#include <private/qglpixelbuffer_p.h>
+#include <private/qwindowsurface_gl_p.h>
+#include <private/qimagepixmapcleanuphooks_p.h>
+#include "qcolormap.h"
+#include "qfile.h"
+#include "qlibrary.h"
+QT_BEGIN_NAMESPACE
+#ifdef QT_OPENGL_ES_1_CL
+#include "qgl_cl_p.h"
+#endif
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;
+#endif
+struct QGLThreadContext {
+QGLContext *context;
+};
+static QThreadStorage<QGLThreadContext *> qgl_context_storage;
+Q_GLOBAL_STATIC(QGLFormat, qgl_default_format)
+class QGLDefaultOverlayFormat: public QGLFormat
+{
+public:
+inline QGLDefaultOverlayFormat()
+{
+setOption(QGL::FormatOption(0xffff << 16)); // turn off all options
+setOption(QGL::DirectRendering);
+setPlane(1);
+}
+};
+Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)
+QGLExtensions::Extensions QGLExtensions::glExtensions = 0;
+bool QGLExtensions::nvidiaFboNeedsFinish = false;
+#ifndef APIENTRY
+# define APIENTRY
+#endif
+typedef void (APIENTRY *pfn_glCompressedTexImage2DARB) (GLenum, GLint, GLenum, GLsizei,
+GLsizei, GLint, GLsizei, const GLvoid *);
+static pfn_glCompressedTexImage2DARB qt_glCompressedTexImage2DARB = 0;
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)
+QGLSignalProxy *QGLSignalProxy::instance()
+{
+return theSignalProxy();
+}
+class QGLEngineSelector
+{
+public:
+QGLEngineSelector() : engineType(QPaintEngine::MaxUser)
+{
+}
+void setPreferredPaintEngine(QPaintEngine::Type type) {
+if (type == QPaintEngine::OpenGL || type == QPaintEngine::OpenGL2)
+engineType = type;
+}
+QPaintEngine::Type preferredPaintEngine() {
+#ifdef Q_WS_MAC
+// The ATI X1600 driver for Mac OS X does not support return
+// values from functions in GLSL. Since working around this in
+// the GL2 engine would require a big, ugly rewrite, we're
+// falling back to the GL 1 engine..
+static bool mac_x1600_check_done = false;
+if (!mac_x1600_check_done) {
+QGLWidget *tmp = 0;
+if (!QGLContext::currentContext()) {
+tmp = new QGLWidget();
+tmp->makeCurrent();
+}
+if (strstr((char *) glGetString(GL_RENDERER), "X1600"))
+engineType = QPaintEngine::OpenGL;
+if (tmp)
+delete tmp;
+mac_x1600_check_done = true;
+}
+#endif
+if (engineType == QPaintEngine::MaxUser) {
+// No user-set engine - use the defaults
+#if defined(QT_OPENGL_ES_2)
+engineType = QPaintEngine::OpenGL2;
+#else
+// We can't do this in the constructor for this object because it
+// needs to be called *before* the QApplication constructor
+if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0)
+&& qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty())
+engineType = QPaintEngine::OpenGL2;
+else
+engineType = QPaintEngine::OpenGL;
+#endif
+}
+return engineType;
+}
+private:
+QPaintEngine::Type engineType;
+};
+Q_GLOBAL_STATIC(QGLEngineSelector, qgl_engine_selector)
+bool qt_gl_preferGL2Engine()
+{
+return qgl_engine_selector()->preferredPaintEngine() == QPaintEngine::OpenGL2;
+}
+/*!
+\namespace QGL
+\inmodule QtOpenGL
+\brief The QGL namespace specifies miscellaneous identifiers used
+in the Qt OpenGL module.
+\ingroup painting-3D
+*/
+/*!
+\enum QGL::FormatOption
+This enum specifies the format options that can be used to configure an OpenGL
+context. These are set using QGLFormat::setOption().
+\value DoubleBuffer      Specifies the use of double buffering.
+\value DepthBuffer       Enables the use of a depth buffer.
+\value Rgba              Specifies that the context should use RGBA as its pixel format.
+\value AlphaChannel      Enables the use of an alpha channel.
+\value AccumBuffer       Enables the use of an accumulation buffer.
+\value StencilBuffer     Enables the use of a stencil buffer.
+\value StereoBuffers     Enables the use of a stereo buffers for use with visualization hardware.
+\value DirectRendering   Specifies that the context is used for direct rendering to a display.
+\value HasOverlay        Enables the use of an overlay.
+\value SampleBuffers     Enables the use of sample buffers.
+\value SingleBuffer      Specifies the use of a single buffer, as opposed to double buffers.
+\value NoDepthBuffer     Disables the use of a depth buffer.
+\value ColorIndex        Specifies that the context should use a color index as its pixel format.
+\value NoAlphaChannel    Disables the use of an alpha channel.
+\value NoAccumBuffer     Disables the use of an accumulation buffer.
+\value NoStencilBuffer   Disables the use of a stencil buffer.
+\value NoStereoBuffers   Disables the use of stereo buffers.
+\value IndirectRendering Specifies that the context is used for indirect rendering to a buffer.
+\value NoOverlay         Disables the use of an overlay.
+\value NoSampleBuffers   Disables the use of sample buffers.
+\sa {Sample Buffers Example}
+*/
+/*!
+\fn void QGL::setPreferredPaintEngine(QPaintEngine::Type engineType)
+\since 4.6
+Sets the preferred OpenGL paint engine that is used to draw onto
+QGLWidget, QGLPixelBuffer and QGLFramebufferObject targets with QPainter
+in Qt.
+The \a engineType parameter specifies which of the GL engines to
+use. Only \c QPaintEngine::OpenGL and \c QPaintEngine::OpenGL2 are
+valid parameters to this function. All other values are ignored.
+By default, the \c QPaintEngine::OpenGL2 engine is used if GL/GLES
+version 2.0 is available, otherwise \c QPaintEngine::OpenGL is
+used.
+\warning This function must be called before the QApplication
+constructor is called.
+*/
+void QGL::setPreferredPaintEngine(QPaintEngine::Type engineType)
+{
+qgl_engine_selector()->setPreferredPaintEngine(engineType);
+}
+/*****************************************************************************
+QGLFormat implementation
+*****************************************************************************/
+/*!
+\class QGLFormat
+\brief The QGLFormat class specifies the display format of an OpenGL
+rendering context.
+\ingroup painting-3D
+A display format has several characteristics:
+\list
+\i \link setDoubleBuffer() Double or single buffering.\endlink
+\i \link setDepth() Depth buffer.\endlink
+\i \link setRgba() RGBA or color index mode.\endlink
+\i \link setAlpha() Alpha channel.\endlink
+\i \link setAccum() Accumulation buffer.\endlink
+\i \link setStencil() Stencil buffer.\endlink
+\i \link setStereo() Stereo buffers.\endlink
+\i \link setDirectRendering() Direct rendering.\endlink
+\i \link setOverlay() Presence of an overlay.\endlink
+\i \link setPlane() Plane of an overlay.\endlink
+\i \link setSampleBuffers() Multisample buffers.\endlink
+\endlist
+You can also specify preferred bit depths for the color buffer,
+depth buffer, alpha buffer, accumulation buffer and the stencil
+buffer with the functions: setRedBufferSize(), setGreenBufferSize(),
+setBlueBufferSize(), setDepthBufferSize(), setAlphaBufferSize(),
+setAccumBufferSize() and setStencilBufferSize().
+Note that even if you specify that you prefer a 32 bit depth
+buffer (e.g. with setDepthBufferSize(32)), the format that is
+chosen may not have a 32 bit depth buffer, even if there is a
+format available with a 32 bit depth buffer. The main reason for
+this is how the system dependant picking algorithms work on the
+different platforms, and some format options may have higher
+precedence than others.
+You create and tell a QGLFormat object what rendering options you
+want from an OpenGL rendering context.
+OpenGL drivers or accelerated hardware may or may not support
+advanced features such as alpha channel or stereographic viewing.
+If you request some features that the driver/hardware does not
+provide when you create a QGLWidget, you will get a rendering
+context with the nearest subset of features.
+There are different ways to define the display characteristics of
+a rendering context. One is to create a QGLFormat and make it the
+default for the entire application:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 0
+Or you can specify the desired format when creating an object of
+your QGLWidget subclass:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 1
+After the widget has been created, you can find out which of the
+requested features the system was able to provide:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 2
+\legalese
+OpenGL is a trademark of Silicon Graphics, Inc. in the
+United States and other countries.
+\endlegalese
+\sa QGLContext, QGLWidget
+*/
+#ifndef QT_OPENGL_ES
+static inline void transform_point(GLdouble out[4], const GLdouble m[16], const GLdouble in[4])
+{
+#define M(row,col)  m[col*4+row]
+out[0] =
+M(0, 0) * in[0] + M(0, 1) * in[1] + M(0, 2) * in[2] + M(0, 3) * in[3];
+out[1] =
+M(1, 0) * in[0] + M(1, 1) * in[1] + M(1, 2) * in[2] + M(1, 3) * in[3];
+out[2] =
+M(2, 0) * in[0] + M(2, 1) * in[1] + M(2, 2) * in[2] + M(2, 3) * in[3];
+out[3] =
+M(3, 0) * in[0] + M(3, 1) * in[1] + M(3, 2) * in[2] + M(3, 3) * in[3];
+#undef M
+}
+static inline GLint qgluProject(GLdouble objx, GLdouble objy, GLdouble objz,
+const GLdouble model[16], const GLdouble proj[16],
+const GLint viewport[4],
+GLdouble * winx, GLdouble * winy, GLdouble * winz)
+{
+GLdouble in[4], out[4];
+in[0] = objx;
+in[1] = objy;
+in[2] = objz;
+in[3] = 1.0;
+transform_point(out, model, in);
+transform_point(in, proj, out);
+if (in[3] == 0.0)
+return GL_FALSE;
+in[0] /= in[3];
+in[1] /= in[3];
+in[2] /= in[3];
+*winx = viewport[0] + (1 + in[0]) * viewport[2] / 2;
+*winy = viewport[1] + (1 + in[1]) * viewport[3] / 2;
+*winz = (1 + in[2]) / 2;
+return GL_TRUE;
+}
+#endif // !QT_OPENGL_ES
+/*!
+Constructs a QGLFormat object with the following default settings:
+\list
+\i \link setDoubleBuffer() Double buffer:\endlink Enabled.
+\i \link setDepth() Depth buffer:\endlink Enabled.
+\i \link setRgba() RGBA:\endlink Enabled (i.e., color index disabled).
+\i \link setAlpha() Alpha channel:\endlink Disabled.
+\i \link setAccum() Accumulator buffer:\endlink Disabled.
+\i \link setStencil() Stencil buffer:\endlink Enabled.
+\i \link setStereo() Stereo:\endlink Disabled.
+\i \link setDirectRendering() Direct rendering:\endlink Enabled.
+\i \link setOverlay() Overlay:\endlink Disabled.
+\i \link setPlane() Plane:\endlink 0 (i.e., normal plane).
+\i \link setSampleBuffers() Multisample buffers:\endlink Enabled on
+OpenGL/ES 2.0, disabled on other platforms.
+\endlist
+*/
+QGLFormat::QGLFormat()
+{
+d = new QGLFormatPrivate;
+}
+/*!
+Creates a QGLFormat object that is a copy of the current
+defaultFormat().
+If \a options is not 0, the default format is modified by the
+specified format options. The \a options parameter should be
+QGL::FormatOption values OR'ed together.
+This constructor makes it easy to specify a certain desired format
+in classes derived from QGLWidget, for example:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 3
+Note that there are QGL::FormatOption values to turn format settings
+both on and off, e.g. QGL::DepthBuffer and QGL::NoDepthBuffer,
+QGL::DirectRendering and QGL::IndirectRendering, etc.
+The \a plane parameter defaults to 0 and is the plane which this
+format should be associated with. Not all OpenGL implementations
+supports overlay/underlay rendering planes.
+\sa defaultFormat(), setOption(), setPlane()
+*/
+QGLFormat::QGLFormat(QGL::FormatOptions options, int plane)
+{
+d = new QGLFormatPrivate;
+QGL::FormatOptions newOpts = options;
+d->opts = defaultFormat().d->opts;
+d->opts |= (newOpts & 0xffff);
+d->opts &= ~(newOpts >> 16);
+d->pln = plane;
+}
+/*!
+\internal
+*/
+void QGLFormat::detach()
+{
+if (d->ref != 1) {
+QGLFormatPrivate *newd = new QGLFormatPrivate(d);
+if (!d->ref.deref())
+delete d;
+d = newd;
+}
+}
+/*!
+Constructs a copy of \a other.
+*/
+QGLFormat::QGLFormat(const QGLFormat &other)
+{
+d = other.d;
+d->ref.ref();
+}
+/*!
+Assigns \a other to this object.
+*/
+QGLFormat &QGLFormat::operator=(const QGLFormat &other)
+{
+if (d != other.d) {
+other.d->ref.ref();
+if (!d->ref.deref())
+delete d;
+d = other.d;
+}
+return *this;
+}
+/*!
+Destroys the QGLFormat.
+*/
+QGLFormat::~QGLFormat()
+{
+if (!d->ref.deref())
+delete d;
+}
+/*!
+\fn bool QGLFormat::doubleBuffer() const
+Returns true if double buffering is enabled; otherwise returns
+false. Double buffering is enabled by default.
+\sa setDoubleBuffer()
+*/
+/*!
+If \a enable is true sets double buffering; otherwise sets single
+buffering.
+Double buffering is enabled by default.
+Double buffering is a technique where graphics are rendered on an
+off-screen buffer and not directly to the screen. When the drawing
+has been completed, the program calls a swapBuffers() function to
+exchange the screen contents with the buffer. The result is
+flicker-free drawing and often better performance.
+\sa doubleBuffer(), QGLContext::swapBuffers(),
+QGLWidget::swapBuffers()
+*/
+void QGLFormat::setDoubleBuffer(bool enable)
+{
+setOption(enable ? QGL::DoubleBuffer : QGL::SingleBuffer);
+}
+/*!
+\fn bool QGLFormat::depth() const
+Returns true if the depth buffer is enabled; otherwise returns
+false. The depth buffer is enabled by default.
+\sa setDepth(), setDepthBufferSize()
+*/
+/*!
+If \a enable is true enables the depth buffer; otherwise disables
+the depth buffer.
+The depth buffer is enabled by default.
+The purpose of a depth buffer (or Z-buffering) is to remove hidden
+surfaces. Pixels are assigned Z values based on the distance to
+the viewer. A pixel with a high Z value is closer to the viewer
+than a pixel with a low Z value. This information is used to
+decide whether to draw a pixel or not.
+\sa depth(), setDepthBufferSize()
+*/
+void QGLFormat::setDepth(bool enable)
+{
+setOption(enable ? QGL::DepthBuffer : QGL::NoDepthBuffer);
+}
+/*!
+\fn bool QGLFormat::rgba() const
+Returns true if RGBA color mode is set. Returns false if color
+index mode is set. The default color mode is RGBA.
+\sa setRgba()
+*/
+/*!
+If \a enable is true sets RGBA mode. If \a enable is false sets
+color index mode.
+The default color mode is RGBA.
+RGBA is the preferred mode for most OpenGL applications. In RGBA
+color mode you specify colors as red + green + blue + alpha
+quadruplets.
+In color index mode you specify an index into a color lookup
+table.
+\sa rgba()
+*/
+void QGLFormat::setRgba(bool enable)
+{
+setOption(enable ? QGL::Rgba : QGL::ColorIndex);
+}
+/*!
+\fn bool QGLFormat::alpha() const
+Returns true if the alpha buffer in the framebuffer is enabled;
+otherwise returns false. The alpha buffer is disabled by default.
+\sa setAlpha(), setAlphaBufferSize()
+*/
+/*!
+If \a enable is true enables the alpha buffer; otherwise disables
+the alpha buffer.
+The alpha buffer is disabled by default.
+The alpha buffer is typically used for implementing transparency
+or translucency. The A in RGBA specifies the transparency of a
+pixel.
+\sa alpha(), setAlphaBufferSize()
+*/
+void QGLFormat::setAlpha(bool enable)
+{
+setOption(enable ? QGL::AlphaChannel : QGL::NoAlphaChannel);
+}
+/*!
+\fn bool QGLFormat::accum() const
+Returns true if the accumulation buffer is enabled; otherwise
+returns false. The accumulation buffer is disabled by default.
+\sa setAccum(), setAccumBufferSize()
+*/
+/*!
+If \a enable is true enables the accumulation buffer; otherwise
+disables the accumulation buffer.
+The accumulation buffer is disabled by default.
+The accumulation buffer is used to create blur effects and
+multiple exposures.
+\sa accum(), setAccumBufferSize()
+*/
+void QGLFormat::setAccum(bool enable)
+{
+setOption(enable ? QGL::AccumBuffer : QGL::NoAccumBuffer);
+}
+/*!
+\fn bool QGLFormat::stencil() const
+Returns true if the stencil buffer is enabled; otherwise returns
+false. The stencil buffer is enabled by default.
+\sa setStencil(), setStencilBufferSize()
+*/
+/*!
+If \a enable is true enables the stencil buffer; otherwise
+disables the stencil buffer.
+The stencil buffer is enabled by default.
+The stencil buffer masks certain parts of the drawing area so that
+masked parts are not drawn on.
+\sa stencil(), setStencilBufferSize()
+*/
+void QGLFormat::setStencil(bool enable)
+{
+setOption(enable ? QGL::StencilBuffer: QGL::NoStencilBuffer);
+}
+/*!
+\fn bool QGLFormat::stereo() const
+Returns true if stereo buffering is enabled; otherwise returns
+false. Stereo buffering is disabled by default.
+\sa setStereo()
+*/
+/*!
+If \a enable is true enables stereo buffering; otherwise disables
+stereo buffering.
+Stereo buffering is disabled by default.
+Stereo buffering provides extra color buffers to generate left-eye
+and right-eye images.
+\sa stereo()
+*/
+void QGLFormat::setStereo(bool enable)
+{
+setOption(enable ? QGL::StereoBuffers : QGL::NoStereoBuffers);
+}
+/*!
+\fn bool QGLFormat::directRendering() const
+Returns true if direct rendering is enabled; otherwise returns
+false.
+Direct rendering is enabled by default.
+\sa setDirectRendering()
+*/
+/*!
+If \a enable is true enables direct rendering; otherwise disables
+direct rendering.
+Direct rendering is enabled by default.
+Enabling this option will make OpenGL bypass the underlying window
+system and render directly from hardware to the screen, if this is
+supported by the system.
+\sa directRendering()
+*/
+void QGLFormat::setDirectRendering(bool enable)
+{
+setOption(enable ? QGL::DirectRendering : QGL::IndirectRendering);
+}
+/*!
+\fn bool QGLFormat::sampleBuffers() const
+Returns true if multisample buffer support is enabled; otherwise
+returns false.
+The multisample buffer is disabled by default.
+\sa setSampleBuffers()
+*/
+/*!
+If \a enable is true, a GL context with multisample buffer support
+is picked; otherwise ignored.
+\sa sampleBuffers(), setSamples(), samples()
+*/
+void QGLFormat::setSampleBuffers(bool enable)
+{
+setOption(enable ? QGL::SampleBuffers : QGL::NoSampleBuffers);
+}
+/*!
+Returns the number of samples per pixel when multisampling is
+enabled. By default, the highest number of samples that is
+available is used.
+\sa setSampleBuffers(), sampleBuffers(), setSamples()
+*/
+int QGLFormat::samples() const
+{
+return d->numSamples;
+}
+/*!
+Set the preferred number of samples per pixel when multisampling
+is enabled to \a numSamples. By default, the highest number of
+samples available is used.
+\sa setSampleBuffers(), sampleBuffers(), samples()
+*/
+void QGLFormat::setSamples(int numSamples)
+{
+detach();
+if (numSamples < 0) {
+qWarning("QGLFormat::setSamples: Cannot have negative number of samples per pixel %d", numSamples);
+return;
+}
+d->numSamples = numSamples;
+}
+/*!
+\since 4.2
+Set the preferred swap interval. This can be used to sync the GL
+drawing into a system window to the vertical refresh of the screen.
+Setting an \a interval value of 0 will turn the vertical refresh syncing
+off, any value higher than 0 will turn the vertical syncing on.
+Under Windows and under X11, where the \c{WGL_EXT_swap_control}
+and \c{GLX_SGI_video_sync} extensions are used, the \a interval
+parameter can be used to set the minimum number of video frames
+that are displayed before a buffer swap will occur. In effect,
+setting the \a interval to 10, means there will be 10 vertical
+retraces between every buffer swap.
+Under Windows the \c{WGL_EXT_swap_control} extension has to be present,
+and under X11 the \c{GLX_SGI_video_sync} extension has to be present.
+*/
+void QGLFormat::setSwapInterval(int interval)
+{
+detach();
+d->swapInterval = interval;
+}
+/*!
+\since 4.2
+Returns the currently set swap interval. -1 is returned if setting
+the swap interval isn't supported in the system GL implementation.
+*/
+int QGLFormat::swapInterval() const
+{
+return d->swapInterval;
+}
+/*!
+\fn bool QGLFormat::hasOverlay() const
+Returns true if overlay plane is enabled; otherwise returns false.
+Overlay is disabled by default.
+\sa setOverlay()
+*/
+/*!
+If \a enable is true enables an overlay plane; otherwise disables
+the overlay plane.
+Enabling the overlay plane will cause QGLWidget to create an
+additional context in an overlay plane. See the QGLWidget
+documentation for further information.
+\sa hasOverlay()
+*/
+void QGLFormat::setOverlay(bool enable)
+{
+setOption(enable ? QGL::HasOverlay : QGL::NoOverlay);
+}
+/*!
+Returns the plane of this format. The default for normal formats
+is 0, which means the normal plane. The default for overlay
+formats is 1, which is the first overlay plane.
+\sa setPlane(), defaultOverlayFormat()
+*/
+int QGLFormat::plane() const
+{
+return d->pln;
+}
+/*!
+Sets the requested plane to \a plane. 0 is the normal plane, 1 is
+the first overlay plane, 2 is the second overlay plane, etc.; -1,
+-2, etc. are underlay planes.
+Note that in contrast to other format specifications, the plane
+specifications will be matched exactly. This means that if you
+specify a plane that the underlying OpenGL system cannot provide,
+an \link QGLWidget::isValid() invalid\endlink QGLWidget will be
+created.
+\sa plane()
+*/
+void QGLFormat::setPlane(int plane)
+{
+detach();
+d->pln = plane;
+}
+/*!
+Sets the format option to \a opt.
+\sa testOption()
+*/
+void QGLFormat::setOption(QGL::FormatOptions opt)
+{
+detach();
+if (opt & 0xffff)
+d->opts |= opt;
+else
+d->opts &= ~(opt >> 16);
+}
+/*!
+Returns true if format option \a opt is set; otherwise returns false.
+\sa setOption()
+*/
+bool QGLFormat::testOption(QGL::FormatOptions opt) const
+{
+if (opt & 0xffff)
+return (d->opts & opt) != 0;
+else
+return (d->opts & (opt >> 16)) == 0;
+}
+/*!
+Set the minimum depth buffer size to \a size.
+\sa depthBufferSize(), setDepth(), depth()
+*/
+void QGLFormat::setDepthBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setDepthBufferSize: Cannot set negative depth buffer size %d", size);
+return;
+}
+d->depthSize = size;
+}
+/*!
+Returns the depth buffer size.
+\sa depth(), setDepth(), setDepthBufferSize()
+*/
+int QGLFormat::depthBufferSize() const
+{
+return d->depthSize;
+}
+/*!
+\since 4.2
+Set the preferred red buffer size to \a size.
+\sa setGreenBufferSize(), setBlueBufferSize(), setAlphaBufferSize()
+*/
+void QGLFormat::setRedBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setRedBufferSize: Cannot set negative red buffer size %d", size);
+return;
+}
+d->redSize = size;
+}
+/*!
+\since 4.2
+Returns the red buffer size.
+\sa setRedBufferSize()
+*/
+int QGLFormat::redBufferSize() const
+{
+return d->redSize;
+}
+/*!
+\since 4.2
+Set the preferred green buffer size to \a size.
+\sa setRedBufferSize(), setBlueBufferSize(), setAlphaBufferSize()
+*/
+void QGLFormat::setGreenBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setGreenBufferSize: Cannot set negative green buffer size %d", size);
+return;
+}
+d->greenSize = size;
+}
+/*!
+\since 4.2
+Returns the green buffer size.
+\sa setGreenBufferSize()
+*/
+int QGLFormat::greenBufferSize() const
+{
+return d->greenSize;
+}
+/*!
+\since 4.2
+Set the preferred blue buffer size to \a size.
+\sa setRedBufferSize(), setGreenBufferSize(), setAlphaBufferSize()
+*/
+void QGLFormat::setBlueBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setBlueBufferSize: Cannot set negative blue buffer size %d", size);
+return;
+}
+d->blueSize = size;
+}
+/*!
+\since 4.2
+Returns the blue buffer size.
+\sa setBlueBufferSize()
+*/
+int QGLFormat::blueBufferSize() const
+{
+return d->blueSize;
+}
+/*!
+Set the preferred alpha buffer size to \a size.
+This function implicitly enables the alpha channel.
+\sa setRedBufferSize(), setGreenBufferSize(), alphaBufferSize()
+*/
+void QGLFormat::setAlphaBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setAlphaBufferSize: Cannot set negative alpha buffer size %d", size);
+return;
+}
+d->alphaSize = size;
+setOption(QGL::AlphaChannel);
+}
+/*!
+Returns the alpha buffer size.
+\sa alpha(), setAlpha(), setAlphaBufferSize()
+*/
+int QGLFormat::alphaBufferSize() const
+{
+return d->alphaSize;
+}
+/*!
+Set the preferred accumulation buffer size, where \a size is the
+bit depth for each RGBA component.
+\sa accum(), setAccum(), accumBufferSize()
+*/
+void QGLFormat::setAccumBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setAccumBufferSize: Cannot set negative accumulate buffer size %d", size);
+return;
+}
+d->accumSize = size;
+}
+/*!
+Returns the accumulation buffer size.
+\sa setAccumBufferSize(), accum(), setAccum()
+*/
+int QGLFormat::accumBufferSize() const
+{
+return d->accumSize;
+}
+/*!
+Set the preferred stencil buffer size to \a size.
+\sa stencilBufferSize(), setStencil(), stencil()
+*/
+void QGLFormat::setStencilBufferSize(int size)
+{
+detach();
+if (size < 0) {
+qWarning("QGLFormat::setStencilBufferSize: Cannot set negative stencil buffer size %d", size);
+return;
+}
+d->stencilSize = size;
+}
+/*!
+Returns the stencil buffer size.
+\sa stencil(), setStencil(), setStencilBufferSize()
+*/
+int QGLFormat::stencilBufferSize() const
+{
+return d->stencilSize;
+}
+/*!
+\fn bool QGLFormat::hasOpenGL()
+Returns true if the window system has any OpenGL support;
+otherwise returns false.
+\warning This function must not be called until the QApplication
+object has been created.
+*/
+/*!
+\fn bool QGLFormat::hasOpenGLOverlays()
+Returns true if the window system supports OpenGL overlays;
+otherwise returns false.
+\warning This function must not be called until the QApplication
+object has been created.
+*/
+QGLFormat::OpenGLVersionFlags Q_AUTOTEST_EXPORT qOpenGLVersionFlagsFromString(const QString &versionString)
+{
+QGLFormat::OpenGLVersionFlags versionFlags = QGLFormat::OpenGL_Version_None;
+if (versionString.startsWith(QLatin1String("OpenGL ES"))) {
+QStringList parts = versionString.split(QLatin1Char(' '));
+if (parts.size() >= 3) {
+if (parts[2].startsWith(QLatin1String("1."))) {
+if (parts[1].endsWith(QLatin1String("-CM"))) {
+versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_0 |
+QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
+if (parts[2].startsWith(QLatin1String("1.1")))
+versionFlags |= QGLFormat::OpenGL_ES_Common_Version_1_1 |
+QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
+}
+else {
+// Not -CM, must be CL, CommonLite
+versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_0;
+if (parts[2].startsWith(QLatin1String("1.1")))
+versionFlags |= QGLFormat::OpenGL_ES_CommonLite_Version_1_1;
+}
+}
+else {
+// OpenGL ES version 2.0 or higher
+versionFlags |= QGLFormat::OpenGL_ES_Version_2_0;
+}
+}
+else {
+// if < 3 parts to the name, it is an unrecognised OpenGL ES
+qWarning("Unrecognised OpenGL ES version");
+}
+}
+else {
+// not ES, regular OpenGL, the version numbers are first in the string
+if (versionString.startsWith(QLatin1String("1."))) {
+switch (versionString[2].toAscii()) {
+case '5':
+versionFlags |= QGLFormat::OpenGL_Version_1_5;
+case '4':
+versionFlags |= QGLFormat::OpenGL_Version_1_4;
+case '3':
+versionFlags |= QGLFormat::OpenGL_Version_1_3;
+case '2':
+versionFlags |= QGLFormat::OpenGL_Version_1_2;
+case '1':
+versionFlags |= QGLFormat::OpenGL_Version_1_1;
+default:
+break;
+}
+}
+else if (versionString.startsWith(QLatin1String("2."))) {
+versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+QGLFormat::OpenGL_Version_1_2 |
+QGLFormat::OpenGL_Version_1_3 |
+QGLFormat::OpenGL_Version_1_4 |
+QGLFormat::OpenGL_Version_1_5 |
+QGLFormat::OpenGL_Version_2_0;
+QString minorVersion = versionString.section(QLatin1Char(' '), 0, 0).section(QLatin1Char('.'), 1, 1);
+if (minorVersion == QChar(QLatin1Char('1')))
+versionFlags |= QGLFormat::OpenGL_Version_2_1;
+}
+else if (versionString.startsWith(QLatin1String("3."))) {
+versionFlags |= QGLFormat::OpenGL_Version_1_1 |
+QGLFormat::OpenGL_Version_1_2 |
+QGLFormat::OpenGL_Version_1_3 |
+QGLFormat::OpenGL_Version_1_4 |
+QGLFormat::OpenGL_Version_1_5 |
+QGLFormat::OpenGL_Version_2_0 |
+QGLFormat::OpenGL_Version_2_1 |
+QGLFormat::OpenGL_Version_3_0;
+}
+else
+qWarning("Unrecognised OpenGL version");
+}
+return versionFlags;
+}
+/*!
+\enum QGLFormat::OpenGLVersionFlag
+\since 4.2
+This enum describes the various OpenGL versions that are
+recognized by Qt. Use the QGLFormat::openGLVersionFlags() function
+to identify which versions that are supported at runtime.
+\value OpenGL_Version_None  If no OpenGL is present or if no OpenGL context is current.
+\value OpenGL_Version_1_1  OpenGL version 1.1 or higher is present.
+\value OpenGL_Version_1_2  OpenGL version 1.2 or higher is present.
+\value OpenGL_Version_1_3  OpenGL version 1.3 or higher is present.
+\value OpenGL_Version_1_4  OpenGL version 1.4 or higher is present.
+\value OpenGL_Version_1_5  OpenGL version 1.5 or higher is present.
+\value OpenGL_Version_2_0  OpenGL version 2.0 or higher is present.
+Note that version 2.0 supports all the functionality of version 1.5.
+\value OpenGL_Version_2_1  OpenGL version 2.1 or higher is present.
+\value OpenGL_Version_3_0  OpenGL version 3.0 or higher is present.
+\value OpenGL_ES_CommonLite_Version_1_0  OpenGL ES version 1.0 Common Lite or higher is present.
+\value OpenGL_ES_Common_Version_1_0  OpenGL ES version 1.0 Common or higher is present.
+The Common profile supports all the features of Common Lite.
+\value OpenGL_ES_CommonLite_Version_1_1  OpenGL ES version 1.1 Common Lite or higher is present.
+\value OpenGL_ES_Common_Version_1_1  OpenGL ES version 1.1 Common or higher is present.
+The Common profile supports all the features of Common Lite.
+\value OpenGL_ES_Version_2_0  OpenGL ES version 2.0 or higher is present.
+Note that OpenGL ES version 2.0 does not support all the features of OpenGL ES 1.x.
+So if OpenGL_ES_Version_2_0 is returned, none of the ES 1.x flags are returned.
+See also \l{http://www.opengl.org} for more information about the different
+revisions of OpenGL.
+\sa openGLVersionFlags()
+*/
+/*!
+\since 4.2
+Identifies, at runtime, which OpenGL versions that are supported
+by the current platform.
+Note that if OpenGL version 1.5 is supported, its predecessors
+(i.e., version 1.4 and lower) are also supported. To identify the
+support of a particular feature, like multi texturing, test for
+the version in which the feature was first introduced (i.e.,
+version 1.3 in the case of multi texturing) to adapt to the largest
+possible group of runtime platforms.
+This function needs a valid current OpenGL context to work;
+otherwise it will return OpenGL_Version_None.
+\sa hasOpenGL(), hasOpenGLOverlays()
+*/
+QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags()
+{
+static bool cachedDefault = false;
+static OpenGLVersionFlags defaultVersionFlags = OpenGL_Version_None;
+QGLContext *currentCtx = const_cast<QGLContext *>(QGLContext::currentContext());
+QGLWidget *dummy = 0;
+if (currentCtx && currentCtx->d_func()->version_flags_cached)
+return currentCtx->d_func()->version_flags;
+if (!currentCtx) {
+if (cachedDefault) {
+return defaultVersionFlags;
+} else {
+if (!hasOpenGL())
+return defaultVersionFlags;
+dummy = new QGLWidget;
+dummy->makeCurrent(); // glGetString() needs a current context
+cachedDefault = true;
+}
+}
+QString versionString(QLatin1String(reinterpret_cast<const char*>(glGetString(GL_VERSION))));
+OpenGLVersionFlags versionFlags = qOpenGLVersionFlagsFromString(versionString);
+if (currentCtx) {
+currentCtx->d_func()->version_flags_cached = true;
+currentCtx->d_func()->version_flags = versionFlags;
+}
+if (dummy) {
+defaultVersionFlags = versionFlags;
+delete dummy;
+}
+return versionFlags;
+}
+/*!
+Returns the default QGLFormat for the application. All QGLWidget
+objects that are created use this format unless another format is
+specified, e.g. when they are constructed.
+If no special default format has been set using
+setDefaultFormat(), the default format is the same as that created
+with QGLFormat().
+\sa setDefaultFormat()
+*/
+QGLFormat QGLFormat::defaultFormat()
+{
+return *qgl_default_format();
+}
+/*!
+Sets a new default QGLFormat for the application to \a f. For
+example, to set single buffering as the default instead of double
+buffering, your main() might contain code like this:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 4
+\sa defaultFormat()
+*/
+void QGLFormat::setDefaultFormat(const QGLFormat &f)
+{
+*qgl_default_format() = f;
+}
+/*!
+Returns the default QGLFormat for overlay contexts.
+The default overlay format is:
+\list
+\i \link setDoubleBuffer() Double buffer:\endlink Disabled.
+\i \link setDepth() Depth buffer:\endlink Disabled.
+\i \link setRgba() RGBA:\endlink Disabled (i.e., color index enabled).
+\i \link setAlpha() Alpha channel:\endlink Disabled.
+\i \link setAccum() Accumulator buffer:\endlink Disabled.
+\i \link setStencil() Stencil buffer:\endlink Disabled.
+\i \link setStereo() Stereo:\endlink Disabled.
+\i \link setDirectRendering() Direct rendering:\endlink Enabled.
+\i \link setOverlay() Overlay:\endlink Disabled.
+\i \link setSampleBuffers() Multisample buffers:\endlink Disabled.
+\i \link setPlane() Plane:\endlink 1 (i.e., first overlay plane).
+\endlist
+\sa setDefaultFormat()
+*/
+QGLFormat QGLFormat::defaultOverlayFormat()
+{
+return *defaultOverlayFormatInstance();
+}
+/*!
+Sets a new default QGLFormat for overlay contexts to \a f. This
+format is used whenever a QGLWidget is created with a format that
+hasOverlay() enabled.
+For example, to get a double buffered overlay context (if
+available), use code like this:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 5
+As usual, you can find out after widget creation whether the
+underlying OpenGL system was able to provide the requested
+specification:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 6
+\sa defaultOverlayFormat()
+*/
+void QGLFormat::setDefaultOverlayFormat(const QGLFormat &f)
+{
+QGLFormat *defaultFormat = defaultOverlayFormatInstance();
+*defaultFormat = f;
+// Make sure the user doesn't request that the overlays themselves
+// have overlays, since it is unlikely that the system supports
+// infinitely many planes...
+defaultFormat->setOverlay(false);
+}
+/*!
+Returns true if all the options of the two QGLFormat objects
+\a a and \a b are equal; otherwise returns false.
+\relates QGLFormat
+*/
+bool operator==(const QGLFormat& a, const QGLFormat& b)
+{
+return (int) a.d->opts == (int) b.d->opts && a.d->pln == b.d->pln && a.d->alphaSize == b.d->alphaSize
+&& a.d->accumSize == b.d->accumSize && a.d->stencilSize == b.d->stencilSize
+&& a.d->depthSize == b.d->depthSize
+&& a.d->redSize == b.d->redSize
+&& a.d->greenSize == b.d->greenSize
+&& a.d->blueSize == b.d->blueSize
+&& a.d->numSamples == b.d->numSamples
+&& a.d->swapInterval == b.d->swapInterval;
+}
+/*!
+Returns false if all the options of the two QGLFormat objects
+\a a and \a b are equal; otherwise returns true.
+\relates QGLFormat
+*/
+bool operator!=(const QGLFormat& a, const QGLFormat& b)
+{
+return !(a == b);
+}
+/*****************************************************************************
+QGLContext implementation
+*****************************************************************************/
+QGLContextGroup::~QGLContextGroup()
+{
+// Clear any remaining QGLSharedResourceGuard objects on the group.
+QGLSharedResourceGuard *guard = m_guards;
+while (guard != 0) {
+guard->m_group = 0;
+guard->m_id = 0;
+guard = guard->m_next;
+}
+}
+void QGLContextGroup::addGuard(QGLSharedResourceGuard *guard)
+{
+if (m_guards)
+m_guards->m_prev = guard;
+guard->m_next = m_guards;
+guard->m_prev = 0;
+m_guards = guard;
+}
+void QGLContextGroup::removeGuard(QGLSharedResourceGuard *guard)
+{
+if (guard->m_next)
+guard->m_next->m_prev = guard->m_prev;
+if (guard->m_prev)
+guard->m_prev->m_next = guard->m_next;
+else
+m_guards = guard->m_next;
+}
+QGLContextPrivate::~QGLContextPrivate()
+{
+if (!group->m_refs.deref()) {
+Q_ASSERT(group->context() == q_ptr);
+delete group;
+}
+}
+void QGLContextPrivate::init(QPaintDevice *dev, const QGLFormat &format)
+{
+Q_Q(QGLContext);
+glFormat = reqFormat = format;
+valid = false;
+q->setDevice(dev);
+#if defined(Q_WS_X11)
+pbuf = 0;
+gpm = 0;
+vi = 0;
+screen = QX11Info::appScreen();
+#endif
+#if defined(Q_WS_WIN)
+dc = 0;
+win = 0;
+pixelFormatId = 0;
+cmap = 0;
+hbitmap = 0;
+hbitmap_hdc = 0;
+#endif
+#if defined(Q_WS_MAC)
+#  ifndef QT_MAC_USE_COCOA
+update = false;
+#  endif
+vi = 0;
+#endif
+#if defined(QT_OPENGL_ES)
+eglContext = 0;
+eglSurface = EGL_NO_SURFACE;
+#endif
+fbo = 0;
+crWin = false;
+initDone = false;
+sharing = false;
+max_texture_size = -1;
+version_flags_cached = false;
+version_flags = QGLFormat::OpenGL_Version_None;
+current_fbo = 0;
+active_engine = 0;
+}
+QGLContext* QGLContext::currentCtx = 0;
+/*
+Read back the contents of the currently bound framebuffer, used in
+QGLWidget::grabFrameBuffer(), QGLPixelbuffer::toImage() and
+QGLFramebufferObject::toImage()
+*/
+static void convertFromGLImage(QImage &img, int w, int h, bool alpha_format, bool include_alpha)
+{
+if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+// OpenGL gives RGBA; Qt wants ARGB
+uint *p = (uint*)img.bits();
+uint *end = p + w*h;
+if (alpha_format && include_alpha) {
+while (p < end) {
+uint a = *p << 24;
+*p = (*p >> 8) | a;
+p++;
+}
+} else {
+// This is an old legacy fix for PowerPC based Macs, which
+// we shouldn't remove
+while (p < end) {
+*p = 0xff000000 | (*p>>8);
+++p;
+}
+}
+} else {
+// OpenGL gives ABGR (i.e. RGBA backwards); Qt wants ARGB
+for (int y = 0; y < h; y++) {
+uint *q = (uint*)img.scanLine(y);
+for (int x=0; x < w; ++x) {
+const uint pixel = *q;
+*q = ((pixel << 16) & 0xff0000) | ((pixel >> 16) & 0xff) | (pixel & 0xff00ff00);
+q++;
+}
+}
+}
+img = img.mirrored();
+}
+QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha)
+{
+QImage img(size, alpha_format ? QImage::Format_ARGB32 : QImage::Format_RGB32);
+int w = size.width();
+int h = size.height();
+glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
+convertFromGLImage(img, w, h, alpha_format, include_alpha);
+return img;
+}
+QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha)
+{
+QImage img(size, alpha_format ? QImage::Format_ARGB32 : QImage::Format_RGB32);
+int w = size.width();
+int h = size.height();
+#if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+//### glGetTexImage not in GL ES 2.0, need to do something else here!
+glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, img.bits());
+#endif
+convertFromGLImage(img, w, h, alpha_format, include_alpha);
+return img;
+}
+// returns the highest number closest to v, which is a power of 2
+// NB! assumes 32 bit ints
+int qt_next_power_of_two(int v)
+{
+v--;
+v |= v >> 1;
+v |= v >> 2;
+v |= v >> 4;
+v |= v >> 8;
+v |= v >> 16;
+++v;
+return v;
+}
+typedef void (*_qt_pixmap_cleanup_hook_64)(qint64);
+typedef void (*_qt_image_cleanup_hook_64)(qint64);
+extern Q_GUI_EXPORT _qt_pixmap_cleanup_hook_64 qt_pixmap_cleanup_hook_64;
+extern Q_GUI_EXPORT _qt_image_cleanup_hook_64 qt_image_cleanup_hook_64;
+static QGLTextureCache *qt_gl_texture_cache = 0;
+QGLTextureCache::QGLTextureCache()
+: m_cache(64*1024) // cache ~64 MB worth of textures - this is not accurate though
+{
+Q_ASSERT(qt_gl_texture_cache == 0);
+qt_gl_texture_cache = this;
+QImagePixmapCleanupHooks::instance()->addPixmapModificationHook(cleanupTextures);
+#ifdef Q_WS_X11
+QImagePixmapCleanupHooks::instance()->addPixmapDestructionHook(cleanupPixmapSurfaces);
+#endif
+QImagePixmapCleanupHooks::instance()->addImageHook(imageCleanupHook);
+}
+QGLTextureCache::~QGLTextureCache()
+{
+qt_gl_texture_cache = 0;
+QImagePixmapCleanupHooks::instance()->removePixmapModificationHook(cleanupTextures);
+#ifdef Q_WS_X11
+QImagePixmapCleanupHooks::instance()->removePixmapDestructionHook(cleanupPixmapSurfaces);
+#endif
+QImagePixmapCleanupHooks::instance()->removeImageHook(imageCleanupHook);
+}
+void QGLTextureCache::insert(QGLContext* ctx, qint64 key, QGLTexture* texture, int cost)
+{
+if (m_cache.totalCost() + cost > m_cache.maxCost()) {
+// the cache is full - make an attempt to remove something
+const QList<qint64> keys = m_cache.keys();
+int i = 0;
+while (i < m_cache.count()
+&& (m_cache.totalCost() + cost > m_cache.maxCost())) {
+QGLTexture *tex = m_cache.object(keys.at(i));
+if (tex->context == ctx)
+m_cache.remove(keys.at(i));
+++i;
+}
+}
+m_cache.insert(key, texture, cost);
+}
+bool QGLTextureCache::remove(QGLContext* ctx, GLuint textureId)
+{
+QList<qint64> keys = m_cache.keys();
+for (int i = 0; i < keys.size(); ++i) {
+QGLTexture *tex = m_cache.object(keys.at(i));
+if (tex->id == textureId && tex->context == ctx) {
+tex->options |= QGLContext::MemoryManagedBindOption; // forces a glDeleteTextures() call
+m_cache.remove(keys.at(i));
+return true;
+}
+}
+return false;
+}
+void QGLTextureCache::removeContextTextures(QGLContext* ctx)
+{
+QList<qint64> keys = m_cache.keys();
+for (int i = 0; i < keys.size(); ++i) {
+const qint64 &key = keys.at(i);
+if (m_cache.object(key)->context == ctx)
+m_cache.remove(key);
+}
+}
+QGLTextureCache* QGLTextureCache::instance()
+{
+if (!qt_gl_texture_cache)
+qt_gl_texture_cache = new QGLTextureCache;
+return qt_gl_texture_cache;
+}
+/*
+a hook that removes textures from the cache when a pixmap/image
+is deref'ed
+*/
+void QGLTextureCache::imageCleanupHook(qint64 cacheKey)
+{
+// ### remove when the GL texture cache becomes thread-safe
+if (qApp->thread() != QThread::currentThread())
+return;
+QGLTexture *texture = instance()->getTexture(cacheKey);
+if (texture && texture->options & QGLContext::MemoryManagedBindOption)
+instance()->remove(cacheKey);
+}
+void QGLTextureCache::cleanupTextures(QPixmap* pixmap)
+{
+// ### remove when the GL texture cache becomes thread-safe
+if (qApp->thread() == QThread::currentThread()) {
+const qint64 cacheKey = pixmap->cacheKey();
+QGLTexture *texture = instance()->getTexture(cacheKey);
+if (texture && texture->options & QGLContext::MemoryManagedBindOption)
+instance()->remove(cacheKey);
+}
+}
+#if defined(Q_WS_X11)
+void QGLTextureCache::cleanupPixmapSurfaces(QPixmap* pixmap)
+{
+// Remove any bound textures first:
+cleanupTextures(pixmap);
+QPixmapData *pd = pixmap->data_ptr().data();
+if (pd->classId() == QPixmapData::X11Class) {
+Q_ASSERT(pd->ref == 1); // Make sure reference counting isn't broken
+QGLContextPrivate::destroyGlSurfaceForPixmap(pd);
+}
+}
+#endif
+void QGLTextureCache::deleteIfEmpty()
+{
+if (instance()->size() == 0)
+delete instance();
+}
+// DDS format structure
+struct DDSFormat {
+quint32 dwSize;
+quint32 dwFlags;
+quint32 dwHeight;
+quint32 dwWidth;
+quint32 dwLinearSize;
+quint32 dummy1;
+quint32 dwMipMapCount;
+quint32 dummy2[11];
+struct {
+quint32 dummy3[2];
+quint32 dwFourCC;
+quint32 dummy4[5];
+} ddsPixelFormat;
+};
+// compressed texture pixel formats
+#define FOURCC_DXT1  0x31545844
+#define FOURCC_DXT2  0x32545844
+#define FOURCC_DXT3  0x33545844
+#define FOURCC_DXT4  0x34545844
+#define FOURCC_DXT5  0x35545844
+#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+#ifndef GL_GENERATE_MIPMAP_SGIS
+#define GL_GENERATE_MIPMAP_SGIS       0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS  0x8192
+#endif
+Q_GLOBAL_STATIC(QGLShareRegister, _qgl_share_reg)
+Q_OPENGL_EXPORT QGLShareRegister* qgl_share_reg()
+{
+return _qgl_share_reg();
+}
+/*!
+\class QGLContext
+\brief The QGLContext class encapsulates an OpenGL rendering context.
+\ingroup painting-3D
+An OpenGL rendering context is a complete set of OpenGL state
+variables. The rendering context's \l {QGL::FormatOption} {format}
+is set in the constructor, but it can also be set later with
+setFormat(). The format options that are actually set are returned
+by format(); the options you asked for are returned by
+requestedFormat(). Note that after a QGLContext object has been
+constructed, the actual OpenGL context must be created by
+explicitly calling the \link create() create()\endlink
+function. The makeCurrent() function makes this context the
+current rendering context. You can make \e no context current
+using doneCurrent(). The reset() function will reset the context
+and make it invalid.
+You can examine properties of the context with, e.g. isValid(),
+isSharing(), initialized(), windowCreated() and
+overlayTransparentColor().
+If you're using double buffering you can swap the screen contents
+with the off-screen buffer using swapBuffers().
+Please note that QGLContext is not thread safe.
+*/
+/*!
+\enum QGLContext::BindOption
+A set of options to decide how to bind a texture using bindTexture().
+\value NoBindOption Don't do anything, pass the texture straight
+thru.
+\value InvertedYBindOption Specifies that the texture should be flipped
+over the X axis so that the texture coordinate 0,0 corresponds to
+the top left corner. Inverting the texture implies a deep copy
+prior to upload.
+\value MipmapBindOption Specifies that bindTexture() should try
+to generate mipmaps.  If the GL implementation supports the \c
+GL_SGIS_generate_mipmap extension, mipmaps will be automatically
+generated for the texture. Mipmap generation is only supported for
+the \c GL_TEXTURE_2D target.
+\value PremultipliedAlphaBindOption Specifies that the image should be
+uploaded with premultiplied alpha and does a conversion accordingly.
+\value LinearFilteringBindOption Specifies that the texture filtering
+should be set to GL_LINEAR. Default is GL_NEAREST. If mipmap is
+also enabled, filtering will be set to GL_LINEAR_MIPMAP_LINEAR.
+\value DefaultBindOption In Qt 4.5 and earlier, bindTexture()
+would mirror the image and automatically generate mipmaps. This
+option helps preserve this default behavior.
+\omitvalue CanFlipNativePixmapBindOption Used by x11 from pixmap to choose
+wether or not it can bind the pixmap upside down or not.
+\omitvalue MemoryManagedBindOption Used by paint engines to
+indicate that the pixmap should be memory managed along side with
+the pixmap/image that it stems from, e.g. installing destruction
+hooks in them.
+\omitvalue InternalBindOption
+*/
+/*!
+\obsolete
+Constructs an OpenGL context for the given paint \a device, which
+can be a widget or a pixmap. The \a format specifies several
+display options for the context.
+If the underlying OpenGL/Window system cannot satisfy all the
+features requested in \a format, the nearest subset of features
+will be used. After creation, the format() method will return the
+actual format obtained.
+Note that after a QGLContext object has been constructed, \l
+create() must be called explicitly to create the actual OpenGL
+context. The context will be \l {isValid()}{invalid} if it was not
+possible to obtain a GL context at all.
+*/
+QGLContext::QGLContext(const QGLFormat &format, QPaintDevice *device)
+: d_ptr(new QGLContextPrivate(this))
+{
+Q_D(QGLContext);
+d->init(device, format);
+}
+/*!
+Constructs an OpenGL context with the given \a format which
+specifies several display options for the context.
+If the underlying OpenGL/Window system cannot satisfy all the
+features requested in \a format, the nearest subset of features
+will be used. After creation, the format() method will return the
+actual format obtained.
+Note that after a QGLContext object has been constructed, \l
+create() must be called explicitly to create the actual OpenGL
+context. The context will be \l {isValid()}{invalid} if it was not
+possible to obtain a GL context at all.
+\sa format(), isValid()
+*/
+QGLContext::QGLContext(const QGLFormat &format)
+: d_ptr(new QGLContextPrivate(this))
+{
+Q_D(QGLContext);
+d->init(0, format);
+}
+/*!
+Destroys the OpenGL context and frees its resources.
+*/
+QGLContext::~QGLContext()
+{
+// remove any textures cached in this context
+QGLTextureCache::instance()->removeContextTextures(this);
+QGLTextureCache::deleteIfEmpty(); // ### thread safety
+d_ptr->group->cleanupResources(this);
+QGLSignalProxy::instance()->emitAboutToDestroyContext(this);
+reset();
+}
+void QGLContextPrivate::cleanup()
+{
+}
+typedef QHash<QString, GLuint> QGLDDSCache;
+Q_GLOBAL_STATIC(QGLDDSCache, qgl_dds_cache)
+/*!
+\overload
+Reads the DirectDrawSurface (DDS) compressed file \a fileName and
+generates a 2D GL texture from it.
+Only the DXT1, DXT3 and DXT5 DDS formats are supported.
+Note that this will only work if the implementation supports the
+\c GL_ARB_texture_compression and \c GL_EXT_texture_compression_s3tc
+extensions.
+\sa deleteTexture()
+*/
+GLuint QGLContext::bindTexture(const QString &fileName)
+{
+if (!qt_glCompressedTexImage2DARB) {
+qWarning("QGLContext::bindTexture(): The GL implementation does not support texture"
+"compression extensions.");
+return 0;
+}
+QGLDDSCache::const_iterator it = qgl_dds_cache()->constFind(fileName);
+if (it != qgl_dds_cache()->constEnd()) {
+glBindTexture(GL_TEXTURE_2D, it.value());
+return it.value();
+}
+QFile f(fileName);
+f.open(QIODevice::ReadOnly);
+char tag[4];
+f.read(&tag[0], 4);
+if (strncmp(tag,"DDS ", 4) != 0) {
+qWarning("QGLContext::bindTexture(): not a DDS image file.");
+return 0;
+}
+DDSFormat ddsHeader;
+f.read((char *) &ddsHeader, sizeof(DDSFormat));
+if (!ddsHeader.dwLinearSize) {
+qWarning("QGLContext::bindTexture() DDS image size is not valid.");
+return 0;
+}
+int factor = 4;
+int bufferSize = 0;
+int blockSize = 16;
+GLenum format;
+switch(ddsHeader.ddsPixelFormat.dwFourCC) {
+case FOURCC_DXT1:
+format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+factor = 2;
+blockSize = 8;
+break;
+case FOURCC_DXT3:
+format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+break;
+case FOURCC_DXT5:
+format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+break;
+default:
+qWarning("QGLContext::bindTexture() DDS image format not supported.");
+return 0;
+}
+if (ddsHeader.dwMipMapCount > 1)
+bufferSize = ddsHeader.dwLinearSize * factor;
+else
+bufferSize = ddsHeader.dwLinearSize;
+GLubyte *pixels = (GLubyte *) malloc(bufferSize*sizeof(GLubyte));
+f.seek(ddsHeader.dwSize + 4);
+f.read((char *) pixels, bufferSize);
+f.close();
+GLuint tx_id;
+glGenTextures(1, &tx_id);
+glBindTexture(GL_TEXTURE_2D, tx_id);
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+int size;
+int offset = 0;
+int w = ddsHeader.dwWidth;
+int h = ddsHeader.dwHeight;
+// load mip-maps
+for(int i = 0; i < (int) ddsHeader.dwMipMapCount; ++i) {
+if (w == 0) w = 1;
+if (h == 0) h = 1;
+size = ((w+3)/4) * ((h+3)/4) * blockSize;
+qt_glCompressedTexImage2DARB(GL_TEXTURE_2D, i, format, w, h, 0,
+size, pixels + offset);
+offset += size;
+// half size for each mip-map level
+w = w/2;
+h = h/2;
+}
+free(pixels);
+qgl_dds_cache()->insert(fileName, tx_id);
+return tx_id;
+}
+static inline QRgb qt_gl_convertToGLFormatHelper(QRgb src_pixel, GLenum texture_format)
+{
+if (texture_format == GL_BGRA) {
+if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+return ((src_pixel << 24) & 0xff000000)
+| ((src_pixel >> 24) & 0x000000ff)
+| ((src_pixel << 8) & 0x00ff0000)
+| ((src_pixel >> 8) & 0x0000ff00);
+} else {
+return src_pixel;
+}
+} else {  // GL_RGBA
+if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+return (src_pixel << 8) | ((src_pixel >> 24) & 0xff);
+} else {
+return ((src_pixel << 16) & 0xff0000)
+| ((src_pixel >> 16) & 0xff)
+| (src_pixel & 0xff00ff00);
+}
+}
+}
+QRgb qt_gl_convertToGLFormat(QRgb src_pixel, GLenum texture_format)
+{
+return qt_gl_convertToGLFormatHelper(src_pixel, texture_format);
+}
+static void convertToGLFormatHelper(QImage &dst, const QImage &img, GLenum texture_format)
+{
+Q_ASSERT(dst.depth() == 32);
+Q_ASSERT(img.depth() == 32);
+if (dst.size() != img.size()) {
+int target_width = dst.width();
+int target_height = dst.height();
+qreal sx = target_width / qreal(img.width());
+qreal sy = target_height / qreal(img.height());
+quint32 *dest = (quint32 *) dst.scanLine(0); // NB! avoid detach here
+uchar *srcPixels = (uchar *) img.scanLine(img.height() - 1);
+int sbpl = img.bytesPerLine();
+int dbpl = dst.bytesPerLine();
+int ix = int(0x00010000 / sx);
+int iy = int(0x00010000 / sy);
+quint32 basex = int(0.5 * ix);
+quint32 srcy = int(0.5 * iy);
+// scale, swizzle and mirror in one loop
+while (target_height--) {
+const uint *src = (const quint32 *) (srcPixels - (srcy >> 16) * sbpl);
+int srcx = basex;
+for (int x=0; x<target_width; ++x) {
+dest[x] = qt_gl_convertToGLFormatHelper(src[srcx >> 16], texture_format);
+srcx += ix;
+}
+dest = (quint32 *)(((uchar *) dest) + dbpl);
+srcy += iy;
+}
+} else {
+const int width = img.width();
+const int height = img.height();
+const uint *p = (const uint*) img.scanLine(img.height() - 1);
+uint *q = (uint*) dst.scanLine(0);
+if (texture_format == GL_BGRA) {
+if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+// mirror + swizzle
+for (int i=0; i < height; ++i) {
+const uint *end = p + width;
+while (p < end) {
+*q = ((*p << 24) & 0xff000000)
+| ((*p >> 24) & 0x000000ff)
+| ((*p << 8) & 0x00ff0000)
+| ((*p >> 8) & 0x0000ff00);
+p++;
+q++;
+}
+p -= 2 * width;
+}
+} else {
+const uint bytesPerLine = img.bytesPerLine();
+for (int i=0; i < height; ++i) {
+memcpy(q, p, bytesPerLine);
+q += width;
+p -= width;
+}
+}
+} else {
+if (QSysInfo::ByteOrder == QSysInfo::BigEndian) {
+for (int i=0; i < height; ++i) {
+const uint *end = p + width;
+while (p < end) {
+*q = (*p << 8) | ((*p >> 24) & 0xff);
+p++;
+q++;
+}
+p -= 2 * width;
+}
+} else {
+for (int i=0; i < height; ++i) {
+const uint *end = p + width;
+while (p < end) {
+*q = ((*p << 16) & 0xff0000) | ((*p >> 16) & 0xff) | (*p & 0xff00ff00);
+p++;
+q++;
+}
+p -= 2 * width;
+}
+}
+}
+}
+}
+QImage QGLContextPrivate::convertToGLFormat(const QImage &image, bool force_premul,
+GLenum texture_format)
+{
+QImage::Format target_format = image.format();
+if (force_premul || image.format() != QImage::Format_ARGB32)
+target_format = QImage::Format_ARGB32_Premultiplied;
+QImage result(image.width(), image.height(), target_format);
+convertToGLFormatHelper(result, image.convertToFormat(target_format), texture_format);
+return result;
+}
+/*! \internal */
+QGLTexture *QGLContextPrivate::bindTexture(const QImage &image, GLenum target, GLint format,
+QGLContext::BindOptions options)
+{
+const qint64 key = image.cacheKey();
+QGLTexture *texture = textureCacheLookup(key, target);
+if (texture) {
+glBindTexture(target, texture->id);
+return texture;
+}
+if (!texture)
+texture = bindTexture(image, target, format, key, options);
+// NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
+Q_ASSERT(texture);
+if (texture->id > 0)
+const_cast<QImage &>(image).data_ptr()->is_cached = true;
+return texture;
+}
+// #define QGL_BIND_TEXTURE_DEBUG
+QGLTexture* QGLContextPrivate::bindTexture(const QImage &image, GLenum target, GLint internalFormat,
+const qint64 key, QGLContext::BindOptions options)
+{
+Q_Q(QGLContext);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf("QGLContextPrivate::bindTexture(), imageSize=(%d,%d), internalFormat =0x%x, options=%x\n",
+image.width(), image.height(), internalFormat, int(options));
+QTime time;
+time.start();
+#endif
+// Scale the pixmap if needed. GL textures needs to have the
+// dimensions 2^n+2(border) x 2^m+2(border), unless we're using GL
+// 2.0 or use the GL_TEXTURE_RECTANGLE texture target
+int tx_w = qt_next_power_of_two(image.width());
+int tx_h = qt_next_power_of_two(image.height());
+QImage img = image;
+if (( !(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0) &&
+!(QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_ES_Version_2_0) )
+&& (target == GL_TEXTURE_2D && (tx_w != image.width() || tx_h != image.height())))
+{
+img = img.scaled(tx_w, tx_h);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - upscaled to %dx%d (%d ms)\n", tx_w, tx_h, time.elapsed());
+#endif
+}
+GLuint filtering = options & QGLContext::LinearFilteringBindOption ? GL_LINEAR : GL_NEAREST;
+GLuint tx_id;
+glGenTextures(1, &tx_id);
+glBindTexture(target, tx_id);
+glTexParameterf(target, GL_TEXTURE_MAG_FILTER, filtering);
+#if defined(QT_OPENGL_ES_2)
+bool genMipmap = false;
+#endif
+if (glFormat.directRendering()
+&& QGLExtensions::glExtensions & QGLExtensions::GenerateMipmap
+&& target == GL_TEXTURE_2D
+&& options & QGLContext::MipmapBindOption)
+{
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - generating mipmaps (%d ms)\n", time.elapsed());
+#endif
+#if !defined(QT_OPENGL_ES_2)
+glHint(GL_GENERATE_MIPMAP_HINT_SGIS, GL_NICEST);
+#ifndef QT_OPENGL_ES
+glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
+#else
+glTexParameterf(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
+#endif
+#else
+glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
+genMipmap = true;
+#endif
+glTexParameterf(target, GL_TEXTURE_MIN_FILTER, options & QGLContext::LinearFilteringBindOption
+? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST);
+} else {
+glTexParameterf(target, GL_TEXTURE_MIN_FILTER, filtering);
+}
+QImage::Format target_format = img.format();
+bool premul = options & QGLContext::PremultipliedAlphaBindOption;
+GLenum externalFormat;
+GLuint pixel_type;
+if (QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2) {
+externalFormat = GL_BGRA;
+pixel_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+} else {
+externalFormat = GL_RGBA;
+pixel_type = GL_UNSIGNED_BYTE;
+}
+switch (target_format) {
+case QImage::Format_ARGB32:
+if (premul) {
+img = img.convertToFormat(target_format = QImage::Format_ARGB32_Premultiplied);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - converting ARGB32 -> ARGB32_Premultiplied (%d ms) \n", time.elapsed());
+#endif
+}
+break;
+case QImage::Format_ARGB32_Premultiplied:
+if (!premul) {
+img = img.convertToFormat(target_format = QImage::Format_ARGB32);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - converting ARGB32_Premultiplied -> ARGB32 (%d ms)\n", time.elapsed());
+#endif
+}
+break;
+case QImage::Format_RGB16:
+pixel_type = GL_UNSIGNED_SHORT_5_6_5;
+externalFormat = GL_RGB;
+internalFormat = GL_RGB;
+break;
+case QImage::Format_RGB32:
+break;
+default:
+if (img.hasAlphaChannel()) {
+img = img.convertToFormat(premul
+? QImage::Format_ARGB32_Premultiplied
+: QImage::Format_ARGB32);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - converting to 32-bit alpha format (%d ms)\n", time.elapsed());
+#endif
+} else {
+img = img.convertToFormat(QImage::Format_RGB32);
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - converting to 32-bit (%d ms)\n", time.elapsed());
+#endif
+}
+}
+if (options & QGLContext::InvertedYBindOption) {
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - flipping bits over y (%d ms)\n", time.elapsed());
+#endif
+int ipl = img.bytesPerLine() / 4;
+int h = img.height();
+for (int y=0; y<h/2; ++y) {
+int *a = (int *) img.scanLine(y);
+int *b = (int *) img.scanLine(h - y - 1);
+for (int x=0; x<ipl; ++x)
+qSwap(a[x], b[x]);
+}
+}
+if (externalFormat == GL_RGBA) {
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - doing byte swapping (%d ms)\n", time.elapsed());
+#endif
+// The only case where we end up with a depth different from
+// 32 in the switch above is for the RGB16 case, where we set
+// the format to GL_RGB
+Q_ASSERT(img.depth() == 32);
+const int width = img.width();
+const int height = img.height();
+if (pixel_type == GL_UNSIGNED_INT_8_8_8_8_REV
+|| (pixel_type == GL_UNSIGNED_BYTE && QSysInfo::ByteOrder == QSysInfo::LittleEndian)) {
+for (int i=0; i < height; ++i) {
+uint *p = (uint *) img.scanLine(i);
+for (int x=0; x<width; ++x)
+p[x] = ((p[x] << 16) & 0xff0000) | ((p[x] >> 16) & 0xff) | (p[x] & 0xff00ff00);
+}
+} else {
+for (int i=0; i < height; ++i) {
+uint *p = (uint *) img.scanLine(i);
+for (int x=0; x<width; ++x)
+p[x] = (p[x] << 8) | ((p[x] >> 24) & 0xff);
+}
+}
+}
+#ifdef QGL_BIND_TEXTURE_DEBUG
+printf(" - uploading, image.format=%d, externalFormat=0x%x, internalFormat=0x%x, pixel_type=0x%x\n",
+img.format(), externalFormat, internalFormat, pixel_type);
+#endif
+const QImage &constRef = img; // to avoid detach in bits()...
+glTexImage2D(target, 0, internalFormat, img.width(), img.height(), 0, externalFormat,
+pixel_type, constRef.bits());
+#if defined(QT_OPENGL_ES_2)
+if (genMipmap)
+glGenerateMipmap(target);
+#endif
+#ifndef QT_NO_DEBUG
+GLenum error = glGetError();
+if (error != GL_NO_ERROR) {
+qWarning(" - texture upload failed, error code 0x%x\n", error);
+}
+#endif
+#ifdef QGL_BIND_TEXTURE_DEBUG
+static int totalUploadTime = 0;
+totalUploadTime += time.elapsed();
+printf(" - upload done in (%d ms) time=%d\n", time.elapsed(), totalUploadTime);
+#endif
+// this assumes the size of a texture is always smaller than the max cache size
+int cost = img.width()*img.height()*4/1024;
+QGLTexture *texture = new QGLTexture(q, tx_id, target, options);
+QGLTextureCache::instance()->insert(q, key, texture, cost);
+return texture;
+}
+QGLTexture *QGLContextPrivate::textureCacheLookup(const qint64 key, GLenum target)
+{
+Q_Q(QGLContext);
+QGLTexture *texture = QGLTextureCache::instance()->getTexture(key);
+if (texture && texture->target == target
+&& (texture->context == q || QGLContext::areSharing(q, texture->context)))
+{
+return texture;
+}
+return 0;
+}
+/*! \internal */
+QGLTexture *QGLContextPrivate::bindTexture(const QPixmap &pixmap, GLenum target, GLint format, QGLContext::BindOptions options)
+{
+Q_Q(QGLContext);
+QPixmapData *pd = pixmap.pixmapData();
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+if (target == GL_TEXTURE_2D && pd->classId() == QPixmapData::OpenGLClass) {
+const QGLPixmapData *data = static_cast<const QGLPixmapData *>(pd);
+if (data->isValidContext(q)) {
+data->bind();
+return data->texture();
+}
+}
+#else
+Q_UNUSED(pd);
+Q_UNUSED(q);
+#endif
+const qint64 key = pixmap.cacheKey();
+QGLTexture *texture = textureCacheLookup(key, target);
+if (texture) {
+glBindTexture(target, texture->id);
+return texture;
+}
+#if defined(Q_WS_X11)
+// Try to use texture_from_pixmap
+if (pd->classId() == QPixmapData::X11Class && pd->pixelType() == QPixmapData::PixmapType) {
+texture = bindTextureFromNativePixmap(pd, key, options);
+if (texture) {
+texture->options |= QGLContext::MemoryManagedBindOption;
+texture->boundPixmap = pd;
+boundPixmaps.insert(pd, QPixmap(pixmap));
+}
+}
+#endif
+if (!texture)
+texture = bindTexture(pixmap.toImage(), target, format, key, options);
+// NOTE: bindTexture(const QImage&, GLenum, GLint, const qint64, bool) should never return null
+Q_ASSERT(texture);
+if (texture->id > 0)
+const_cast<QPixmap &>(pixmap).data_ptr()->is_cached = true;
+return texture;
+}
+/*! \internal */
+int QGLContextPrivate::maxTextureSize()
+{
+if (max_texture_size != -1)
+return max_texture_size;
+glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
+#if defined(QT_OPENGL_ES)
+return max_texture_size;
+#else
+GLenum proxy = GL_PROXY_TEXTURE_2D;
+GLint size;
+GLint next = 64;
+glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &size);
+if (size == 0) {
+return max_texture_size;
+}
+do {
+size = next;
+next = size * 2;
+if (next > max_texture_size)
+break;
+glTexImage2D(proxy, 0, GL_RGBA, next, next, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+glGetTexLevelParameteriv(proxy, 0, GL_TEXTURE_WIDTH, &next);
+} while (next > size);
+max_texture_size = size;
+return max_texture_size;
+#endif
+}
+/*!
+Generates and binds a 2D GL texture to the current context, based
+on \a image. The generated texture id is returned and can be used in
+later \c glBindTexture() calls.
+\overload
+*/
+GLuint QGLContext::bindTexture(const QImage &image, GLenum target, GLint format)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(image, target, format, false, DefaultBindOption);
+return texture->id;
+}
+/*!
+\since 4.6
+Generates and binds a 2D GL texture to the current context, based
+on \a image. The generated texture id is returned and can be used
+in later \c glBindTexture() calls.
+The \a target parameter specifies the texture target. The default
+target is \c GL_TEXTURE_2D.
+The \a format parameter sets the internal format for the
+texture. The default format is \c GL_RGBA.
+The binding \a options are a set of options used to decide how to
+bind the texture to the context.
+The texture that is generated is cached, so multiple calls to
+bindTexture() with the same QImage will return the same texture
+id.
+Note that we assume default values for the glPixelStore() and
+glPixelTransfer() parameters.
+\sa deleteTexture()
+*/
+GLuint QGLContext::bindTexture(const QImage &image, GLenum target, GLint format, BindOptions options)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(image, target, format, false, options);
+return texture->id;
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+GLuint QGLContext::bindTexture(const QImage &image, QMacCompatGLenum target, QMacCompatGLint format)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, DefaultBindOption);
+return texture->id;
+}
+/*! \internal */
+GLuint QGLContext::bindTexture(const QImage &image, QMacCompatGLenum target, QMacCompatGLint format,
+BindOptions options)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(image, GLenum(target), GLint(format), false, options);
+return texture->id;
+}
+#endif
+/*! \overload
+Generates and binds a 2D GL texture based on \a pixmap.
+*/
+GLuint QGLContext::bindTexture(const QPixmap &pixmap, GLenum target, GLint format)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(pixmap, target, format, DefaultBindOption);
+return texture->id;
+}
+/*!
+\overload
+\since 4.6
+Generates and binds a 2D GL texture to the current context, based
+on \a pixmap.
+*/
+GLuint QGLContext::bindTexture(const QPixmap &pixmap, GLenum target, GLint format, BindOptions options)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(pixmap, target, format, options);
+return texture->id;
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+GLuint QGLContext::bindTexture(const QPixmap &pixmap, QMacCompatGLenum target, QMacCompatGLint format)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(pixmap, GLenum(target), GLint(format), DefaultBindOption);
+return texture->id;
+}
+/*! \internal */
+GLuint QGLContext::bindTexture(const QPixmap &pixmap, QMacCompatGLenum target, QMacCompatGLint format,
+BindOptions options)
+{
+Q_D(QGLContext);
+QGLTexture *texture = d->bindTexture(pixmap, GLenum(target), GLint(format), options);
+return texture->id;
+}
+#endif
+/*!
+Removes the texture identified by \a id from the texture cache,
+and calls glDeleteTextures() to delete the texture from the
+context.
+\sa bindTexture()
+*/
+void QGLContext::deleteTexture(GLuint id)
+{
+if (QGLTextureCache::instance()->remove(this, id))
+return;
+// check the DDS cache if the texture wasn't found in the pixmap/image
+// cache
+QList<QString> ddsKeys = qgl_dds_cache()->keys();
+for (int i = 0; i < ddsKeys.size(); ++i) {
+GLuint texture = qgl_dds_cache()->value(ddsKeys.at(i));
+if (id == texture) {
+glDeleteTextures(1, &texture);
+qgl_dds_cache()->remove(ddsKeys.at(i));
+return;
+}
+}
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLContext::deleteTexture(QMacCompatGLuint id)
+{
+return deleteTexture(GLuint(id));
+}
+#endif
+void qt_add_rect_to_array(const QRectF &r, q_vertexType *array)
+{
+qreal left = r.left();
+qreal right = r.right();
+qreal top = r.top();
+qreal bottom = r.bottom();
+array[0] = f2vt(left);
+array[1] = f2vt(top);
+array[2] = f2vt(right);
+array[3] = f2vt(top);
+array[4] = f2vt(right);
+array[5] = f2vt(bottom);
+array[6] = f2vt(left);
+array[7] = f2vt(bottom);
+}
+void qt_add_texcoords_to_array(qreal x1, qreal y1, qreal x2, qreal y2, q_vertexType *array)
+{
+array[0] = f2vt(x1);
+array[1] = f2vt(y1);
+array[2] = f2vt(x2);
+array[3] = f2vt(y1);
+array[4] = f2vt(x2);
+array[5] = f2vt(y2);
+array[6] = f2vt(x1);
+array[7] = f2vt(y2);
+}
+#if !defined(QT_OPENGL_ES_2)
+static void qDrawTextureRect(const QRectF &target, GLint textureWidth, GLint textureHeight, GLenum textureTarget)
+{
+q_vertexType tx = f2vt(1);
+q_vertexType ty = f2vt(1);
+#ifdef QT_OPENGL_ES
+Q_UNUSED(textureWidth);
+Q_UNUSED(textureHeight);
+Q_UNUSED(textureTarget);
+#else
+if (textureTarget != GL_TEXTURE_2D) {
+if (textureWidth == -1 || textureHeight == -1) {
+glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
+glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
+}
+tx = f2vt(textureWidth);
+ty = f2vt(textureHeight);
+}
+#endif
+q_vertexType texCoordArray[4*2] = {
+0, ty, tx, ty, tx, 0, 0, 0
+};
+q_vertexType vertexArray[4*2];
+qt_add_rect_to_array(target, vertexArray);
+glVertexPointer(2, q_vertexTypeEnum, 0, vertexArray);
+glTexCoordPointer(2, q_vertexTypeEnum, 0, texCoordArray);
+glEnableClientState(GL_VERTEX_ARRAY);
+glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+glDisableClientState(GL_VERTEX_ARRAY);
+glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+}
+#endif // !QT_OPENGL_ES_2
+/*!
+\since 4.4
+Draws the given texture, \a textureId, to the given target rectangle,
+\a target, in OpenGL model space. The \a textureTarget should be a 2D
+texture target.
+\note This function is not supported under OpenGL/ES 2.0.
+*/
+void QGLContext::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
+{
+#ifndef QT_OPENGL_ES_2
+#ifdef QT_OPENGL_ES
+if (textureTarget != GL_TEXTURE_2D) {
+qWarning("QGLContext::drawTexture(): texture target must be GL_TEXTURE_2D on OpenGL ES");
+return;
+}
+#else
+const bool wasEnabled = glIsEnabled(GL_TEXTURE_2D);
+GLint oldTexture;
+glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
+#endif
+glEnable(textureTarget);
+glBindTexture(textureTarget, textureId);
+qDrawTextureRect(target, -1, -1, textureTarget);
+#ifdef QT_OPENGL_ES
+glDisable(textureTarget);
+#else
+if (!wasEnabled)
+glDisable(textureTarget);
+glBindTexture(textureTarget, oldTexture);
+#endif
+#else
+Q_UNUSED(target);
+Q_UNUSED(textureId);
+Q_UNUSED(textureTarget);
+qWarning("drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES/2.0");
+#endif
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLContext::drawTexture(const QRectF &target, QMacCompatGLuint textureId, QMacCompatGLenum textureTarget)
+{
+drawTexture(target, GLuint(textureId), GLenum(textureTarget));
+}
+#endif
+/*!
+\since 4.4
+Draws the given texture at the given \a point in OpenGL model
+space. The \a textureTarget should be a 2D texture target.
+\note This function is not supported under OpenGL/ES.
+*/
+void QGLContext::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
+{
+// this would be ok on OpenGL ES 2.0, but currently we don't have a define for that
+#ifdef QT_OPENGL_ES
+Q_UNUSED(point);
+Q_UNUSED(textureId);
+Q_UNUSED(textureTarget);
+qWarning("drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget) not supported with OpenGL ES, use rect version instead");
+#else
+const bool wasEnabled = glIsEnabled(GL_TEXTURE_2D);
+GLint oldTexture;
+glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
+glEnable(textureTarget);
+glBindTexture(textureTarget, textureId);
+GLint textureWidth;
+GLint textureHeight;
+glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_WIDTH, &textureWidth);
+glGetTexLevelParameteriv(textureTarget, 0, GL_TEXTURE_HEIGHT, &textureHeight);
+qDrawTextureRect(QRectF(point, QSizeF(textureWidth, textureHeight)), textureWidth, textureHeight, textureTarget);
+if (!wasEnabled)
+glDisable(textureTarget);
+glBindTexture(textureTarget, oldTexture);
+#endif
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLContext::drawTexture(const QPointF &point, QMacCompatGLuint textureId, QMacCompatGLenum textureTarget)
+{
+drawTexture(point, GLuint(textureId), GLenum(textureTarget));
+}
+#endif
+/*!
+This function sets the limit for the texture cache to \a size,
+expressed in kilobytes.
+By default, the cache limit is approximately 64 MB.
+\sa textureCacheLimit()
+*/
+void QGLContext::setTextureCacheLimit(int size)
+{
+QGLTextureCache::instance()->setMaxCost(size);
+}
+/*!
+Returns the current texture cache limit in kilobytes.
+\sa setTextureCacheLimit()
+*/
+int QGLContext::textureCacheLimit()
+{
+return QGLTextureCache::instance()->maxCost();
+}
+/*!
+\fn QGLFormat QGLContext::format() const
+Returns the frame buffer format that was obtained (this may be a
+subset of what was requested).
+\sa requestedFormat()
+*/
+/*!
+\fn QGLFormat QGLContext::requestedFormat() const
+Returns the frame buffer format that was originally requested in
+the constructor or setFormat().
+\sa format()
+*/
+/*!
+Sets a \a format for this context. The context is \link reset()
+reset\endlink.
+Call create() to create a new GL context that tries to match the
+new format.
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 7
+\sa format(), reset(), create()
+*/
+void QGLContext::setFormat(const QGLFormat &format)
+{
+Q_D(QGLContext);
+reset();
+d->glFormat = d->reqFormat = format;
+}
+/*!
+\internal
+*/
+void QGLContext::setDevice(QPaintDevice *pDev)
+{
+Q_D(QGLContext);
+if (isValid())
+reset();
+d->paintDevice = pDev;
+if (d->paintDevice && (d->paintDevice->devType() != QInternal::Widget
+&& d->paintDevice->devType() != QInternal::Pixmap
+&& d->paintDevice->devType() != QInternal::Pbuffer)) {
+qWarning("QGLContext: Unsupported paint device type");
+}
+}
+/*!
+\fn bool QGLContext::isValid() const
+Returns true if a GL rendering context has been successfully
+created; otherwise returns false.
+*/
+/*!
+\fn void QGLContext::setValid(bool valid)
+\internal
+Forces the GL rendering context to be valid.
+*/
+/*!
+\fn bool QGLContext::isSharing() const
+Returns true if this context is sharing its GL context with
+another QGLContext, otherwise false is returned. Note that context
+sharing might not be supported between contexts with different
+formats.
+*/
+/*!
+Returns true if \a context1 and \a context2 are sharing their
+GL resources such as textures, shader programs, etc;
+otherwise returns false.
+\since 4.6
+*/
+bool QGLContext::areSharing(const QGLContext *context1, const QGLContext *context2)
+{
+if (!context1 || !context2)
+return false;
+return context1->d_ptr->group == context2->d_ptr->group;
+}
+/*!
+\fn bool QGLContext::deviceIsPixmap() const
+Returns true if the paint device of this context is a pixmap;
+otherwise returns false.
+*/
+/*!
+\fn bool QGLContext::windowCreated() const
+Returns true if a window has been created for this context;
+otherwise returns false.
+\sa setWindowCreated()
+*/
+/*!
+\fn void QGLContext::setWindowCreated(bool on)
+If \a on is true the context has had a window created for it. If
+\a on is false no window has been created for the context.
+\sa windowCreated()
+*/
+/*!
+\fn uint QGLContext::colorIndex(const QColor& c) const
+\internal
+Returns a colormap index for the color c, in ColorIndex mode. Used
+by qglColor() and qglClearColor().
+*/
+/*!
+\fn bool QGLContext::initialized() const
+Returns true if this context has been initialized, i.e. if
+QGLWidget::initializeGL() has been performed on it; otherwise
+returns false.
+\sa setInitialized()
+*/
+/*!
+\fn void QGLContext::setInitialized(bool on)
+If \a on is true the context has been initialized, i.e.
+QGLContext::setInitialized() has been called on it. If \a on is
+false the context has not been initialized.
+\sa initialized()
+*/
+/*!
+\fn const QGLContext* QGLContext::currentContext()
+Returns the current context, i.e. the context to which any OpenGL
+commands will currently be directed. Returns 0 if no context is
+current.
+\sa makeCurrent()
+*/
+/*!
+\fn QColor QGLContext::overlayTransparentColor() const
+If this context is a valid context in an overlay plane, returns
+the plane's transparent color. Otherwise returns an \link
+QColor::isValid() invalid \endlink color.
+The returned color's \link QColor::pixel() pixel \endlink value is
+the index of the transparent color in the colormap of the overlay
+plane. (Naturally, the color's RGB values are meaningless.)
+The returned QColor object will generally work as expected only
+when passed as the argument to QGLWidget::qglColor() or
+QGLWidget::qglClearColor(). Under certain circumstances it can
+also be used to draw transparent graphics with a QPainter. See the
+examples/opengl/overlay_x11 example for details.
+*/
+/*!
+Creates the GL context. Returns true if it was successful in
+creating a valid GL rendering context on the paint device
+specified in the constructor; otherwise returns false (i.e. the
+context is invalid).
+After successful creation, format() returns the set of features of
+the created GL rendering context.
+If \a shareContext points to a valid QGLContext, this method will
+try to establish OpenGL display list and texture object sharing
+between this context and the \a shareContext. Note that this may
+fail if the two contexts have different \l {format()} {formats}.
+Use isSharing() to see if sharing is in effect.
+\warning Implementation note: initialization of C++ class
+members usually takes place in the class constructor. QGLContext
+is an exception because it must be simple to customize. The
+virtual functions chooseContext() (and chooseVisual() for X11) can
+be reimplemented in a subclass to select a particular context. The
+problem is that virtual functions are not properly called during
+construction (even though this is correct C++) because C++
+constructs class hierarchies from the bottom up. For this reason
+we need a create() function.
+\sa chooseContext(), format(), isValid()
+*/
+bool QGLContext::create(const QGLContext* shareContext)
+{
+Q_D(QGLContext);
+if (!d->paintDevice)
+return false;
+reset();
+d->valid = chooseContext(shareContext);
+if (d->valid && d->paintDevice->devType() == QInternal::Widget) {
+QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
+wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
+}
+if (d->sharing)  // ok, we managed to share
+qgl_share_reg()->addShare(this, shareContext);
+return d->valid;
+}
+bool QGLContext::isValid() const
+{
+Q_D(const QGLContext);
+return d->valid;
+}
+void QGLContext::setValid(bool valid)
+{
+Q_D(QGLContext);
+d->valid = valid;
+}
+bool QGLContext::isSharing() const
+{
+Q_D(const QGLContext);
+return d->sharing;
+}
+QGLFormat QGLContext::format() const
+{
+Q_D(const QGLContext);
+return d->glFormat;
+}
+QGLFormat QGLContext::requestedFormat() const
+{
+Q_D(const QGLContext);
+return d->reqFormat;
+}
+QPaintDevice* QGLContext::device() const
+{
+Q_D(const QGLContext);
+return d->paintDevice;
+}
+bool QGLContext::deviceIsPixmap() const
+{
+Q_D(const QGLContext);
+return d->paintDevice->devType() == QInternal::Pixmap;
+}
+bool QGLContext::windowCreated() const
+{
+Q_D(const QGLContext);
+return d->crWin;
+}
+void QGLContext::setWindowCreated(bool on)
+{
+Q_D(QGLContext);
+d->crWin = on;
+}
+bool QGLContext::initialized() const
+{
+Q_D(const QGLContext);
+return d->initDone;
+}
+void QGLContext::setInitialized(bool on)
+{
+Q_D(QGLContext);
+d->initDone = on;
+}
+const QGLContext* QGLContext::currentContext()
+{
+QGLThreadContext *threadContext = qgl_context_storage.localData();
+if (threadContext)
+return threadContext->context;
+return 0;
+}
+void QGLContextPrivate::setCurrentContext(QGLContext *context)
+{
+QGLThreadContext *threadContext = qgl_context_storage.localData();
+if (!threadContext) {
+if (!QThread::currentThread()) {
+// We don't have a current QThread, so just set the static.
+QGLContext::currentCtx = context;
+return;
+}
+threadContext = new QGLThreadContext;
+qgl_context_storage.setLocalData(threadContext);
+}
+threadContext->context = context;
+QGLContext::currentCtx = context; // XXX: backwards-compat, not thread-safe
+}
+/*!
+\fn bool QGLContext::chooseContext(const QGLContext* shareContext = 0)
+This semi-internal function is called by create(). It creates a
+system-dependent OpenGL handle that matches the format() of \a
+shareContext as closely as possible, returning true if successful
+or false if a suitable handle could not be found.
+On Windows, it calls the virtual function choosePixelFormat(),
+which finds a matching pixel format identifier. On X11, it calls
+the virtual function chooseVisual() which finds an appropriate X
+visual. On other platforms it may work differently.
+*/
+/*! \fn int QGLContext::choosePixelFormat(void* dummyPfd, HDC pdc)
+\bold{Win32 only:} This virtual function chooses a pixel format
+that matches the OpenGL \link setFormat() format\endlink.
+Reimplement this function in a subclass if you need a custom
+context.
+\warning The \a dummyPfd pointer and \a pdc are used as a \c
+PIXELFORMATDESCRIPTOR*. We use \c void to avoid using
+Windows-specific types in our header files.
+\sa chooseContext()
+*/
+/*! \fn void *QGLContext::chooseVisual()
+\bold{X11 only:} This virtual function tries to find a visual that
+matches the format, reducing the demands if the original request
+cannot be met.
+The algorithm for reducing the demands of the format is quite
+simple-minded, so override this method in your subclass if your
+application has spcific requirements on visual selection.
+\sa chooseContext()
+*/
+/*! \fn void *QGLContext::tryVisual(const QGLFormat& f, int bufDepth)
+\internal
+\bold{X11 only:} This virtual function chooses a visual that matches
+the OpenGL \link format() format\endlink. Reimplement this function
+in a subclass if you need a custom visual.
+\sa chooseContext()
+*/
+/*!
+\fn void QGLContext::reset()
+Resets the context and makes it invalid.
+\sa create(), isValid()
+*/
+/*!
+\fn void QGLContext::makeCurrent()
+Makes this context the current OpenGL rendering context. All GL
+functions you call operate on this context until another context
+is made current.
+In some very rare cases the underlying call may fail. If this
+occurs an error message is output to stderr.
+*/
+/*!
+\fn void QGLContext::swapBuffers() const
+Swaps the screen contents with an off-screen buffer. Only works if
+the context is in double buffer mode.
+\sa QGLFormat::setDoubleBuffer()
+*/
+/*!
+\fn void QGLContext::doneCurrent()
+Makes no GL context the current context. Normally, you do not need
+to call this function; QGLContext calls it as necessary.
+*/
+/*!
+\fn QPaintDevice* QGLContext::device() const
+Returns the paint device set for this context.
+\sa QGLContext::QGLContext()
+*/
+/*!
+\obsolete
+\fn void QGLContext::generateFontDisplayLists(const QFont& font, int listBase)
+Generates a set of 256 display lists for the 256 first characters
+in the font \a font. The first list will start at index \a listBase.
+\sa QGLWidget::renderText()
+*/
+/*****************************************************************************
+QGLWidget implementation
+*****************************************************************************/
+/*!
+\class QGLWidget
+\brief The QGLWidget class is a widget for rendering OpenGL graphics.
+\ingroup painting-3D
+QGLWidget provides functionality for displaying OpenGL graphics
+integrated into a Qt application. It is very simple to use. You
+inherit from it and use the subclass like any other QWidget,
+except that you have the choice between using QPainter and
+standard OpenGL rendering commands.
+QGLWidget provides three convenient virtual functions that you can
+reimplement in your subclass to perform the typical OpenGL tasks:
+\list
+\i paintGL() - Renders the OpenGL scene. Gets called whenever the widget
+needs to be updated.
+\i resizeGL() - Sets up the OpenGL viewport, projection, etc. Gets
+called whenever the widget has been resized (and also when it
+is shown for the first time because all newly created widgets get a
+resize event automatically).
+\i initializeGL() - Sets up the OpenGL rendering context, defines display
+lists, etc. Gets called once before the first time resizeGL() or
+paintGL() is called.
+\endlist
+Here is a rough outline of how a QGLWidget subclass might look:
+\snippet doc/src/snippets/code/src_opengl_qgl.cpp 8
+If you need to trigger a repaint from places other than paintGL()
+(a typical example is when using \link QTimer timers\endlink to
+animate scenes), you should call the widget's updateGL() function.
+Your widget's OpenGL rendering context is made current when
+paintGL(), resizeGL(), or initializeGL() is called. If you need to
+call the standard OpenGL API functions from other places (e.g. in
+your widget's constructor or in your own paint functions), you
+must call makeCurrent() first.
+QGLWidget provides functions for requesting a new display \link
+QGLFormat format\endlink and you can also create widgets with
+customized rendering \link QGLContext contexts\endlink.
+You can also share OpenGL display lists between QGLWidget objects (see
+the documentation of the QGLWidget constructors for details).
+Note that under Windows, the QGLContext belonging to a QGLWidget
+has to be recreated when the QGLWidget is reparented. This is
+necessary due to limitations on the Windows platform. This will
+most likely cause problems for users that have subclassed and
+installed their own QGLContext on a QGLWidget. It is possible to
+work around this issue by putting the QGLWidget inside a dummy
+widget and then reparenting the dummy widget, instead of the
+QGLWidget. This will side-step the issue altogether, and is what
+we recommend for users that need this kind of functionality.
+On Mac OS X, when Qt is built with Cocoa support, a QGLWidget
+can't have any sibling widgets placed ontop of itself. This is due
+to limitations in the Cocoa API and is not supported by Apple.
+\section1 Overlays
+The QGLWidget creates a GL overlay context in addition to the
+normal context if overlays are supported by the underlying system.
+If you want to use overlays, you specify it in the \link QGLFormat
+format\endlink. (Note: Overlay must be requested in the format
+passed to the QGLWidget constructor.) Your GL widget should also
+implement some or all of these virtual methods:
+\list
+\i paintOverlayGL()
+\i resizeOverlayGL()
+\i initializeOverlayGL()
+\endlist
+These methods work in the same way as the normal paintGL() etc.
+functions, except that they will be called when the overlay
+context is made current. You can explicitly make the overlay
+context current by using makeOverlayCurrent(), and you can access
+the overlay context directly (e.g. to ask for its transparent
+color) by calling overlayContext().
+On X servers in which the default visual is in an overlay plane,
+non-GL Qt windows can also be used for overlays.
+\section1 Painting Techniques
+As described above, subclass QGLWidget to render pure 3D content in the
+following way:
+\list
+\o Reimplement the QGLWidget::initializeGL() and QGLWidget::resizeGL() to
+set up the OpenGL state and provide a perspective transformation.
+\o Reimplement QGLWidget::paintGL() to paint the 3D scene, calling only
+OpenGL functions to draw on the widget.
+\endlist
+It is also possible to draw 2D graphics onto a QGLWidget subclass, it is necessary
+to reimplement QGLWidget::paintEvent() and do the following:
+\list
+\o Construct a QPainter object.
+\o Initialize it for use on the widget with the QPainter::begin() function.
+\o Draw primitives using QPainter's member functions.
+\o Call QPainter::end() to finish painting.
+\endlist
+Overpainting 2D content on top of 3D content takes a little more effort.
+One approach to doing this is shown in the
+\l{Overpainting Example}{Overpainting} example.
+\e{OpenGL is a trademark of Silicon Graphics, Inc. in the United States and other
+countries.}
+\sa QGLPixelBuffer, {Hello GL Example}, {2D Painting Example}, {Overpainting Example},
+{Grabber Example}
+*/
+/*!
+Constructs an OpenGL widget with a \a parent widget.
+The \link QGLFormat::defaultFormat() default format\endlink is
+used. The widget will be \link isValid() invalid\endlink if the
+system has no \link QGLFormat::hasOpenGL() OpenGL support\endlink.
+The \a parent and widget flag, \a f, arguments are passed
+to the QWidget constructor.
+If \a shareWidget is a valid QGLWidget, this widget will share
+OpenGL display lists and texture objects with \a shareWidget. But
+if \a shareWidget and this widget have different \l {format()}
+{formats}, sharing might not be possible. You can check whether
+sharing is in effect by calling isSharing().
+The initialization of OpenGL rendering state, etc. should be done
+by overriding the initializeGL() function, rather than in the
+constructor of your QGLWidget subclass.
+\sa QGLFormat::defaultFormat(), {Textures Example}
+*/
+QGLWidget::QGLWidget(QWidget *parent, const QGLWidget* shareWidget, Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(new QGLContext(QGLFormat::defaultFormat(), this), shareWidget);
+}
+/*!
+Constructs an OpenGL widget with parent \a parent.
+The \a format argument specifies the desired \link QGLFormat
+rendering options \endlink. If the underlying OpenGL/Window system
+cannot satisfy all the features requested in \a format, the
+nearest subset of features will be used. After creation, the
+format() method will return the actual format obtained.
+The widget will be \link isValid() invalid\endlink if the system
+has no \link QGLFormat::hasOpenGL() OpenGL support\endlink.
+The \a parent and widget flag, \a f, arguments are passed
+to the QWidget constructor.
+If \a shareWidget is a valid QGLWidget, this widget will share
+OpenGL display lists and texture objects with \a shareWidget. But
+if \a shareWidget and this widget have different \l {format()}
+{formats}, sharing might not be possible. You can check whether
+sharing is in effect by calling isSharing().
+The initialization of OpenGL rendering state, etc. should be done
+by overriding the initializeGL() function, rather than in the
+constructor of your QGLWidget subclass.
+\sa QGLFormat::defaultFormat(), isValid()
+*/
+QGLWidget::QGLWidget(const QGLFormat &format, QWidget *parent, const QGLWidget* shareWidget,
+Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(new QGLContext(format, this), shareWidget);
+}
+/*!
+Constructs an OpenGL widget with parent \a parent.
+The \a context argument is a pointer to the QGLContext that
+you wish to be bound to this widget. This allows you to pass in
+your own QGLContext sub-classes.
+The widget will be \link isValid() invalid\endlink if the system
+has no \link QGLFormat::hasOpenGL() OpenGL support\endlink.
+The \a parent and widget flag, \a f, arguments are passed
+to the QWidget constructor.
+If \a shareWidget is a valid QGLWidget, this widget will share
+OpenGL display lists and texture objects with \a shareWidget. But
+if \a shareWidget and this widget have different \l {format()}
+{formats}, sharing might not be possible. You can check whether
+sharing is in effect by calling isSharing().
+The initialization of OpenGL rendering state, etc. should be done
+by overriding the initializeGL() function, rather than in the
+constructor of your QGLWidget subclass.
+\sa QGLFormat::defaultFormat(), isValid()
+*/
+QGLWidget::QGLWidget(QGLContext *context, QWidget *parent, const QGLWidget *shareWidget,
+Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(context, shareWidget);
+}
+/*!
+Destroys the widget.
+*/
+QGLWidget::~QGLWidget()
+{
+Q_D(QGLWidget);
+#if defined(GLX_MESA_release_buffers) && defined(QGL_USE_MESA_EXT)
+bool doRelease = (glcx && glcx->windowCreated());
+#endif
+delete d->glcx;
+#if defined(Q_WGL)
+delete d->olcx;
+#endif
+#if defined(GLX_MESA_release_buffers) && defined(QGL_USE_MESA_EXT)
+if (doRelease)
+glXReleaseBuffersMESA(x11Display(), winId());
+#endif
+d->cleanupColormaps();
+#ifdef Q_WS_MAC
+QWidget *current = parentWidget();
+while (current) {
+qt_widget_private(current)->glWidgets.removeAll(QWidgetPrivate::GlWidgetInfo(this));
+if (current->isWindow())
+break;
+current = current->parentWidget();
+};
+#endif
+}
+/*!
+\fn QGLFormat QGLWidget::format() const
+Returns the format of the contained GL rendering context.
+*/
+/*!
+\fn bool QGLWidget::doubleBuffer() const
+Returns true if the contained GL rendering context has double
+buffering; otherwise returns false.
+\sa QGLFormat::doubleBuffer()
+*/
+/*!
+\fn void QGLWidget::setAutoBufferSwap(bool on)
+If \a on is true automatic GL buffer swapping is switched on;
+otherwise it is switched off.
+If \a on is true and the widget is using a double-buffered format,
+the background and foreground GL buffers will automatically be
+swapped after each paintGL() call.
+The buffer auto-swapping is on by default.
+\sa autoBufferSwap(), doubleBuffer(), swapBuffers()
+*/
+/*!
+\fn bool QGLWidget::autoBufferSwap() const
+Returns true if the widget is doing automatic GL buffer swapping;
+otherwise returns false.
+\sa setAutoBufferSwap()
+*/
+/*!
+\fn void *QGLContext::getProcAddress(const QString &proc) const
+Returns a function pointer to the GL extension function passed in
+\a proc. 0 is returned if a pointer to the function could not be
+obtained.
+*/
+/*!
+\fn bool QGLWidget::isValid() const
+Returns true if the widget has a valid GL rendering context;
+otherwise returns false. A widget will be invalid if the system
+has no \link QGLFormat::hasOpenGL() OpenGL support\endlink.
+*/
+bool QGLWidget::isValid() const
+{
+Q_D(const QGLWidget);
+return d->glcx && d->glcx->isValid();
+}
+/*!
+\fn bool QGLWidget::isSharing() const
+Returns true if this widget's GL context is shared with another GL
+context, otherwise false is returned. Context sharing might not be
+possible if the widgets use different formats.
+\sa format()
+*/
+bool QGLWidget::isSharing() const
+{
+Q_D(const QGLWidget);
+return d->glcx->isSharing();
+}
+/*!
+\fn void QGLWidget::makeCurrent()
+Makes this widget the current widget for OpenGL operations, i.e.
+makes the widget's rendering context the current OpenGL rendering
+context.
+*/
+void QGLWidget::makeCurrent()
+{
+Q_D(QGLWidget);
+d->glcx->makeCurrent();
+}
+/*!
+\fn void QGLWidget::doneCurrent()
+Makes no GL context the current context. Normally, you do not need
+to call this function; QGLContext calls it as necessary. However,
+it may be useful in multithreaded environments.
+*/
+void QGLWidget::doneCurrent()
+{
+Q_D(QGLWidget);
+d->glcx->doneCurrent();
+}
+/*!
+\fn void QGLWidget::swapBuffers()
+Swaps the screen contents with an off-screen buffer. This only
+works if the widget's format specifies double buffer mode.
+Normally, there is no need to explicitly call this function
+because it is done automatically after each widget repaint, i.e.
+each time after paintGL() has been executed.
+\sa doubleBuffer(), setAutoBufferSwap(), QGLFormat::setDoubleBuffer()
+*/
+void QGLWidget::swapBuffers()
+{
+Q_D(QGLWidget);
+d->glcx->swapBuffers();
+}
+/*!
+\fn const QGLContext* QGLWidget::overlayContext() const
+Returns the overlay context of this widget, or 0 if this widget
+has no overlay.
+\sa context()
+*/
+/*!
+\fn void QGLWidget::makeOverlayCurrent()
+Makes the overlay context of this widget current. Use this if you
+need to issue OpenGL commands to the overlay context outside of
+initializeOverlayGL(), resizeOverlayGL(), and paintOverlayGL().
+Does nothing if this widget has no overlay.
+\sa makeCurrent()
+*/
+/*!
+\obsolete
+Sets a new format for this widget.
+If the underlying OpenGL/Window system cannot satisfy all the
+features requested in \a format, the nearest subset of features will
+be used. After creation, the format() method will return the actual
+rendering context format obtained.
+The widget will be assigned a new QGLContext, and the initializeGL()
+function will be executed for this new context before the first
+resizeGL() or paintGL().
+This method will try to keep display list and texture object sharing
+in effect with other QGLWidget objects, but changing the format might make
+sharing impossible. Use isSharing() to see if sharing is still in
+effect.
+\sa format(), isSharing(), isValid()
+*/
+void QGLWidget::setFormat(const QGLFormat &format)
+{
+setContext(new QGLContext(format,this));
+}
+/*!
+\fn const QGLContext *QGLWidget::context() const
+Returns the context of this widget.
+It is possible that the context is not valid (see isValid()), for
+example, if the underlying hardware does not support the format
+attributes that were requested.
+*/
+/*
+\fn void QGLWidget::setContext(QGLContext *context,
+const QGLContext* shareContext,
+bool deleteOldContext)
+\obsolete
+Sets a new context for this widget. The QGLContext \a context must
+be created using \e new. QGLWidget will delete \a context when
+another context is set or when the widget is destroyed.
+If \a context is invalid, QGLContext::create() is performed on
+it. The initializeGL() function will then be executed for the new
+context before the first resizeGL() or paintGL().
+If \a context is invalid, this method will try to keep display list
+and texture object sharing in effect, or (if \a shareContext points
+to a valid context) start display list and texture object sharing
+with that context, but sharing might be impossible if the two
+contexts have different \l {format()} {formats}. Use isSharing() to
+see whether sharing is in effect.
+If \a deleteOldContext is true (the default), the existing context
+will be deleted. You may use false here if you have kept a pointer
+to the old context (as returned by context()), and want to restore
+that context later.
+\sa context(), isSharing()
+*/
+/*!
+\fn void QGLWidget::updateGL()
+Updates the widget by calling glDraw().
+*/
+void QGLWidget::updateGL()
+{
+if (updatesEnabled())
+glDraw();
+}
+/*!
+\fn void QGLWidget::updateOverlayGL()
+Updates the widget's overlay (if any). Will cause the virtual
+function paintOverlayGL() to be executed.
+The widget's rendering context will become the current context and
+initializeGL() will be called if it hasn't already been called.
+*/
+/*!
+This virtual function is called once before the first call to
+paintGL() or resizeGL(), and then once whenever the widget has
+been assigned a new QGLContext. Reimplement it in a subclass.
+This function should set up any required OpenGL context rendering
+flags, defining display lists, etc.
+There is no need to call makeCurrent() because this has already
+been done when this function is called.
+*/
+void QGLWidget::initializeGL()
+{
+}
+/*!
+This virtual function is called whenever the widget needs to be
+painted. Reimplement it in a subclass.
+There is no need to call makeCurrent() because this has already
+been done when this function is called.
+*/
+void QGLWidget::paintGL()
+{
+}
+/*!
+\fn void QGLWidget::resizeGL(int width , int height)
+This virtual function is called whenever the widget has been
+resized. The new size is passed in \a width and \a height.
+Reimplement it in a subclass.
+There is no need to call makeCurrent() because this has already
+been done when this function is called.
+*/
+void QGLWidget::resizeGL(int, int)
+{
+}
+/*!
+This virtual function is used in the same manner as initializeGL()
+except that it operates on the widget's overlay context instead of
+the widget's main context. This means that initializeOverlayGL()
+is called once before the first call to paintOverlayGL() or
+resizeOverlayGL(). Reimplement it in a subclass.
+This function should set up any required OpenGL context rendering
+flags, defining display lists, etc. for the overlay context.
+There is no need to call makeOverlayCurrent() because this has
+already been done when this function is called.
+*/
+void QGLWidget::initializeOverlayGL()
+{
+}
+/*!
+This virtual function is used in the same manner as paintGL()
+except that it operates on the widget's overlay context instead of
+the widget's main context. This means that paintOverlayGL() is
+called whenever the widget's overlay needs to be painted.
+Reimplement it in a subclass.
+There is no need to call makeOverlayCurrent() because this has
+already been done when this function is called.
+*/
+void QGLWidget::paintOverlayGL()
+{
+}
+/*!
+\fn void QGLWidget::resizeOverlayGL(int width , int height)
+This virtual function is used in the same manner as paintGL()
+except that it operates on the widget's overlay context instead of
+the widget's main context. This means that resizeOverlayGL() is
+called whenever the widget has been resized. The new size is
+passed in \a width and \a height. Reimplement it in a subclass.
+There is no need to call makeOverlayCurrent() because this has
+already been done when this function is called.
+*/
+void QGLWidget::resizeOverlayGL(int, int)
+{
+}
+/*! \fn bool QGLWidget::event(QEvent *e)
+\reimp
+*/
+#if !defined(Q_OS_WINCE) && !defined(Q_WS_QWS)
+bool QGLWidget::event(QEvent *e)
+{
+Q_D(QGLWidget);
+if (e->type() == QEvent::Paint) {
+QPoint offset;
+QPaintDevice *redirectedDevice = d->redirected(&offset);
+if (redirectedDevice && redirectedDevice->devType() == QInternal::Pixmap) {
+d->restoreRedirected();
+QPixmap pixmap = renderPixmap();
+d->setRedirected(redirectedDevice, offset);
+QPainter p(redirectedDevice);
+p.drawPixmap(-offset, pixmap);
+return true;
+}
+}
+#if defined(Q_WS_X11)
+// prevents X errors on some systems, where we get a flush to a
+// hidden widget
+if (e->type() == QEvent::Hide) {
+makeCurrent();
+glFinish();
+doneCurrent();
+} else if (e->type() == QEvent::ParentChange) {
+// if we've reparented a window that has the current context
+// bound, we need to rebind that context to the new window id
+if (d->glcx == QGLContext::currentContext())
+makeCurrent();
+if (d->glcx->d_func()->screen != d->xinfo.screen() || testAttribute(Qt::WA_TranslucentBackground)) {
+setContext(new QGLContext(d->glcx->requestedFormat(), this));
+// ### recreating the overlay isn't supported atm
+}
+}
+#if defined(QT_OPENGL_ES)
+if ((e->type() == QEvent::ParentChange) || (e->type() == QEvent::WindowStateChange)) {
+// The window may have been re-created during re-parent or state change - if so, the EGL
+// surface will need to be re-created.
+d->recreateEglSurface(false);
+}
+#endif
+#elif defined(Q_WS_WIN)
+if (e->type() == QEvent::ParentChange) {
+QGLContext *newContext = new QGLContext(d->glcx->requestedFormat(), this);
+setContext(newContext, d->glcx);
+// the overlay needs to be recreated as well
+delete d->olcx;
+if (isValid() && context()->format().hasOverlay()) {
+d->olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), this);
+if (!d->olcx->create(isSharing() ? d->glcx : 0)) {
+delete d->olcx;
+d->olcx = 0;
+d->glcx->d_func()->glFormat.setOverlay(false);
+}
+} else {
+d->olcx = 0;
+}
+} else if (e->type() == QEvent::Show) {
+if (!format().rgba())
+d->updateColormap();
+}
+#elif defined(Q_WS_MAC)
+if (e->type() == QEvent::MacGLWindowChange
+#if 0 //(MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)
+&& ((QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5 && isWindow())
+|| QSysInfo::MacintoshVersion <= QSysInfo::MV_10_4)
+#endif
+) {
+if (d->needWindowChange) {
+d->needWindowChange = false;
+d->glcx->updatePaintDevice();
+update();
+}
+return true;
+#  if defined(QT_MAC_USE_COCOA)
+} else if (e->type() == QEvent::MacGLClearDrawable) {
+d->glcx->d_ptr->clearDrawable();
+#  endif
+}
+#endif
+return QWidget::event(e);
+}
+#endif
+/*!
+\fn void QGLWidget::paintEvent(QPaintEvent *event)
+Handles paint events passed in the \a event parameter. Will cause
+the virtual paintGL() function to be called.
+The widget's rendering context will become the current context and
+initializeGL() will be called if it hasn't already been called.
+*/
+void QGLWidget::paintEvent(QPaintEvent *)
+{
+if (updatesEnabled()) {
+glDraw();
+updateOverlayGL();
+}
+}
+/*!
+\fn void QGLWidget::resizeEvent(QResizeEvent *event)
+Handles resize events that are passed in the \a event parameter.
+Calls the virtual function resizeGL().
+*/
+/*!
+\fn void QGLWidget::setMouseTracking(bool enable)
+If \a enable is true then mouse tracking is enabled; otherwise it
+is disabled.
+*/
+/*!
+Renders the current scene on a pixmap and returns the pixmap.
+You can use this method on both visible and invisible QGLWidget objects.
+This method will create a pixmap and a temporary QGLContext to
+render on the pixmap. It will then call initializeGL(),
+resizeGL(), and paintGL() on this context. Finally, the widget's
+original GL context is restored.
+The size of the pixmap will be \a w pixels wide and \a h pixels
+high unless one of these parameters is 0 (the default), in which
+case the pixmap will have the same size as the widget.
+If \a useContext is true, this method will try to be more
+efficient by using the existing GL context to render the pixmap.
+The default is false. Only use true if you understand the risks.
+Note that under Windows a temporary context has to be created
+and usage of the \e useContext parameter is not supported.
+Overlays are not rendered onto the pixmap.
+If the GL rendering context and the desktop have different bit
+depths, the result will most likely look surprising.
+Note that the creation of display lists, modifications of the view
+frustum etc. should be done from within initializeGL(). If this is
+not done, the temporary QGLContext will not be initialized
+properly, and the rendered pixmap may be incomplete/corrupted.
+*/
+QPixmap QGLWidget::renderPixmap(int w, int h, bool useContext)
+{
+Q_D(QGLWidget);
+QSize sz = size();
+if ((w > 0) && (h > 0))
+sz = QSize(w, h);
+#if defined(Q_WS_X11)
+extern int qt_x11_preferred_pixmap_depth;
+int old_depth = qt_x11_preferred_pixmap_depth;
+qt_x11_preferred_pixmap_depth = x11Info().depth();
+QPixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
+data->resize(sz.width(), sz.height());
+QPixmap pm(data);
+qt_x11_preferred_pixmap_depth = old_depth;
+QX11Info xinfo = x11Info();
+// make sure we use a pixmap with the same depth/visual as the widget
+if (xinfo.visual() != QX11Info::appVisual()) {
+QX11InfoData* xd = pm.x11Info().getX11Data(true);
+xd->depth = xinfo.depth();
+xd->visual = static_cast<Visual *>(xinfo.visual());
+const_cast<QX11Info &>(pm.x11Info()).setX11Data(xd);
+}
+#else
+QPixmap pm(sz);
+#endif
+d->glcx->doneCurrent();
+bool success = true;
+if (useContext && isValid() && d->renderCxPm(&pm))
+return pm;
+QGLFormat fmt = d->glcx->requestedFormat();
+fmt.setDirectRendering(false);                // Direct is unlikely to work
+fmt.setDoubleBuffer(false);                // We don't need dbl buf
+#ifdef Q_WS_MAC // crash prevention on the Mac - it's unlikely to work anyway
+fmt.setSampleBuffers(false);
+#endif
+QGLContext* ocx = d->glcx;
+ocx->doneCurrent();
+d->glcx = new QGLContext(fmt, &pm);
+d->glcx->create();
+if (d->glcx->isValid())
+updateGL();
+else
+success = false;
+delete d->glcx;
+d->glcx = ocx;
+ocx->makeCurrent();
+if (success) {
+#if defined(Q_WS_X11)
+if (xinfo.visual() != QX11Info::appVisual()) {
+QImage image = pm.toImage();
+QPixmap p = QPixmap::fromImage(image);
+return p;
+}
+#endif
+return pm;
+}
+return QPixmap();
+}
+/*!
+Returns an image of the frame buffer. If \a withAlpha is true the
+alpha channel is included.
+Depending on your hardware, you can explicitly select which color
+buffer to grab with a glReadBuffer() call before calling this
+function.
+*/
+QImage QGLWidget::grabFrameBuffer(bool withAlpha)
+{
+makeCurrent();
+QImage res;
+int w = width();
+int h = height();
+if (format().rgba()) {
+res = qt_gl_read_framebuffer(QSize(w, h), format().alpha(), withAlpha);
+} else {
+#if defined (Q_WS_WIN) && !defined(QT_OPENGL_ES)
+res = QImage(w, h, QImage::Format_Indexed8);
+glReadPixels(0, 0, w, h, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, res.bits());
+const QVector<QColor> pal = QColormap::instance().colormap();
+if (pal.size()) {
+res.setNumColors(pal.size());
+for (int i = 0; i < pal.size(); i++)
+res.setColor(i, pal.at(i).rgb());
+}
+res = res.mirrored();
+#endif
+}
+return res;
+}
+/*!
+Initializes OpenGL for this widget's context. Calls the virtual
+function initializeGL().
+*/
+void QGLWidget::glInit()
+{
+Q_D(QGLWidget);
+if (!isValid())
+return;
+makeCurrent();
+initializeGL();
+d->glcx->setInitialized(true);
+}
+/*!
+Executes the virtual function paintGL().
+The widget's rendering context will become the current context and
+initializeGL() will be called if it hasn't already been called.
+*/
+void QGLWidget::glDraw()
+{
+Q_D(QGLWidget);
+if (!isValid())
+return;
+makeCurrent();
+#ifndef QT_OPENGL_ES
+if (d->glcx->deviceIsPixmap())
+glDrawBuffer(GL_FRONT);
+#endif
+if (!d->glcx->initialized()) {
+glInit();
+resizeGL(d->glcx->device()->width(), d->glcx->device()->height()); // New context needs this "resize"
+}
+paintGL();
+if (doubleBuffer()) {
+if (d->autoSwap)
+swapBuffers();
+} else {
+glFlush();
+}
+}
+/*!
+Convenience function for specifying a drawing color to OpenGL.
+Calls glColor4 (in RGBA mode) or glIndex (in color-index mode)
+with the color \a c. Applies to this widgets GL context.
+\note This function is not supported on OpenGL/ES 2.0 systems.
+\sa qglClearColor(), QGLContext::currentContext(), QColor
+*/
+void QGLWidget::qglColor(const QColor& c) const
+{
+#if !defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES
+glColor4f(c.redF(), c.greenF(), c.blueF(), c.alphaF());
+#else
+Q_D(const QGLWidget);
+const QGLContext *ctx = QGLContext::currentContext();
+if (ctx) {
+if (ctx->format().rgba())
+glColor4ub(c.red(), c.green(), c.blue(), c.alpha());
+else if (!d->cmap.isEmpty()) { // QGLColormap in use?
+int i = d->cmap.find(c.rgb());
+if (i < 0)
+i = d->cmap.findNearest(c.rgb());
+glIndexi(i);
+} else
+glIndexi(ctx->colorIndex(c));
+}
+#endif //QT_OPENGL_ES
+#else
+Q_UNUSED(c);
+#endif //QT_OPENGL_ES_2
+}
+/*!
+Convenience function for specifying the clearing color to OpenGL.
+Calls glClearColor (in RGBA mode) or glClearIndex (in color-index
+mode) with the color \a c. Applies to this widgets GL context.
+\sa qglColor(), QGLContext::currentContext(), QColor
+*/
+void QGLWidget::qglClearColor(const QColor& c) const
+{
+#ifdef QT_OPENGL_ES
+glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
+#else
+Q_D(const QGLWidget);
+const QGLContext *ctx = QGLContext::currentContext();
+if (ctx) {
+if (ctx->format().rgba())
+glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF());
+else if (!d->cmap.isEmpty()) { // QGLColormap in use?
+int i = d->cmap.find(c.rgb());
+if (i < 0)
+i = d->cmap.findNearest(c.rgb());
+glClearIndex(i);
+} else
+glClearIndex(ctx->colorIndex(c));
+}
+#endif
+}
+/*!
+Converts the image \a img into the unnamed format expected by
+OpenGL functions such as glTexImage2D(). The returned image is not
+usable as a QImage, but QImage::width(), QImage::height() and
+QImage::bits() may be used with OpenGL. The GL format used is
+\c GL_RGBA.
+\omit ###
+\l opengl/texture example
+The following few lines are from the texture example. Most of the
+code is irrelevant, so we just quote the relevant bits:
+\quotefromfile opengl/texture/gltexobj.cpp
+\skipto tex1
+\printline tex1
+\printline gllogo.bmp
+We create \e tex1 (and another variable) for OpenGL, and load a real
+image into \e buf.
+\skipto convertToGLFormat
+\printline convertToGLFormat
+A few lines later, we convert \e buf into OpenGL format and store it
+in \e tex1.
+\skipto glTexImage2D
+\printline glTexImage2D
+\printline tex1.bits
+Note the dimension restrictions for texture images as described in
+the glTexImage2D() documentation. The width must be 2^m + 2*border
+and the height 2^n + 2*border where m and n are integers and
+border is either 0 or 1.
+Another function in the same example uses \e tex1 with OpenGL.
+\endomit
+*/
+QImage QGLWidget::convertToGLFormat(const QImage& img)
+{
+QImage res(img.size(), QImage::Format_ARGB32);
+convertToGLFormatHelper(res, img.convertToFormat(QImage::Format_ARGB32), GL_RGBA);
+return res;
+}
+/*!
+\fn QGLColormap & QGLWidget::colormap() const
+Returns the colormap for this widget.
+Usually it is only top-level widgets that can have different
+colormaps installed. Asking for the colormap of a child widget
+will return the colormap for the child's top-level widget.
+If no colormap has been set for this widget, the QGLColormap
+returned will be empty.
+\sa setColormap(), QGLColormap::isEmpty()
+*/
+/*!
+\fn void QGLWidget::setColormap(const QGLColormap & cmap)
+Set the colormap for this widget to \a cmap. Usually it is only
+top-level widgets that can have colormaps installed.
+\sa colormap()
+*/
+/*!
+\obsolete
+Returns the value of the first display list that is generated for
+the characters in the given \a font. \a listBase indicates the base
+value used when generating the display lists for the font. The
+default value is 2000.
+\note This function is not supported on OpenGL/ES systems.
+*/
+int QGLWidget::fontDisplayListBase(const QFont & font, int listBase)
+{
+#ifndef QT_OPENGL_ES
+Q_D(QGLWidget);
+int base;
+if (!d->glcx) { // this can't happen unless we run out of mem
+return 0;
+}
+// always regenerate font disp. lists for pixmaps - hw accelerated
+// contexts can't handle this otherwise
+bool regenerate = d->glcx->deviceIsPixmap();
+#ifndef QT_NO_FONTCONFIG
+// font color needs to be part of the font cache key when using
+// antialiased fonts since one set of glyphs needs to be generated
+// for each font color
+QString color_key;
+if (font.styleStrategy() != QFont::NoAntialias) {
+GLfloat color[4];
+glGetFloatv(GL_CURRENT_COLOR, color);
+color_key.sprintf("%f_%f_%f",color[0], color[1], color[2]);
+}
+QString key = font.key() + color_key + QString::number((int) regenerate);
+#else
+QString key = font.key() + QString::number((int) regenerate);
+#endif
+if (!regenerate && (d->displayListCache.find(key) != d->displayListCache.end())) {
+base = d->displayListCache[key];
+} else {
+int maxBase = listBase - 256;
+QMap<QString,int>::ConstIterator it;
+for (it = d->displayListCache.constBegin(); it != d->displayListCache.constEnd(); ++it) {
+if (maxBase < it.value()) {
+maxBase = it.value();
+}
+}
+maxBase += 256;
+d->glcx->generateFontDisplayLists(font, maxBase);
+d->displayListCache[key] = maxBase;
+base = maxBase;
+}
+return base;
+#else // QT_OPENGL_ES
+Q_UNUSED(font);
+Q_UNUSED(listBase);
+return 0;
+#endif
+}
+#ifndef QT_OPENGL_ES
+static void qt_save_gl_state()
+{
+glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
+glPushAttrib(GL_ALL_ATTRIB_BITS);
+glMatrixMode(GL_TEXTURE);
+glPushMatrix();
+glLoadIdentity();
+glMatrixMode(GL_PROJECTION);
+glPushMatrix();
+glMatrixMode(GL_MODELVIEW);
+glPushMatrix();
+glShadeModel(GL_FLAT);
+glDisable(GL_CULL_FACE);
+glDisable(GL_LIGHTING);
+glDisable(GL_STENCIL_TEST);
+glEnable(GL_BLEND);
+glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+}
+static void qt_restore_gl_state()
+{
+glMatrixMode(GL_TEXTURE);
+glPopMatrix();
+glMatrixMode(GL_PROJECTION);
+glPopMatrix();
+glMatrixMode(GL_MODELVIEW);
+glPopMatrix();
+glPopAttrib();
+glPopClientAttrib();
+}
+static void qt_gl_draw_text(QPainter *p, int x, int y, const QString &str,
+const QFont &font)
+{
+GLfloat color[4];
+glGetFloatv(GL_CURRENT_COLOR, &color[0]);
+QColor col;
+col.setRgbF(color[0], color[1], color[2],color[3]);
+QPen old_pen = p->pen();
+QFont old_font = p->font();
+p->setPen(col);
+p->setFont(font);
+p->drawText(x, y, str);
+p->setPen(old_pen);
+p->setFont(old_font);
+}
+#endif // !QT_OPENGL_ES
+/*!
+Renders the string \a str into the GL context of this widget.
+\a x and \a y are specified in window coordinates, with the origin
+in the upper left-hand corner of the window. If \a font is not
+specified, the currently set application font will be used to
+render the string. To change the color of the rendered text you can
+use the glColor() call (or the qglColor() convenience function),
+just before the renderText() call.
+The \a listBase parameter is obsolete and will be removed in a
+future version of Qt.
+\note This function clears the stencil buffer.
+\note This function is not supported on OpenGL/ES systems.
+\l{Overpainting Example}{Overpaint} with QPainter::drawText() instead.
+*/
+void QGLWidget::renderText(int x, int y, const QString &str, const QFont &font, int)
+{
+#ifndef QT_OPENGL_ES
+Q_D(QGLWidget);
+if (str.isEmpty() || !isValid())
+return;
+GLint view[4];
+bool use_scissor_testing = glIsEnabled(GL_SCISSOR_TEST);
+if (!use_scissor_testing)
+glGetIntegerv(GL_VIEWPORT, &view[0]);
+int width = d->glcx->device()->width();
+int height = d->glcx->device()->height();
+bool auto_swap = autoBufferSwap();
+QPaintEngine *engine = paintEngine();
+if (engine->type() == QPaintEngine::OpenGL2)
+static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(true);
+QPainter *p;
+bool reuse_painter = false;
+if (engine->isActive()) {
+reuse_painter = true;
+p = engine->painter();
+qt_save_gl_state();
+glDisable(GL_DEPTH_TEST);
+glViewport(0, 0, width, height);
+glMatrixMode(GL_PROJECTION);
+glLoadIdentity();
+glOrtho(0, width, height, 0, 0, 1);
+glMatrixMode(GL_MODELVIEW);
+glLoadIdentity();
+} else {
+setAutoBufferSwap(false);
+// disable glClear() as a result of QPainter::begin()
+d->disable_clear_on_painter_begin = true;
+if (engine->type() == QPaintEngine::OpenGL2) {
+qt_save_gl_state();
+glMatrixMode(GL_MODELVIEW);
+glLoadIdentity();
+}
+p = new QPainter(this);
+}
+QRect viewport(view[0], view[1], view[2], view[3]);
+if (!use_scissor_testing && viewport != rect()) {
+// if the user hasn't set a scissor box, we set one that
+// covers the current viewport
+glScissor(view[0], view[1], view[2], view[3]);
+glEnable(GL_SCISSOR_TEST);
+} else if (use_scissor_testing) {
+// use the scissor box set by the user
+glEnable(GL_SCISSOR_TEST);
+}
+qt_gl_draw_text(p, x, y, str, font);
+if (reuse_painter) {
+qt_restore_gl_state();
+} else {
+p->end();
+delete p;
+setAutoBufferSwap(auto_swap);
+d->disable_clear_on_painter_begin = false;
+if (engine->type() == QPaintEngine::OpenGL2)
+qt_restore_gl_state();
+}
+if (engine->type() == QPaintEngine::OpenGL2)
+static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(false);
+#else // QT_OPENGL_ES
+Q_UNUSED(x);
+Q_UNUSED(y);
+Q_UNUSED(str);
+Q_UNUSED(font);
+qWarning("QGLWidget::renderText is not supported under OpenGL/ES");
+#endif
+}
+/*! \overload
+\a x, \a y and \a z are specified in scene or object coordinates
+relative to the currently set projection and model matrices. This
+can be useful if you want to annotate models with text labels and
+have the labels move with the model as it is rotated etc.
+\note This function is not supported on OpenGL/ES systems.
+\l{Overpainting Example}{Overpaint} with QPainter::drawText() instead.
+*/
+void QGLWidget::renderText(double x, double y, double z, const QString &str, const QFont &font, int)
+{
+#ifndef QT_OPENGL_ES
+Q_D(QGLWidget);
+if (str.isEmpty() || !isValid())
+return;
+bool auto_swap = autoBufferSwap();
+int width = d->glcx->device()->width();
+int height = d->glcx->device()->height();
+GLdouble model[4][4], proj[4][4];
+GLint view[4];
+glGetDoublev(GL_MODELVIEW_MATRIX, &model[0][0]);
+glGetDoublev(GL_PROJECTION_MATRIX, &proj[0][0]);
+glGetIntegerv(GL_VIEWPORT, &view[0]);
+GLdouble win_x = 0, win_y = 0, win_z = 0;
+qgluProject(x, y, z, &model[0][0], &proj[0][0], &view[0],
+&win_x, &win_y, &win_z);
+win_y = height - win_y; // y is inverted
+QPaintEngine *engine = paintEngine();
+if (engine->type() == QPaintEngine::OpenGL2)
+static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(true);
+QPainter *p;
+bool reuse_painter = false;
+bool use_depth_testing = glIsEnabled(GL_DEPTH_TEST);
+bool use_scissor_testing = glIsEnabled(GL_SCISSOR_TEST);
+if (engine->isActive()) {
+reuse_painter = true;
+p = engine->painter();
+qt_save_gl_state();
+} else {
+setAutoBufferSwap(false);
+// disable glClear() as a result of QPainter::begin()
+d->disable_clear_on_painter_begin = true;
+if (engine->type() == QPaintEngine::OpenGL2)
+qt_save_gl_state();
+p = new QPainter(this);
+}
+QRect viewport(view[0], view[1], view[2], view[3]);
+if (!use_scissor_testing && viewport != rect()) {
+glScissor(view[0], view[1], view[2], view[3]);
+glEnable(GL_SCISSOR_TEST);
+} else if (use_scissor_testing) {
+glEnable(GL_SCISSOR_TEST);
+}
+glMatrixMode(GL_PROJECTION);
+glLoadIdentity();
+glViewport(0, 0, width, height);
+glOrtho(0, width, height, 0, 0, 1);
+glMatrixMode(GL_MODELVIEW);
+glLoadIdentity();
+glAlphaFunc(GL_GREATER, 0.0);
+glEnable(GL_ALPHA_TEST);
+if (use_depth_testing)
+glEnable(GL_DEPTH_TEST);
+glTranslated(0, 0, -win_z);
+qt_gl_draw_text(p, qRound(win_x), qRound(win_y), str, font);
+if (reuse_painter) {
+qt_restore_gl_state();
+} else {
+p->end();
+delete p;
+if (engine->type() == QPaintEngine::OpenGL2)
+qt_restore_gl_state();
+setAutoBufferSwap(auto_swap);
+d->disable_clear_on_painter_begin = false;
+}
+if (engine->type() == QPaintEngine::OpenGL2)
+static_cast<QGL2PaintEngineEx *>(engine)->setRenderTextActive(false);
+#else // QT_OPENGL_ES
+Q_UNUSED(x);
+Q_UNUSED(y);
+Q_UNUSED(z);
+Q_UNUSED(str);
+Q_UNUSED(font);
+qWarning("QGLWidget::renderText is not supported under OpenGL/ES");
+#endif
+}
+QGLFormat QGLWidget::format() const
+{
+Q_D(const QGLWidget);
+return d->glcx->format();
+}
+const QGLContext *QGLWidget::context() const
+{
+Q_D(const QGLWidget);
+return d->glcx;
+}
+bool QGLWidget::doubleBuffer() const
+{
+Q_D(const QGLWidget);
+return d->glcx->d_ptr->glFormat.testOption(QGL::DoubleBuffer);
+}
+void QGLWidget::setAutoBufferSwap(bool on)
+{
+Q_D(QGLWidget);
+d->autoSwap = on;
+}
+bool QGLWidget::autoBufferSwap() const
+{
+Q_D(const QGLWidget);
+return d->autoSwap;
+}
+/*!
+Calls QGLContext:::bindTexture(\a image, \a target, \a format) on the currently
+set context.
+\sa deleteTexture()
+*/
+GLuint QGLWidget::bindTexture(const QImage &image, GLenum target, GLint format)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(image, target, format, QGLContext::DefaultBindOption);
+}
+/*!
+\overload
+\since 4.6
+The binding \a options are a set of options used to decide how to
+bind the texture to the context.
+*/
+GLuint QGLWidget::bindTexture(const QImage &image, GLenum target, GLint format, QGLContext::BindOptions options)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(image, target, format, options);
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+GLuint QGLWidget::bindTexture(const QImage &image, QMacCompatGLenum target, QMacCompatGLint format)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(image, GLenum(target), GLint(format), QGLContext::DefaultBindOption);
+}
+GLuint QGLWidget::bindTexture(const QImage &image, QMacCompatGLenum target, QMacCompatGLint format,
+QGLContext::BindOptions options)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(image, GLenum(target), GLint(format), options);
+}
+#endif
+/*!
+Calls QGLContext:::bindTexture(\a pixmap, \a target, \a format) on the currently
+set context.
+\sa deleteTexture()
+*/
+GLuint QGLWidget::bindTexture(const QPixmap &pixmap, GLenum target, GLint format)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(pixmap, target, format, QGLContext::DefaultBindOption);
+}
+/*!
+\overload
+\since 4.6
+Generates and binds a 2D GL texture to the current context, based
+on \a pixmap. The generated texture id is returned and can be used in
+The binding \a options are a set of options used to decide how to
+bind the texture to the context.
+*/
+GLuint QGLWidget::bindTexture(const QPixmap &pixmap, GLenum target, GLint format,
+QGLContext::BindOptions options)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(pixmap, target, format, options);
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+GLuint QGLWidget::bindTexture(const QPixmap &pixmap, QMacCompatGLenum target, QMacCompatGLint format)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(pixmap, target, format, QGLContext::DefaultBindOption);
+}
+GLuint QGLWidget::bindTexture(const QPixmap &pixmap, QMacCompatGLenum target, QMacCompatGLint format,
+QGLContext::BindOptions options)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(pixmap, target, format, options);
+}
+#endif
+/*! \overload
+Calls QGLContext::bindTexture(\a fileName) on the currently set context.
+\sa deleteTexture()
+*/
+GLuint QGLWidget::bindTexture(const QString &fileName)
+{
+Q_D(QGLWidget);
+return d->glcx->bindTexture(fileName);
+}
+/*!
+Calls QGLContext::deleteTexture(\a id) on the currently set
+context.
+\sa bindTexture()
+*/
+void QGLWidget::deleteTexture(GLuint id)
+{
+Q_D(QGLWidget);
+d->glcx->deleteTexture(id);
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLWidget::deleteTexture(QMacCompatGLuint id)
+{
+Q_D(QGLWidget);
+d->glcx->deleteTexture(GLuint(id));
+}
+#endif
+/*!
+\since 4.4
+Draws the given texture, \a textureId to the given target rectangle,
+\a target, in OpenGL model space. The \a textureTarget should be a 2D
+texture target.
+Equivalent to the corresponding QGLContext::drawTexture().
+*/
+void QGLWidget::drawTexture(const QRectF &target, GLuint textureId, GLenum textureTarget)
+{
+Q_D(QGLWidget);
+d->glcx->drawTexture(target, textureId, textureTarget);
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLWidget::drawTexture(const QRectF &target, QMacCompatGLuint textureId, QMacCompatGLenum textureTarget)
+{
+Q_D(QGLWidget);
+d->glcx->drawTexture(target, GLint(textureId), GLenum(textureTarget));
+}
+#endif
+/*!
+\since 4.4
+Draws the given texture, \a textureId, at the given \a point in OpenGL
+model space. The \a textureTarget should be a 2D texture target.
+Equivalent to the corresponding QGLContext::drawTexture().
+*/
+void QGLWidget::drawTexture(const QPointF &point, GLuint textureId, GLenum textureTarget)
+{
+Q_D(QGLWidget);
+d->glcx->drawTexture(point, textureId, textureTarget);
+}
+#ifdef Q_MAC_COMPAT_GL_FUNCTIONS
+/*! \internal */
+void QGLWidget::drawTexture(const QPointF &point, QMacCompatGLuint textureId, QMacCompatGLenum textureTarget)
+{
+Q_D(QGLWidget);
+d->glcx->drawTexture(point, GLuint(textureId), GLenum(textureTarget));
+}
+#endif
+#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_2_engine)
+#endif
+#ifndef QT_OPENGL_ES_2
+Q_GLOBAL_STATIC(QOpenGLPaintEngine, qt_gl_engine)
+#endif
+Q_OPENGL_EXPORT QPaintEngine* qt_qgl_paint_engine()
+{
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+return qt_gl_engine();
+#elif defined(QT_OPENGL_ES_2)
+return qt_gl_2_engine();
+#else
+if (qt_gl_preferGL2Engine())
+return qt_gl_2_engine();
+else
+return qt_gl_engine();
+#endif
+}
+/*!
+\internal
+Returns the GL widget's paint engine. This is normally a
+QOpenGLPaintEngine.
+*/
+QPaintEngine *QGLWidget::paintEngine() const
+{
+return qt_qgl_paint_engine();
+}
+#ifdef QT3_SUPPORT
+/*!
+\overload
+\obsolete
+*/
+QGLWidget::QGLWidget(QWidget *parent, const char *name,
+const QGLWidget* shareWidget, Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+if (name)
+setObjectName(QString::fromAscii(name));
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(new QGLContext(QGLFormat::defaultFormat(), this), shareWidget);
+}
+/*!
+\overload
+\obsolete
+*/
+QGLWidget::QGLWidget(const QGLFormat &format, QWidget *parent,
+const char *name, const QGLWidget* shareWidget,
+Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+if (name)
+setObjectName(QString::fromAscii(name));
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(new QGLContext(format, this), shareWidget);
+}
+/*!
+\overload
+\obsolete
+*/
+QGLWidget::QGLWidget(QGLContext *context, QWidget *parent,
+const char *name, const QGLWidget *shareWidget, Qt::WindowFlags f)
+: QWidget(*(new QGLWidgetPrivate), parent, f | Qt::MSWindowsOwnDC)
+{
+Q_D(QGLWidget);
+if (name)
+setObjectName(QString::fromAscii(name));
+setAttribute(Qt::WA_PaintOnScreen);
+setAttribute(Qt::WA_NoSystemBackground);
+setAutoFillBackground(true); // for compatibility
+d->init(context, shareWidget);
+}
+#endif // QT3_SUPPORT
+void QGLExtensions::init_extensions()
+{
+QString extensions = QLatin1String(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)));
+if (extensions.contains(QLatin1String("texture_rectangle")))
+glExtensions |= TextureRectangle;
+if (extensions.contains(QLatin1String("multisample")))
+glExtensions |= SampleBuffers;
+if (extensions.contains(QLatin1String("generate_mipmap")))
+glExtensions |= GenerateMipmap;
+if (extensions.contains(QLatin1String("texture_compression_s3tc")))
+glExtensions |= TextureCompression;
+if (extensions.contains(QLatin1String("ARB_fragment_program")))
+glExtensions |= FragmentProgram;
+if (extensions.contains(QLatin1String("mirrored_repeat")))
+glExtensions |= MirroredRepeat;
+if (extensions.contains(QLatin1String("EXT_framebuffer_object")))
+glExtensions |= FramebufferObject;
+if (extensions.contains(QLatin1String("EXT_stencil_two_side")))
+glExtensions |= StencilTwoSide;
+if (extensions.contains(QLatin1String("EXT_stencil_wrap")))
+glExtensions |= StencilWrap;
+if (extensions.contains(QLatin1String("EXT_packed_depth_stencil")))
+glExtensions |= PackedDepthStencil;
+if (extensions.contains(QLatin1String("GL_NV_float_buffer")))
+glExtensions |= NVFloatBuffer;
+if (extensions.contains(QLatin1String("ARB_pixel_buffer_object")))
+glExtensions |= PixelBufferObject;
+#if defined(QT_OPENGL_ES_2)
+glExtensions |= FramebufferObject;
+glExtensions |= GenerateMipmap;
+#endif
+#if defined(QT_OPENGL_ES_1) || defined(QT_OPENGL_ES_1_CL)
+if (extensions.contains(QLatin1String("OES_framebuffer_object")))
+glExtensions |= FramebufferObject;
+#endif
+#if defined(QT_OPENGL_ES)
+if (extensions.contains(QLatin1String("OES_packed_depth_stencil")))
+glExtensions |= PackedDepthStencil;
+#endif
+if (extensions.contains(QLatin1String("ARB_framebuffer_object"))) {
+// ARB_framebuffer_object also includes EXT_framebuffer_blit.
+glExtensions |= FramebufferObject;
+glExtensions |= FramebufferBlit;
+}
+if (extensions.contains(QLatin1String("EXT_framebuffer_blit")))
+glExtensions |= FramebufferBlit;
+if (extensions.contains(QLatin1String("GL_ARB_texture_non_power_of_two")))
+glExtensions |= NPOTTextures;
+QGLContext cx(QGLFormat::defaultFormat());
+if (glExtensions & TextureCompression) {
+qt_glCompressedTexImage2DARB = (pfn_glCompressedTexImage2DARB) cx.getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
+}
+}
+/*
+This is the shared initialization for all platforms. Called from QGLWidgetPrivate::init()
+*/
+void QGLWidgetPrivate::initContext(QGLContext *context, const QGLWidget* shareWidget)
+{
+Q_Q(QGLWidget);
+glDevice.setWidget(q);
+QGLExtensions::init();
+glcx = 0;
+autoSwap = true;
+if (context && !context->device())
+context->setDevice(q);
+q->setContext(context, shareWidget ? shareWidget->context() : 0);
+if (!glcx)
+glcx = new QGLContext(QGLFormat::defaultFormat(), q);
+q->setAttribute(Qt::WA_NoSystemBackground);
+}
+#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)
+Q_GLOBAL_STATIC(QString, qt_gl_lib_name)
+Q_OPENGL_EXPORT void qt_set_gl_library_name(const QString& name)
+{
+qt_gl_lib_name()->operator=(name);
+}
+Q_OPENGL_EXPORT const QString qt_gl_library_name()
+{
+if (qt_gl_lib_name()->isNull()) {
+#if defined(Q_WS_X11) || defined(Q_WS_QWS)
+return QLatin1String("GL");
+#else // Q_WS_MAC
+return QLatin1String("/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
+#endif
+}
+return *qt_gl_lib_name();
+}
+#endif
+void QGLShareRegister::addShare(const QGLContext *context, const QGLContext *share) {
+Q_ASSERT(context && share);
+if (context->d_ptr->group == share->d_ptr->group)
+return;
+// Make sure 'context' is not already shared with another group of contexts.
+Q_ASSERT(context->d_ptr->group->m_refs == 1);
+// Free 'context' group resources and make it use the same resources as 'share'.
+QGLContextGroup *group = share->d_ptr->group;
+delete context->d_ptr->group;
+context->d_ptr->group = group;
+group->m_refs.ref();
+// Maintain a list of all the contexts in each group of sharing contexts.
+// The list is empty if the "share" context wasn't sharing already.
+if (group->m_shares.isEmpty())
+group->m_shares.append(share);
+group->m_shares.append(context);
+}
+QList<const QGLContext *> QGLShareRegister::shares(const QGLContext *context) {
+return context->d_ptr->group->m_shares;
+}
+void QGLShareRegister::removeShare(const QGLContext *context) {
+// Remove the context from the group.
+QGLContextGroup *group = context->d_ptr->group;
+if (group->m_shares.isEmpty())
+return;
+group->m_shares.removeAll(context);
+// Update context group representative.
+Q_ASSERT(group->m_shares.size() != 0);
+if (group->m_context == context)
+group->m_context = group->m_shares[0];
+// If there is only one context left, then make the list empty.
+if (group->m_shares.size() == 1)
+group->m_shares.clear();
+}
+QGLContextResource::QGLContextResource(FreeFunc f)
+: free(f), active(0)
+{
+}
+QGLContextResource::~QGLContextResource()
+{
+#ifndef QT_NO_DEBUG
+if (active != 0) {
+qWarning("QtOpenGL: Resources are still available at program shutdown.\n"
+"          This is possibly caused by a leaked QGLWidget, \n"
+"          QGLFramebufferObject or QGLPixelBuffer.");
+}
+#endif
+}
+void QGLContextResource::insert(const QGLContext *key, void *value)
+{
+QGLContextGroup *group = QGLContextPrivate::contextGroup(key);
+Q_ASSERT(!group->m_resources.contains(this));
+group->m_resources.insert(this, value);
+active.ref();
+}
+void *QGLContextResource::value(const QGLContext *key)
+{
+QGLContextGroup *group = QGLContextPrivate::contextGroup(key);
+return group->m_resources.value(this, 0);
+}
+void QGLContextResource::cleanup(const QGLContext *ctx, void *value)
+{
+QGLShareContextScope scope(ctx);
+free(value);
+active.deref();
+}
+void QGLContextGroup::cleanupResources(const QGLContext *ctx)
+{
+// If there are still shares, then no cleanup to be done yet.
+if (m_shares.size() > 1)
+return;
+// Iterate over all resources and free each in turn.
+QHash<QGLContextResource *, void *>::ConstIterator it;
+for (it = m_resources.begin(); it != m_resources.end(); ++it)
+it.key()->cleanup(ctx, it.value());
+}
+QGLSharedResourceGuard::~QGLSharedResourceGuard()
+{
+if (m_group)
+m_group->removeGuard(this);
+}
+void QGLSharedResourceGuard::setContext(const QGLContext *context)
+{
+if (m_group)
+m_group->removeGuard(this);
+if (context) {
+m_group = QGLContextPrivate::contextGroup(context);
+m_group->addGuard(this);
+} else {
+m_group = 0;
+}
+}
+QT_END_NAMESPACE

changeset 0	1918ee327afb
child 3	41300fa6a67c