Removed unnecessary and/or TDE-unrelated code.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

7 files changed, 0 insertions, 4947 deletions

diff --git a/tqtinterface/qt4/src/opengl/qt_opengl.pri b/tqtinterface/qt4/src/opengl/qt_opengl.pri
deleted file mode 100644
index 9e324db..0000000
--- a/tqtinterface/qt4/src/opengl/qt_opengl.pri
+++ /dev/null
@@ -1,18 +0,0 @@
-# Qt opengl module
-
-opengl {
-	HEADERS += $$OPENGL_H/tqgl.h \
-		   $$OPENGL_H/tqglcolormap.h
-	SOURCES	+= $$OPENGL_CPP/tqgl.cpp \
-		   $$OPENGL_CPP/tqglcolormap.cpp
-	x11 {
-		HEADERS += $$OPENGL_H/tqgl_x11_p.h
-		SOURCES += $$OPENGL_CPP/tqgl_x11.cpp
-	}
-	else:mac:SOURCES += $$OPENGL_CPP/tqgl_mac.cpp
-	else:win32:SOURCES += $$OPENGL_CPP/tqgl_win.cpp
-
-	dlopen_opengl:DEFINES+=TQT_DLOPEN_OPENGL
-}
-
-
diff --git a/tqtinterface/qt4/src/opengl/tqgl.cpp b/tqtinterface/qt4/src/opengl/tqgl.cpp
deleted file mode 100644
index 77d4809..0000000
--- a/tqtinterface/qt4/src/opengl/tqgl.cpp
+++ /dev/null
@@ -1,2374 +0,0 @@
-/****************************************************************************
-**
-** Implementation of OpenGL classes for TQt
-**
-** Created : 970112
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the opengl module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#include "tqgl.h"
-#include "tqpixmap.h"
-#include "tqpaintdevicemetrics.h"
-#include "tqimage.h"
-#include "tqcleanuphandler.h"
-#include "tqptrdict.h"
-
-static TQGLFormat* qgl_default_format = 0;
-static TQGLFormat* qgl_default_overlay_format = 0;
-
-#if defined(TQ_WS_X11)
-#include "private/tqt_x11_p.h"
-#define INT32 dummy_INT32
-#define INT8 dummy_INT8
-#include <GL/glx.h>
-#undef INT32
-#undef INT8
-#include "tqgl_x11_p.h"
-#endif
-
-static TQCleanupHandler<TQGLFormat> qgl_cleanup_format;
-
-
-/*!
-    \class TQGL tqgl.h
-    \brief The TQGL class is a namespace for miscellaneous identifiers
-    in the TQt OpenGL module.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \module OpenGL
-    \ingroup graphics
-    \ingroup images
-
-
-    Normally you can ignore this class. TQGLWidget and the other
-    OpenGL<sup>*</sup> module classes inherit it, so when you make your
-    own TQGLWidget subclass you can use the identifiers in the TQGL
-    namespace without qualification.
-
-    However, you may occasionally find yourself in situations where you
-    need to refer to these identifiers from outside the TQGL namespace's
-    scope, e.g. in static functions. In such cases, simply write e.g. \c
-    TQGL::DoubleBuffer instead of just \c DoubleBuffer.
-
-    <sup>*</sup> OpenGL is a trademark of Silicon Graphics, Inc. in the
-    United States and other countries.
-
-*/
-
-
-/*****************************************************************************
-  TQGLFormat implementation
- *****************************************************************************/
-
-
-/*!
-    \class TQGLFormat tqgl.h
-    \brief The TQGLFormat class specifies the display format of an OpenGL
-    rendering context.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup graphics
-    \ingroup images
-    \module OpenGL
-
-    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() The plane of an overlay format.\endlink
-    \endlist
-
-    You create and tell a TQGLFormat object what rendering options you
-    want from an OpenGL<sup>*</sup> 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 TQGLWidget, 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 TQGLFormat and make it the
-    default for the entire application:
-    \code
-    TQGLFormat f;
-    f.setAlpha( TRUE );
-    f.setStereo( TRUE );
-    TQGLFormat::setDefaultFormat( f );
-    \endcode
-
-    Or you can specify the desired format when creating an object of
-    your TQGLWidget subclass:
-    \code
-    TQGLFormat f;
-    f.setDoubleBuffer( FALSE );                 // single buffer
-    f.setDirectRendering( FALSE );              // software rendering
-    MyGLWidget* myWidget = new MyGLWidget( f, ... );
-    \endcode
-
-    After the widget has been created, you can find out which of the
-    requested features the system was able to provide:
-    \code
-    TQGLFormat f;
-    f.setOverlay( TRUE );
-    f.setStereo( TRUE );
-    MyGLWidget* myWidget = new MyGLWidget( f, ... );
-    if ( !w->format().stereo() ) {
-	// ok, goggles off
-	if ( !w->format().hasOverlay() ) {
-	    qFatal( "Cool hardware required" );
-	}
-    }
-    \endcode
-
-    <sup>*</sup> OpenGL is a trademark of Silicon Graphics, Inc. in the
-    United States and other countries.
-
-    \sa TQGLContext, TQGLWidget
-*/
-
-
-/*!
-    Constructs a TQGLFormat object with the factory 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 Disabled.
-    \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).
-    \endlist
-*/
-
-TQGLFormat::TQGLFormat()
-{
-    opts = DoubleBuffer | DepthBuffer | Rgba | DirectRendering;
-    pln = 0;
-}
-
-
-/*!
-    Creates a TQGLFormat object that is a copy of the current \link
-    defaultFormat() application default format\endlink.
-
-    If \a options is not 0, this copy is modified by these format
-    options. The \a options parameter should be \c FormatOption values
-    OR'ed together.
-
-    This constructor makes it easy to specify a certain desired format
-    in classes derived from TQGLWidget, for example:
-    \code
-    // The rendering in MyGLWidget depends on using
-    // stencil buffer and alpha channel
-    MyGLWidget::MyGLWidget( TQWidget* parent, const char* name )
-	: TQGLWidget( TQGLFormat( StencilBuffer | AlphaChannel ), parent, name )
-    {
-	if ( !format().stencil() )
-	    qWarning( "Could not get stencil buffer; results will be suboptimal" );
-	if ( !format().alphaChannel() )
-	    qWarning( "Could not get alpha channel; results will be suboptimal" );
-	...
-    }
-    \endcode
-
-    Note that there are \c FormatOption values to turn format settings
-    both on and off, e.g. \c DepthBuffer and \c NoDepthBuffer,
-    \c DirectRendering and \c IndirectRendering, etc.
-
-    The \a plane parameter defaults to 0 and is the plane which this
-    format should be associated with. Not all OpenGL implmentations
-    supports overlay/underlay rendering planes.
-
-    \sa defaultFormat(), setOption()
-*/
-
-TQGLFormat::TQGLFormat( int options, int plane )
-{
-    uint newOpts = options;
-    opts = defaultFormat().opts;
-    opts |= ( newOpts & 0xffff );
-    opts &= ~( newOpts >> 16 );
-    pln = plane;
-}
-
-
-/*!
-    \fn bool TQGLFormat::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(), TQGLContext::swapBuffers(),
-    TQGLWidget::swapBuffers()
-*/
-
-void TQGLFormat::setDoubleBuffer( bool enable )
-{
-    setOption( enable ? DoubleBuffer : SingleBuffer );
-}
-
-
-/*!
-    \fn bool TQGLFormat::depth() const
-
-    Returns TRUE if the depth buffer is enabled; otherwise returns
-    FALSE. The depth buffer is enabled by default.
-
-    \sa setDepth()
-*/
-
-/*!
-    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()
-*/
-
-void TQGLFormat::setDepth( bool enable )
-{
-    setOption( enable ? DepthBuffer : NoDepthBuffer );
-}
-
-
-/*!
-    \fn bool TQGLFormat::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 TQGLFormat::setRgba( bool enable )
-{
-    setOption( enable ? Rgba : ColorIndex );
-}
-
-
-/*!
-    \fn bool TQGLFormat::alpha() const
-
-    Returns TRUE if the alpha channel of the framebuffer is enabled;
-    otherwise returns FALSE. The alpha channel is disabled by default.
-
-    \sa setAlpha()
-*/
-
-/*!
-    If \a enable is TRUE enables the alpha channel; otherwise disables
-    the alpha channel.
-
-    The alpha buffer is disabled by default.
-
-    The alpha channel is typically used for implementing transparency
-    or translucency. The A in RGBA specifies the transparency of a
-    pixel.
-
-    \sa alpha()
-*/
-
-void TQGLFormat::setAlpha( bool enable )
-{
-    setOption( enable ? AlphaChannel : NoAlphaChannel );
-}
-
-
-/*!
-    \fn bool TQGLFormat::accum() const
-
-    Returns TRUE if the accumulation buffer is enabled; otherwise
-    returns FALSE. The accumulation buffer is disabled by default.
-
-    \sa setAccum()
-*/
-
-/*!
-    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()
-*/
-
-void TQGLFormat::setAccum( bool enable )
-{
-    setOption( enable ? AccumBuffer : NoAccumBuffer );
-}
-
-
-/*!
-    \fn bool TQGLFormat::stencil() const
-
-    Returns TRUE if the stencil buffer is enabled; otherwise returns
-    FALSE. The stencil buffer is disabled by default.
-
-    \sa setStencil()
-*/
-
-/*!
-    If \a enable is TRUE enables the stencil buffer; otherwise
-    disables the stencil buffer.
-
-    The stencil buffer is disabled by default.
-
-    The stencil buffer masks certain parts of the drawing area so that
-    masked parts are not drawn on.
-
-    \sa stencil()
-*/
-
-void TQGLFormat::setStencil( bool enable )
-{
-    setOption( enable ? StencilBuffer: NoStencilBuffer );
-}
-
-
-/*!
-    \fn bool TQGLFormat::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 TQGLFormat::setStereo( bool enable )
-{
-    setOption( enable ? StereoBuffers : NoStereoBuffers );
-}
-
-
-/*!
-    \fn bool TQGLFormat::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 TQGLFormat::setDirectRendering( bool enable )
-{
-    setOption( enable ? DirectRendering : IndirectRendering );
-}
-
-
-/*!
-    \fn bool TQGLFormat::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 TQGLWidget to create an
-    additional context in an overlay plane. See the TQGLWidget
-    documentation for further information.
-
-    \sa hasOverlay()
-*/
-
-void TQGLFormat::setOverlay( bool enable )
-{
-    setOption( enable ? HasOverlay : 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()
-*/
-int TQGLFormat::plane() const
-{
-    return 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 TQGLWidget::isValid() invalid\endlink TQGLWidget will be
-    created.
-
-    \sa plane()
-*/
-void TQGLFormat::setPlane( int plane )
-{
-    pln = plane;
-}
-
-/*!
-    Sets the format option to \a opt.
-
-    \sa testOption()
-*/
-
-void TQGLFormat::setOption( FormatOption opt )
-{
-    if ( opt & 0xffff )
-	opts |= opt;
-    else
-       opts &= ~( opt >> 16 );
-}
-
-
-
-/*!
-    Returns TRUE if format option \a opt is set; otherwise returns FALSE.
-
-    \sa setOption()
-*/
-
-bool TQGLFormat::testOption( FormatOption opt ) const
-{
-    if ( opt & 0xffff )
-       return ( opts & opt ) != 0;
-    else
-       return ( opts & ( opt >> 16 ) ) == 0;
-}
-
-
-
-/*!
-    \fn bool TQGLFormat::hasOpenGL()
-
-    Returns TRUE if the window system has any OpenGL support;
-    otherwise returns FALSE.
-
-    \warning This function must not be called until the TQApplication
-    object has been created.
-*/
-
-
-
-/*!
-    \fn bool TQGLFormat::hasOpenGLOverlays()
-
-    Returns TRUE if the window system supports OpenGL overlays;
-    otherwise returns FALSE.
-
-    \warning This function must not be called until the TQApplication
-    object has been created.
-*/
-
-/*!
-    Returns the default TQGLFormat for the application. All TQGLWidgets
-    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 TQGLFormat().
-
-    \sa setDefaultFormat()
-*/
-
-TQGLFormat TQGLFormat::defaultFormat()
-{
-    if ( !qgl_default_format ) {
-	qgl_default_format = new TQGLFormat;
-	qgl_cleanup_format.add( &qgl_default_format );
-    }
-    return *qgl_default_format;
-}
-
-/*!
-    Sets a new default TQGLFormat 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:
-    \code
-    TQApplication a(argc, argv);
-    TQGLFormat f;
-    f.setDoubleBuffer( FALSE );
-    TQGLFormat::setDefaultFormat( f );
-    \endcode
-
-    \sa defaultFormat()
-*/
-
-void TQGLFormat::setDefaultFormat( const TQGLFormat &f )
-{
-    if ( !qgl_default_format ) {
-	qgl_default_format = new TQGLFormat;
-	qgl_cleanup_format.add( &qgl_default_format );
-    }
-    *qgl_default_format = f;
-}
-
-
-/*!
-    Returns the default TQGLFormat for overlay contexts.
-
-    The factory 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 setPlane() Plane:\endlink 1 (i.e., first overlay plane).
-    \endlist
-
-    \sa setDefaultFormat()
-*/
-
-TQGLFormat TQGLFormat::defaultOverlayFormat()
-{
-    if ( !qgl_default_overlay_format ) {
-	qgl_default_overlay_format = new TQGLFormat;
-	qgl_default_overlay_format->opts = DirectRendering;
-	qgl_default_overlay_format->pln = 1;
-	qgl_cleanup_format.add( &qgl_default_overlay_format );
-    }
-    return *qgl_default_overlay_format;
-}
-
-/*!
-    Sets a new default TQGLFormat for overlay contexts to \a f. This
-    format is used whenever a TQGLWidget is created with a format that
-    hasOverlay() enabled.
-
-    For example, to get a double buffered overlay context (if
-    available), use code like this:
-
-    \code
-    TQGLFormat f = TQGLFormat::defaultOverlayFormat();
-    f.setDoubleBuffer( TRUE );
-    TQGLFormat::setDefaultOverlayFormat( f );
-    \endcode
-
-    As usual, you can find out after widget creation whether the
-    underlying OpenGL system was able to provide the requested
-    specification:
-
-    \code
-    // ...continued from above
-    MyGLWidget* myWidget = new MyGLWidget( TQGLFormat( TQGL::HasOverlay ), ... );
-    if ( myWidget->format().hasOverlay() ) {
-	// Yes, we got an overlay, let's check _its_ format:
-	TQGLContext* olContext = myWidget->overlayContext();
-	if ( olContext->format().doubleBuffer() )
-	    ; // yes, we got a double buffered overlay
-	else
-	    ; // no, only single buffered overlays are available
-    }
-    \endcode
-
-    \sa defaultOverlayFormat()
-*/
-
-void TQGLFormat::setDefaultOverlayFormat( const TQGLFormat &f )
-{
-    if ( !qgl_default_overlay_format ) {
-	qgl_default_overlay_format = new TQGLFormat;
-	qgl_cleanup_format.add( &qgl_default_overlay_format );
-    }
-    *qgl_default_overlay_format = 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...
-    qgl_default_overlay_format->setOverlay( FALSE );
-}
-
-
-/*!
-    Returns TRUE if all the options of the two TQGLFormats are equal;
-    otherwise returns FALSE.
-*/
-
-bool operator==( const TQGLFormat& a, const TQGLFormat& b )
-{
-    return (a.opts == b.opts) && (a.pln == b.pln);
-}
-
-
-/*!
-    Returns FALSE if all the options of the two TQGLFormats are equal;
-    otherwise returns TRUE.
-*/
-
-bool operator!=( const TQGLFormat& a, const TQGLFormat& b )
-{
-    return !( a == b );
-}
-
-
-
-/*****************************************************************************
-  TQGLContext implementation
- *****************************************************************************/
-
-TQGLContext* TQGLContext::currentCtx = 0;
-
-/*!
-    \class TQGLContext tqgl.h
-    \brief The TQGLContext class encapsulates an OpenGL rendering context.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup graphics
-    \ingroup images
-    \module OpenGL
-
-    An OpenGL<sup>*</sup> rendering context is a complete set of
-    OpenGL state variables.
-
-    The context's \link TQGL::FormatOption format\endlink is set in the
-    constructor or 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 TQGLContext
-    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 TQGLContext is not thread safe.
-
-    <sup>*</sup> OpenGL is a trademark of Silicon Graphics, Inc. in the
-    United States and other countries.
-
-*/
-
-
-/*!
-    Constructs an OpenGL context for the paint tqdevice \a tqdevice, 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 TQGLContext object has been constructed, \link
-    create() create()\endlink must be called explicitly to create
-    the actual OpenGL context. The context will be \link isValid()
-    invalid\endlink if it was not possible to obtain a GL context at
-    all.
-
-    \sa format(), isValid()
-*/
-
-TQGLContext::TQGLContext( const TQGLFormat &format, TQPaintDevice *tqdevice )
-    : glFormat(format), reqFormat(format)
-{
-    init( tqdevice );
-}
-
-/*!
-    \overload
-    \internal
-*/
-TQGLContext::TQGLContext( const TQGLFormat &format )
-    : glFormat( format ), reqFormat(format)
-{
-    init();
-}
-
-/*!
-    Destroys the OpenGL context and frees its resources.
-*/
-
-TQGLContext::~TQGLContext()
-{
-    reset();
-    if ( d )
-	delete d;
-}
-
-
-/*!
-    \fn TQGLFormat TQGLContext::format() const
-
-    Returns the frame buffer format that was obtained (this may be a
-    subset of what was requested).
-
-    \sa requestedFormat()
-*/
-
-/*!
-    \fn TQGLFormat TQGLContext::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.
-
-    \code
-    TQGLContext *cx;
-    //  ...
-    TQGLFormat f;
-    f.setStereo( TRUE );
-    cx->setFormat( f );
-    if ( !cx->create() )
-	exit(); // no OpenGL support, or cannot render on the specified painttqdevice
-    if ( !cx->format().stereo() )
-	exit(); // could not create stereo context
-    \endcode
-
-    \sa format(), reset(), create()
-*/
-
-void TQGLContext::setFormat( const TQGLFormat &format )
-{
-    reset();
-    glFormat = reqFormat = format;
-}
-
-/*!
-    \internal
-*/
-void TQGLContext::setDevice( TQPaintDevice *pDev )
-{
-    if ( isValid() )
-	reset();
-    d->paintDevice = pDev;
-    if ( d->paintDevice && (d->paintDevice->devType() != TQInternal::Widget
-			&& d->paintDevice->devType() != TQInternal::Pixmap) ) {
-#if defined(TQT_CHECK_RANGE)
-	qWarning( "TQGLContext: Unsupported paint tqdevice type" );
-#endif
-    }
-}
-
-void TQGLContext::init( TQPaintDevice *dev )
-{
-    d = new Private;
-    d->valid = FALSE;
-#if defined(TQ_WS_X11)
-    qt_resolve_gl_symbols();
-    gpm = 0;
-#endif
-    setDevice( dev );
-#if defined(TQ_WS_WIN)
-    dc = 0;
-    win = 0;
-    pixelFormatId = 0;
-    cmap = 0;
-#endif
-#if defined(TQ_WS_MAC)
-    d->oldR = TQRect(1, 1, 1, 1);
-#endif
-    d->crWin = FALSE;
-    d->initDone = FALSE;
-    d->sharing = FALSE;
-}
-
-/*!
-    \fn bool TQGLContext::isValid() const
-
-    Returns TRUE if a GL rendering context has been successfully
-    created; otherwise returns FALSE.
-*/
-
-/*!
-    \fn void TQGLContext::setValid( bool valid )
-    \internal
-
-    Forces the GL rendering context to be valid.
-*/
-
-/*!
-    \fn bool TQGLContext::isSharing() const
-
-    Returns TRUE if display list sharing with another context was
-    requested in the create() call and the GL system was able to
-    fulfill this request; otherwise returns FALSE. Note that display
-    list sharing might not be supported between contexts with
-    different formats.
-*/
-
-/*!
-    \fn bool TQGLContext::tqdeviceIsPixmap() const
-
-    Returns TRUE if the paint tqdevice of this context is a pixmap;
-    otherwise returns FALSE.
-*/
-
-/*!
-    \fn bool TQGLContext::windowCreated() const
-
-    Returns TRUE if a window has been created for this context;
-    otherwise returns FALSE.
-
-    \sa setWindowCreated()
-*/
-
-/*!
-    \fn void TQGLContext::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 TQGLContext::colorIndex( const TQColor& c ) const
-
-    \internal
-
-    Returns a colormap index for the color c, in ColorIndex mode. Used
-    by qglColor() and qglClearColor().
-*/
-
-
-/*!
-    \fn bool TQGLContext::initialized() const
-
-    Returns TRUE if this context has been initialized, i.e. if
-    TQGLWidget::initializeGL() has been performed on it; otherwise
-    returns FALSE.
-
-    \sa setInitialized()
-*/
-
-/*!
-    \fn void TQGLContext::setInitialized( bool on )
-
-    If \a on is TRUE the context has been initialized, i.e.
-    TQGLContext::setInitialized() has been called on it. If \a on is
-    FALSE the context has not been initialized.
-
-    \sa initialized()
-*/
-
-/*!
-    \fn const TQGLContext* TQGLContext::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 TQColor TQGLContext::overlayTransparentColor() const
-
-    If this context is a valid context in an overlay plane, returns
-    the plane's transparent color. Otherwise returns an \link
-    TQColor::isValid() invalid \endlink color.
-
-    The returned color's \link TQColor::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 TQColor object will generally work as expected only
-    when passed as the argument to TQGLWidget::qglColor() or
-    TQGLWidget::qglClearColor(). Under certain circumstances it can
-    also be used to draw transparent graphics with a TQPainter. 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 tqdevice
-    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 TQGLContext, this method will
-    try to establish OpenGL display list sharing between this context
-    and the \a shareContext. Note that this may fail if the two
-    contexts have different formats. Use isSharing() to see if sharing
-    succeeded.
-
-    \warning Implementation note: initialization of C++ class
-    members usually takes place in the class constructor. TQGLContext
-    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 TQGLContext::create( const TQGLContext* shareContext )
-{
-    reset();
-    d->valid = chooseContext( shareContext );
-    return d->valid;
-}
-
-
-
-/*!
-    \fn bool TQGLContext::chooseContext( const TQGLContext* 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.
-
-    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 void TQGLContext::reset()
-
-    Resets the context and makes it invalid.
-
-    \sa create(), isValid()
-*/
-
-
-/*!
-    \fn void TQGLContext::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 TQGLContext::swapBuffers() const
-
-    Swaps the screen contents with an off-screen buffer. Only works if
-    the context is in double buffer mode.
-
-    \sa TQGLFormat::setDoubleBuffer()
-*/
-
-
-/*!
-    \fn void TQGLContext::doneCurrent()
-
-    Makes no GL context the current context. Normally, you do not need
-    to call this function; TQGLContext calls it as necessary.
-*/
-
-
-/*!
-    \fn TQPaintDevice* TQGLContext::tqdevice() const
-
-    Returns the paint tqdevice set for this context.
-
-    \sa TQGLContext::TQGLContext()
-*/
-
-/*!
-    \fn void TQGLContext::generateFontDisplayLists( const TQFont& 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 TQGLWidget::renderText()
-*/
-
-
-/*****************************************************************************
-  TQGLWidget implementation
- *****************************************************************************/
-
-
-/*!
-    \class TQGLWidget tqgl.h
-    \brief The TQGLWidget class is a widget for rendering OpenGL graphics.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \ingroup graphics
-    \ingroup images
-    \mainclass
-    \module OpenGL
-
-    TQGLWidget provides functionality for displaying OpenGL<sup>*</sup>
-    graphics integrated into a TQt application. It is very simple to
-    use. You inherit from it and use the subclass like any other
-    TQWidget, except that instead of drawing the widget's contents
-    using TQPainter etc. you use the standard OpenGL rendering
-    commands.
-
-    TQGLWidget 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 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 TQGLWidget subclass might look:
-
-    \code
-    class MyGLDrawer : public TQGLWidget
-    {
-	TQ_OBJECT	// must include this if you use TQt Q_SIGNALS/Q_SLOTS
-
-    public:
-	MyGLDrawer( TQWidget *parent, const char *name )
-	    : TQGLWidget(parent, name) {}
-
-    protected:
-
-	void initializeGL()
-	{
-	    // Set up the rendering context, define display lists etc.:
-	    ...
-	    glClearColor( 0.0, 0.0, 0.0, 0.0 );
-	    glEnable(GL_DEPTH_TEST);
-	    ...
-	}
-
-	void resizeGL( int w, int h )
-	{
-	    // setup viewport, projection etc.:
-	    glViewport( 0, 0, (GLint)w, (GLint)h );
-	    ...
-	    glFrustum( ... );
-	    ...
-	}
-
-	void paintGL()
-	{
-	    // draw the scene:
-	    ...
-	    glRotatef( ... );
-	    glMaterialfv( ... );
-	    glBegin( GL_TQUADS );
-	    glVertex3f( ... );
-	    glVertex3f( ... );
-	    ...
-	    glEnd();
-	    ...
-	}
-
-    };
-    \endcode
-
-    If you need to trigger a tqrepaint from places other than paintGL()
-    (a typical example is when using \link TQTimer 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.
-
-    TQGLWidget provides functions for requesting a new display \link
-    TQGLFormat format\endlink and you can also create widgets with
-    customized rendering \link TQGLContext contexts\endlink.
-
-    You can also share OpenGL display lists between TQGLWidgets (see
-    the documentation of the TQGLWidget constructors for details).
-
-    \section1 Overlays
-
-    The TQGLWidget 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 TQGLFormat
-    format\endlink. (Note: Overlay must be requested in the format
-    passed to the TQGLWidget 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 TQt windows can also be used for overlays. See the
-    examples/opengl/overlay_x11 example program for details.
-
-    <sup>*</sup> OpenGL is a trademark of Silicon Graphics, Inc. in the
-    United States and other countries.
-*/
-
-// ### BCI - fix in 4.0
-
-// the display list cache can't be global because display lists are
-// tied to the GL contexts for each individual widget
-
-class TQGLWidgetPrivate
-{
-public:
-    TQMap<TQString, int> displayListCache;
-};
-
-static TQPtrDict<TQGLWidgetPrivate> * qgl_d_ptr = 0;
-static TQSingleCleanupHandler< TQPtrDict<TQGLWidgetPrivate> > qgl_cleanup_d_ptr;
-
-static TQGLWidgetPrivate * qgl_d( const TQGLWidget * w )
-{
-    if ( !qgl_d_ptr ) {
-	qgl_d_ptr = new TQPtrDict<TQGLWidgetPrivate>;
-	qgl_cleanup_d_ptr.set( &qgl_d_ptr );
-	qgl_d_ptr->setAutoDelete( TRUE );
-    }
-    TQGLWidgetPrivate * ret = qgl_d_ptr->find( (void *) w );
-    if ( !ret ) {
-	ret = new TQGLWidgetPrivate;
-	qgl_d_ptr->replace( (void *) w, ret );
-    }
-    return ret;
-}
-
-void qgl_delete_d( const TQGLWidget * w )
-{
-    if ( qgl_d_ptr )
-	qgl_d_ptr->remove( (void *) w );
-}
-
-/*!
-    Constructs an OpenGL widget with a \a parent widget and a \a name.
-
-    The \link TQGLFormat::defaultFormat() default format\endlink is
-    used. The widget will be \link isValid() invalid\endlink if the
-    system has no \link TQGLFormat::hasOpenGL() OpenGL support\endlink.
-
-    The \a parent, \a name and widget flag, \a f, arguments are passed
-    to the TQWidget constructor.
-
-    If the \a shareWidget parameter points to a valid TQGLWidget, this
-    widget will share OpenGL display lists with \a shareWidget. If
-    this widget and \a shareWidget have different \link format()
-    formats\endlink, display list sharing may fail. You can check
-    whether display list sharing succeeded 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 TQGLWidget subclass.
-
-    \sa TQGLFormat::defaultFormat()
-*/
-
-TQGLWidget::TQGLWidget( TQWidget *parent, const char *name,
-		      const TQGLWidget* shareWidget, WFlags f )
-    : TQWidget( parent, name, (WFlags)(f | TQt::WWinOwnDC | WNoAutoErase) )
-{
-    init( new TQGLContext(TQGLFormat::defaultFormat(), TQT_TQPAINTDEVICE(this)), shareWidget );
-}
-
-
-/*!
-    Constructs an OpenGL widget with parent \a parent, called \a name.
-
-    The \a format argument specifies the desired \link TQGLFormat
-    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 TQGLFormat::hasOpenGL() OpenGL support\endlink.
-
-    The \a parent, \a name and widget flag, \a f, arguments are passed
-    to the TQWidget constructor.
-
-    If the \a shareWidget parameter points to a valid TQGLWidget, this
-    widget will share OpenGL display lists with \a shareWidget. If
-    this widget and \a shareWidget have different \link format()
-    formats\endlink, display list sharing may fail. You can check
-    whether display list sharing succeeded 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 TQGLWidget subclass.
-
-    \sa TQGLFormat::defaultFormat(), isValid()
-*/
-
-TQGLWidget::TQGLWidget( const TQGLFormat &format, TQWidget *parent,
-		      const char *name, const TQGLWidget* shareWidget,
-		      WFlags f )
-    : TQWidget( parent, name, f | (WFlags)(TQt::WWinOwnDC | WNoAutoErase) )
-{
-    init( new TQGLContext(format, TQT_TQPAINTDEVICE(this)), shareWidget );
-}
-
-/*!
-    Constructs an OpenGL widget with parent \a parent, called \a name.
-
-    The \a context argument is a pointer to the TQGLContext that
-    you wish to be bound to this widget. This allows you to pass in
-    your own TQGLContext sub-classes.
-
-    The widget will be \link isValid() invalid\endlink if the system
-    has no \link TQGLFormat::hasOpenGL() OpenGL support\endlink.
-
-    The \a parent, \a name and widget flag, \a f, arguments are passed
-    to the TQWidget constructor.
-
-    If the \a shareWidget parameter points to a valid TQGLWidget, this
-    widget will share OpenGL display lists with \a shareWidget. If
-    this widget and \a shareWidget have different \link format()
-    formats\endlink, display list sharing may fail. You can check
-    whether display list sharing succeeded 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 TQGLWidget subclass.
-
-    \sa TQGLFormat::defaultFormat(), isValid()
-*/
-TQGLWidget::TQGLWidget( TQGLContext *context, TQWidget *parent,
-		      const char *name, const TQGLWidget *shareWidget, WFlags f )
-    : TQWidget( parent, name, (WFlags)(f | TQt::WWinOwnDC | WNoAutoErase) )
-{
-    init( context, shareWidget );
-}
-
-/*!
-    Destroys the widget.
-*/
-
-TQGLWidget::~TQGLWidget()
-{
-#if defined(GLX_MESA_release_buffers) && defined(TQGL_USE_MESA_EXT)
-    bool doRelease = ( glcx && glcx->windowCreated() );
-#endif
-    qgl_delete_d( this );
-    delete glcx;
-#if defined(TQ_WGL)
-    delete olcx;
-#endif
-#if defined(GLX_MESA_release_buffers) && defined(TQGL_USE_MESA_EXT)
-    if ( doRelease )
-	glXReleaseBuffersMESA( x11Display(), winId() );
-#endif
-#if defined(TQ_WS_MAC)
-    if(gl_pix) {
-	delete gl_pix;
-	gl_pix = NULL;
-    }
-#endif
-    cleanupColormaps();
-}
-
-
-
-
-
-/*!
-    \fn TQGLFormat TQGLWidget::format() const
-
-    Returns the format of the contained GL rendering context.
-*/
-
-/*!
-    \fn bool TQGLWidget::doubleBuffer() const
-
-    Returns TRUE if the contained GL rendering context has double
-    buffering; otherwise returns FALSE.
-
-    \sa TQGLFormat::doubleBuffer()
-*/
-
-/*!
-    \fn void TQGLWidget::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 TQGLWidget::autoBufferSwap() const
-
-    Returns TRUE if the widget is doing automatic GL buffer swapping;
-    otherwise returns FALSE.
-
-    \sa setAutoBufferSwap()
-*/
-
-/*!
-    \fn bool TQGLWidget::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 TQGLFormat::hasOpenGL() OpenGL support\endlink.
-*/
-
-bool TQGLWidget::isValid() const
-{
-    return glcx->isValid();
-}
-
-/*!
-    \fn bool TQGLWidget::isSharing() const
-
-    Returns TRUE if display list sharing with another TQGLWidget was
-    requested in the constructor, and the GL system was able to
-    provide it; otherwise returns FALSE. The GL system may fail to
-    provide display list sharing if the two TQGLWidgets use different
-    formats.
-
-    \sa format()
-*/
-
-bool TQGLWidget::isSharing() const
-{
-    return glcx->isSharing();
-}
-
-/*!
-    \fn void TQGLWidget::makeCurrent()
-
-    Makes this widget the current widget for OpenGL operations, i.e.
-    makes the widget's rendering context the current OpenGL rendering
-    context.
-*/
-
-void TQGLWidget::makeCurrent()
-{
-#if defined( TQ_WS_MAC )
-    macInternalDoubleBuffer(); //make sure the correct context is used
-#endif
-    glcx->makeCurrent();
-}
-
-/*!
-    \fn void TQGLWidget::doneCurrent()
-
-    Makes no GL context the current context. Normally, you do not need
-    to call this function; TQGLContext calls it as necessary. However,
-    it may be useful in multithreaded environments.
-*/
-
-void TQGLWidget::doneCurrent()
-{
-    glcx->doneCurrent();
-}
-
-/*!
-    \fn void TQGLWidget::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 tqrepaint, i.e.
-    each time after paintGL() has been executed.
-
-    \sa doubleBuffer(), setAutoBufferSwap(), TQGLFormat::setDoubleBuffer()
-*/
-
-void TQGLWidget::swapBuffers()
-{
-    glcx->swapBuffers();
-#if defined(TQ_WS_MAC)
-    if(macInternalDoubleBuffer() && gl_pix)
-	bitBlt(this, 0, 0, gl_pix);
-#endif
-}
-
-
-/*!
-    \fn const TQGLContext* TQGLWidget::overlayContext() const
-
-    Returns the overlay context of this widget, or 0 if this widget
-    has no overlay.
-
-    \sa context()
-*/
-
-
-
-/*!
-    \fn void TQGLWidget::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 TQGLContext, and the initializeGL()
-  function will be executed for this new context before the first
-  resizeGL() or paintGL().
-
-  This method will try to keep any existing display list sharing with
-  other TQGLWidgets, but it may fail. Use isSharing() to test.
-
-  \sa format(), isSharing(), isValid()
-*/
-
-void TQGLWidget::setFormat( const TQGLFormat &format )
-{
-    setContext( new TQGLContext(format,TQT_TQPAINTDEVICE(this)) );
-}
-
-
-
-
-/*!
-    \fn const TQGLContext *TQGLWidget::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.
-*/
-
-/*
-  \obsolete
-
-  \fn void TQGLWidget::setContext( TQGLContext *context,
-				  const TQGLContext* shareContext,
-				  bool deleteOldContext )
-
-  Sets a new context for this widget. The TQGLContext \a context must
-  be created using \e new. TQGLWidget will delete \a context when
-  another context is set or when the widget is destroyed.
-
-  If \a context is invalid, TQGLContext::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 any existing
-  display list sharing with other TQGLWidgets this widget currently
-  has, or (if \a shareContext points to a valid context) start display
-  list sharing with that context, but it may fail. Use isSharing() to
-  test.
-
-  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 TQGLWidget::updateGL()
-
-    Updates the widget by calling glDraw().
-*/
-
-void TQGLWidget::updateGL()
-{
-    glDraw();
-}
-
-
-/*!
-    \fn void TQGLWidget::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 TQGLContext. 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 TQGLWidget::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 TQGLWidget::paintGL()
-{
-}
-
-
-/*!
-    \fn void TQGLWidget::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 TQGLWidget::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 TQGLWidget::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 TQGLWidget::paintOverlayGL()
-{
-}
-
-
-/*!
-    \fn void TQGLWidget::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 TQGLWidget::resizeOverlayGL( int, int )
-{
-}
-
-
-
-
-/*!
-    Handles paint events. 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 TQGLWidget::paintEvent( TQPaintEvent * )
-{
-    glDraw();
-    updateOverlayGL();
-}
-
-
-/*!
-    \fn void TQGLWidget::resizeEvent( TQResizeEvent * )
-
-    Handles resize events. Calls the virtual function resizeGL().
-*/
-
-
-/*!
-  \fn void TQGLWidget::setMouseTracking( bool enable )
-
-  \reimp
-*/
-
-
-/*!
-    Renders the current scene on a pixmap and returns the pixmap.
-
-    You can use this method on both visible and invisible TQGLWidgets.
-
-    This method will create a pixmap and a temporary TQGLContext 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.
-
-    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 TQGLContext will not be initialized
-    properly, and the rendered pixmap may be incomplete/corrupted.
-*/
-
-TQPixmap TQGLWidget::renderPixmap( int w, int h, bool useContext )
-{
-    TQSize sz = size();
-    if ( (w > 0) && (h > 0) )
-	sz = TQSize( w, h );
-
-#ifdef USE_QT4
-    // [FIXME]
-    bool needConversion = false;
-    TQPixmap pm;
-    pm.resize( sz );
-#else // USE_QT4
-#if defined(TQ_WS_X11)
-    TQPixmap pm( sz.width(), sz.height(), x11Depth() );
-    bool needConversion = x11Visual() != TQPaintDevice::x11AppVisual();
-
-    // make sure the pixmap uses the same visual as the widget itself
-    if ( needConversion ) {
-        TQPaintDeviceX11Data* xd = pm.getX11Data( TRUE );
-        xd->x_depth = x11Depth();
-        xd->x_visual = (Visual *) x11Visual();
-        pm.setX11Data( xd );
-    }
-#else
-    TQPixmap pm;
-    pm.resize( sz );
-#endif
-#endif // USE_QT4
-
-    glcx->doneCurrent();
-
-    bool success = TRUE;
-
-    if ( useContext && isValid() && renderCxPm( &pm ) )
-	return pm;
-
-    TQGLFormat fmt = glcx->requestedFormat();
-    fmt.setDirectRendering( FALSE );		// Direct is unlikely to work
-    fmt.setDoubleBuffer( FALSE );		// We don't need dbl buf
-
-    TQGLContext* ocx = glcx;
-    bool wasCurrent = (TQGLContext::currentContext() == ocx );
-    ocx->doneCurrent();
-    glcx = new TQGLContext( fmt, TQT_TQPAINTDEVICE(&pm) );
-    glcx->create();
-
-    if ( glcx->isValid() )
-	updateGL();
-    else
-	success = FALSE;
-
-    delete glcx;
-    glcx = ocx;
-
-    if ( wasCurrent )
-	ocx->makeCurrent();
-
-    if ( success ) {
-#if defined(TQ_WS_X11)
-	if ( needConversion ) {
-	    TQImage image = pm.convertToImage();
-	    TQPixmap p;
-	    p = image;
-	    return p;
-	}
-#endif
-	return pm;
-    } else
-	return TQPixmap();
-}
-
-
-
-/*!
-    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.
-*/
-TQImage TQGLWidget::grabFrameBuffer( bool withAlpha )
-{
-#if defined( TQ_WS_MAC )
-    if(dblbuf == macInternalDoubleBuffer(FALSE) && gl_pix) //why not optimize?
-	return ((TQPixmap*)gl_pix)->convertToImage();
-#endif
-    makeCurrent();
-    TQImage res;
-    int w = width();
-    int h = height();
-    if ( format().rgba() ) {
-	res = TQImage( w, h, 32 );
-	glReadPixels( 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, res.bits() );
-	if ( TQImage::systemByteOrder() == TQImage::BigEndian ) {
-	    // OpenGL gives RGBA; TQt wants ARGB
-	    uint *p = (uint*)res.bits();
-	    uint *end = p + w*h;
-	    if ( withAlpha && format().alpha() ) {
-		while ( p < end ) {
-		    uint a = *p << 24;
-		    *p = (*p >> 8) | a;
-		    p++;
-		}
-	    }
-	    else {
-		while ( p < end )
-		    *p++ >>= 8;
-	    }
-	}
-	else {
-	    // OpenGL gives ABGR (i.e. RGBA backwards); TQt wants ARGB
-	    res = res.swapRGB();
-	}
-	res.setAlphaBuffer( withAlpha && format().alpha() );
-    }
-    else {
-#if defined (TQ_WS_WIN)
-	res = TQImage( w, h, 8 );
-	glReadPixels( 0, 0, w, h, GL_COLOR_INDEX, GL_UNSIGNED_BYTE,
-		      res.bits() );
-	int palSize = 0;
-	const TQRgb* pal = TQColor::palette( &palSize );
-	if ( pal && palSize ) {
-	    res.setNumColors( palSize );
-	    for ( int i = 0; i < palSize; i++ )
-		res.setColor( i, pal[i] );
-	}
-#endif
-    }
-
-    return res.mirror();
-}
-
-
-
-/*!
-    Initializes OpenGL for this widget's context. Calls the virtual
-    function initializeGL().
-*/
-
-void TQGLWidget::glInit()
-{
-    if ( !isValid() )
-	return;
-    makeCurrent();
-    initializeGL();
-    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 TQGLWidget::glDraw()
-{
-    if ( !isValid() )
-	return;
-    makeCurrent();
-    if ( glcx->tqdeviceIsPixmap() )
-	glDrawBuffer( GL_FRONT );
-    if ( !glcx->initialized() ) {
-	glInit();
-	TQPaintDeviceMetrics dm( glcx->tqdevice() );
-	resizeGL( dm.width(), dm.height() ); // New context needs this "resize"
-    }
-    paintGL();
-    if ( doubleBuffer() ) {
-	if ( autoSwap )
-	    swapBuffers();
-    } else {
-	glFlush();
-#if defined( TQ_WS_MAC )
-	if(dblbuf && gl_pix)
-	    bitBlt(this, 0, 0, gl_pix);
-#endif
-    }
-}
-
-
-/*!
-    Convenience function for specifying a drawing color to OpenGL.
-    Calls glColor3 (in RGBA mode) or glIndex (in color-index mode)
-    with the color \a c. Applies to the current GL context.
-
-    \sa qglClearColor(), TQGLContext::currentContext(), TQColor
-*/
-
-void TQGLWidget::qglColor( const TQColor& c ) const
-{
-    const TQGLContext* ctx = TQGLContext::currentContext();
-    if ( ctx ) {
-	if ( ctx->format().rgba() )
-	    glColor3ub( c.red(), c.green(), c.blue() );
-
-	else if ( ctx->tqdevice() == context()->tqdevice()
-                  && !cmap.isEmpty() ) { // TQGLColormap in use?
-	    int i = cmap.find( c.rgb() );
-	    if ( i < 0 )
-		i = cmap.findNearest( c.rgb() );
-	    glIndexi( i );
-	} else
-	    glIndexi( ctx->colorIndex( c ) );
-    }
-}
-
-/*!
-    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 the current GL context.
-
-    \sa qglColor(), TQGLContext::currentContext(), TQColor
-*/
-
-void TQGLWidget::qglClearColor( const TQColor& c ) const
-{
-    const TQGLContext* ctx = TQGLContext::currentContext();
-    if ( ctx ) {
-	if ( ctx->format().rgba() )
-	    glClearColor( (GLfloat)c.red() / 255.0, (GLfloat)c.green() / 255.0,
-			  (GLfloat)c.blue() / 255.0, (GLfloat) 0.0 );
-	else if ( ctx->tqdevice() == context()->tqdevice()
-                  && !cmap.isEmpty() ) { // TQGLColormap in use?
-	    int i = cmap.find( c.rgb() );
-	    if ( i < 0 )
-		i = cmap.findNearest( c.rgb() );
-	    glClearIndex( i );
-	} else
-	    glClearIndex( ctx->colorIndex( c ) );
-    }
-}
-
-
-/*!
-    Converts the image \a img into the unnamed format expected by
-    OpenGL functions such as glTexImage2D(). The returned image is not
-    usable as a TQImage, but TQImage::width(), TQImage::height() and
-    TQImage::bits() may be used with OpenGL. The following few lines
-    are from the texture example. Most of the code is irrelevant, so
-    we just quote the relevant bits:
-
-    \quotefile 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.
-*/
-
-
-TQImage TQGLWidget::convertToGLFormat( const TQImage& img )
-{
-    TQImage res = img.convertDepth( 32 );
-    res = res.mirror();
-
-    if ( TQImage::systemByteOrder() == TQImage::BigEndian ) {
-	// TQt has ARGB; OpenGL wants RGBA
-	for ( int i=0; i < res.height(); i++ ) {
-	    uint *p = (uint*)res.scanLine( i );
-	    uint *end = p + res.width();
-	    while ( p < end ) {
-		*p = (*p << 8) | ((*p >> 24) & 0xFF);
-		p++;
-	    }
-	}
-    }
-    else {
-	// TQt has ARGB; OpenGL wants ABGR (i.e. RGBA backwards)
-	res = res.swapRGB();
-    }
-    return res;
-}
-
-
-/*!
-    \fn TQGLColormap & TQGLWidget::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 TQColormap
-    returned will be empty.
-
-    \sa setColormap()
-*/
-
-/*!
-    \fn void TQGLWidget::setColormap( const TQGLColormap & cmap )
-
-    Set the colormap for this widget to \a cmap. Usually it is only
-    top-level widgets that can have colormaps installed.
-
-    \sa colormap()
-*/
-
-int TQGLWidget::displayListBase( const TQFont & fnt, int listBase )
-{
-    int base;
-
-    TQGLWidgetPrivate * d = qgl_d( this );
-    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 = glcx->tqdeviceIsPixmap();
-
-#if 0 // TQT_NO_XFTFREETYPE
-    // 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
-    TQString color_key;
-    if (fnt.styleStrategy() != TQFont::NoAntialias) {
-	GLfloat color[4];
-	glGetFloatv(GL_CURRENT_COLOR, color);
-	color_key.sprintf("%f_%f_%f",color[0], color[1], color[2]);
-    }
-    TQString key = fnt.key() + color_key + TQString::number((int) regenerate);
-#else
-    TQString key = fnt.key() + TQString::number((int) regenerate);
-#endif
-
-    if ( !regenerate && (d->displayListCache.find( key ) != d->displayListCache.end()) ) {
-	base = d->displayListCache[ key ];
-    } else {
-	int maxBase = listBase - 256;
-	TQMapConstIterator<TQString,int> it;
-	for ( it = d->displayListCache.begin(); it != d->displayListCache.end(); ++it ) {
-	    if ( maxBase < it.data() ) {
-		maxBase = it.data();
-	    }
-	}
-	maxBase += 256;
-	glcx->generateFontDisplayLists( fnt, maxBase );
-	d->displayListCache[ key ] = maxBase;
-	base = maxBase;
-    }
-    return base;
-}
-
-/*!
-   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 fnt 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. Note that if you have
-   GL_LIGHTING enabled, the string will not appear in the color you
-   want. You should therefore switch lighting off before using
-   renderText().
-
-   \a listBase specifies the index of the first display list that is
-   generated by this function. The default value is 2000. 256 display
-   lists will be generated, one for each of the first 256 characters
-   in the font that is used to render the string. If several fonts are
-   used in the same widget, the display lists for these fonts will
-   follow the last generated list. You would normally not have to
-   change this value unless you are using lists in the same range. The
-   lists are deleted when the widget is destroyed.
-
-   Note: This function only works reliably with ASCII strings.
-*/
-
-void TQGLWidget::renderText( int x, int y, const TQString & str, const TQFont & fnt, int listBase )
-{
-    if (str.isEmpty())
-        return;
-    makeCurrent();
-    glPushAttrib( GL_TRANSFORM_BIT | GL_VIEWPORT_BIT | GL_LIST_BIT | GL_CURRENT_BIT );
-    glMatrixMode( GL_PROJECTION );
-    glPushMatrix();
-    glLoadIdentity();
-    glOrtho( 0, width(), height(), 0, -1, 1 );
-    glMatrixMode( GL_MODELVIEW );
-    glPushMatrix();
-    glLoadIdentity();
-
-    glRasterPos2i( 0, 0 );
-    glBitmap(0, 0, 0, 0, x, -y, NULL);
-    glListBase( displayListBase( fnt, listBase ) );
-    const char *cstr = str.latin1();
-    glCallLists( tqstrlen(cstr), GL_UNSIGNED_BYTE, cstr );
-
-    // restore the matrix stacks and GL state
-    glPopMatrix();
-    glMatrixMode( GL_PROJECTION );
-    glPopMatrix();
-    glPopAttrib();
-}
-
-/*! \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.
-*/
-void TQGLWidget::renderText( double x, double y, double z, const TQString & str, const TQFont & fnt,
-			    int listBase )
-{
-    if (str.isEmpty())
-        return;
-    makeCurrent();
-    glRasterPos3d( x, y, z );
-    glPushAttrib( GL_LIST_BIT );
-    glListBase( displayListBase( fnt, listBase ) );
-    const char *cstr = str.latin1();
-    glCallLists( tqstrlen(cstr), GL_UNSIGNED_BYTE, cstr );
-    glPopAttrib();
-}
-
-/*****************************************************************************
-  TQGL classes overview documentation.
- *****************************************************************************/
-
-/*!
-
-\page opengl.html
-
-\title TQt OpenGL 3D Graphics
-
-\if defined(commercial)
-This module is part of the \link commercialeditions.html TQt Enterprise
-Edition\endlink.
-\endif
-
-\section1 Introduction
-
-OpenGL is a standard API for rendering 3D graphics.
-
-OpenGL only deals with 3D rendering and provides little or no support
-for GUI programming issues. The user interface for an
-OpenGL<sup>*</sup> application must be created with another toolkit,
-such as Motif on the X platform, Microsoft Foundation Classes (MFC)
-under Windows, or TQt on \e both platforms.
-
-The TQt OpenGL module makes it easy to use OpenGL in TQt applications.
-It provides an OpenGL widget class that can be used just like any
-other TQt widget, except that it opens an OpenGL display buffer where
-you can use the OpenGL API to render the contents.
-
-The TQt OpenGL module is implemented as a platform-independent TQt/C++
-wrapper around the platform-dependent GLX, WGL, or AGL C APIs. The
-functionality provided is very similar to Mark Kilgard's GLUT library,
-but with much more non-OpenGL-specific GUI functionality, i.e. the
-whole TQt API.
-
-\section1 Installation
-
-When you install TQt for X11, the configure script will autodetect if
-OpenGL headers and libraries are installed on your system, and if so,
-it will include the TQt OpenGL module in the TQt library. (If your
-OpenGL headers or libraries are placed in a non-standard directory,
-you may need to change the TQMAKE_INCDIR_OPENGL and/or
-TQMAKE_LIBDIR_OPENGL in the config file for your system). Some
-configurations require threading to be enabled for OpenGL, so if
-OpenGL is not detected, try \c{configure -thread}.
-
-When you install TQt for Windows, the TQt OpenGL module is always
-included.
-
-The TQt OpenGL module is not licensed for use with the TQt Professional
-Edition. Consider upgrading to the TQt Enterprise Edition if you
-require OpenGL support.
-
-Note about using Mesa on X11: Mesa versions earlier than 3.1 would use
-the name "MesaGL" and "MesaGLU" for the libraries, instead of "GL" and
-"GLU". If you want to use a pre-3.1 version of Mesa, you must change
-the Makefiles to use these library names instead. The easiest way to
-do this is to edit the TQMAKE_LIBS_OPENGL line in the config file you
-are using, changing "-lGL -lGLU" to "-lMesaGL -lMesaGLU"; then run
-"configure" again.
-
-\section1 The TQGL Classes
-
-The OpenGL support classes in TQt are:
-\list
-\i \link TQGLWidget TQGLWidget\endlink: An easy-to-use TQt
-  widget for rendering OpenGL scenes.
-\i \link TQGLContext TQGLContext\endlink: Encapsulates an OpenGL rendering context.
-\i \link TQGLFormat TQGLFormat\endlink: Specifies the
-display format of a rendering context.
-\i \link TQGLColormap TQGLColormap\endlink: Handles indexed
-colormaps in GL-index mode.
-\endlist
-
-Many applications only need the high-level TQGLWidget class. The other
-TQGL classes provide advanced features. X11 users might like to read
-the notes on \link opengl-x11-overlays.html overlays\endlink.
-
-See also the \link opengl-examples.html OpenGL examples\endlink.
-
-The TQGL documentation assumes that you are familiar with OpenGL
-programming. If you're new to the subject a good starting point is
-\l{http://www.opengl.org/}.
-
-
-<sup>*</sup> OpenGL is a trademark of Silicon Graphics, Inc. in the
-United States and other countries.
-
-*/
-
-/*!
-    \enum TQGL::FormatOption
-
-    This enum specifies the format options.
-
-    \value DoubleBuffer
-    \value DepthBuffer
-    \value Rgba
-    \value AlphaChannel
-    \value AccumBuffer
-    \value StencilBuffer
-    \value StereoBuffers
-    \value DirectRendering
-    \value HasOverlay
-    \value SingleBuffer
-    \value NoDepthBuffer
-    \value ColorIndex
-    \value NoAlphaChannel
-    \value NoAccumBuffer
-    \value NoStencilBuffer
-    \value NoStereoBuffers
-    \value IndirectRendering
-    \value NoOverlay
-*/
diff --git a/tqtinterface/qt4/src/opengl/tqgl.h b/tqtinterface/qt4/src/opengl/tqgl.h
deleted file mode 100644
index 2f0431f..0000000
--- a/tqtinterface/qt4/src/opengl/tqgl.h
+++ /dev/null
@@ -1,542 +0,0 @@
-/****************************************************************************
-**
-** Definition of OpenGL classes for TQt
-**
-** Created : 970112
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the opengl module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#ifndef TQGL_H
-#define TQGL_H
-
-#ifndef TQT_H
-#include "tqwidget.h"
-#include "tqglcolormap.h"
-#endif // TQT_H
-
-#if !defined( TQT_MODULE_OPENGL ) || defined( TQT_LICENSE_PROFESSIONAL )
-#define TQM_EXPORT_OPENGL
-#else
-#define TQM_EXPORT_OPENGL TQ_EXPORT
-#endif
-
-#ifndef TQT_NO_COMPAT
-#define TQGL_VERSION	450
-#define TQGL_VERSION_STR	"4.5"
-TQM_EXPORT_OPENGL inline const char *qGLVersion() {
-    qObsolete( 0, "qGLVersion", "qVersion" );
-    return TQGL_VERSION_STR;
-}
-#endif
-
-#if defined(TQ_WS_WIN)
-# include "tqt_windows.h"
-#endif
-
-#if defined(TQ_WS_MAC)
-#if !defined( TQMAC_OPENGL_DOUBLEBUFFER )
-/* This macro is different now. If the macro is not defined TQGLWidget will
- * try to determine when you need double buffering.  If set to 0 it will
- * never double buffer and *can* be acclerated. If set to 1 (the default)
- * it will always double buffer. Unlike before the value of this macro does
- * not upset binary compatability either. */
-#if TQT_MACOSX_VERSION >= 0x1020
-# define TQMAC_OPENGL_DOUBLEBUFFER 0
-#endif
-#endif
-# include <OpenGL/gl.h>
-# include <OpenGL/glu.h>
-#else
-# include <GL/gl.h>
-# include <GL/glu.h>
-#endif
-
-#if defined(TQ_WS_WIN) || defined(TQ_WS_MAC)
-class TQGLCmap;
-#endif
-
-class TQPixmap;
-#if defined(TQ_WS_X11)
-class TQGLOverlayWidget;
-#endif
-
-// Namespace class:
-class TQM_EXPORT_OPENGL TQGL
-{
-public:
-    enum FormatOption {
-	DoubleBuffer		= 0x0001,
-	DepthBuffer		= 0x0002,
-	Rgba			= 0x0004,
-	AlphaChannel		= 0x0008,
-	AccumBuffer		= 0x0010,
-	StencilBuffer		= 0x0020,
-	StereoBuffers		= 0x0040,
-	DirectRendering		= 0x0080,
-	HasOverlay		= 0x0100,
-	SingleBuffer            = DoubleBuffer  << 16,
-	NoDepthBuffer           = DepthBuffer   << 16,
-	ColorIndex              = Rgba          << 16,
-	NoAlphaChannel          = AlphaChannel  << 16,
-	NoAccumBuffer           = AccumBuffer   << 16,
-	NoStencilBuffer         = StencilBuffer << 16,
-	NoStereoBuffers         = StereoBuffers << 16,
-	IndirectRendering       = DirectRendering << 16,
-	NoOverlay		= HasOverlay << 16
-    };
-};
-
-
-
-class TQM_EXPORT_OPENGL TQGLFormat : public TQGL
-{
-public:
-    TQGLFormat();
-    TQGLFormat( int options, int plane = 0 );
-
-    bool doubleBuffer() const;
-    void setDoubleBuffer( bool enable );
-    bool depth() const;
-    void setDepth( bool enable );
-    bool rgba() const;
-    void setRgba( bool enable );
-    bool alpha() const;
-    void setAlpha( bool enable );
-    bool accum() const;
-    void setAccum( bool enable );
-    bool stencil() const;
-    void setStencil( bool enable );
-    bool stereo() const;
-    void setStereo( bool enable );
-    bool directRendering() const;
-    void setDirectRendering( bool enable );
-    bool hasOverlay() const;
-    void setOverlay( bool enable );
-
-    int plane() const;
-    void setPlane( int plane );
-
-    void setOption( FormatOption opt );
-    bool testOption( FormatOption opt ) const;
-
-    static TQGLFormat defaultFormat();
-    static void setDefaultFormat( const TQGLFormat& f );
-
-    static TQGLFormat defaultOverlayFormat();
-    static void setDefaultOverlayFormat( const TQGLFormat& f );
-
-    static bool hasOpenGL();
-    static bool hasOpenGLOverlays();
-
-    friend TQM_EXPORT_OPENGL bool operator==( const TQGLFormat&,
-					     const TQGLFormat& );
-    friend TQM_EXPORT_OPENGL bool operator!=( const TQGLFormat&,
-					     const TQGLFormat& );
-private:
-    uint opts;
-    int pln;
-};
-
-
-TQM_EXPORT_OPENGL bool operator==( const TQGLFormat&, const TQGLFormat& );
-TQM_EXPORT_OPENGL bool operator!=( const TQGLFormat&, const TQGLFormat& );
-
-class TQM_EXPORT_OPENGL TQGLContext : public TQGL
-{
-public:
-    TQGLContext( const TQGLFormat& format, TQPaintDevice* tqdevice );
-    TQGLContext( const TQGLFormat& format );
-    virtual ~TQGLContext();
-
-    virtual bool create( const TQGLContext* shareContext = 0 );
-    bool isValid() const;
-    bool isSharing() const;
-    virtual void reset();
-
-    TQGLFormat format() const;
-    TQGLFormat requestedFormat() const;
-    virtual void setFormat( const TQGLFormat& format );
-
-    virtual void makeCurrent();
-    virtual void swapBuffers() const;
-
-    TQPaintDevice* tqdevice() const;
-
-    TQColor overlayTransparentColor() const;
-
-    static const TQGLContext* currentContext();
-
-protected:
-    virtual bool chooseContext( const TQGLContext* shareContext = 0 );
-    virtual void doneCurrent(); // ### 4.0: make this public - needed for multithreading stuff
-
-#if defined(TQ_WS_WIN)
-    virtual int choosePixelFormat( void* pfd, HDC pdc );
-#endif
-#if defined(TQ_WS_X11)
-    virtual void* tryVisual( const TQGLFormat& f, int bufDepth = 1 );
-    virtual void* chooseVisual();
-#endif
-#if defined(TQ_WS_MAC)
-    virtual void* chooseMacVisual(GDHandle);
-#endif
-
-    bool tqdeviceIsPixmap() const;
-    bool windowCreated() const;
-    void setWindowCreated( bool on );
-    bool initialized() const;
-    void setInitialized( bool on );
-    void generateFontDisplayLists( const TQFont & fnt, int listBase );
-
-    uint colorIndex( const TQColor& c ) const;
-    void setValid( bool valid );
-    void setDevice( TQPaintDevice *pDev );
-
-protected:
-#if  defined(TQ_WS_WIN)
-    HGLRC rc;
-    HDC dc;
-    WId	win;
-    int pixelFormatId;
-    TQGLCmap* cmap;
-#elif defined(TQ_WS_X11) || defined(TQ_WS_MAC)
-    void* vi;
-    void* cx;
-#if defined(TQ_WS_X11)
-    TQ_UINT32 gpm;
-#endif
-#endif
-    TQGLFormat glFormat;
-    TQGLFormat reqFormat;
-    static TQGLContext*	currentCtx;
-
-private:
-    void init( TQPaintDevice *dev = 0 );
-    class Private {
-    public:
-	bool valid;
-	bool sharing;
-	bool initDone;
-	bool crWin;
-	TQPaintDevice* paintDevice;
-	TQColor transpColor;
-#ifdef TQ_WS_MAC
-	TQRect oldR;
-#endif
-    };
-    Private* d;
-
-    friend class TQGLWidget;
-#ifdef TQ_WS_MAC
-    void fixBufferRect();
-#endif
-
-private:	// Disabled copy constructor and operator=
-    TQGLContext() {}
-    TQGLContext( const TQGLContext& ) {}
-    TQGLContext& operator=( const TQGLContext& ) { return *this; }
-};
-
-
-
-
-class TQM_EXPORT_OPENGL TQGLWidget : public TQWidget, public TQGL
-{
-    Q_OBJECT
-    TQ_OBJECT
-public:
-    TQGLWidget( TQWidget* parent=0, const char* name=0,
-	       const TQGLWidget* shareWidget = 0, WFlags f=0 );
-    TQGLWidget( TQGLContext *context, TQWidget* parent, const char* name=0,
-	       const TQGLWidget* shareWidget = 0, WFlags f=0 );
-    TQGLWidget( const TQGLFormat& format, TQWidget* parent=0, const char* name=0,
-	       const TQGLWidget* shareWidget = 0, WFlags f=0 );
-    ~TQGLWidget();
-
-    void qglColor( const TQColor& c ) const;
-    void qglClearColor( const TQColor& c ) const;
-
-    bool isValid() const;
-    bool isSharing() const;
-    virtual void makeCurrent();
-    void doneCurrent();
-
-    bool doubleBuffer() const;
-    virtual void swapBuffers();
-
-    TQGLFormat format() const;
-#ifndef TQ_TQDOC
-    virtual void setFormat( const TQGLFormat& format );
-#endif
-
-    const TQGLContext* context() const;
-#ifndef TQ_TQDOC
-    virtual void setContext( TQGLContext* context,
-			     const TQGLContext* shareContext = 0,
-			     bool deleteOldContext = TRUE );
-#endif
-
-    virtual TQPixmap renderPixmap( int w = 0, int h = 0,
-				  bool useContext = FALSE );
-    virtual TQImage grabFrameBuffer( bool withAlpha = FALSE );
-
-    virtual void makeOverlayCurrent();
-    const TQGLContext* overlayContext() const;
-
-    static TQImage convertToGLFormat( const TQImage& img );
-
-    void setMouseTracking( bool enable );
-    virtual void  reparent( TQWidget* parent, WFlags f, const TQPoint& p,
-			    bool showIt = FALSE );
-
-    const TQGLColormap & colormap() const;
-    void  setColormap( const TQGLColormap & map );
-
-    void renderText( int x, int y, const TQString & str,
-		     const TQFont & fnt = TQFont(), int listBase = 2000 );
-    void renderText( double x, double y, double z, const TQString & str,
-		     const TQFont & fnt = TQFont(), int listBase = 2000 );
-public Q_SLOTS:
-    virtual void updateGL();
-    virtual void updateOverlayGL();
-
-protected:
-    virtual void initializeGL();
-    virtual void resizeGL( int w, int h );
-    virtual void paintGL();
-
-    virtual void initializeOverlayGL();
-    virtual void resizeOverlayGL( int w, int h );
-    virtual void paintOverlayGL();
-
-    void setAutoBufferSwap( bool on );
-    bool autoBufferSwap() const;
-
-    void paintEvent( TQPaintEvent* );
-    void resizeEvent( TQResizeEvent* );
-
-    virtual void glInit();
-    virtual void glDraw();
-
-private:
-    int displayListBase( const TQFont & fnt, int listBase );
-    void cleanupColormaps();
-    void init( TQGLContext *context, const TQGLWidget* shareWidget );
-    bool renderCxPm( TQPixmap* pm );
-    TQGLContext* glcx;
-    bool autoSwap;
-
-    TQGLColormap cmap;
-
-#if defined(TQ_WS_WIN) || defined(TQ_WS_MAC)
-    TQGLContext* olcx;
-#elif defined(TQ_WS_X11)
-    TQGLOverlayWidget*	olw;
-    friend class TQGLOverlayWidget;
-#endif
-
-private:	// Disabled copy constructor and operator=
-#if defined(TQ_DISABLE_COPY)
-    TQGLWidget( const TQGLWidget& );
-    TQGLWidget& operator=( const TQGLWidget& );
-#endif
-
-#if defined(TQ_WS_MAC)
-private:
-    const TQGLContext *slcx;
-    uint pending_fix : 1,
-	 glcx_dblbuf : 2,
-	 dblbuf : 1,
-	 clp_serial : 15;
-    TQPixmap *gl_pix;
-    TQGLFormat req_format;
-
-    void macInternalRecreateContext( TQGLContext *ctx,
-				     const TQGLContext* = NULL,
-				     bool update = TRUE );
-    bool macInternalDoubleBuffer( bool fix = TRUE );
-    virtual void setRegionDirty( bool );
-    virtual void macWidgetChangedWindow();
-#endif
-private Q_SLOTS:
-    void macInternalFixBufferRect();
-};
-
-
-//
-// TQGLFormat inline functions
-//
-
-inline bool TQGLFormat::doubleBuffer() const
-{
-    return testOption( DoubleBuffer );
-}
-
-inline bool TQGLFormat::depth() const
-{
-    return testOption( DepthBuffer );
-}
-
-inline bool TQGLFormat::rgba() const
-{
-    return testOption( Rgba );
-}
-
-inline bool TQGLFormat::alpha() const
-{
-    return testOption( AlphaChannel );
-}
-
-inline bool TQGLFormat::accum() const
-{
-    return testOption( AccumBuffer );
-}
-
-inline bool TQGLFormat::stencil() const
-{
-    return testOption( StencilBuffer );
-}
-
-inline bool TQGLFormat::stereo() const
-{
-    return testOption( StereoBuffers );
-}
-
-inline bool TQGLFormat::directRendering() const
-{
-    return testOption( DirectRendering );
-}
-
-inline bool TQGLFormat::hasOverlay() const
-{
-    return testOption( HasOverlay );
-}
-
-//
-// TQGLContext inline functions
-//
-
-inline bool TQGLContext::isValid() const
-{
-    return d->valid;
-}
-
-inline void TQGLContext::setValid( bool valid )
-{
-    d->valid = valid;
-}
-
-inline bool TQGLContext::isSharing() const
-{
-    return d->sharing;
-}
-
-inline TQGLFormat TQGLContext::format() const
-{
-    return glFormat;
-}
-
-inline TQGLFormat TQGLContext::requestedFormat() const
-{
-    return reqFormat;
-}
-
-inline TQPaintDevice* TQGLContext::tqdevice() const
-{
-    return d->paintDevice;
-}
-
-inline bool TQGLContext::tqdeviceIsPixmap() const
-{
-    return d->paintDevice->devType() == TQInternal::Pixmap;
-}
-
-
-inline bool TQGLContext::windowCreated() const
-{
-    return d->crWin;
-}
-
-
-inline void TQGLContext::setWindowCreated( bool on )
-{
-    d->crWin = on;
-}
-
-inline bool TQGLContext::initialized() const
-{
-    return d->initDone;
-}
-
-inline void TQGLContext::setInitialized( bool on )
-{
-    d->initDone = on;
-}
-
-inline const TQGLContext* TQGLContext::currentContext()
-{
-    return currentCtx;
-}
-
-//
-// TQGLWidget inline functions
-//
-
-inline TQGLFormat TQGLWidget::format() const
-{
-    return glcx->format();
-}
-
-inline const TQGLContext *TQGLWidget::context() const
-{
-    return glcx;
-}
-
-inline bool TQGLWidget::doubleBuffer() const
-{
-    return glcx->format().doubleBuffer();
-}
-
-inline void TQGLWidget::setAutoBufferSwap( bool on )
-{
-    autoSwap = on;
-}
-
-inline bool TQGLWidget::autoBufferSwap() const
-{
-    return autoSwap;
-}
-
-#endif
diff --git a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp b/tqtinterface/qt4/src/opengl/tqgl_x11.cpp
deleted file mode 100644
index bc6bc0e..0000000
--- a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp
+++ /dev/null
@@ -1,1425 +0,0 @@
-/****************************************************************************
-**
-** Implementation of OpenGL classes for TQt
-**
-** Created : 970112
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the opengl module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#include "tqgl.h"
-
-#if defined(TQ_WS_X11)
-
-#include "tqmap.h"
-#include "tqpixmap.h"
-#include "tqapplication.h"
-
-#include "tqintdict.h"
-#include "private/tqfontengine_p.h"
-
-#define INT8  dummy_INT8
-#define INT32 dummy_INT32
-#include <GL/glx.h>
-#undef  INT8
-#undef  INT32
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xos.h>
-#include <X11/Xatom.h>
-
-// POSIX Large File Support redefines truncate -> truncate64
-#if defined(truncate)
-# undef truncate
-#endif
-
-#ifndef TQT_DLOPEN_OPENGL
-extern "C" {
-    Status XmuLookupStandardColormap( Display *dpy, int screen, VisualID visualid,
-				      unsigned int depth, Atom property,
-				      Bool replace, Bool retain );
-}
-#endif
-
-#include "tqgl_x11_p.h"
-#ifdef TQT_DLOPEN_OPENGL
-#include "tqlibrary.h"
-
-extern "C" {
-_glCallLists qt_glCallLists;
-_glClearColor qt_glClearColor;
-_glClearIndex qt_glClearIndex;
-_glColor3ub qt_glColor3ub;
-_glDeleteLists qt_glDeleteLists;
-_glDrawBuffer qt_glDrawBuffer;
-_glFlush qt_glFlush;
-_glIndexi qt_glIndexi;
-_glListBase qt_glListBase;
-_glLoadIdentity qt_glLoadIdentity;
-_glMatrixMode qt_glMatrixMode;
-_glOrtho qt_glOrtho;
-_glPopAttrib qt_glPopAttrib;
-_glPopMatrix qt_glPopMatrix;
-_glPushAttrib qt_glPushAttrib;
-_glPushMatrix qt_glPushMatrix;
-_glRasterPos2i qt_glRasterPos2i;
-_glRasterPos3d qt_glRasterPos3d;
-_glReadPixels qt_glReadPixels;
-_glViewport qt_glViewport;
-_glPixelStorei qt_glPixelStorei;
-_glBitmap qt_glBitmap;
-_glDrawPixels qt_glDrawPixels;
-_glNewList qt_glNewList;
-_glGetFloatv qt_glGetFloatv;
-_glGetIntegerv qt_glGetIntegerv;
-_glEndList qt_glEndList;
-
-_glXChooseVisual qt_glXChooseVisual;
-_glXCreateContext qt_glXCreateContext;
-_glXCreateGLXPixmap qt_glXCreateGLXPixmap;
-_glXDestroyContext qt_glXDestroyContext;
-_glXDestroyGLXPixmap qt_glXDestroyGLXPixmap;
-_glXGetClientString qt_glXGetClientString;
-_glXGetConfig qt_glXGetConfig;
-_glXIsDirect qt_glXIsDirect;
-_glXMakeCurrent qt_glXMakeCurrent;
-_glXQueryExtension qt_glXQueryExtension;
-_glXQueryExtensionsString qt_glXQueryExtensionsString;
-_glXQueryServerString qt_glXQueryServerString;
-_glXSwapBuffers qt_glXSwapBuffers;
-_glXUseXFont qt_glXUseXFont;
-_glXWaitX qt_glXWaitX;
-};
-
-bool qt_resolve_gl_symbols(bool fatal)
-{
-    static bool gl_syms_resolved = FALSE;
-    if (gl_syms_resolved)
-	return TRUE;
-
-    TQLibrary gl("GL.so.1");
-    gl.setAutoUnload(FALSE);
-
-    qt_glCallLists = (_glCallLists) gl.resolve("glCallLists");
-
-    if (!qt_glCallLists) { // if this fails the rest will surely fail
-	if (fatal)
-	    qFatal("Unable to resolve GL/GLX symbols - please check your GL library installation.");
-	return FALSE;
-    }
-
-    qt_glClearColor = (_glClearColor) gl.resolve("glClearColor");
-    qt_glClearIndex = (_glClearIndex) gl.resolve("glClearIndex");
-    qt_glColor3ub = (_glColor3ub) gl.resolve("glColor3ub");
-    qt_glDeleteLists = (_glDeleteLists) gl.resolve("glDeleteLists");
-    qt_glDrawBuffer = (_glDrawBuffer) gl.resolve("glDrawBuffer");
-    qt_glFlush = (_glFlush) gl.resolve("glFlush");
-    qt_glIndexi = (_glIndexi) gl.resolve("glIndexi");
-    qt_glListBase = (_glListBase) gl.resolve("glListBase");
-    qt_glLoadIdentity = (_glLoadIdentity) gl.resolve("glLoadIdentity");
-    qt_glMatrixMode = (_glMatrixMode) gl.resolve("glMatrixMode");
-    qt_glOrtho = (_glOrtho) gl.resolve("glOrtho");
-    qt_glPopAttrib = (_glPopAttrib) gl.resolve("glPopAttrib");
-    qt_glPopMatrix = (_glPopMatrix) gl.resolve("glPopMatrix");
-    qt_glPushAttrib = (_glPushAttrib) gl.resolve("glPushAttrib");
-    qt_glPushMatrix = (_glPushMatrix) gl.resolve("glPushMatrix");
-    qt_glRasterPos2i = (_glRasterPos2i) gl.resolve("glRasterPos2i");
-    qt_glRasterPos3d = (_glRasterPos3d) gl.resolve("glRasterPos3d");
-    qt_glReadPixels = (_glReadPixels) gl.resolve("glReadPixels");
-    qt_glViewport = (_glViewport) gl.resolve("glViewport");
-    qt_glPixelStorei = (_glPixelStorei) gl.resolve("glPixelStorei");
-    qt_glBitmap = (_glBitmap) gl.resolve("glBitmap");
-    qt_glDrawPixels = (_glDrawPixels) gl.resolve("glDrawPixels");
-    qt_glNewList = (_glNewList) gl.resolve("glNewList");
-    qt_glGetFloatv = (_glGetFloatv) gl.resolve("glGetFloatv");
-    qt_glGetIntegerv = (_glGetIntegerv) gl.resolve("glGetIntegerv");
-    qt_glEndList = (_glEndList) gl.resolve("glEndList");
-
-    qt_glXChooseVisual = (_glXChooseVisual) gl.resolve("glXChooseVisual");
-    qt_glXCreateContext = (_glXCreateContext) gl.resolve("glXCreateContext");
-    qt_glXCreateGLXPixmap = (_glXCreateGLXPixmap) gl.resolve("glXCreateGLXPixmap");
-    qt_glXDestroyContext = (_glXDestroyContext) gl.resolve("glXDestroyContext");
-    qt_glXDestroyGLXPixmap = (_glXDestroyGLXPixmap) gl.resolve("glXDestroyGLXPixmap");
-    qt_glXGetClientString = (_glXGetClientString) gl.resolve("glXGetClientString");
-    qt_glXGetConfig = (_glXGetConfig) gl.resolve("glXGetConfig");
-    qt_glXIsDirect = (_glXIsDirect) gl.resolve("glXIsDirect");
-    qt_glXMakeCurrent = (_glXMakeCurrent) gl.resolve("glXMakeCurrent");
-    qt_glXQueryExtension = (_glXQueryExtension) gl.resolve("glXQueryExtension");
-    qt_glXQueryExtensionsString = (_glXQueryExtensionsString) gl.resolve("glXQueryExtensionsString");
-    qt_glXQueryServerString = (_glXQueryServerString) gl.resolve("glXQueryServerString");
-    qt_glXSwapBuffers = (_glXSwapBuffers) gl.resolve("glXSwapBuffers");
-    qt_glXUseXFont = (_glXUseXFont) gl.resolve("glXUseXFont");
-    qt_glXWaitX = (_glXWaitX) gl.resolve("glXWaitX");
-    gl_syms_resolved = TRUE;
-    return TRUE;
-}
-#endif // TQT_DLOPEN_OPENGL
-
-
-/*
-  The choose_cmap function is internal and used by TQGLWidget::setContext()
-  and GLX (not Windows).  If the application can't find any sharable
-  colormaps, it must at least create as few colormaps as possible.  The
-  dictionary solution below ensures only one colormap is created per visual.
-  Colormaps are also deleted when the application terminates.
-*/
-
-struct CMapEntry {
-    CMapEntry();
-   ~CMapEntry();
-    Colormap		cmap;
-    bool		alloc;
-    XStandardColormap	scmap;
-};
-
-CMapEntry::CMapEntry()
-{
-    cmap = 0;
-    alloc = FALSE;
-    scmap.colormap = 0;
-}
-
-CMapEntry::~CMapEntry()
-{
-    if ( alloc )
-	XFreeColormap( TQPaintDevice::x11AppDisplay(), cmap );
-}
-
-static TQIntDict<CMapEntry> *cmap_dict = 0;
-static bool		    mesa_gl   = FALSE;
-static TQIntDict< TQMap<int, TQRgb> > *qglcmap_dict = 0;
-
-static void cleanup_cmaps()
-{
-    if (cmap_dict) {
-	cmap_dict->setAutoDelete(TRUE);
-	delete cmap_dict;
-	cmap_dict = 0;
-    }
-    if (qglcmap_dict) {
-	qglcmap_dict->setAutoDelete(TRUE);
-	delete qglcmap_dict;
-	qglcmap_dict = 0;
-    }
-}
-
-static Colormap choose_cmap( Display *dpy, XVisualInfo *vi )
-{
-    if ( !cmap_dict ) {
-	cmap_dict = new TQIntDict<CMapEntry>;
-	const char *v = glXQueryServerString( dpy, vi->screen, GLX_VERSION );
-	if ( v )
-	    mesa_gl = strstr(v,"Mesa") != 0;
-	qAddPostRoutine( cleanup_cmaps );
-    }
-
-    CMapEntry *x = cmap_dict->find( (long) vi->visualid + ( vi->screen * 256 ) );
-    if ( x )					// found colormap for visual
-	return x->cmap;
-
-    x = new CMapEntry();
-
-    XStandardColormap *c;
-    int n, i;
-
-    // qDebug( "Choosing cmap for vID %0x", vi->visualid );
-
-    if ( vi->visualid ==
-	 XVisualIDFromVisual( (Visual*)TQPaintDevice::x11AppVisual( vi->screen ) ) ) {
-	// qDebug( "Using x11AppColormap" );
-	return TQPaintDevice::x11AppColormap( vi->screen );
-    }
-
-    if ( mesa_gl ) {				// we're using MesaGL
-	Atom hp_cmaps = XInternAtom( dpy, "_HP_RGB_SMOOTH_MAP_LIST", TRUE );
-	if ( hp_cmaps && vi->visual->c_class == TrueColor && vi->depth == 8 ) {
-	    if ( XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
-				  hp_cmaps) ) {
-		i = 0;
-		while ( i < n && x->cmap == 0 ) {
-		    if ( c[i].visualid == vi->visual->visualid ) {
-			x->cmap = c[i].colormap;
-			x->scmap = c[i];
-			//qDebug( "Using HP_RGB scmap" );
-
-		    }
-		    i++;
-		}
-		XFree( (char *)c );
-	    }
-	}
-    }
-#if !defined(TQ_OS_SOLARIS)
-    if ( !x->cmap ) {
-#ifdef TQT_DLOPEN_OPENGL
-	typedef Status (*_XmuLookupStandardColormap)( Display *dpy, int screen, VisualID visualid, unsigned int depth,
-						      Atom property, Bool replace, Bool retain );
-	_XmuLookupStandardColormap qt_XmuLookupStandardColormap;
-	qt_XmuLookupStandardColormap = (_XmuLookupStandardColormap) TQLibrary::resolve("Xmu.so.6", "XmuLookupStandardColormap");
-	if (!qt_XmuLookupStandardColormap)
-	    qFatal("Unable to resolve Xmu symbols - please check your Xmu library installation.");
-#define XmuLookupStandardColormap qt_XmuLookupStandardColormap
-
-#endif
-
-	if ( XmuLookupStandardColormap(dpy,vi->screen,vi->visualid,vi->depth,
-					  XA_RGB_DEFAULT_MAP,FALSE,TRUE) ) {
-	    if ( XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,
-				  XA_RGB_DEFAULT_MAP) ) {
-		i = 0;
-		while ( i < n && x->cmap == 0 ) {
-		    if ( c[i].visualid == vi->visualid ) {
-			x->cmap = c[i].colormap;
-			x->scmap = c[i];
-			//qDebug( "Using RGB_DEFAULT scmap" );
-		    }
-		    i++;
-		}
-		XFree( (char *)c );
-	    }
-	}
-    }
-#endif
-    if ( !x->cmap ) {				// no shared cmap found
-	x->cmap = XCreateColormap( dpy, RootWindow(dpy,vi->screen), vi->visual,
-				   AllocNone );
-	x->alloc = TRUE;
-	// qDebug( "Allocating cmap" );
-    }
-
-    // associate cmap with visualid
-    cmap_dict->insert( (long) vi->visualid + ( vi->screen * 256 ), x );
-    return x->cmap;
-}
-
-struct TransColor
-{
-    VisualID	vis;
-    int		screen;
-    long	color;
-};
-
-static TQMemArray<TransColor> trans_colors;
-static int trans_colors_init = FALSE;
-
-
-static void find_trans_colors()
-{
-    struct OverlayProp {
-	long  visual;
-	long  type;
-	long  value;
-	long  layer;
-    };
-
-    trans_colors_init = TRUE;
-
-    Display* appDisplay = TQPaintDevice::x11AppDisplay();
-
-    int scr;
-    int lastsize = 0;
-    for ( scr = 0; scr < ScreenCount( appDisplay ); scr++ ) {
-	TQWidget* rootWin = TQT_TQWIDGET(TQApplication::desktop()->screen( scr ));
-	if ( !rootWin )
-	    return;					// Should not happen
-	Atom overlayVisualsAtom = XInternAtom( appDisplay,
-					       "SERVER_OVERLAY_VISUALS", True );
-	if ( overlayVisualsAtom == None )
-	    return;					// Server has no overlays
-
-	Atom actualType;
-	int actualFormat;
-	ulong nItems;
-	ulong bytesAfter;
-	OverlayProp* overlayProps = 0;
-	int res = XGetWindowProperty( appDisplay, rootWin->winId(),
-				      overlayVisualsAtom, 0, 10000, False,
-				      overlayVisualsAtom, &actualType,
-				      &actualFormat, &nItems, &bytesAfter,
-				      (uchar**)&overlayProps );
-
-	if ( res != Success || actualType != overlayVisualsAtom
-	     || actualFormat != 32 || nItems < 4 || !overlayProps )
-	    return;					// Error reading property
-
-	int numProps = nItems / 4;
-	trans_colors.resize( lastsize + numProps );
-	int j = lastsize;
-	for ( int i = 0; i < numProps; i++ ) {
-	    if ( overlayProps[i].type == 1 ) {
-		trans_colors[j].vis = (VisualID)overlayProps[i].visual;
-		trans_colors[j].screen = scr;
-		trans_colors[j].color = (int)overlayProps[i].value;
-		j++;
-	    }
-	}
-	XFree( overlayProps );
-	lastsize = j;
-	trans_colors.truncate( lastsize );
-    }
-}
-
-
-/*****************************************************************************
-  TQGLFormat UNIX/GLX-specific code
- *****************************************************************************/
-
-bool TQGLFormat::hasOpenGL()
-{
-    if (!qt_resolve_gl_symbols(FALSE))
-	return FALSE;
-    return glXQueryExtension(qt_xdisplay(),0,0) != 0;
-}
-
-
-bool TQGLFormat::hasOpenGLOverlays()
-{
-    qt_resolve_gl_symbols();
-    if ( !trans_colors_init )
-	find_trans_colors();
-    return trans_colors.size() > 0;
-}
-
-
-
-/*****************************************************************************
-  TQGLContext UNIX/GLX-specific code
- *****************************************************************************/
-
-bool TQGLContext::chooseContext( const TQGLContext* shareContext )
-{
-    Display* disp = d->paintDevice->x11Display();
-    vi = chooseVisual();
-    if ( !vi )
-	return FALSE;
-
-    if ( tqdeviceIsPixmap() &&
-	 (((XVisualInfo*)vi)->depth != d->paintDevice->x11Depth() ||
-	  ((XVisualInfo*)vi)->screen != d->paintDevice->x11Screen()) )
-    {
-	XFree( vi );
-	XVisualInfo appVisInfo;
-	memset( &appVisInfo, 0, sizeof(XVisualInfo) );
-	appVisInfo.visualid = XVisualIDFromVisual( (Visual*)d->paintDevice->x11Visual() );
-	appVisInfo.screen = d->paintDevice->x11Screen();
-	int nvis;
-	vi = XGetVisualInfo( disp, VisualIDMask | VisualScreenMask, &appVisInfo, &nvis );
-	if ( !vi )
-	    return FALSE;
-
-	int useGL;
-	glXGetConfig( disp, (XVisualInfo*)vi, GLX_USE_GL, &useGL );
-	if ( !useGL )
-	    return FALSE;	//# Chickening out already...
-    }
-    int res;
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_LEVEL, &res );
-    glFormat.setPlane( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_DOUBLEBUFFER, &res );
-    glFormat.setDoubleBuffer( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_DEPTH_SIZE, &res );
-    glFormat.setDepth( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_RGBA, &res );
-    glFormat.setRgba( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_ALPHA_SIZE, &res );
-    glFormat.setAlpha( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_ACCUM_RED_SIZE, &res );
-    glFormat.setAccum( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_STENCIL_SIZE, &res );
-    glFormat.setStencil( res );
-    glXGetConfig( disp, (XVisualInfo*)vi, GLX_STEREO, &res );
-    glFormat.setStereo( res );
-
-    Bool direct = format().directRendering() ? True : False;
-
-    if ( shareContext &&
-	 ( !shareContext->isValid() || !shareContext->cx ) ) {
-#if defined(TQT_CHECK_NULL)
-	    qWarning("TQGLContext::chooseContext(): Cannot share with invalid context");
-#endif
-	    shareContext = 0;
-    }
-
-    // 1. Sharing between rgba and color-index will give wrong colors.
-    // 2. Contexts cannot be shared btw. direct/non-direct renderers.
-    // 3. Pixmaps cannot share contexts that are set up for direct rendering.
-    if ( shareContext && (format().rgba() != shareContext->format().rgba() ||
-			  (tqdeviceIsPixmap() &&
-			   glXIsDirect( disp, (GLXContext)shareContext->cx ))))
-	shareContext = 0;
-
-    cx = 0;
-    if ( shareContext ) {
-	cx = glXCreateContext( disp, (XVisualInfo *)vi,
-			       (GLXContext)shareContext->cx, direct );
-	if ( cx )
-	    d->sharing = TRUE;
-    }
-    if ( !cx )
-	cx = glXCreateContext( disp, (XVisualInfo *)vi, None, direct );
-    if ( !cx )
-	return FALSE;
-    glFormat.setDirectRendering( glXIsDirect( disp, (GLXContext)cx ) );
-    if ( tqdeviceIsPixmap() ) {
-#if defined(GLX_MESA_pixmap_colormap) && defined(TQGL_USE_MESA_EXT)
-	gpm = glXCreateGLXPixmapMESA( disp, (XVisualInfo *)vi,
-				      d->paintDevice->handle(),
-				      choose_cmap( disp, (XVisualInfo *)vi ) );
-#else
-	gpm = (TQ_UINT32)glXCreateGLXPixmap( disp, (XVisualInfo *)vi,
-					    d->paintDevice->handle() );
-#endif
-	if ( !gpm )
-	    return FALSE;
-    }
-    return TRUE;
-}
-
-
-/*!
-  <strong>X11 only</strong>: 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()
-*/
-
-void *TQGLContext::chooseVisual()
-{
-    static 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;
-    TQGLFormat fmt = format();
-    bool tryDouble = !fmt.doubleBuffer();  // Some GL impl's only have double
-    bool triedDouble = FALSE;
-    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 ( 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;
-    }
-    glFormat = fmt;
-    return vis;
-}
-
-
-/*!
-
-  \internal
-
-  <strong>X11 only</strong>: 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()
-*/
-
-void *TQGLContext::tryVisual( const TQGLFormat& f, int bufDepth )
-{
-    int spec[40];
-    int i = 0;
-    spec[i++] = GLX_LEVEL;
-    spec[i++] = f.plane();
-
-#if defined(GLX_VERSION_1_1) && defined(GLX_EXT_visual_info)
-    static bool useTranspExt = FALSE;
-    static bool useTranspExtChecked = FALSE;
-    if ( f.plane() && !useTranspExtChecked && d->paintDevice ) {
-	TQCString estr( glXQueryExtensionsString( d->paintDevice->x11Display(),
-						 d->paintDevice->x11Screen() ) );
-	useTranspExt = estr.contains( "GLX_EXT_visual_info" );
-	//# (A bit simplistic; that could theoretically be a substring)
-	if ( useTranspExt ) {
-	    TQCString cstr( glXGetClientString( d->paintDevice->x11Display(),
-					       GLX_VENDOR ) );
-	    useTranspExt = !cstr.contains( "Xi Graphics" ); // bug workaround
-	    if ( useTranspExt ) {
-		// bug workaround - some systems (eg. FireGL) refuses to return an overlay
-		// visual if the GLX_TRANSPARENT_TYPE_EXT attribute is specfied, even if
-		// the implementation supports transparent overlays
-		int tmpSpec[] = { GLX_LEVEL, f.plane(), GLX_TRANSPARENT_TYPE_EXT,
-				  f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT,
-				  None };
-		XVisualInfo * vinf = glXChooseVisual( d->paintDevice->x11Display(),
-						      d->paintDevice->x11Screen(), tmpSpec );
-		if ( !vinf ) {
-		    useTranspExt = FALSE;
-		}
-	    }
-	}
-
-	useTranspExtChecked = TRUE;
-    }
-    if ( f.plane() && useTranspExt ) {
-	// Required to avoid non-transparent overlay visual(!) on some systems
-	spec[i++] = GLX_TRANSPARENT_TYPE_EXT;
-	spec[i++] = f.rgba() ? GLX_TRANSPARENT_RGB_EXT : GLX_TRANSPARENT_INDEX_EXT;
-    }
-#endif
-
-    if ( f.doubleBuffer() )
-	spec[i++] = GLX_DOUBLEBUFFER;
-    if ( f.depth() ) {
-	spec[i++] = GLX_DEPTH_SIZE;
-	spec[i++] = 1;
-    }
-    if ( f.stereo() ) {
-	spec[i++] = GLX_STEREO;
-    }
-    if ( f.stencil() ) {
-	spec[i++] = GLX_STENCIL_SIZE;
-	spec[i++] = 1;
-    }
-    if ( f.rgba() ) {
-	spec[i++] = GLX_RGBA;
-	spec[i++] = GLX_RED_SIZE;
-	spec[i++] = 1;
-	spec[i++] = GLX_GREEN_SIZE;
-	spec[i++] = 1;
-	spec[i++] = GLX_BLUE_SIZE;
-	spec[i++] = 1;
-	if ( f.alpha() ) {
-	    spec[i++] = GLX_ALPHA_SIZE;
-	    spec[i++] = 1;
-	}
-	if ( f.accum() ) {
-	    spec[i++] = GLX_ACCUM_RED_SIZE;
-	    spec[i++] = 1;
-	    spec[i++] = GLX_ACCUM_GREEN_SIZE;
-	    spec[i++] = 1;
-	    spec[i++] = GLX_ACCUM_BLUE_SIZE;
-	    spec[i++] = 1;
-	    if ( f.alpha() ) {
-		spec[i++] = GLX_ACCUM_ALPHA_SIZE;
-		spec[i++] = 1;
-	    }
-	}
-    }
-    else {
-	spec[i++] = GLX_BUFFER_SIZE;
-	spec[i++] = bufDepth;
-    }
-
-    spec[i] = None;
-    return glXChooseVisual( d->paintDevice->x11Display(),
-			    d->paintDevice->x11Screen(), spec );
-}
-
-
-void TQGLContext::reset()
-{
-    if ( !d->valid )
-	return;
-    doneCurrent();
-    if ( gpm )
-	glXDestroyGLXPixmap( d->paintDevice->x11Display(), (GLXPixmap)gpm );
-    gpm = 0;
-    glXDestroyContext( d->paintDevice->x11Display(), (GLXContext)cx );
-    if ( vi )
-	XFree( vi );
-    vi = 0;
-    cx = 0;
-    d->crWin = FALSE;
-    d->sharing = FALSE;
-    d->valid = FALSE;
-    d->transpColor = TQColor();
-    d->initDone = FALSE;
-}
-
-
-void TQGLContext::makeCurrent()
-{
-    if ( !d->valid ) {
-#if defined(TQT_CHECK_STATE)
-	qWarning("TQGLContext::makeCurrent(): Cannot make invalid context current.");
-#endif
-	return;
-    }
-    bool ok = TRUE;
-    if ( tqdeviceIsPixmap() )
-	ok = glXMakeCurrent( d->paintDevice->x11Display(),
-			     (GLXPixmap)gpm,
-			     (GLXContext)cx );
-
-    else
-	ok = glXMakeCurrent( d->paintDevice->x11Display(),
-			     ((TQWidget *)d->paintDevice)->winId(),
-			     (GLXContext)cx );
-#if defined(TQT_CHECK_NULL)
-    //    qDebug("makeCurrent: %i, vi=%i, vi->vi=%i, vi->id=%i", (int)this, (int)vi, (int)((XVisualInfo*)vi)->visual, (int)((XVisualInfo*)vi)->visualid );
-    if ( !ok )
-	qWarning("TQGLContext::makeCurrent(): Failed.");
-#endif
-    if ( ok )
-	currentCtx = this;
-}
-
-void TQGLContext::doneCurrent()
-{
-    glXMakeCurrent( d->paintDevice->x11Display(), 0, 0 );
-    currentCtx = 0;
-}
-
-
-void TQGLContext::swapBuffers() const
-{
-    if ( !d->valid )
-	return;
-    if ( !tqdeviceIsPixmap() )
-	glXSwapBuffers( d->paintDevice->x11Display(),
-			((TQWidget *)d->paintDevice)->winId() );
-}
-
-TQColor TQGLContext::overlayTransparentColor() const
-{
-    //### make more efficient using the transpColor member
-    if ( isValid() ) {
-	if ( !trans_colors_init )
-	    find_trans_colors();
-
-	VisualID myVisualId = ((XVisualInfo*)vi)->visualid;
-	int myScreen = ((XVisualInfo*)vi)->screen;
-	for ( int i = 0; i < (int)trans_colors.size(); i++ ) {
-	    if ( trans_colors[i].vis == myVisualId &&
-		 trans_colors[i].screen == myScreen ) {
-		XColor col;
-		col.pixel = trans_colors[i].color;
-		col.red = col.green = col.blue = 0;
-		col.flags = 0;
-		Display *dpy = d->paintDevice->x11Display();
-		if (col.pixel > (uint) ((XVisualInfo *)vi)->colormap_size - 1)
-		    col.pixel = ((XVisualInfo *)vi)->colormap_size - 1;
-		XQueryColor(dpy, choose_cmap(dpy, (XVisualInfo *) vi), &col);
-		uchar r = (uchar)((col.red / 65535.0) * 255.0 + 0.5);
-		uchar g = (uchar)((col.green / 65535.0) * 255.0 + 0.5);
-		uchar b = (uchar)((col.blue / 65535.0) * 255.0 + 0.5);
-		return TQColor(tqRgb(r,g,b), trans_colors[i].color);
-	    }
-	}
-    }
-    return TQColor();		// Invalid color
-}
-
-
-uint TQGLContext::colorIndex( const TQColor& c ) const
-{
-    int screen = ((XVisualInfo *)vi)->screen;
-    if ( isValid() ) {
-	if ( format().plane()
-	     && c.pixel( screen ) == overlayTransparentColor().pixel( screen ) )
-	    return c.pixel( screen );		// Special; don't look-up
-	if ( ((XVisualInfo*)vi)->visualid ==
-	     XVisualIDFromVisual( (Visual*)TQPaintDevice::x11AppVisual( screen ) ) )
-	    return c.pixel( screen );		// We're using TQColor's cmap
-
-	XVisualInfo *info = (XVisualInfo *) vi;
-	CMapEntry *x = cmap_dict->find( (long) info->visualid + ( info->screen * 256 ) );
-	if ( x && !x->alloc) {		// It's a standard colormap
-	    int rf = (int)(((float)c.red() * (x->scmap.red_max+1))/256.0);
-	    int gf = (int)(((float)c.green() * (x->scmap.green_max+1))/256.0);
-	    int bf = (int)(((float)c.blue() * (x->scmap.blue_max+1))/256.0);
-	    uint p = x->scmap.base_pixel
-		     + ( rf * x->scmap.red_mult )
-		     + ( gf * x->scmap.green_mult )
-		     + ( bf * x->scmap.blue_mult );
-	    return p;
-	} else {
-	    if (!qglcmap_dict) {
-		qglcmap_dict = new TQIntDict< TQMap<int, TQRgb> >;
-	    }
-	    TQMap<int, TQRgb> *cmap;
-	    if ((cmap = qglcmap_dict->find((long) info->visualid)) == 0) {
-		cmap = new TQMap<int, TQRgb>;
-		qglcmap_dict->insert((long) info->visualid, cmap);
-	    }
-
-	    // already in the map?
-	    TQRgb target = c.rgb();
-	    TQMap<int, TQRgb>::Iterator it = cmap->begin();
-	    for (; it != cmap->end(); ++it) {
-		if ((*it) == target)
-		    return it.key();
-	    }
-
-	    // need to alloc color
-	    unsigned long plane_mask[2];
-	    unsigned long color_map_entry;
-	    if (!XAllocColorCells (TQPaintDevice::x11AppDisplay(), x->cmap, TRUE, plane_mask, 0,
-				   &color_map_entry, 1))
-		return c.pixel(screen);
-
-	    XColor col;
-	    col.flags = DoRed | DoGreen | DoBlue;
-	    col.pixel = color_map_entry;
-	    col.red   = (ushort)((tqRed(c.rgb()) / 255.0) * 65535.0 + 0.5);
-	    col.green = (ushort)((tqGreen(c.rgb()) / 255.0) * 65535.0 + 0.5);
-	    col.blue  = (ushort)((tqBlue(c.rgb()) / 255.0) * 65535.0 + 0.5);
-	    XStoreColor(TQPaintDevice::x11AppDisplay(), x->cmap, &col);
-
-	    cmap->insert(color_map_entry, target);
-	    return color_map_entry;
-	}
-    }
-    return 0;
-}
-
-#ifdef USE_QT4
-// [FIXME] Implement this or switch to Qt4's OpenGL classes (preferred)
-void TQGLContext::generateFontDisplayLists( const TQFont & fnt, int listBase )
-{
-	printf("[FIXME] void TQGLContext::generateFontDisplayLists( const TQFont & fnt, int listBase ) unimplemented\n\r");
-}
-#else // USE_QT4
-#ifndef TQT_NO_XFTFREETYPE
-/*! \internal
-    This is basically a substitute for glxUseXFont() which can only
-    handle XLFD fonts. This version relies on XFT v2 to render the
-    glyphs, but it works with all fonts that XFT2 provides - both
-    antialiased and aliased bitmap and outline fonts.
-*/
-void qgl_use_font(TQFontEngineXft *engine, int first, int count, int listBase)
-{
-    GLfloat color[4];
-    glGetFloatv(GL_CURRENT_COLOR, color);
-
-    // save the pixel unpack state
-    GLint gl_swapbytes, gl_lsbfirst, gl_rowlength, gl_skiprows, gl_skippixels, gl_tqalignment;
-    glGetIntegerv (GL_UNPACK_SWAP_BYTES, &gl_swapbytes);
-    glGetIntegerv (GL_UNPACK_LSB_FIRST, &gl_lsbfirst);
-    glGetIntegerv (GL_UNPACK_ROW_LENGTH, &gl_rowlength);
-    glGetIntegerv (GL_UNPACK_SKIP_ROWS, &gl_skiprows);
-    glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &gl_skippixels);
-    glGetIntegerv (GL_UNPACK_ALIGNMENT, &gl_tqalignment);
-
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE);
-    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    Bool antialiased = False;
-#if 0 // disable antialias support for now
-    XftPatternGetBool(engine->pattern(), XFT_ANTIALIAS, 0, &antialiased);
-#endif
-#ifdef TQT_XFT2
-    FT_Face face = XftLockFace(engine->font());
-#else
-    FT_Face face = engine->face();
-#endif
-    // start generating font glyphs
-    for (int i = first; i < count; ++i) {
-	int list = listBase + i;
-	GLfloat x0, y0, dx, dy;
-
-	FT_Error err;
-
-	err = FT_Load_Glyph(face, FT_Get_Char_Index(face, i), FT_LOAD_DEFAULT);
-	if (err) {
-	    qDebug("failed loading glyph %d from font", i);
-	    TQ_ASSERT(!err);
-	}
-	err = FT_Render_Glyph(face->glyph, (antialiased ? ft_render_mode_normal
-					    : ft_render_mode_mono));
-	if (err) {
-	    qDebug("failed rendering glyph %d from font", i);
-	    TQ_ASSERT(!err);
-	}
-
-	FT_Bitmap bm = face->glyph->bitmap;
-	x0 = face->glyph->metrics.horiBearingX >> 6;
-	y0 = (face->glyph->metrics.height - face->glyph->metrics.horiBearingY) >> 6;
-	dx = face->glyph->metrics.horiAdvance >> 6;
-	dy = 0;
- 	int sz = bm.pitch * bm.rows;
-	uint *aa_glyph = 0;
-	uchar *ua_glyph = 0;
-
-	if (antialiased)
-	    aa_glyph = new uint[sz];
-	else
-	    ua_glyph = new uchar[sz];
-
-	// convert to GL format
-	for (int y = 0; y < bm.rows; ++y) {
-	    for (int x = 0; x < bm.pitch; ++x) {
-		int c1 = y*bm.pitch + x;
-		int c2 = (bm.rows - y - 1) > 0 ? (bm.rows-y-1)*bm.pitch + x : x;
-		if (antialiased) {
-		    aa_glyph[c1] = (int(color[0]*255) << 24)
-					 | (int(color[1]*255) << 16)
-					 | (int(color[2]*255) << 8) | bm.buffer[c2];
-		} else {
-		    ua_glyph[c1] = bm.buffer[c2];
-		}
-	    }
-	}
-
-	glNewList(list, GL_COMPILE);
-	if (antialiased) {
-	    // calling glBitmap() is just a trick to move the current
-	    // raster pos, since glGet*() won't work in display lists
-	    glBitmap(0, 0, 0, 0, x0, -y0, 0);
-	    glDrawPixels(bm.pitch, bm.rows, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, aa_glyph);
-	    glBitmap(0, 0, 0, 0, dx-x0, y0, 0);
-	} else {
-	    glBitmap(bm.pitch*8, bm.rows, -x0, y0, dx, dy, ua_glyph);
-	}
-	glEndList();
-	antialiased ? delete[] aa_glyph : delete[] ua_glyph;
-    }
-
-#ifdef TQT_XFT2
-    XftUnlockFace(engine->font());
-#endif
-
-    // restore pixel unpack settings
-    glPixelStorei(GL_UNPACK_SWAP_BYTES, gl_swapbytes);
-    glPixelStorei(GL_UNPACK_LSB_FIRST, gl_lsbfirst);
-    glPixelStorei(GL_UNPACK_ROW_LENGTH, gl_rowlength);
-    glPixelStorei(GL_UNPACK_SKIP_ROWS, gl_skiprows);
-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, gl_skippixels);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, gl_tqalignment);
-}
-#endif
-
-void TQGLContext::generateFontDisplayLists( const TQFont & fnt, int listBase )
-{
-    TQFont f(fnt);
-    TQFontEngine *engine = f.d->engineForScript(TQFont::Latin);
-
-#ifndef TQT_NO_XFTFREETYPE
-    if(engine->type() == TQFontEngine::Xft) {
-	qgl_use_font((TQFontEngineXft *) engine, 0, 256, listBase);
-	return;
-    }
-#endif
-    // glXUseXFont() only works with XLFD font structures and a few GL
-    // drivers crash if 0 is passed as the font handle
-    f.setStyleStrategy(TQFont::OpenGLCompatible);
-    if (f.handle() && (engine->type() == TQFontEngine::XLFD
-		       || engine->type() == TQFontEngine::LatinXLFD)) {
- 	glXUseXFont((Font) f.handle(), 0, 256, listBase);
-    }
-}
-
-#endif // USE_QT4
-
-/*****************************************************************************
-  TQGLOverlayWidget (Internal overlay class for X11)
- *****************************************************************************/
-
-class TQGLOverlayWidget : public TQGLWidget
-{
-    TQ_OBJECT
-public:
-    TQGLOverlayWidget( const TQGLFormat& format, TQGLWidget* parent,
-		      const char* name=0, const TQGLWidget* shareWidget=0 );
-
-protected:
-    void		initializeGL();
-    void		paintGL();
-    void		resizeGL( int w, int h );
-
-private:
-    TQGLWidget*		realWidget;
-
-private:	// Disabled copy constructor and operator=
-#if defined(TQ_DISABLE_COPY)
-    TQGLOverlayWidget( const TQGLOverlayWidget& );
-    TQGLOverlayWidget&	operator=( const TQGLOverlayWidget& );
-#endif
-};
-
-
-TQGLOverlayWidget::TQGLOverlayWidget( const TQGLFormat& format, TQGLWidget* parent,
-				    const char* name,
-				    const TQGLWidget* shareWidget )
-    : TQGLWidget( format, parent, name, shareWidget ? shareWidget->olw : 0 )
-{
-    realWidget = parent;
-}
-
-
-
-void TQGLOverlayWidget::initializeGL()
-{
-    TQColor transparentColor = context()->overlayTransparentColor();
-    if ( transparentColor.isValid() )
-	qglClearColor( transparentColor );
-    else
-	qWarning( "TQGLOverlayWidget::initializeGL(): Could not get transparent color" );
-    realWidget->initializeOverlayGL();
-}
-
-
-void TQGLOverlayWidget::resizeGL( int w, int h )
-{
-    glViewport( 0, 0, w, h );
-    realWidget->resizeOverlayGL( w, h );
-}
-
-
-void TQGLOverlayWidget::paintGL()
-{
-    realWidget->paintOverlayGL();
-}
-
-#undef Bool
-#include "tqgl_x11.tqmoc"
-
-/*****************************************************************************
-  TQGLWidget UNIX/GLX-specific code
- *****************************************************************************/
-void TQGLWidget::init( TQGLContext *context, const TQGLWidget *shareWidget )
-{
-    qt_resolve_gl_symbols();
-
-    glcx = 0;
-    olw = 0;
-    autoSwap = TRUE;
-    if ( !context->tqdevice() )
-	context->setDevice( TQT_TQPAINTDEVICE(this) );
-
-    if ( shareWidget )
-	setContext( context, shareWidget->context() );
-    else
-	setContext( context );
-    setBackgroundMode( TQt::NoBackground );
-
-    if ( isValid() && context->format().hasOverlay() ) {
-	TQCString olwName( name() );
-	olwName += "-TQGL_internal_overlay_widget";
-	olw = new TQGLOverlayWidget( TQGLFormat::defaultOverlayFormat(),
-				    this, olwName, shareWidget );
-	if ( olw->isValid() ) {
-	    olw->setAutoBufferSwap( FALSE );
-	    olw->setFocusProxy( this );
-	}
-	else {
-	    delete olw;
-	    olw = 0;
-	    glcx->glFormat.setOverlay( FALSE );
-	}
-    }
-}
-
-/*! \reimp */
-void TQGLWidget::reparent( TQWidget* parent, WFlags f, const TQPoint& p,
-			  bool showIt )
-{
-    if (glcx)
-        glcx->doneCurrent();
-    TQWidget::reparent( parent, f, p, FALSE );
-    if ( showIt )
-	show();
-}
-
-
-void TQGLWidget::setMouseTracking( bool enable )
-{
-    if ( olw )
-	olw->setMouseTracking( enable );
-    TQWidget::setMouseTracking( enable );
-}
-
-
-void TQGLWidget::resizeEvent( TQResizeEvent * )
-{
-    if ( !isValid() )
-	return;
-    makeCurrent();
-    if ( !glcx->initialized() )
-	glInit();
-    glXWaitX();
-    resizeGL( width(), height() );
-    if ( olw )
-	olw->setGeometry( rect() );
-}
-
-const TQGLContext* TQGLWidget::overlayContext() const
-{
-    if ( olw )
-	return olw->context();
-    else
-	return 0;
-}
-
-
-void TQGLWidget::makeOverlayCurrent()
-{
-    if ( olw )
-	olw->makeCurrent();
-}
-
-
-void TQGLWidget::updateOverlayGL()
-{
-    if ( olw )
-	olw->updateGL();
-}
-
-void TQGLWidget::setContext( TQGLContext *context,
-			    const TQGLContext* shareContext,
-			    bool deleteOldContext )
-{
-    if ( context == 0 ) {
-#if defined(TQT_CHECK_NULL)
-	qWarning( "TQGLWidget::setContext: Cannot set null context" );
-#endif
-	return;
-    }
-    if ( !context->tqdeviceIsPixmap() && context->tqdevice() != TQT_TQPAINTDEVICE(this) ) {
-#if defined(TQT_CHECK_STATE)
-	qWarning( "TQGLWidget::setContext: Context must refer to this widget" );
-#endif
-	return;
-    }
-
-    if ( glcx )
-	glcx->doneCurrent();
-    TQGLContext* oldcx = glcx;
-    glcx = context;
-
-    bool createFailed = FALSE;
-    if ( !glcx->isValid() ) {
-	if ( !glcx->create( shareContext ? shareContext : oldcx ) )
-	    createFailed = TRUE;
-    }
-    if ( createFailed ) {
-	if ( deleteOldContext )
-	    delete oldcx;
-	return;
-    }
-
-    if ( glcx->windowCreated() || glcx->tqdeviceIsPixmap() ) {
-	if ( deleteOldContext )
-	    delete oldcx;
-	return;
-    }
-
-    bool visible = isVisible();
-    if ( visible )
-	hide();
-
-    XVisualInfo *vi = (XVisualInfo*)glcx->vi;
-    XSetWindowAttributes a;
-
-    a.colormap = choose_cmap( x11Display(), vi );	// find best colormap
-    a.background_pixel = backgroundColor().pixel( vi->screen );
-    a.border_pixel = TQt::black.pixel( vi->screen );
-    Window p = RootWindow( x11Display(), vi->screen );
-    if ( parentWidget() )
-	p = parentWidget()->winId();
-
-    Window w = XCreateWindow( x11Display(), p,  x(), y(), width(), height(),
-			      0, vi->depth, InputOutput,  vi->visual,
-			      CWBackPixel|CWBorderPixel|CWColormap, &a );
-
-    Window *cmw;
-    Window *cmwret;
-    int count;
-    if ( XGetWMColormapWindows( x11Display(), tqtopLevelWidget()->winId(),
-				&cmwret, &count ) ) {
-	cmw = new Window[count+1];
-	memcpy( (char *)cmw, (char *)cmwret, sizeof(Window)*count );
-	XFree( (char *)cmwret );
-	int i;
-	for ( i=0; i<count; i++ ) {
-	    if ( cmw[i] == winId() ) {		// replace old window
-		cmw[i] = w;
-		break;
-	    }
-	}
-	if ( i >= count )			// append new window
-	    cmw[count++] = w;
-    } else {
-	count = 1;
-	cmw = new Window[count];
-	cmw[0] = w;
-    }
-
-#if defined(GLX_MESA_release_buffers) && defined(TQGL_USE_MESA_EXT)
-    if ( oldcx && oldcx->windowCreated() )
-	glXReleaseBuffersMESA( x11Display(), winId() );
-#endif
-    if ( deleteOldContext )
-	delete oldcx;
-    oldcx = 0;
-
-    create( w );
-
-    XSetWMColormapWindows( x11Display(), tqtopLevelWidget()->winId(), cmw,
-			   count );
-    delete [] cmw;
-
-    if ( visible )
-	show();
-    XFlush( x11Display() );
-    glcx->setWindowCreated( TRUE );
-}
-
-
-bool TQGLWidget::renderCxPm( TQPixmap* pm )
-{
-    if ( ((XVisualInfo*)glcx->vi)->depth != pm->depth() )
-	return FALSE;
-
-    GLXPixmap glPm;
-#if defined(GLX_MESA_pixmap_colormap) && defined(TQGL_USE_MESA_EXT)
-    glPm = glXCreateGLXPixmapMESA( x11Display(),
-				   (XVisualInfo*)glcx->vi,
-				   (Pixmap)pm->handle(),
-				   choose_cmap( pm->x11Display(),
-						(XVisualInfo*)glcx->vi ) );
-#else
-    glPm = (TQ_UINT32)glXCreateGLXPixmap( x11Display(),
-					 (XVisualInfo*)glcx->vi,
-					 (Pixmap)pm->handle() );
-#endif
-
-    if ( !glXMakeCurrent( x11Display(), glPm, (GLXContext)glcx->cx ) ) {
-	glXDestroyGLXPixmap( x11Display(), glPm );
-	return FALSE;
-    }
-
-    glDrawBuffer( GL_FRONT );
-    if ( !glcx->initialized() )
-	glInit();
-    resizeGL( pm->width(), pm->height() );
-    paintGL();
-    glFlush();
-    makeCurrent();
-    glXDestroyGLXPixmap( x11Display(), glPm );
-    resizeGL( width(), height() );
-    return TRUE;
-}
-
-const TQGLColormap & TQGLWidget::colormap() const
-{
-    return cmap;
-}
-
-/*\internal
-  Store color values in the given colormap.
-*/
-static void qStoreColors( TQWidget * tlw, Colormap cmap,
-			  const TQGLColormap & cols )
-{
-    XColor c;
-    TQRgb color;
-
-    for ( int i = 0; i < cols.size(); i++ ) {
-	color = cols.entryRgb( i );
-	c.pixel = i;
-	c.red   = (ushort)( (tqRed( color ) / 255.0) * 65535.0 + 0.5 );
-	c.green = (ushort)( (tqGreen( color ) / 255.0) * 65535.0 + 0.5 );
-	c.blue  = (ushort)( (tqBlue( color ) / 255.0) * 65535.0 + 0.5 );
-	c.flags = DoRed | DoGreen | DoBlue;
-	XStoreColor( tlw->x11Display(), cmap, &c );
-    }
-}
-
-#ifdef USE_QT4
-/*\internal
-  Check whether the given visual supports dynamic colormaps or not.
-*/
-static bool qCanAllocColors( TQWidget * w )
-{
-    return false;
-}
-#else // USE_QT4
-/*\internal
-  Check whether the given visual supports dynamic colormaps or not.
-*/
-static bool qCanAllocColors( TQWidget * w )
-{
-    bool validVisual = FALSE;
-    int  numVisuals;
-    long mask;
-    XVisualInfo templ;
-    XVisualInfo * visuals;
-    VisualID id = XVisualIDFromVisual( (Visual *)
-				       w->tqtopLevelWidget()->x11Visual() );
-
-    mask = VisualScreenMask;
-    templ.screen = w->x11Screen();
-    visuals = XGetVisualInfo( w->x11Display(), mask, &templ, &numVisuals );
-
-    for ( int i = 0; i < numVisuals; i++ ) {
-	if ( visuals[i].visualid == id ) {
-	    switch ( visuals[i].c_class ) {
-		case TrueColor:
-		case StaticColor:
-		case StaticGray:
-		case GrayScale:
-		    validVisual = FALSE;
-		    break;
-		case DirectColor:
-		case PseudoColor:
-		    validVisual = TRUE;
-		    break;
-	    }
-	    break;
-	}
-    }
-    XFree( visuals );
-
-    if ( !validVisual )
-	return FALSE;
-    return TRUE;
-}
-
-void TQGLWidget::setColormap( const TQGLColormap & c )
-{
-    TQWidget * tlw = tqtopLevelWidget(); // must return a valid widget
-
-    cmap = c;
-    if ( !cmap.d )
-	return;
-
-    if ( !cmap.d->cmapHandle && !qCanAllocColors( this ) ) {
-	qWarning( "TQGLWidget::setColormap: Cannot create a read/write "
-		  "colormap for this visual" );
-	return;
-    }
-
-    // If the child GL widget is not of the same visual class as the
-    // toplevel widget we will get in trouble..
-    Window wid = tlw->winId();
-    Visual * vis = (Visual *) tlw->x11Visual();;
-    VisualID cvId = XVisualIDFromVisual( (Visual *) x11Visual() );
-    VisualID tvId = XVisualIDFromVisual( (Visual *) tlw->x11Visual() );
-    if ( cvId != tvId ) {
-	wid = winId();
-	vis = (Visual *) x11Visual();
-    }
-
-    if ( !cmap.d->cmapHandle ) // allocate a cmap if necessary
-	cmap.d->cmapHandle = XCreateColormap( x11Display(), wid, vis,
-					      AllocAll );
-
-    qStoreColors( this, (Colormap) cmap.d->cmapHandle, c );
-    XSetWindowColormap( x11Display(), wid, (Colormap) cmap.d->cmapHandle );
-
-    // tell the wm that this window has a special colormap
-    Window * cmw;
-    Window * cmwret;
-    int count;
-    if ( XGetWMColormapWindows( x11Display(), tlw->winId(), &cmwret,
-				&count ) )
-    {
-	cmw = new Window[count+1];
-	memcpy( (char *) cmw, (char *) cmwret, sizeof(Window) * count );
-	XFree( (char *) cmwret );
-	int i;
-	for ( i = 0; i < count; i++ ) {
-	    if ( cmw[i] == winId() ) {
-		break;
-	    }
-	}
-	if ( i >= count )   // append new window only if not in the list
-	    cmw[count++] = winId();
-    } else {
-	count = 1;
-	cmw = new Window[count];
-	cmw[0] = winId();
-    }
-    XSetWMColormapWindows( x11Display(), tlw->winId(), cmw, count );
-    delete [] cmw;
-}
-#endif // USE_QT4
-
-/*! \internal
-  Free up any allocated colormaps. This fn is only called for
-  top-level widgets.
-*/
-void TQGLWidget::cleanupColormaps()
-{
-    if ( !cmap.d )
-	return;
-
-    if ( cmap.d->cmapHandle ) {
-	XFreeColormap( tqtopLevelWidget()->x11Display(),
-		       (Colormap) cmap.d->cmapHandle );
-	cmap.d->cmapHandle = 0;
-    }
-}
-
-void TQGLWidget::macInternalFixBufferRect()
-{
-}
-
-#endif
diff --git a/tqtinterface/qt4/src/opengl/tqgl_x11_p.h b/tqtinterface/qt4/src/opengl/tqgl_x11_p.h
deleted file mode 100644
index dfb8acd..0000000
--- a/tqtinterface/qt4/src/opengl/tqgl_x11_p.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/****************************************************************************
-**
-** Definitions needed for resolving GL/GLX symbols using dlopen()
-** under X11.
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the OpenGL module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** Licensees holding valid TQt Commercial licenses may use this file in
-** accordance with the TQt Commercial License Agreement provided with
-** the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#ifndef TQGL_P_H
-#define TQGL_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the TQt API.  This header file may
-// change from version to version without notice, or even be
-// removed.
-//
-// We mean it.
-//
-//
-
-#ifdef TQT_DLOPEN_OPENGL
-// resolve the GL symbols we use ourselves
-bool qt_resolve_gl_symbols(bool = TRUE);
-extern "C" {
-// GL symbols
-typedef void (*_glCallLists)( GLsizei n, GLenum type, const GLvoid *lists );
-typedef void (*_glClearColor)( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
-typedef void (*_glClearIndex)( GLfloat c );
-typedef void (*_glColor3ub)( GLubyte red, GLubyte green, GLubyte blue );
-typedef void (*_glDeleteLists)( GLuint list, GLsizei range );
-typedef void (*_glDrawBuffer)( GLenum mode );
-typedef void (*_glFlush)( void );
-typedef void (*_glIndexi)( GLint c );
-typedef void (*_glListBase)( GLuint base );
-typedef void (*_glLoadIdentity)( void );
-typedef void (*_glMatrixMode)( GLenum mode );
-typedef void (*_glOrtho)( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val );
-typedef void (*_glPopAttrib)( void );
-typedef void (*_glPopMatrix)( void );
-typedef void (*_glPushAttrib)( GLbitfield mask );
-typedef void (*_glPushMatrix)( void );
-typedef void (*_glRasterPos2i)( GLint x, GLint y );
-typedef void (*_glRasterPos3d)( GLdouble x, GLdouble y, GLdouble z );
-typedef void (*_glReadPixels)( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels );
-typedef void (*_glViewport)( GLint x, GLint y, GLsizei width, GLsizei height );
-typedef void (*_glPixelStorei)( GLenum pname, GLint param );
-typedef void (*_glBitmap)( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
-			   const GLubyte *bitmap );
-typedef void (*_glDrawPixels)( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels );
-typedef void (*_glNewList)( GLuint list, GLenum mode );
-typedef void (*_glGetFloatv)( GLenum pname, GLfloat *params );
-typedef void (*_glGetIntegerv)( GLenum pname, GLint *params );
-typedef void (*_glEndList)( void );
-
-
-// GLX symbols - should be in the GL lib as well
-typedef XVisualInfo* (*_glXChooseVisual)(Display *dpy, int screen, int *attribList);
-typedef GLXContext (*_glXCreateContext)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
-typedef GLXPixmap (*_glXCreateGLXPixmap)(Display *dpy, XVisualInfo *vis, Pixmap pixmap);
-typedef void (*_glXDestroyContext)(Display *dpy, GLXContext ctx);
-typedef void (*_glXDestroyGLXPixmap)(Display *dpy, GLXPixmap pix);
-typedef const char* (*_glXGetClientString)(Display *dpy, int name );
-typedef int (*_glXGetConfig)(Display *dpy, XVisualInfo *vis, int attrib, int *value);
-typedef Bool (*_glXIsDirect)(Display *dpy, GLXContext ctx);
-typedef Bool (*_glXMakeCurrent)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
-typedef Bool (*_glXQueryExtension)(Display *dpy, int *errorBase, int *eventBase);
-typedef const char* (*_glXQueryExtensionsString)(Display *dpy, int screen);
-typedef const char* (*_glXQueryServerString)(Display *dpy, int screen, int name);
-typedef void (*_glXSwapBuffers)(Display *dpy, GLXDrawable drawable);
-typedef void (*_glXUseXFont)(Font font, int first, int count, int listBase);
-typedef void (*_glXWaitX)(void);
-
-extern _glCallLists qt_glCallLists;
-extern _glClearColor qt_glClearColor;
-extern _glClearIndex qt_glClearIndex;
-extern _glColor3ub qt_glColor3ub;
-extern _glDeleteLists qt_glDeleteLists;
-extern _glDrawBuffer qt_glDrawBuffer;
-extern _glFlush qt_glFlush;
-extern _glIndexi qt_glIndexi;
-extern _glListBase qt_glListBase;
-extern _glLoadIdentity qt_glLoadIdentity;
-extern _glMatrixMode qt_glMatrixMode;
-extern _glOrtho qt_glOrtho;
-extern _glPopAttrib qt_glPopAttrib;
-extern _glPopMatrix qt_glPopMatrix;
-extern _glPushAttrib qt_glPushAttrib;
-extern _glPushMatrix qt_glPushMatrix;
-extern _glRasterPos2i qt_glRasterPos2i;
-extern _glRasterPos3d qt_glRasterPos3d;
-extern _glReadPixels qt_glReadPixels;
-extern _glViewport qt_glViewport;
-extern _glPixelStorei qt_glPixelStorei;
-extern _glBitmap qt_glBitmap;
-extern _glDrawPixels qt_glDrawPixels;
-extern _glNewList qt_glNewList;
-extern _glGetFloatv qt_glGetFloatv;
-extern _glGetIntegerv qt_glGetIntegerv;
-extern _glEndList qt_glEndList;
-
-extern _glXChooseVisual qt_glXChooseVisual;
-extern _glXCreateContext qt_glXCreateContext;
-extern _glXCreateGLXPixmap qt_glXCreateGLXPixmap;
-extern _glXDestroyContext qt_glXDestroyContext;
-extern _glXDestroyGLXPixmap qt_glXDestroyGLXPixmap;
-extern _glXGetClientString qt_glXGetClientString;
-extern _glXGetConfig qt_glXGetConfig;
-extern _glXIsDirect qt_glXIsDirect;
-extern _glXMakeCurrent qt_glXMakeCurrent;
-extern _glXQueryExtension qt_glXQueryExtension;
-extern _glXQueryExtensionsString qt_glXQueryExtensionsString;
-extern _glXQueryServerString qt_glXQueryServerString;
-extern _glXSwapBuffers qt_glXSwapBuffers;
-extern _glXUseXFont qt_glXUseXFont;
-extern _glXWaitX qt_glXWaitX;
-}; // extern "C"
-
-#define glCallLists qt_glCallLists
-#define glClearColor qt_glClearColor
-#define glClearIndex qt_glClearIndex
-#define glColor3ub qt_glColor3ub
-#define glDeleteLists qt_glDeleteLists
-#define glDrawBuffer qt_glDrawBuffer
-#define glFlush qt_glFlush
-#define glIndexi qt_glIndexi
-#define glListBase qt_glListBase
-#define glLoadIdentity qt_glLoadIdentity
-#define glMatrixMode qt_glMatrixMode
-#define glOrtho qt_glOrtho
-#define glPopAttrib qt_glPopAttrib
-#define glPopMatrix qt_glPopMatrix
-#define glPushAttrib qt_glPushAttrib
-#define glPushMatrix qt_glPushMatrix
-#define glRasterPos2i qt_glRasterPos2i
-#define glRasterPos3d qt_glRasterPos3d
-#define glReadPixels qt_glReadPixels
-#define glViewport qt_glViewport
-#define glPixelStorei qt_glPixelStorei
-#define glBitmap qt_glBitmap
-#define glDrawPixels qt_glDrawPixels
-#define glNewList qt_glNewList
-#define glGetFloatv qt_glGetFloatv
-#define glGetIntegerv qt_glGetIntegerv
-#define glEndList qt_glEndList
-
-#define glXChooseVisual qt_glXChooseVisual
-#define glXCreateContext qt_glXCreateContext
-#define glXCreateGLXPixmap qt_glXCreateGLXPixmap
-#define glXDestroyContext qt_glXDestroyContext
-#define glXDestroyGLXPixmap qt_glXDestroyGLXPixmap
-#define glXGetClientString qt_glXGetClientString
-#define glXGetConfig qt_glXGetConfig
-#define glXIsDirect qt_glXIsDirect
-#define glXMakeCurrent qt_glXMakeCurrent
-#define glXQueryExtension qt_glXQueryExtension
-#define glXQueryExtensionsString qt_glXQueryExtensionsString
-#define glXQueryServerString qt_glXQueryServerString
-#define glXSwapBuffers qt_glXSwapBuffers
-#define glXUseXFont qt_glXUseXFont
-#define glXWaitX qt_glXWaitX
-
-#else
-inline bool qt_resolve_gl_symbols(bool = TRUE) { return TRUE; }
-#endif // TQT_DLOPEN_OPENGL
-#endif // TQGL_P_H
diff --git a/tqtinterface/qt4/src/opengl/tqglcolormap.cpp b/tqtinterface/qt4/src/opengl/tqglcolormap.cpp
deleted file mode 100644
index 3afdb7c..0000000
--- a/tqtinterface/qt4/src/opengl/tqglcolormap.cpp
+++ /dev/null
@@ -1,292 +0,0 @@
-/****************************************************************************
-**
-** Implementation of TQGLColormap class
-**
-** Created : 20010326
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the opengl module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-/*!
-    \class TQGLColormap tqglcolormap.h
-    \brief The TQGLColormap class is used for installing custom colormaps into
-    TQGLWidgets.
-\if defined(commercial)
-    It is part of the <a href="commercialeditions.html">TQt Enterprise Edition</a>.
-\endif
-
-    \module OpenGL
-    \ingroup graphics
-    \ingroup images
-
-    TQGLColormap provides a platform independent way of specifying and
-    installing indexed colormaps into TQGLWidgets. TQGLColormap is
-    especially useful when using the \link opengl.html OpenGL\endlink
-    color-index mode.
-
-    Under X11 you must use an X server that supports either a \c
-    PseudoColor or \c DirectColor visual class. If your X server
-    currently only provides a \c GrayScale, \c TrueColor, \c
-    StaticColor or \c StaticGray visual, you will not be able to
-    allocate colorcells for writing. If this is the case, try setting
-    your X server to 8 bit mode. It should then provide you with at
-    least a \c PseudoColor visual. Note that you may experience
-    colormap flashing if your X server is running in 8 bit mode.
-
-    Under Windows the size of the colormap is always set to 256
-    colors. Note that under Windows you can also install colormaps
-    in child widgets.
-
-    This class uses explicit sharing (see \link shclass.html Shared
-    Classes\endlink).
-
-    Example of use:
-    \code
-    #include <tqapplication.h>
-    #include <tqglcolormap.h>
-
-    int main()
-    {
-	TQApplication a( argc, argv );
-
-	MySuperGLWidget widget( 0 ); // A TQGLWidget in color-index mode
-	TQGLColormap colormap;
-
-	// This will fill the colormap with colors ranging from
-	// black to white.
-	for ( int i = 0; i < colormap.size(); i++ )
-	    colormap.setEntry( i, tqRgb( i, i, i ) );
-
-	widget.setColormap( colormap );
-	widget.show();
-	return a.exec();
-    }
-    \endcode
-
-    \sa TQGLWidget::setColormap(), TQGLWidget::colormap()
-*/
-
-#include "tqglcolormap.h"
-#include "tqmemarray.h"
-
-
-/*!
-    Construct a TQGLColormap.
-*/
-TQGLColormap::TQGLColormap()
-{
-    d = 0;
-}
-
-
-/*!
-    Construct a shallow copy of \a map.
-*/
-TQGLColormap::TQGLColormap( const TQGLColormap & map )
-{
-    d = map.d;
-    if ( d )
-	d->ref();
-}
-
-/*!
-    Dereferences the TQGLColormap and deletes it if this was the last
-    reference to it.
-*/
-TQGLColormap::~TQGLColormap()
-{
-    if ( d && d->deref() ) {
-	delete d;
-	d = 0;
-    }
-}
-
-/*!
-    Assign a shallow copy of \a map to this TQGLColormap.
-*/
-TQGLColormap & TQGLColormap::operator=( const TQGLColormap & map )
-{
-    if ( map.d != 0 )
-	map.d->ref();
-
-    if ( d && d->deref() )
-	delete d;
-    d = map.d;
-
-    return *this;
-}
-
-/*!
-    Detaches this TQGLColormap from the shared block.
-*/
-void TQGLColormap::detach()
-{
-    if ( d && d->count != 1 ) {
-	// ### What about the actual colormap handle?
-	Private * newd = new Private();
-	newd->cells = d->cells;
-	newd->cells.detach();
-	if ( d->deref() )
-	    delete d;
-	d = newd;
-    }
-}
-
-/*!
-    Set cell at index \a idx in the colormap to color \a color.
-*/
-void TQGLColormap::setEntry( int idx, TQRgb color )
-{
-    if ( !d )
-	d = new Private();
-
-#if defined(TQT_CHECK_RANGE)
-    if ( idx < 0 || idx > (int) d->cells.size() ) {
-	qWarning( "TQGLColormap::setRgb: Index out of range." );
-	return;
-    }
-#endif
-    d->cells[ idx ] = color;
-}
-
-/*!
-    Set an array of cells in this colormap. \a count is the number of
-    colors that should be set, \a colors is the array of colors, and
-    \a base is the starting index.
-*/
-void TQGLColormap::setEntries( int count, const TQRgb * colors, int base )
-{
-    if ( !d )
-	d = new Private();
-
-    if ( !colors || base < 0 || base >= (int) d->cells.size() )
-	return;
-
-    for( int i = base; i < base + count; i++ ) {
-	if ( i < (int) d->cells.size() )
-	    setEntry( i, colors[i] );
-	else
-	    break;
-    }
-}
-
-/*!
-    Returns the TQRgb value in the colorcell with index \a idx.
-*/
-TQRgb TQGLColormap::entryRgb( int idx ) const
-{
-    if ( !d || idx < 0 || idx > (int) d->cells.size() )
-	return 0;
-    else
-	return d->cells[ idx ];
-}
-
-/*!
-    \overload
-
-    Set the cell with index \a idx in the colormap to color \a color.
-*/
-void TQGLColormap::setEntry( int idx, const TQColor & color )
-{
-    setEntry( idx, color.rgb() );
-}
-
-/*!
-    Returns the TQRgb value in the colorcell with index \a idx.
-*/
-TQColor TQGLColormap::entryColor( int idx ) const
-{
-    if ( !d || idx < 0 || idx > (int) d->cells.size() )
-	return TQColor();
-    else
-	return TQColor( d->cells[ idx ] );
-}
-
-/*!
-    Returns TRUE if the colormap is empty; otherwise returns FALSE. A
-    colormap with no color values set is considered to be empty.
-*/
-bool TQGLColormap::isEmpty() const
-{
-    return (d == 0) || (d->cells.size() == 0)  || (d->cmapHandle == 0);
-}
-
-
-/*!
-    Returns the number of colorcells in the colormap.
-*/
-int TQGLColormap::size() const
-{
-    return d != 0 ? d->cells.size() : 0;
-}
-
-/*!
-    Returns the index of the color \a color. If \a color is not in the
-    map, -1 is returned.
-*/
-int TQGLColormap::find( TQRgb color ) const
-{
-    if ( d )
-	return d->cells.find( color );
-    return -1;
-}
-
-/*!
-    Returns the index of the color that is the closest match to color
-    \a color.
-*/
-int TQGLColormap::findNearest( TQRgb color ) const
-{
-    int idx = find( color );
-    if ( idx >= 0 )
-	return idx;
-    int mapSize = size();
-    int mindist = 200000;
-    int r = tqRed( color );
-    int g = tqGreen( color );
-    int b = tqBlue( color );
-    int rx, gx, bx, dist;
-    for ( int i=0; i < mapSize; i++ ) {
-	TQRgb ci = d->cells[i];
-	rx = r - tqRed( ci );
-	gx = g - tqGreen( ci );
-	bx = b - tqBlue( ci );
-	dist = rx*rx + gx*gx + bx*bx;	// calculate distance
-	if ( dist < mindist ) {		// minimal?
-	    mindist = dist;
-	    idx = i;
-	}
-    }
-    return idx;
-}
diff --git a/tqtinterface/qt4/src/opengl/tqglcolormap.h b/tqtinterface/qt4/src/opengl/tqglcolormap.h
deleted file mode 100644
index 2019496..0000000
--- a/tqtinterface/qt4/src/opengl/tqglcolormap.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/****************************************************************************
-**
-** Definition of TQGLColormap class
-**
-** Created : 20010326
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the opengl module of the TQt GUI Toolkit.
-**
-** This file may be used under the terms of the GNU General
-** Public License versions 2.0 or 3.0 as published by the Free
-** Software Foundation and appearing in the files LICENSE.GPL2
-** and LICENSE.GPL3 included in the packaging of this file.
-** Alternatively you may (at your option) use any later version
-** of the GNU General Public License if such license has been
-** publicly approved by Trolltech ASA (or its successors, if any)
-** and the KDE Free TQt Foundation.
-**
-** Please review the following information to ensure GNU General
-** Public Licensing requirements will be met:
-** http://trolltech.com/products/qt/licenses/licensing/opensource/.
-** If you are unsure which license is appropriate for your use, please
-** review the following information:
-** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
-** or contact the sales department at sales@trolltech.com.
-**
-** This file may be used under the terms of the Q Public License as
-** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** Commercial License Agreement provided with the Software.
-**
-** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
-** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
-** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
-** herein.
-**
-**********************************************************************/
-
-#ifndef TQGLCOLORMAP_H
-#define TQGLCOLORMAP_H
-
-#ifndef TQT_H
-#include "tqcolor.h"
-#include "tqmemarray.h"
-#include "tqshared.h"
-#endif // TQT_H
-
-#if !defined( TQT_MODULE_OPENGL ) || defined( TQT_LICENSE_PROFESSIONAL )
-#define TQM_EXPORT_OPENGL
-#else
-#define TQM_EXPORT_OPENGL TQ_EXPORT
-#endif
-
-class TQWidget;
-class TQM_EXPORT_OPENGL TQGLColormap
-{
-public:
-    TQGLColormap();
-    TQGLColormap( const TQGLColormap & );
-    ~TQGLColormap();
-    
-    TQGLColormap &operator=( const TQGLColormap & );
-    
-    bool   isEmpty() const;
-    int    size() const;
-    void   detach();
-
-    void   setEntries( int count, const TQRgb * colors, int base = 0 );
-    void   setEntry( int idx, TQRgb color );
-    void   setEntry( int idx, const TQColor & color );
-    TQRgb   entryRgb( int idx ) const;
-    TQColor entryColor( int idx ) const;
-    int    find( TQRgb color ) const;
-    int    findNearest( TQRgb color ) const;
-    
-private:
-    class Private : public TQShared
-    {
-    public:
-	Private() {
-	    cells.resize( 256 ); // ### hardcoded to 256 entries for now
-	    cmapHandle = 0;
-	}
-
-	~Private() {
-	}
-
-	TQMemArray<TQRgb> cells;
-	TQt::HANDLE      cmapHandle;
-    };
-    
-    Private * d;
-
-    friend class TQGLWidget;
-};
-
-#endif