QGLContext Class Reference

The QGLContext class encapsulates an OpenGL rendering context. More...

#include <qgl.h>

Public Types
enum	BindOption {   NoBindOption = 0x0000, InvertedYBindOption = 0x0001, MipmapBindOption = 0x0002, PremultipliedAlphaBindOption = 0x0004,   LinearFilteringBindOption = 0x0008, MemoryManagedBindOption = 0x0010, CanFlipNativePixmapBindOption = 0x0020, DefaultBindOption,   InternalBindOption }
	A set of options to decide how to bind a texture using bindTexture(). More...

Public Functions
GLuint	bindTexture (const QImage &image, GLenum target, GLint format, BindOptions options)
	Generates and binds a 2D GL texture to the current context, based on image. More...
GLuint	bindTexture (const QPixmap &pixmap, GLenum target, GLint format, BindOptions options)
	Generates and binds a 2D GL texture to the current context, based on pixmap. More...
GLuint	bindTexture (const QImage &image, GLenum target=GL_TEXTURE_2D, GLint format=GL_RGBA)
	Generates and binds a 2D GL texture to the current context, based on image. More...
GLuint	bindTexture (const QPixmap &pixmap, GLenum target=GL_TEXTURE_2D, GLint format=GL_RGBA)
	Generates and binds a 2D GL texture based on pixmap. More...
GLuint	bindTexture (const QString &fileName)
	Reads the compressed texture file fileName and generates a 2D GL texture from it. More...
void	deleteTexture (GLuint tx_id)
	Removes the texture identified by id from the texture cache, and calls glDeleteTextures() to delete the texture from the context. More...
void	drawTexture (const QRectF &target, GLuint textureId, GLenum textureTarget=GL_TEXTURE_2D)
	This function supports the following use cases: More...
void	drawTexture (const QPointF &point, GLuint textureId, GLenum textureTarget=GL_TEXTURE_2D)
	This function supports the following use cases: More...
	QGLContext (const QGLFormat &format, QPaintDevice *device)
	Constructs an OpenGL context for the given paint device, which can be a widget or a pixmap. More...
	QGLContext (const QGLFormat &format)
	Constructs an OpenGL context with the given format which specifies several display options for the context. More...
void	setFormat (const QGLFormat &format)
	Sets a format for this context. More...
void	updatePaintDevice ()
virtual	~QGLContext ()
	Destroys the OpenGL context and frees its resources. More...

Static Public Functions
static bool	areSharing (const QGLContext *context1, const QGLContext *context2)
	Returns true if context1 and context2 are sharing their GL resources such as textures, shader programs, etc; otherwise returns false. More...
static void	setTextureCacheLimit (int size)
	This function sets the limit for the texture cache to size, expressed in kilobytes. More...
static int	textureCacheLimit ()
	Returns the current texture cache limit in kilobytes. More...

Protected Functions
virtual void *	chooseMacVisual (GDHandle)
	Mac OS X only: This virtual function tries to find a visual that matches the format, reducing the demands if the original request cannot be met. More...
uint	colorIndex (const QColor &c) const
	Returns a colormap index for the color c, in ColorIndex mode. More...
void	setDevice (QPaintDevice *pDev)

Static Protected Variables
static QGLContext *	currentCtx = 0

Properties
QScopedPointer< QGLContextPrivate >	d_ptr

Friends
class	QGL2PaintEngineEx
class	QGL2PaintEngineExPrivate
class	QGLContextGroup
class	QGLContextResourceBase
class	QGLEngineShaderManager
class	QGLExtensions
class	QGLFBOGLPaintDevice
QGLFormat::OpenGLVersionFlags	QGLFormat::openGLVersionFlags ()
class	QGLFramebufferObject
class	QGLFramebufferObjectPrivate
class	QGLGlyphCache
struct	QGLGlyphTexture
class	QGLPaintDevice
class	QGLPixelBuffer
class	QGLPixelBufferPrivate
class	QGLPixmapBlurFilter
class	QGLPixmapData
class	QGLPixmapFilterBase
class	QGLSharedResourceGuard
class	QGLTexture
class	QGLTextureGlyphCache
class	QGLWidget
class	QGLWidgetGLPaintDevice
class	QGLWidgetPrivate
class	QGLWindowSurface
class	QMacGLWindowChangeEvent
class	QOpenGLPaintEngine
class	QOpenGLPaintEnginePrivate
QGLContextPrivate *	qt_phonon_get_dptr (const QGLContext *)
class	QX11GLPixmapData
class	QX11GLSharedContexts
virtual bool	create (const QGLContext *shareContext=0)
	Creates the GL context. More...
bool	isValid () const
	Returns true if a GL rendering context has been successfully created; otherwise returns false. More...
bool	isSharing () const
	Returns true if this context is sharing its GL context with another QGLContext, otherwise false is returned. More...
void	reset ()
	Resets the context and makes it invalid. More...
QGLFormat	format () const
	Returns the frame buffer format that was obtained (this may be a subset of what was requested). More...
QGLFormat	requestedFormat () const
	Returns the frame buffer format that was originally requested in the constructor or setFormat(). More...
virtual void	makeCurrent ()
	Makes this context the current OpenGL rendering context. More...
virtual void	doneCurrent ()
	Makes no GL context the current context. More...
virtual void	swapBuffers () const
	Swaps the screen contents with an off-screen buffer. More...
void *	getProcAddress (const QString &proc) const
	Returns a function pointer to the GL extension function passed in proc. More...
QPaintDevice *	device () const
	Returns the paint device set for this context. More...
QColor	overlayTransparentColor () const
	If this context is a valid context in an overlay plane, returns the plane's transparent color. More...
static const QGLContext *	currentContext ()
	Returns the current context, i.e. More...
virtual bool	chooseContext (const QGLContext *shareContext=0)
	This semi-internal function is called by create(). More...
virtual int	choosePixelFormat (void *pfd, HDC pdc)
	Win32 only: This virtual function chooses a pixel format that matches the OpenGL format. More...
virtual void *	tryVisual (const QGLFormat &f, int bufDepth=1)
virtual void *	chooseVisual ()
	X11 only: This virtual function tries to find a visual that matches the format, reducing the demands if the original request cannot be met. More...
bool	deviceIsPixmap () const
	Returns true if the paint device of this context is a pixmap; otherwise returns false. More...
bool	windowCreated () const
	Returns true if a window has been created for this context; otherwise returns false. More...
void	setWindowCreated (bool on)
	If on is true the context has had a window created for it. More...
bool	initialized () const
	Returns true if this context has been initialized, i. More...
void	setInitialized (bool on)
	If on is true the context has been initialized, i. More...
void	generateFontDisplayLists (const QFont &fnt, int listBase)
	Generates a set of 256 display lists for the 256 first characters in the font font. More...
void	setValid (bool valid)
	Forces the GL rendering context to be valid. More...

Detailed Description

The QGLContext class encapsulates an OpenGL rendering context.

An OpenGL rendering context is a complete set of OpenGL state variables. The rendering context's 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 create() function. The makeCurrent() function makes this context the current rendering context. You can make 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.

Definition at line 310 of file qgl.h.

Enumerations

BindOption

enum QGLContext::BindOption

A set of options to decide how to bind a texture using bindTexture().

Since

4.6

• NoBindOption Don't do anything, pass the texture straight through.

• 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.

• MipmapBindOption Specifies that bindTexture() should try to generate mipmaps. If the GL implementation supports the GL_SGIS_generate_mipmap extension, mipmaps will be automatically generated for the texture. Mipmap generation is only supported for the GL_TEXTURE_2D target.

• PremultipliedAlphaBindOption Specifies that the image should be uploaded with premultiplied alpha and does a conversion accordingly.

• 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.

• DefaultBindOption In Qt 4.5 and earlier, bindTexture() would mirror the image and automatically generate mipmaps. This option helps preserve this default behavior.

• CanFlipNativePixmapBindOption Used by x11 from pixmap to choose whether or not it can bind the pixmap upside down or not.

• 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.

• InternalBindOption

Enumerator
NoBindOption
InvertedYBindOption
MipmapBindOption
PremultipliedAlphaBindOption
LinearFilteringBindOption
MemoryManagedBindOption
CanFlipNativePixmapBindOption
DefaultBindOption
InternalBindOption

Definition at line 335 of file qgl.h.

                    {
        NoBindOption                            = 0x0000,
        InvertedYBindOption                     = 0x0001,
        MipmapBindOption                        = 0x0002,
        PremultipliedAlphaBindOption            = 0x0004,
        LinearFilteringBindOption               = 0x0008,

        MemoryManagedBindOption                 = 0x0010, // internal flag
        CanFlipNativePixmapBindOption           = 0x0020, // internal flag

        DefaultBindOption                       = LinearFilteringBindOption
                                                  | InvertedYBindOption
                                                  | MipmapBindOption,
        InternalBindOption                      = MemoryManagedBindOption
                                                  | PremultipliedAlphaBindOption
    };

Constructors and Destructors

QGLContext() [1/2]

QGLContext::QGLContext	(	const QGLFormat &	format,
		QPaintDevice *	device
	)

Constructs an OpenGL context for the given paint device, which can be a widget or a pixmap.

The format specifies several display options for the context.

If the underlying OpenGL/Window system cannot satisfy all the features requested in 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, create() must be called explicitly to create the actual OpenGL context. The context will be isValid(){invalid} if it was not possible to obtain a GL context at all.

Definition at line 2133 of file qgl.cpp.

Referenced by QGLWidget::event().

    : d_ptr(new QGLContextPrivate(this))
{
    Q_D(QGLContext);
    d->init(device, format);
}

QGLContext() [2/2]

QGLContext::QGLContext

(

const QGLFormat &

format

)

Constructs an OpenGL context with the given format which specifies several display options for the context.

If the underlying OpenGL/Window system cannot satisfy all the features requested in 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, create() must be called explicitly to create the actual OpenGL context. The context will be isValid(){invalid} if it was not possible to obtain a GL context at all.

See also

format(), isValid()

Definition at line 2155 of file qgl.cpp.

    : d_ptr(new QGLContextPrivate(this))
{
    Q_D(QGLContext);
    d->init(0, format);
}

~QGLContext()

QGLContext::~QGLContext ( )

virtual

Destroys the OpenGL context and frees its resources.

Definition at line 2166 of file qgl.cpp.

{
    // remove any textures cached in this context
    QGLTextureCache::instance()->removeContextTextures(this);

    // clean up resources specific to this context
    d_ptr->cleanup();
    // clean up resources belonging to this context's group
    d_ptr->group->cleanupResources(this);

    QGLSignalProxy::instance()->emitAboutToDestroyContext(this);
    reset();
}

Functions

areSharing()

bool QGLContext::areSharing ( const QGLContext *  context1, const QGLContext *  context2  )

static

Returns true if context1 and context2 are sharing their GL resources such as textures, shader programs, etc; otherwise returns false.

Since

4.6

Definition at line 3319 of file qgl.cpp.

Referenced by QGLShaderProgram::addShader(), QOpenGLPaintEngine::begin(), QGLBuffer::bind(), QGLShaderProgram::bind(), QGLGlyphCache::cacheGlyphs(), QGLGradientCache::getBuffer(), QGLProgramCache::getProgram(), QGLOffscreen::initialize(), QGLPixmapData::isValidContext(), QGLShader::QGLShader(), QGLShareContextScope::QGLShareContextScope(), and QGLShaderProgram::release().

{
    if (!context1 || !context2)
        return false;
    return context1->d_ptr->group == context2->d_ptr->group;
}

bindTexture() [1/5]

GLuint QGLContext::bindTexture	(	const QImage &	image,
		GLenum	target,
		GLint	format,
		BindOptions	options
	)

Generates and binds a 2D GL texture to the current context, based on image.

Since

4.6

The generated texture id is returned and can be used in later glBindTexture() calls.

The target parameter specifies the texture target. The default target is GL_TEXTURE_2D.

The format parameter sets the internal format for the texture. The default format is GL_RGBA.

The binding 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.

See also

deleteTexture()

Definition at line 2854 of file qgl.cpp.

Referenced by QGLPixmapFilterBase::bindTexture(), QOpenGLPaintEnginePrivate::composite(), QGL2PaintEngineEx::drawImage(), QGL2PaintEngineEx::drawPixmap(), and QGL2PaintEngineExPrivate::updateBrushTexture().

{
    if (image.isNull())
        return 0;

    Q_D(QGLContext);
    QGLTexture *texture = d->bindTexture(image, target, format, options);
    return texture->id;
}

bindTexture() [2/5]

GLuint QGLContext::bindTexture	(	const QPixmap &	pixmap,
		GLenum	target,
		GLint	format,
		BindOptions	options
	)

Generates and binds a 2D GL texture to the current context, based on pixmap.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Since

4.6

Definition at line 2916 of file qgl.cpp.

{
    if (pixmap.isNull())
        return 0;

    Q_D(QGLContext);
    QGLTexture *texture = d->bindTexture(pixmap, target, format, options);
    return texture->id;
}

bindTexture() [3/5]

GLuint QGLContext::bindTexture	(	const QImage &	image,
		GLenum	target = GL_TEXTURE_2D,
		GLint	format = GL_RGBA
	)

Generates and binds a 2D GL texture to the current context, based on image.

The generated texture id is returned and can be used in later glBindTexture() calls.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2816 of file qgl.cpp.

{
    if (image.isNull())
        return 0;

    Q_D(QGLContext);
    QGLTexture *texture = d->bindTexture(image, target, format, DefaultBindOption);
    return texture->id;
}

bindTexture() [4/5]

GLuint QGLContext::bindTexture	(	const QPixmap &	pixmap,
		GLenum	target = GL_TEXTURE_2D,
		GLint	format = GL_RGBA
	)

Generates and binds a 2D GL texture based on pixmap.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2896 of file qgl.cpp.

{
    if (pixmap.isNull())
        return 0;

    Q_D(QGLContext);
    QGLTexture *texture = d->bindTexture(pixmap, target, format, DefaultBindOption);
    return texture->id;
}

bindTexture() [5/5]

GLuint QGLContext::bindTexture

(

const QString &

fileName

)

Reads the compressed texture file fileName and generates a 2D GL texture from it.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This function can load DirectDrawSurface (DDS) textures in the DXT1, DXT3 and DXT5 DDS formats if the GL_ARB_texture_compression and GL_EXT_texture_compression_s3tc extensions are supported.

Since 4.6.1, textures in the ETC1 format can be loaded if the GL_OES_compressed_ETC1_RGB8_texture extension is supported and the ETC1 texture has been encapsulated in the PVR container format. Also, textures in the PVRTC2 and PVRTC4 formats can be loaded if the GL_IMG_texture_compression_pvrtc extension is supported.

See also

deleteTexture()

Definition at line 2250 of file qgl.cpp.

{
    QGLTexture texture(this);
    QSize size = texture.bindCompressedTexture(fileName);
    if (!size.isValid())
        return 0;
    return texture.id;
}

chooseContext()

bool QGLContext::chooseContext ( const QGLContext *  shareContext = 0 )

protectedvirtual

This semi-internal function is called by create().

It creates a system-dependent OpenGL handle that matches the format() of 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.

Definition at line 190 of file qgl_mac.mm.

Referenced by buildSpec(), qDeleteQGLContext(), qt_egl_create_surface(), and QGLContextPrivate::updateFormatVersion().

{
    QMacCocoaAutoReleasePool pool;
    Q_D(QGLContext);
    d->cx = 0;
    d->vi = chooseMacVisual(0);
    if (!d->vi)
        return false;

#ifndef QT_MAC_USE_COCOA
    AGLPixelFormat fmt = (AGLPixelFormat)d->vi;
    GLint res;
    aglDescribePixelFormat(fmt, AGL_LEVEL, &res);
    d->glFormat.setPlane(res);
    if (deviceIsPixmap())
        res = 0;
    else
        aglDescribePixelFormat(fmt, AGL_DOUBLEBUFFER, &res);
    d->glFormat.setDoubleBuffer(res);
    aglDescribePixelFormat(fmt, AGL_DEPTH_SIZE, &res);
    d->glFormat.setDepth(res);
    if (d->glFormat.depth())
        d->glFormat.setDepthBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_RGBA, &res);
    d->glFormat.setRgba(res);
    aglDescribePixelFormat(fmt, AGL_RED_SIZE, &res);
    d->glFormat.setRedBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_GREEN_SIZE, &res);
    d->glFormat.setGreenBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_BLUE_SIZE, &res);
    d->glFormat.setBlueBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_ALPHA_SIZE, &res);
    d->glFormat.setAlpha(res);
    if (d->glFormat.alpha())
        d->glFormat.setAlphaBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_ACCUM_RED_SIZE, &res);
    // Bug in Apple OpenGL (rdr://5015603), when we don't have an accumulation
    // buffer, it still claims that we have a 16-bit one (which is pretty rare).
    // So, we just assume we can never have a buffer that small.
    d->glFormat.setAccum(res > 5);
    if (d->glFormat.accum())
        d->glFormat.setAccumBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_STENCIL_SIZE, &res);
    d->glFormat.setStencil(res);
    if (d->glFormat.stencil())
        d->glFormat.setStencilBufferSize(res);
    aglDescribePixelFormat(fmt, AGL_STEREO, &res);
    d->glFormat.setStereo(res);
    aglDescribePixelFormat(fmt, AGL_SAMPLE_BUFFERS_ARB, &res);
    d->glFormat.setSampleBuffers(res);
    if (d->glFormat.sampleBuffers()) {
        aglDescribePixelFormat(fmt, AGL_SAMPLES_ARB, &res);
        d->glFormat.setSamples(res);
    }
#else
    NSOpenGLPixelFormat *fmt = static_cast<NSOpenGLPixelFormat *>(d->vi);

    d->glFormat = QGLFormat();

    // ### make sure to reset other options
    d->glFormat.setDoubleBuffer(attribValue(fmt, NSOpenGLPFADoubleBuffer));

    int depthSize = attribValue(fmt, NSOpenGLPFADepthSize);
    d->glFormat.setDepth(depthSize > 0);
    if (depthSize > 0)
        d->glFormat.setDepthBufferSize(depthSize);

    int alphaSize = attribValue(fmt, NSOpenGLPFAAlphaSize);
    d->glFormat.setAlpha(alphaSize > 0);
    if (alphaSize > 0)
        d->glFormat.setAlphaBufferSize(alphaSize);

    int accumSize = attribValue(fmt, NSOpenGLPFAAccumSize);
    d->glFormat.setAccum(accumSize > 0);
    if (accumSize > 0)
        d->glFormat.setAccumBufferSize(accumSize);

    int stencilSize = attribValue(fmt, NSOpenGLPFAStencilSize);
    d->glFormat.setStencil(stencilSize > 0);
    if (stencilSize > 0)
        d->glFormat.setStencilBufferSize(stencilSize);

    d->glFormat.setStereo(attribValue(fmt, NSOpenGLPFAStereo));

    int sampleBuffers = attribValue(fmt, NSOpenGLPFASampleBuffers);
    d->glFormat.setSampleBuffers(sampleBuffers);
    if (sampleBuffers > 0)
        d->glFormat.setSamples(attribValue(fmt, NSOpenGLPFASamples));
#endif
    if (shareContext && (!shareContext->isValid() || !shareContext->d_func()->cx)) {
        qWarning("QGLContext::chooseContext: Cannot share with invalid context");
        shareContext = 0;
    }

    // sharing between rgba and color-index will give wrong colors
    if (shareContext && (format().rgba() != shareContext->format().rgba()))
        shareContext = 0;

#ifndef QT_MAC_USE_COCOA
    AGLContext ctx = aglCreateContext(fmt, (AGLContext) (shareContext ? shareContext->d_func()->cx : 0));
#else
    NSOpenGLContext *ctx = [[NSOpenGLContext alloc] initWithFormat:fmt
        shareContext:(shareContext ? static_cast<NSOpenGLContext *>(shareContext->d_func()->cx)
                                   : 0)];
#endif
    if (!ctx) {
#ifndef QT_MAC_USE_COCOA
        GLenum err = aglGetError();
        if (err == AGL_BAD_MATCH || err == AGL_BAD_CONTEXT) {
            if (shareContext && shareContext->d_func()->cx) {
                qWarning("QGLContext::chooseContext(): Context sharing mismatch!");
                if (!(ctx = aglCreateContext(fmt, 0)))
                    return false;
                shareContext = 0;
            }
        }
#else
        if (shareContext) {
            ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];
            if (ctx) {
                qWarning("QGLContext::chooseContext: Context sharing mismatch");
                shareContext = 0;
            }
        }
#endif
        if (!ctx) {
            qWarning("QGLContext::chooseContext: Unable to create QGLContext");
            return false;
        }
    }
    d->cx = ctx;
    if (shareContext && shareContext->d_func()->cx) {
        QGLContext *share = const_cast<QGLContext *>(shareContext);
        d->sharing = true;
        share->d_func()->sharing = true;
    }
    if (deviceIsPixmap())
        updatePaintDevice();

    // vblank syncing
    GLint interval = d->reqFormat.swapInterval();
    if (interval != -1) {
#ifndef QT_MAC_USE_COCOA
        aglSetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);
        if (interval != 0)
            aglEnable((AGLContext)d->cx, AGL_SWAP_INTERVAL);
        else
            aglDisable((AGLContext)d->cx, AGL_SWAP_INTERVAL);
#else
        [ctx setValues:&interval forParameter:NSOpenGLCPSwapInterval];
#endif
    }
#ifndef QT_MAC_USE_COCOA
    aglGetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);
#else
    [ctx getValues:&interval forParameter:NSOpenGLCPSwapInterval];
#endif
    d->glFormat.setSwapInterval(interval);
    return true;
}

chooseMacVisual()

void * QGLContext::chooseMacVisual ( GDHandle  )

protectedvirtual

Mac OS X 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.

The handle argument is always zero and is not used

See also

chooseContext()

Definition at line 492 of file qgl_mac.mm.

{
    Q_D(QGLContext);

    void *fmt = d->tryFormat(d->glFormat);
    if (!fmt && d->glFormat.stereo()) {
        d->glFormat.setStereo(false);
        fmt = d->tryFormat(d->glFormat);
    }
    if (!fmt && d->glFormat.sampleBuffers()) {
        d->glFormat.setSampleBuffers(false);
        fmt = d->tryFormat(d->glFormat);
    }
    if (!fmt)
        qWarning("QGLContext::chooseMacVisual: Unable to choose a pixel format");
    return fmt;
}

choosePixelFormat()

int QGLContext::choosePixelFormat ( void *  dummyPfd, HDC  pdc  )

protectedvirtual

Win32 only: This virtual function chooses a pixel format that matches the OpenGL format.

Reimplement this function in a subclass if you need a custom context.

Warning

The dummyPfd pointer and pdc are used as a PIXELFORMATDESCRIPTOR*. We use void to avoid using Windows-specific types in our header files.

See also

chooseContext()

Definition at line 1015 of file qgl_win.cpp.

Referenced by qLogEq().

{
    Q_D(QGLContext);
    // workaround for matrox driver:
    // make a cheap call to opengl to force loading of DLL
    if (!opengl32dll) {
        GLint params;
        glGetIntegerv(GL_DEPTH_BITS, &params);
        opengl32dll = true;
    }

    PFNWGLCHOOSEPIXELFORMATARB wglChoosePixelFormatARB =
        (PFNWGLCHOOSEPIXELFORMATARB) wglGetProcAddress("wglChoosePixelFormatARB");
    int chosenPfi = 0;
    if (!deviceIsPixmap() && wglChoosePixelFormatARB) {
        bool valid;
        int pixelFormat = 0;
        uint numFormats = 0;
        QVarLengthArray<int> iAttributes(40);
        int i = 0;
        iAttributes[i++] = WGL_ACCELERATION_ARB;
        if (d->glFormat.directRendering())
            iAttributes[i++] = WGL_FULL_ACCELERATION_ARB;
        else
            iAttributes[i++] = WGL_NO_ACCELERATION_ARB;
        iAttributes[i++] = WGL_SUPPORT_OPENGL_ARB;
        iAttributes[i++] = TRUE;
        iAttributes[i++] = WGL_DRAW_TO_WINDOW_ARB;
        iAttributes[i++] = TRUE;
        iAttributes[i++] = WGL_COLOR_BITS_ARB;
        iAttributes[i++] = 24;
        iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB;
        iAttributes[i++] = d->glFormat.doubleBuffer();
        if (d->glFormat.stereo()) {
            iAttributes[i++] = WGL_STEREO_ARB;
            iAttributes[i++] = TRUE;
        }
        if (d->glFormat.depth()) {
            iAttributes[i++] = WGL_DEPTH_BITS_ARB;
            iAttributes[i++] = d->glFormat.depthBufferSize() == -1 ? 24 : d->glFormat.depthBufferSize();
        }
        iAttributes[i++] = WGL_PIXEL_TYPE_ARB;
        if (d->glFormat.rgba()) {
            iAttributes[i++] = WGL_TYPE_RGBA_ARB;
            if (d->glFormat.redBufferSize() != -1) {
                iAttributes[i++] = WGL_RED_BITS_ARB;
                iAttributes[i++] = d->glFormat.redBufferSize();
            }
            if (d->glFormat.greenBufferSize() != -1) {
                iAttributes[i++] = WGL_GREEN_BITS_ARB;
                iAttributes[i++] = d->glFormat.greenBufferSize();
            }
            if (d->glFormat.blueBufferSize() != -1) {
                iAttributes[i++] = WGL_BLUE_BITS_ARB;
                iAttributes[i++] = d->glFormat.blueBufferSize();
            }
        } else {
            iAttributes[i++] = WGL_TYPE_COLORINDEX_ARB;
        }
        if (d->glFormat.alpha()) {
            iAttributes[i++] = WGL_ALPHA_BITS_ARB;
            iAttributes[i++] = d->glFormat.alphaBufferSize() == -1 ? 8 : d->glFormat.alphaBufferSize();
        }
        if (d->glFormat.accum()) {
            iAttributes[i++] = WGL_ACCUM_BITS_ARB;
            iAttributes[i++] = d->glFormat.accumBufferSize() == -1 ? 16 : d->glFormat.accumBufferSize();
        }
        if (d->glFormat.stencil()) {
            iAttributes[i++] = WGL_STENCIL_BITS_ARB;
            iAttributes[i++] = d->glFormat.stencilBufferSize() == -1 ? 8 : d->glFormat.stencilBufferSize();
        }
        if (d->glFormat.hasOverlay()) {
            iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB;
            iAttributes[i++] = 1;
        }
        int si = 0;
        bool trySampleBuffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;
        if (trySampleBuffers && d->glFormat.sampleBuffers()) {
            iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;
            iAttributes[i++] = TRUE;
            iAttributes[i++] = WGL_SAMPLES_ARB;
            si = i;
            iAttributes[i++] = d->glFormat.samples() == -1 ? 4 : d->glFormat.samples();
        }
        iAttributes[i] = 0;

        do {
            valid = wglChoosePixelFormatARB(pdc, iAttributes.constData(), 0, 1,
                                            &pixelFormat, &numFormats);
            if (trySampleBuffers  && (!valid || numFormats < 1) && d->glFormat.sampleBuffers())
                iAttributes[si] /= 2; // try different no. samples - we aim for the best one
            else
                break;
        } while ((!valid || numFormats < 1) && iAttributes[si] > 1);
        chosenPfi = pixelFormat;
    }

    if (!chosenPfi) { // fallback if wglChoosePixelFormatARB() failed
        int pmDepth = deviceIsPixmap() ? ((QPixmap*)d->paintDevice)->depth() : 0;
        PIXELFORMATDESCRIPTOR* p = (PIXELFORMATDESCRIPTOR*)dummyPfd;
        memset(p, 0, sizeof(PIXELFORMATDESCRIPTOR));
        p->nSize = sizeof(PIXELFORMATDESCRIPTOR);
        p->nVersion = 1;
        p->dwFlags  = PFD_SUPPORT_OPENGL;
        if (deviceIsPixmap())
            p->dwFlags |= PFD_DRAW_TO_BITMAP;
        else
            p->dwFlags |= PFD_DRAW_TO_WINDOW;
        if (!d->glFormat.directRendering())
            p->dwFlags |= PFD_GENERIC_FORMAT;
        if (d->glFormat.doubleBuffer() && !deviceIsPixmap())
            p->dwFlags |= PFD_DOUBLEBUFFER;
        if (d->glFormat.stereo())
            p->dwFlags |= PFD_STEREO;
        if (d->glFormat.depth())
            p->cDepthBits = d->glFormat.depthBufferSize() == -1 ? 32 : d->glFormat.depthBufferSize();
        else
            p->dwFlags |= PFD_DEPTH_DONTCARE;
        if (d->glFormat.rgba()) {
            p->iPixelType = PFD_TYPE_RGBA;
            if (d->glFormat.redBufferSize() != -1)
                p->cRedBits = d->glFormat.redBufferSize();
            if (d->glFormat.greenBufferSize() != -1)
                p->cGreenBits = d->glFormat.greenBufferSize();
            if (d->glFormat.blueBufferSize() != -1)
                p->cBlueBits = d->glFormat.blueBufferSize();
            if (deviceIsPixmap())
                p->cColorBits = pmDepth;
            else
                p->cColorBits = 32;
        } else {
            p->iPixelType = PFD_TYPE_COLORINDEX;
            p->cColorBits = 8;
        }
        if (d->glFormat.alpha())
            p->cAlphaBits = d->glFormat.alphaBufferSize() == -1 ? 8 : d->glFormat.alphaBufferSize();
        if (d->glFormat.accum()) {
            p->cAccumRedBits = p->cAccumGreenBits = p->cAccumBlueBits = p->cAccumAlphaBits =
                               d->glFormat.accumBufferSize() == -1 ? 16 : d->glFormat.accumBufferSize();
        }
        if (d->glFormat.stencil())
            p->cStencilBits = d->glFormat.stencilBufferSize() == -1 ? 8 : d->glFormat.stencilBufferSize();
        p->iLayerType = PFD_MAIN_PLANE;
        chosenPfi = ChoosePixelFormat(pdc, p);

        if (!chosenPfi)
            qErrnoWarning("QGLContext: ChoosePixelFormat failed");

        // Since the GDI function ChoosePixelFormat() does not handle
        // overlay and direct-rendering requests, we must roll our own here

        bool doSearch = chosenPfi <= 0;
        PIXELFORMATDESCRIPTOR pfd;
        QGLFormat fmt;
        if (!doSearch) {
            DescribePixelFormat(pdc, chosenPfi, sizeof(PIXELFORMATDESCRIPTOR),
                                &pfd);
            fmt = pfdToQGLFormat(&pfd);
            if (d->glFormat.hasOverlay() && !fmt.hasOverlay())
                doSearch = true;
            else if (!qLogEq(d->glFormat.directRendering(), fmt.directRendering()))
                doSearch = true;
            else if (deviceIsPixmap() && (!(pfd.dwFlags & PFD_DRAW_TO_BITMAP) ||
                                          pfd.cColorBits != pmDepth))
                doSearch = true;
            else if (!deviceIsPixmap() && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))
                doSearch = true;
            else if (!qLogEq(d->glFormat.rgba(), fmt.rgba()))
                doSearch = true;
        }

        if (doSearch) {
            int pfiMax = DescribePixelFormat(pdc, 0, 0, NULL);
            int bestScore = -1;
            int bestPfi = -1;
            for (int pfi = 1; pfi <= pfiMax; pfi++) {
                DescribePixelFormat(pdc, pfi, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
                if (!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
                    continue;
                if (deviceIsPixmap() && (!(pfd.dwFlags & PFD_DRAW_TO_BITMAP) ||
                                         pfd.cColorBits != pmDepth))
                    continue;
                if (!deviceIsPixmap() && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))
                    continue;

                fmt = pfdToQGLFormat(&pfd);
                if (d->glFormat.hasOverlay() && !fmt.hasOverlay())
                    continue;

                int score = pfd.cColorBits;
                if (qLogEq(d->glFormat.depth(), fmt.depth()))
                    score += pfd.cDepthBits;
                if (qLogEq(d->glFormat.alpha(), fmt.alpha()))
                    score += pfd.cAlphaBits;
                if (qLogEq(d->glFormat.accum(), fmt.accum()))
                    score += pfd.cAccumBits;
                if (qLogEq(d->glFormat.stencil(), fmt.stencil()))
                    score += pfd.cStencilBits;
                if (qLogEq(d->glFormat.doubleBuffer(), fmt.doubleBuffer()))
                    score += 1000;
                if (qLogEq(d->glFormat.stereo(), fmt.stereo()))
                    score += 2000;
                if (qLogEq(d->glFormat.directRendering(), fmt.directRendering()))
                    score += 4000;
                if (qLogEq(d->glFormat.rgba(), fmt.rgba()))
                    score += 8000;
                if (score > bestScore) {
                    bestScore = score;
                    bestPfi = pfi;
                }
            }

            if (bestPfi > 0)
                chosenPfi = bestPfi;
        }
    }
    return chosenPfi;
}

chooseVisual()

void * QGLContext::chooseVisual ( )

protectedvirtual

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.

See also

chooseContext()

Definition at line 762 of file qgl_x11.cpp.

{
    Q_D(QGLContext);
    static const int bufDepths[] = { 8, 4, 2, 1 };        // Try 16, 12 also?
    //todo: if pixmap, also make sure that vi->depth == pixmap->depth
    void* vis = 0;
    int i = 0;
    bool fail = false;
    QGLFormat fmt = format();
    bool tryDouble = !fmt.doubleBuffer();  // Some GL impl's only have double
    bool triedDouble = false;
    bool triedSample = false;
    if (fmt.sampleBuffers())
        fmt.setSampleBuffers(QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers);
    while(!fail && !(vis = tryVisual(fmt, bufDepths[i]))) {
        if (!fmt.rgba() && bufDepths[i] > 1) {
            i++;
            continue;
        }
        if (tryDouble) {
            fmt.setDoubleBuffer(true);
            tryDouble = false;
            triedDouble = true;
            continue;
        } else if (triedDouble) {
            fmt.setDoubleBuffer(false);
            triedDouble = false;
        }
        if (!triedSample && fmt.sampleBuffers()) {
            fmt.setSampleBuffers(false);
            triedSample = true;
            continue;
        }
        if (fmt.stereo()) {
            fmt.setStereo(false);
            continue;
        }
        if (fmt.accum()) {
            fmt.setAccum(false);
            continue;
        }
        if (fmt.stencil()) {
            fmt.setStencil(false);
            continue;
        }
        if (fmt.alpha()) {
            fmt.setAlpha(false);
            continue;
        }
        if (fmt.depth()) {
            fmt.setDepth(false);
            continue;
        }
        if (fmt.doubleBuffer()) {
            fmt.setDoubleBuffer(false);
            continue;
        }
        fail = true;
    }
    d->glFormat = fmt;
    return vis;
}

colorIndex()

uint QGLContext::colorIndex ( const QColor &  c ) const

protected

Returns a colormap index for the color c, in ColorIndex mode.

Warning

This function is not part of the public interface.

Used by qglColor() and qglClearColor().

Definition at line 367 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), qDeleteQGLContext(), and qt_transparent_pixel().

{
    Q_UNUSED(c);
    return 0;
}

create()

bool QGLContext::create ( const QGLContext *  shareContext = 0 )

virtual

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 shareContext points to a valid QGLContext, this method will try to establish OpenGL display list and texture object sharing between this context and the shareContext. Note that this may fail if the two contexts have different 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.

See also

chooseContext(), format(), isValid()

Definition at line 3454 of file qgl.cpp.

Referenced by QGLWindowSurface::hijackWindow(), and nearest_gl_texture_size().

{
    Q_D(QGLContext);
#ifdef Q_WS_QPA
    if (!d->paintDevice && !d->platformContext)
#else
    if (!d->paintDevice)
#endif
        return false;

    reset();
    d->valid = chooseContext(shareContext);
    if (d->valid && d->paintDevice && d->paintDevice->devType() == QInternal::Widget) {
        QWidgetPrivate *wd = qt_widget_private(static_cast<QWidget *>(d->paintDevice));
        wd->usesDoubleBufferedGLContext = d->glFormat.doubleBuffer();
    }
#ifndef Q_WS_QPA //We do this in choose context->setupSharing()
    if (d->sharing)  // ok, we managed to share
        QGLContextGroup::addShare(this, shareContext);
#endif
    return d->valid;
}

currentContext()

const QGLContext * QGLContext::currentContext ( )

static

Returns the current context, i.e.

the context to which any OpenGL commands will currently be directed. Returns 0 if no context is current.

See also

makeCurrent()

Definition at line 3545 of file qgl.cpp.

Referenced by QGLPaintDevice::beginPaint(), QGLFramebufferObject::bind(), QGLBuffer::bind(), QGLShaderProgram::bind(), QGLFramebufferObject::bindDefault(), QGLPixmapFilterBase::bindTexture(), QGLFramebufferObject::blitFramebuffer(), buildSpec(), QGLGlyphCache::cleanCache(), QGLFBOGLPaintDevice::context(), QGLBuffer::create(), ShaderEffect::draw(), QGL2PaintEngineExPrivate::drawCachedGlyphs(), drawTexture(), QGLFramebufferObject::drawTexture(), QGLPaintDevice::ensureActiveTarget(), QX11GLWindowSurface::flush(), QGLWindowSurface::flush(), QGLTextureDestroyer::freeTexture_slot(), QX11GLWindowSurface::grabWidget(), QGLShaderProgram::hasOpenGLShaderPrograms(), QGLShader::hasOpenGLShaders(), QGLFramebufferObjectPrivate::init(), QGLShaderProgram::init(), QMeeGoExtensions::initialize(), QGLFramebufferObject::isBound(), ShaderEffectItem::paint(), QGLPixmapData::paintEngine(), QGLEngineSelector::preferredPaintEngine(), QGLPixmapBlurFilter::processGL(), QGLPixmapDropShadowFilter::processGL(), qglfResolveCheckFramebufferStatus(), qglfResolveCreateProgram(), qglfResolveCreateShader(), qglfResolveGetAttribLocation(), qglfResolveGetUniformLocation(), qglfResolveIsBuffer(), qglfResolveIsFramebuffer(), qglfResolveIsProgram(), qglfResolveIsRenderbuffer(), qglfResolveIsShader(), QGLShader::QGLShader(), QGLShareContextScope::QGLShareContextScope(), qt_format_to_attrib_list(), qt_gl_functions(), QGLFramebufferObject::release(), QGLBuffer::release(), QGLShaderProgram::release(), ShaderEffectItem::renderEffect(), QX11GLWindowSurface::scroll(), QGLFBOGLPaintDevice::setFBO(), QGLContextPrivate::unbindPixmapFromTexture(), ShaderEffectSource::updateBackbuffer(), QGL2PaintEngineExPrivate::updateBrushTexture(), QGLWindowSurface::updateGeometry(), QGLGlyphTexture::~QGLGlyphTexture(), and QGLPixelBuffer::~QGLPixelBuffer().

{
#ifdef Q_WS_QPA
    if (const QPlatformGLContext *threadContext = QPlatformGLContext::currentContext()) {
        return QGLContext::fromPlatformGLContext(const_cast<QPlatformGLContext *>(threadContext));
    }
    return 0;
#else
    QGLThreadContext *threadContext = qgl_context_storage.localData();
    if (threadContext) {
#ifdef Q_OS_SYMBIAN
        // Query the current context and return null if it is different.
        // This is needed to support mixed VG-GL rendering.
        // QtOpenVG is free to make a QEglContext current at any time and
        // QGLContext gets no notification that its underlying QEglContext is
        // not current anymore. We query directly from EGL to be thread-safe.
        // QEglContext does not store all the contexts per-thread.
        if (threadContext->context) {
            QEglContext *eglcontext = threadContext->context->d_func()->eglContext;
            if (eglcontext) {
                EGLContext ctx = eglcontext->context();
                if (ctx != eglGetCurrentContext())
                    return 0;
            }
        }
#endif
        return threadContext->context;
    }
    return 0;
#endif //Q_WS_QPA
}

deleteTexture()

void QGLContext::deleteTexture

(

GLuint

id

)

Removes the texture identified by id from the texture cache, and calls glDeleteTextures() to delete the texture from the context.

See also

bindTexture()

Definition at line 2957 of file qgl.cpp.

{
    if (QGLTextureCache::instance()->remove(this, id))
        return;
    glDeleteTextures(1, &id);
}

device()

QPaintDevice * QGLContext::device

(

)

const

Returns the paint device set for this context.

See also

QGLContext::QGLContext()

Definition at line 3507 of file qgl.cpp.

Referenced by QGLFramebufferObject::blitFramebuffer(), QGLGlyphCache::cacheGlyphs(), QGLOverlayWidget::paintGL(), qDeleteQGLContext(), qStoreColors(), and QGLWidgetPrivate::updateColormap().

{
    Q_D(const QGLContext);
    return d->paintDevice;
}

deviceIsPixmap()

bool QGLContext::deviceIsPixmap ( ) const

protected

Returns true if the paint device of this context is a pixmap; otherwise returns false.

Definition at line 3513 of file qgl.cpp.

Referenced by QGLOverlayWidget::paintGL(), qStoreColors(), and QGLWidgetPrivate::updateColormap().

{
    Q_D(const QGLContext);
    return d->paintDevice->devType() == QInternal::Pixmap;
}

doneCurrent()

void QGLContext::doneCurrent ( )

virtual

Makes no GL context the current context.

Normally, you do not need to call this function; QGLContext calls it as necessary.

Definition at line 277 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), qDeleteQGLContext(), tryVisual(), QGLWindowSurface::updateGeometry(), updatePaintDevice(), and QGLThreadContext::~QGLThreadContext().

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

    QGLContextPrivate::setCurrentContext(0);
}

drawTexture() [1/2]

void QGLContext::drawTexture	(	const QRectF &	target,
		GLuint	textureId,
		GLenum	textureTarget = GL_TEXTURE_2D
	)

This function supports the following use cases:

• On OpenGL and OpenGL ES 1.

  Since

  4.4

  x it draws the given texture, textureId, to the given target rectangle, target, in OpenGL model space. The textureTarget should be a 2D texture target.

• On OpenGL and OpenGL ES 2.x, if a painter is active, not inside a beginNativePainting / endNativePainting block, and uses the engine with type QPaintEngine::OpenGL2, the function will draw the given texture, textureId, to the given target rectangle, target, respecting the current painter state. This will let you draw a texture with the clip, transform, render hints, and composition mode set by the painter. Note that the texture target needs to be GL_TEXTURE_2D for this use case, and that this is the only supported use case under OpenGL ES 2.x.

Definition at line 3067 of file qgl.cpp.

{
#if !defined(QT_OPENGL_ES) || defined(QT_OPENGL_ES_2)
     if (d_ptr->active_engine &&
         d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
         QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
         if (!eng->isNativePaintingActive()) {
            QRectF src(0, 0, target.width(), target.height());
            QSize size(target.width(), target.height());
            if (eng->drawTexture(target, textureId, size, src))
                return;
        }
     }
#endif

#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() with OpenGL ES 2.0 requires an active OpenGL2 paint engine");
#endif
}

drawTexture() [2/2]

void QGLContext::drawTexture	(	const QPointF &	point,
		GLuint	textureId,
		GLenum	textureTarget = GL_TEXTURE_2D
	)

This function supports the following use cases:

• By default it draws the given texture, textureId, at the given point in OpenGL model space.

  Since

  4.4

  The textureTarget should be a 2D texture target.

• If a painter is active, not inside a beginNativePainting / endNativePainting block, and uses the engine with type QPaintEngine::OpenGL2, the function will draw the given texture, textureId, at the given point, respecting the current painter state. This will let you draw a texture with the clip, transform, render hints, and composition mode set by the painter. Note that the texture target needs to be GL_TEXTURE_2D for this use case.

Note

This function is not supported under any version of OpenGL ES.

Definition at line 3146 of file qgl.cpp.

{
#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);

    if (d_ptr->active_engine &&
        d_ptr->active_engine->type() == QPaintEngine::OpenGL2) {
        QGL2PaintEngineEx *eng = static_cast<QGL2PaintEngineEx*>(d_ptr->active_engine);
        if (!eng->isNativePaintingActive()) {
            QRectF dest(point, QSizeF(textureWidth, textureHeight));
            QRectF src(0, 0, textureWidth, textureHeight);
            QSize size(textureWidth, textureHeight);
            if (eng->drawTexture(dest, textureId, size, src))
                return;
        }
    }

    qDrawTextureRect(QRectF(point, QSizeF(textureWidth, textureHeight)), textureWidth, textureHeight, textureTarget);

    if (!wasEnabled)
        glDisable(textureTarget);
    glBindTexture(textureTarget, oldTexture);
#endif
}

format()

QGLFormat QGLContext::format

(

)

const

Returns the frame buffer format that was obtained (this may be a subset of what was requested).

See also

requestedFormat()

Definition at line 3495 of file qgl.cpp.

Referenced by QGLWindowSurface::beginPaint(), buildSpec(), chooseContext(), QGLWindowSurface::flush(), QGLPaintDevice::format(), nearest_gl_texture_size(), QGLOverlayWidget::paintGL(), and QGLFBOGLPaintDevice::setFBO().

{
    Q_D(const QGLContext);
    return d->glFormat;
}

generateFontDisplayLists()

void QGLContext::generateFontDisplayLists ( const QFont &  font, int  listBase  )

protected

Generates a set of 256 display lists for the 256 first characters in the font font.

See also

QGLWidget::renderText()

Definition at line 373 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), qDeleteQGLContext(), and qgl_use_font().

{
    Q_UNUSED(fnt);
    Q_UNUSED(listBase);
}

getProcAddress()

void * QGLContext::getProcAddress

(

const QString &

proc

)

const

Returns a function pointer to the GL extension function passed in proc.

0 is returned if a pointer to the function could not be obtained.

Definition at line 379 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), qDeleteQGLContext(), qgl_use_font(), qt_getOpenGLBundle(), qt_gl_getProcAddress_search(), qt_resolve_eglimage_gl_extensions(), qt_resolve_frag_program_extensions(), qt_resolve_glsl_extensions(), qt_resolve_stencil_face_extension(), qt_resolve_version_1_3_functions(), and qt_resolve_version_2_0_functions().

{
    return (void*)eglGetProcAddress(reinterpret_cast<const char *>(proc.toLatin1().data()));
}

initialized()

bool QGLContext::initialized ( ) const

protected

Returns true if this context has been initialized, i.

e. if QGLWidget::initializeGL() has been performed on it; otherwise returns false.

See also

setInitialized()

Definition at line 3533 of file qgl.cpp.

{
    Q_D(const QGLContext);
    return d->initDone;
}

isSharing()

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.

Definition at line 3489 of file qgl.cpp.

Referenced by QGLProgramCache::cleanupPrograms(), nearest_gl_texture_size(), and QGLWidgetPrivate::updateColormap().

{
    Q_D(const QGLContext);
    return d->group->isSharing();
}

isValid()

bool QGLContext::isValid

(

)

const

Returns true if a GL rendering context has been successfully created; otherwise returns false.

Definition at line 3477 of file qgl.cpp.

Referenced by buildSpec(), QGLGlyphCache::cacheGlyphs(), chooseContext(), QX11GLWindowSurface::flush(), QX11GLWindowSurface::grabWidget(), QGLWindowSurface::hijackWindow(), and QX11GLWindowSurface::scroll().

{
    Q_D(const QGLContext);
    return d->valid;
}

makeCurrent()

void QGLContext::makeCurrent ( )

virtual

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.

Definition at line 213 of file qgl_egl.cpp.

Referenced by QOpenGLPaintEngine::begin(), QGLPaintDevice::beginPaint(), chooseMacVisual(), choosePixelFormat(), QX11GLPixmapData::copy(), QGLPaintDevice::ensureActiveTarget(), QX11GLPixmapData::fill(), QGLWindowSurface::flush(), QGLTextureDestroyer::freeTexture_slot(), QGLWindowSurface::paintDevice(), qDeleteQGLContext(), QGLShareContextScope::QGLShareContextScope(), QX11GLPixmapData::scroll(), tryVisual(), QGLWindowSurface::updateGeometry(), and QGLPixelBuffer::~QGLPixelBuffer().

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

    if (d->eglContext->makeCurrent(d->eglSurfaceForDevice())) {
        QGLContextPrivate::setCurrentContext(this);
        if (!d->workaroundsCached) {
            d->workaroundsCached = true;
            const char *renderer = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
            if (!renderer)
                return;
            if ((strstr(renderer, "SGX") || strstr(renderer, "MBX"))) {
                // PowerVR MBX/SGX chips needs to clear all buffers when starting to render
                // a new frame, otherwise there will be a performance penalty to pay for
                // each frame.
                qDebug() << "Found SGX/MBX driver, enabling FullClearOnEveryFrame";
                d->workaround_needsFullClearOnEveryFrame = true;

                // Older PowerVR SGX drivers (like the one in the N900) have a
                // bug which prevents glCopyTexSubImage2D() to work with a POT
                // or GL_ALPHA texture bound to an FBO. The only way to
                // identify that driver is to check the EGL version number for it.
                const char *egl_version = eglQueryString(d->eglContext->display(), EGL_VERSION);

                if (egl_version && strstr(egl_version, "1.3")) {
                    qDebug() << "Found v1.3 driver, enabling brokenFBOReadBack";
                    d->workaround_brokenFBOReadBack = true;
                } else if (egl_version && strstr(egl_version, "1.4")) {
                    qDebug() << "Found v1.4 driver, enabling brokenTexSubImage";
                    d->workaround_brokenTexSubImage = true;

                    // this is a bit complicated; 1.4 version SGX drivers from
                    // Nokia have fixed the brokenFBOReadBack problem, but
                    // official drivers from TI haven't, meaning that things
                    // like the beagleboard are broken unless we hack around it
                    // - but at the same time, we want to not reduce performance
                    // by not enabling this elsewhere.
                    //
                    // so, let's check for a Nokia-specific addon, and only
                    // enable if it isn't present.
                    // (see MeeGo bug #5616)
                    if (!QEgl::hasExtension("EGL_NOK_image_shared")) {
                        // no Nokia extension, this is probably a standard SGX
                        // driver, so enable the workaround
                        qDebug() << "Found non-Nokia v1.4 driver, enabling brokenFBOReadBack";
                        d->workaround_brokenFBOReadBack = true;
                    }
                }
            } else if (strstr(renderer, "VideoCore III")) {
                // Some versions of VideoCore III drivers seem to pollute and use
                // stencil buffer when using glScissors even if stencil test is disabled.
                // Workaround is to clear stencil buffer before disabling scissoring.

                // qDebug() << "Found VideoCore III driver, enabling brokenDisableScissorTest"; 
                d->workaround_brokenScissor = true;
            }
        }
    }
}

overlayTransparentColor()

QColor QGLContext::overlayTransparentColor

(

)

const

If this context is a valid context in an overlay plane, returns the plane's transparent color.

Otherwise returns an QColor::isValid()}{invalid} color.

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.

Definition at line 362 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), QGLOverlayWidget::initializeGL(), qDeleteQGLContext(), tryVisual(), and updatePaintDevice().

{
    return d_func()->transpColor;
}

requestedFormat()

QGLFormat QGLContext::requestedFormat

(

)

const

Returns the frame buffer format that was originally requested in the constructor or setFormat().

See also

format()

Definition at line 3501 of file qgl.cpp.

{
    Q_D(const QGLContext);
    return d->reqFormat;
}

reset()

void QGLContext::reset

(

)

Resets the context and makes it invalid.

See also

create(), isValid()

Definition at line 191 of file qgl_egl.cpp.

Referenced by chooseMacVisual(), choosePixelFormat(), qDeleteQGLContext(), and tryVisual().

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

setDevice()

void QGLContext::setDevice ( QPaintDevice *  pDev )

protected

Warning

This function is not part of the public interface.

Definition at line 3267 of file qgl.cpp.

Referenced by qDeleteQGLContext().

{
    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");
    }
}

setFormat()

void QGLContext::setFormat

(

const QGLFormat &

format

)

Sets a format for this context.

The context is reset.

Call create() to create a new GL context that tries to match the new format.

QGLContext *cx;
//  ...
QGLFormat f;
f.setStereo(true);
cx->setFormat(f);
if (!cx->create())
    exit(); // no OpenGL support, or cannot render on the specified paintdevice
if (!cx->format().stereo())
    exit(); // could not create stereo context

See also

format(), reset(), create()

Definition at line 3257 of file qgl.cpp.

{
    Q_D(QGLContext);
    reset();
    d->glFormat = d->reqFormat = format;
}

setInitialized()

void QGLContext::setInitialized ( bool  on )

protected

If on is true the context has been initialized, i.

e. QGLContext::setInitialized() has been called on it. If on is false the context has not been initialized.

See also

initialized()

Definition at line 3539 of file qgl.cpp.

{
    Q_D(QGLContext);
    d->initDone = on;
}

setTextureCacheLimit()

void QGLContext::setTextureCacheLimit ( int  size )

static

This function sets the limit for the texture cache to size, expressed in kilobytes.

By default, the cache limit is approximately 64 MB.

See also

textureCacheLimit()

Definition at line 3205 of file qgl.cpp.

{
    QGLTextureCache::instance()->setMaxCost(size);
}

setValid()

void QGLContext::setValid ( bool  valid )

protected

Forces the GL rendering context to be valid.

Warning

This function is not part of the public interface.

Definition at line 3483 of file qgl.cpp.

{
    Q_D(QGLContext);
    d->valid = valid;
}

setWindowCreated()

void QGLContext::setWindowCreated ( bool  on )

protected

If on is true the context has had a window created for it.

If on is false no window has been created for the context.

See also

windowCreated()

Definition at line 3527 of file qgl.cpp.

{
    Q_D(QGLContext);
    d->crWin = on;
}

swapBuffers()

void QGLContext::swapBuffers ( ) const

virtual

Swaps the screen contents with an off-screen buffer.

Only works if the context is in double buffer mode.

See also

QGLFormat::setDoubleBuffer()

Definition at line 287 of file qgl_egl.cpp.

Referenced by choosePixelFormat(), QGLWindowSurface::flush(), qDeleteQGLContext(), tryVisual(), and updatePaintDevice().

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

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

textureCacheLimit()

int QGLContext::textureCacheLimit ( )

static

Returns the current texture cache limit in kilobytes.

See also

setTextureCacheLimit()

Definition at line 3215 of file qgl.cpp.

{
    return QGLTextureCache::instance()->maxCost();
}

tryVisual()

void * QGLContext::tryVisual ( const QGLFormat &  f, int  bufDepth = 1  )

protectedvirtual

Warning

This function is not part of the public interface.

X11 only: This virtual function chooses a visual that matches the OpenGL format. Reimplement this function in a subclass if you need a custom visual.

See also

chooseContext()

Definition at line 828 of file qgl_x11.cpp.

{
    Q_D(QGLContext);
    int spec[45];
    const QX11Info *xinfo = qt_x11Info(d->paintDevice);
    bool useFBConfig = buildSpec(spec, f, d->paintDevice, bufDepth, false);

    XVisualInfo* chosenVisualInfo = 0;

#if defined(GLX_VERSION_1_3) && !defined(Q_OS_HPUX)
    while (useFBConfig) {
        GLXFBConfig *configs;
        int configCount = 0;
        configs = glXChooseFBConfig(xinfo->display(), xinfo->screen(), spec, &configCount);

        if (!configs)
            break; // fallback to trying glXChooseVisual

        for (int i = 0; i < configCount; ++i) {
            XVisualInfo* vi;
            vi = glXGetVisualFromFBConfig(xinfo->display(), configs[i]);
            if (!vi)
                continue;

#if !defined(QT_NO_XRENDER)
            QWidget* w = 0;
            if (d->paintDevice->devType() == QInternal::Widget)
                w = static_cast<QWidget*>(d->paintDevice);

            if (w && w->testAttribute(Qt::WA_TranslucentBackground) && f.alpha()) {
                // Attempt to find a config who's visual has a proper alpha channel
                XRenderPictFormat *pictFormat;
                pictFormat = XRenderFindVisualFormat(xinfo->display(), vi->visual);

                if (pictFormat && (pictFormat->type == PictTypeDirect) && pictFormat->direct.alphaMask) {
                    // The pict format for the visual matching the FBConfig indicates ARGB
                    if (chosenVisualInfo)
                        XFree(chosenVisualInfo);
                    chosenVisualInfo = vi;
                    break;
                }
            } else
#endif //QT_NO_XRENDER
            if (chosenVisualInfo) {
                // If we've got a visual we can use and we're not trying to find one with a
                // real alpha channel, we might as well just use the one we've got
                break;
            }

            if (!chosenVisualInfo)
                chosenVisualInfo = vi; // Have something to fall back to
            else
                XFree(vi);
        }

        XFree(configs);
        break;
    }
#endif // defined(GLX_VERSION_1_3)

    if (!chosenVisualInfo)
        chosenVisualInfo = glXChooseVisual(xinfo->display(), xinfo->screen(), spec);

    return chosenVisualInfo;
}

updatePaintDevice()

void QGLContext::updatePaintDevice

(

)

Warning

This function is not part of the public interface.

Definition at line 583 of file qgl_mac.mm.

Referenced by QGLWindowSurface::updateGeometry().

{
    Q_D(QGLContext);
#ifndef QT_MAC_USE_COCOA
    d->update = false;
    if (d->paintDevice->devType() == QInternal::Widget) {
        //get control information
        QWidget *w = (QWidget *)d->paintDevice;
        HIViewRef hiview = (HIViewRef)w->winId();
        WindowRef window = HIViewGetWindow(hiview);
#ifdef DEBUG_OPENGL_REGION_UPDATE
        static int serial_no_gl = 0;
        qDebug("[%d] %p setting on %s::%s %p/%p [%s]", ++serial_no_gl, w,
                w->metaObject()->className(), w->objectName().toLatin1().constData(),
                hiview, window, w->handle() ? "Inside" : "Outside");
#endif

        //update drawable
        if (0 && w->isWindow() && w->isFullScreen()) {
            aglSetDrawable((AGLContext)d->cx, 0);
            aglSetFullScreen((AGLContext)d->cx, w->width(), w->height(), 0, QApplication::desktop()->screenNumber(w));
            w->hide();
        } else {
            AGLDrawable old_draw = aglGetDrawable((AGLContext)d->cx), new_draw = GetWindowPort(window);
            if (old_draw != new_draw)
                aglSetDrawable((AGLContext)d->cx, new_draw);
        }

        float scale  = qt_mac_get_scale_factor(w);

        if (!w->isWindow()) {
            QRegion clp = qt_mac_get_widget_rgn(w); //get drawable area

#ifdef DEBUG_OPENGL_REGION_UPDATE
            if (clp.isEmpty()) {
                qDebug("  Empty area!");
            } else {
                QVector<QRect> rs = clp.rects();
                for(int i = 0; i < rs.count(); i++)
                    qDebug("  %d %d %d %d", rs[i].x(), rs[i].y(), rs[i].width(), rs[i].height());
            }
#endif
            //update the clip
            if (!aglIsEnabled((AGLContext)d->cx, AGL_BUFFER_RECT))
                aglEnable((AGLContext)d->cx, AGL_BUFFER_RECT);
            if (clp.isEmpty()) {
                GLint offs[4] = { 0, 0, 0, 0 };
                aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
                if (aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
                    aglDisable((AGLContext)d->cx, AGL_CLIP_REGION);
            } else {
                HIPoint origin = { 0., 0. };
                HIViewConvertPoint(&origin, HIViewRef(w->winId()), 0);
                const GLint offs[4] = { qRound(origin.x),
                    w->window()->frameGeometry().height() * scale
                        - (qRound(origin.y) + w->height() * scale),
                    w->width() * scale, w->height() * scale};

                RgnHandle region = clp.handle(true);

                if (scale != float(1)) {
                    // Sacle the clip region by the scale factor
                    Rect regionBounds;
                    GetRegionBounds(region, &regionBounds);
                    Rect regionBoundsDest = regionBounds;
                    regionBoundsDest.bottom *= scale;
                    regionBoundsDest.right *= scale;
                    MapRgn(region, &regionBounds, &regionBoundsDest);
                }

                aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
                aglSetInteger((AGLContext)d->cx, AGL_CLIP_REGION, (const GLint *)region);
                if (!aglIsEnabled((AGLContext)d->cx, AGL_CLIP_REGION))
                    aglEnable((AGLContext)d->cx, AGL_CLIP_REGION);
            }
        } else {
            // Set the buffer rect for top-level gl contexts when scaled.
            if (scale != float(1)) {
                aglEnable((AGLContext)d->cx, AGL_BUFFER_RECT);
                const GLint offs[4] = { 0, 0,  w->width() * scale , w->height() * scale};
                aglSetInteger((AGLContext)d->cx, AGL_BUFFER_RECT, offs);
            }
        }
    } else if (d->paintDevice->devType() == QInternal::Pixmap) {
        QPixmap *pm = reinterpret_cast<QPixmap *>(d->paintDevice);

        unsigned long qdformat = k32ARGBPixelFormat;
        if (QSysInfo::ByteOrder == QSysInfo::LittleEndian)
            qdformat = k32BGRAPixelFormat;
        Rect rect;
        SetRect(&rect, 0, 0, pm->width(), pm->height());

        GWorldPtr gworld;
        NewGWorldFromPtr(&gworld, qdformat, &rect, 0, 0, 0,
                         reinterpret_cast<char *>(qt_mac_pixmap_get_base(pm)), 
                         qt_mac_pixmap_get_bytes_per_line(pm));

        PixMapHandle pixmapHandle = GetGWorldPixMap(gworld);
        aglSetOffScreen(reinterpret_cast<AGLContext>(d->cx), pm->width(), pm->height(),
                        GetPixRowBytes(pixmapHandle), GetPixBaseAddr(pixmapHandle));
    } else {
        qWarning("QGLContext::updatePaintDevice(): Not sure how to render OpenGL on this device!");
    }
    aglUpdateContext((AGLContext)d->cx);

#else
    QMacCocoaAutoReleasePool pool;

    if (d->paintDevice->devType() == QInternal::Widget) {
        //get control information
        QWidget *w = (QWidget *)d->paintDevice;
        NSView *view = qt_mac_nativeview_for(w);

        // Trying to attach the GL context to the NSView will fail with
        // "invalid drawable" if done too soon, but we have to make sure
        // the connection is made before the first paint event. Using
        // the NSView do to this check fails as the NSView is visible
        // before it's safe to connect, and using the NSWindow fails as
        // the NSWindow will become visible after the first paint event.
        // This leaves us with the QWidget, who's visible state seems
        // to match the point in time when it's safe to connect.
        if (!w || !w->isVisible())
            return; // Not safe to attach GL context to view yet

        if ([static_cast<NSOpenGLContext *>(d->cx) view] != view && ![view isHidden])
            [static_cast<NSOpenGLContext *>(d->cx) setView:view];
    } else if (d->paintDevice->devType() == QInternal::Pixmap) {
        const QPixmap *pm = static_cast<const QPixmap *>(d->paintDevice);
        [static_cast<NSOpenGLContext *>(d->cx) setOffScreen:qt_mac_pixmap_get_base(pm)
                                                      width:pm->width()
                                                     height:pm->height()
                                                   rowbytes:qt_mac_pixmap_get_bytes_per_line(pm)];
    } else {
        qWarning("QGLContext::updatePaintDevice: Not sure how to render OpenGL on this device");
    }
    [static_cast<NSOpenGLContext *>(d->cx) update];
#endif
}

windowCreated()

bool QGLContext::windowCreated ( ) const

protected

Returns true if a window has been created for this context; otherwise returns false.

See also

setWindowCreated()

Definition at line 3520 of file qgl.cpp.

Referenced by QGLOverlayWidget::paintGL().

{
    Q_D(const QGLContext);
    return d->crWin;
}

Friends and Related Functions

QGL2PaintEngineEx

friend class QGL2PaintEngineEx

friend

Definition at line 439 of file qgl.h.

QGL2PaintEngineExPrivate

friend class QGL2PaintEngineExPrivate

friend

Definition at line 440 of file qgl.h.

QGLContextGroup

friend class QGLContextGroup

friend

Definition at line 447 of file qgl.h.

QGLContextResourceBase

friend class QGLContextResourceBase

friend

Definition at line 467 of file qgl.h.

QGLEngineShaderManager

friend class QGLEngineShaderManager

friend

Definition at line 441 of file qgl.h.

QGLExtensions

friend class QGLExtensions

friend

Definition at line 450 of file qgl.h.

QGLFBOGLPaintDevice

friend class QGLFBOGLPaintDevice

friend

Definition at line 462 of file qgl.h.

QGLFormat::openGLVersionFlags

QGLFormat::OpenGLVersionFlags QGLFormat::openGLVersionFlags ( )

friend

QGLFramebufferObject

friend class QGLFramebufferObject

friend

Definition at line 460 of file qgl.h.

QGLFramebufferObjectPrivate

friend class QGLFramebufferObjectPrivate

friend

Definition at line 461 of file qgl.h.

QGLGlyphCache

friend class QGLGlyphCache

friend

Definition at line 436 of file qgl.h.

QGLGlyphTexture

friend struct QGLGlyphTexture

friend

Definition at line 446 of file qgl.h.

QGLPaintDevice

friend class QGLPaintDevice

friend

Definition at line 463 of file qgl.h.

QGLPixelBuffer

friend class QGLPixelBuffer

friend

Definition at line 432 of file qgl.h.

QGLPixelBufferPrivate

friend class QGLPixelBufferPrivate

friend

Definition at line 433 of file qgl.h.

QGLPixmapBlurFilter

friend class QGLPixmapBlurFilter

friend

Definition at line 449 of file qgl.h.

QGLPixmapData

friend class QGLPixmapData

friend

Definition at line 443 of file qgl.h.

QGLPixmapFilterBase

friend class QGLPixmapFilterBase

friend

Definition at line 444 of file qgl.h.

QGLSharedResourceGuard

friend class QGLSharedResourceGuard

friend

Definition at line 448 of file qgl.h.

QGLTexture

friend class QGLTexture

friend

Definition at line 451 of file qgl.h.

QGLTextureGlyphCache

friend class QGLTextureGlyphCache

friend

Definition at line 445 of file qgl.h.

QGLWidget

friend class QGLWidget

friend

Definition at line 434 of file qgl.h.

QGLWidgetGLPaintDevice

friend class QGLWidgetGLPaintDevice

friend

Definition at line 464 of file qgl.h.

QGLWidgetPrivate

friend class QGLWidgetPrivate

friend

Definition at line 435 of file qgl.h.

QGLWindowSurface

friend class QGLWindowSurface

friend

Definition at line 442 of file qgl.h.

QMacGLWindowChangeEvent

friend class QMacGLWindowChangeEvent

friend

Definition at line 457 of file qgl.h.

QOpenGLPaintEngine

friend class QOpenGLPaintEngine

friend

Definition at line 437 of file qgl.h.

QOpenGLPaintEnginePrivate

friend class QOpenGLPaintEnginePrivate

friend

Definition at line 438 of file qgl.h.

qt_phonon_get_dptr

QGLContextPrivate* qt_phonon_get_dptr ( const QGLContext *  )

friend

QX11GLPixmapData

friend class QX11GLPixmapData

friend

Definition at line 465 of file qgl.h.

QX11GLSharedContexts

friend class QX11GLSharedContexts

friend

Definition at line 466 of file qgl.h.

Properties

currentCtx

QGLContext * QGLContext::currentCtx = 0

staticprotected

Definition at line 423 of file qgl.h.

d_ptr

QScopedPointer<QGLContextPrivate> QGLContext::d_ptr

private

Definition at line 430 of file qgl.h.

Referenced by QOpenGLPaintEngine::begin(), QGLPaintDevice::beginPaint(), QGLFramebufferObject::bind(), QGLFramebufferObject::bindDefault(), QGLFramebufferObject::blitFramebuffer(), QGLContextPrivate::contextGroup(), QGLPixmapData::copy(), QGLPixmapData::copyBackFromRenderFbo(), QGLTextureGlyphCache::createTextureData(), QOpenGLPaintEngine::end(), QGLPaintDevice::endPaint(), QGL2PaintEngineEx::ensureActive(), QGLPaintDevice::ensureActiveTarget(), QGLContextPrivate::extensionFuncs(), QGLTextureGlyphCache::fillTexture(), QGLWindowSurface::flush(), QGLFramebufferObjectPrivate::init(), QGLContextResourceBase::insert(), QGLFramebufferObject::isBound(), QGLTextureGlyphCache::maxTextureHeight(), QGLTextureGlyphCache::maxTextureWidth(), QGLGlyphTexture::QGLGlyphTexture(), QGLFramebufferObject::release(), QGLTextureGlyphCache::resizeTextureData(), QGLWindowSurface::updateGeometry(), and QGLContextResourceBase::value().

---

The documentation for this class was generated from the following files:

• /src/opengl/qgl.h
• /src/opengl/qgl.cpp
• /src/opengl/qgl_egl.cpp
• /src/opengl/qgl_mac.mm
• /src/opengl/qgl_qpa.cpp
• /src/opengl/qgl_qws.cpp
• /src/opengl/qgl_win.cpp
• /src/opengl/qgl_wince.cpp
• /src/opengl/qgl_x11.cpp
• /src/opengl/qgl_x11egl.cpp