Add Qt3 development HEAD version

1 files changed, 541 insertions, 0 deletions

diff --git a/src/opengl/qgl.h b/src/opengl/qgl.h
new file mode 100644
index 0000000..55fa07e
--- /dev/null
+++ b/src/opengl/qgl.h
@@ -0,0 +1,541 @@
+/****************************************************************************
+**
+** Definition of OpenGL classes for Qt
+**
+** Created : 970112
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the opengl module of the Qt 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 Qt 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 [email protected].
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** 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 QGL_H
+#define QGL_H
+
+#ifndef QT_H
+#include "qwidget.h"
+#include "qglcolormap.h"
+#endif // QT_H
+
+#if !defined( QT_MODULE_OPENGL ) || defined( QT_LICENSE_PROFESSIONAL )
+#define QM_EXPORT_OPENGL
+#else
+#define QM_EXPORT_OPENGL Q_EXPORT
+#endif
+
+#ifndef QT_NO_COMPAT
+#define QGL_VERSION	450
+#define QGL_VERSION_STR	"4.5"
+QM_EXPORT_OPENGL inline const char *qGLVersion() {
+    qObsolete( 0, "qGLVersion", "qVersion" );
+    return QGL_VERSION_STR;
+}
+#endif
+
+#if defined(Q_WS_WIN)
+# include "qt_windows.h"
+#endif
+
+#if defined(Q_WS_MAC)
+#if !defined( QMAC_OPENGL_DOUBLEBUFFER )
+/* This macro is different now. If the macro is not defined QGLWidget 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 QT_MACOSX_VERSION >= 0x1020
+# define QMAC_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(Q_WS_WIN) || defined(Q_WS_MAC)
+class QGLCmap;
+#endif
+
+class QPixmap;
+#if defined(Q_WS_X11)
+class QGLOverlayWidget;
+#endif
+
+// Namespace class:
+class QM_EXPORT_OPENGL QGL
+{
+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 QM_EXPORT_OPENGL QGLFormat : public QGL
+{
+public:
+    QGLFormat();
+    QGLFormat( 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 QGLFormat defaultFormat();
+    static void setDefaultFormat( const QGLFormat& f );
+
+    static QGLFormat defaultOverlayFormat();
+    static void setDefaultOverlayFormat( const QGLFormat& f );
+
+    static bool hasOpenGL();
+    static bool hasOpenGLOverlays();
+
+    friend QM_EXPORT_OPENGL bool operator==( const QGLFormat&,
+					     const QGLFormat& );
+    friend QM_EXPORT_OPENGL bool operator!=( const QGLFormat&,
+					     const QGLFormat& );
+private:
+    uint opts;
+    int pln;
+};
+
+
+QM_EXPORT_OPENGL bool operator==( const QGLFormat&, const QGLFormat& );
+QM_EXPORT_OPENGL bool operator!=( const QGLFormat&, const QGLFormat& );
+
+class QM_EXPORT_OPENGL QGLContext : public QGL
+{
+public:
+    QGLContext( const QGLFormat& format, QPaintDevice* device );
+    QGLContext( const QGLFormat& format );
+    virtual ~QGLContext();
+
+    virtual bool create( const QGLContext* shareContext = 0 );
+    bool isValid() const;
+    bool isSharing() const;
+    virtual void reset();
+
+    QGLFormat format() const;
+    QGLFormat requestedFormat() const;
+    virtual void setFormat( const QGLFormat& format );
+
+    virtual void makeCurrent();
+    virtual void swapBuffers() const;
+
+    QPaintDevice* device() const;
+
+    QColor overlayTransparentColor() const;
+
+    static const QGLContext* currentContext();
+
+protected:
+    virtual bool chooseContext( const QGLContext* shareContext = 0 );
+    virtual void doneCurrent(); // ### 4.0: make this public - needed for multithreading stuff
+
+#if defined(Q_WS_WIN)
+    virtual int choosePixelFormat( void* pfd, HDC pdc );
+#endif
+#if defined(Q_WS_X11)
+    virtual void* tryVisual( const QGLFormat& f, int bufDepth = 1 );
+    virtual void* chooseVisual();
+#endif
+#if defined(Q_WS_MAC)
+    virtual void* chooseMacVisual(GDHandle);
+#endif
+
+    bool deviceIsPixmap() const;
+    bool windowCreated() const;
+    void setWindowCreated( bool on );
+    bool initialized() const;
+    void setInitialized( bool on );
+    void generateFontDisplayLists( const QFont & fnt, int listBase );
+
+    uint colorIndex( const QColor& c ) const;
+    void setValid( bool valid );
+    void setDevice( QPaintDevice *pDev );
+
+protected:
+#if  defined(Q_WS_WIN)
+    HGLRC rc;
+    HDC dc;
+    WId	win;
+    int pixelFormatId;
+    QGLCmap* cmap;
+#elif defined(Q_WS_X11) || defined(Q_WS_MAC)
+    void* vi;
+    void* cx;
+#if defined(Q_WS_X11)
+    Q_UINT32 gpm;
+#endif
+#endif
+    QGLFormat glFormat;
+    QGLFormat reqFormat;
+    static QGLContext*	currentCtx;
+
+private:
+    void init( QPaintDevice *dev = 0 );
+    class Private {
+    public:
+	bool valid;
+	bool sharing;
+	bool initDone;
+	bool crWin;
+	QPaintDevice* paintDevice;
+	QColor transpColor;
+#ifdef Q_WS_MAC
+	QRect oldR;
+#endif
+    };
+    Private* d;
+
+    friend class QGLWidget;
+#ifdef Q_WS_MAC
+    void fixBufferRect();
+#endif
+
+private:	// Disabled copy constructor and operator=
+    QGLContext() {}
+    QGLContext( const QGLContext& ) {}
+    QGLContext& operator=( const QGLContext& ) { return *this; }
+};
+
+
+
+
+class QM_EXPORT_OPENGL QGLWidget : public QWidget, public QGL
+{
+    Q_OBJECT
+public:
+    QGLWidget( QWidget* parent=0, const char* name=0,
+	       const QGLWidget* shareWidget = 0, WFlags f=0 );
+    QGLWidget( QGLContext *context, QWidget* parent, const char* name=0,
+	       const QGLWidget* shareWidget = 0, WFlags f=0 );
+    QGLWidget( const QGLFormat& format, QWidget* parent=0, const char* name=0,
+	       const QGLWidget* shareWidget = 0, WFlags f=0 );
+    ~QGLWidget();
+
+    void qglColor( const QColor& c ) const;
+    void qglClearColor( const QColor& c ) const;
+
+    bool isValid() const;
+    bool isSharing() const;
+    virtual void makeCurrent();
+    void doneCurrent();
+    
+    bool doubleBuffer() const;
+    virtual void swapBuffers();
+
+    QGLFormat format() const;
+#ifndef Q_QDOC
+    virtual void setFormat( const QGLFormat& format );
+#endif
+
+    const QGLContext* context() const;
+#ifndef Q_QDOC
+    virtual void setContext( QGLContext* context,
+			     const QGLContext* shareContext = 0,
+			     bool deleteOldContext = TRUE );
+#endif
+
+    virtual QPixmap renderPixmap( int w = 0, int h = 0,
+				  bool useContext = FALSE );
+    virtual QImage grabFrameBuffer( bool withAlpha = FALSE );
+
+    virtual void makeOverlayCurrent();
+    const QGLContext* overlayContext() const;
+
+    static QImage convertToGLFormat( const QImage& img );
+
+    void setMouseTracking( bool enable );
+    virtual void  reparent( QWidget* parent, WFlags f, const QPoint& p,
+			    bool showIt = FALSE );
+
+    const QGLColormap & colormap() const;
+    void  setColormap( const QGLColormap & map );
+
+    void renderText( int x, int y, const QString & str,
+		     const QFont & fnt = QFont(), int listBase = 2000 );
+    void renderText( double x, double y, double z, const QString & str,
+		     const QFont & fnt = QFont(), int listBase = 2000 );
+public 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( QPaintEvent* );
+    void resizeEvent( QResizeEvent* );
+
+    virtual void glInit();
+    virtual void glDraw();
+
+private:
+    int displayListBase( const QFont & fnt, int listBase );
+    void cleanupColormaps();
+    void init( QGLContext *context, const QGLWidget* shareWidget );
+    bool renderCxPm( QPixmap* pm );
+    QGLContext* glcx;
+    bool autoSwap;
+
+    QGLColormap cmap;
+
+#if defined(Q_WS_WIN) || defined(Q_WS_MAC)
+    QGLContext* olcx;
+#elif defined(Q_WS_X11)
+    QGLOverlayWidget*	olw;
+    friend class QGLOverlayWidget;
+#endif
+
+private:	// Disabled copy constructor and operator=
+#if defined(Q_DISABLE_COPY)
+    QGLWidget( const QGLWidget& );
+    QGLWidget& operator=( const QGLWidget& );
+#endif
+
+#if defined(Q_WS_MAC)
+private:
+    const QGLContext *slcx;
+    uint pending_fix : 1,
+	 glcx_dblbuf : 2,
+	 dblbuf : 1,
+	 clp_serial : 15;
+    QPixmap *gl_pix;
+    QGLFormat req_format;
+
+    void macInternalRecreateContext( QGLContext *ctx,
+				     const QGLContext* = NULL,
+				     bool update = TRUE );
+    bool macInternalDoubleBuffer( bool fix = TRUE );
+    virtual void setRegionDirty( bool );
+    virtual void macWidgetChangedWindow();
+#endif
+private slots:
+    void macInternalFixBufferRect();
+};
+
+
+//
+// QGLFormat inline functions
+//
+
+inline bool QGLFormat::doubleBuffer() const
+{
+    return testOption( DoubleBuffer );
+}
+
+inline bool QGLFormat::depth() const
+{
+    return testOption( DepthBuffer );
+}
+
+inline bool QGLFormat::rgba() const
+{
+    return testOption( Rgba );
+}
+
+inline bool QGLFormat::alpha() const
+{
+    return testOption( AlphaChannel );
+}
+
+inline bool QGLFormat::accum() const
+{
+    return testOption( AccumBuffer );
+}
+
+inline bool QGLFormat::stencil() const
+{
+    return testOption( StencilBuffer );
+}
+
+inline bool QGLFormat::stereo() const
+{
+    return testOption( StereoBuffers );
+}
+
+inline bool QGLFormat::directRendering() const
+{
+    return testOption( DirectRendering );
+}
+
+inline bool QGLFormat::hasOverlay() const
+{
+    return testOption( HasOverlay );
+}
+
+//
+// QGLContext inline functions
+//
+
+inline bool QGLContext::isValid() const
+{
+    return d->valid;
+}
+
+inline void QGLContext::setValid( bool valid )
+{
+    d->valid = valid;
+}
+
+inline bool QGLContext::isSharing() const
+{
+    return d->sharing;
+}
+
+inline QGLFormat QGLContext::format() const
+{
+    return glFormat;
+}
+
+inline QGLFormat QGLContext::requestedFormat() const
+{
+    return reqFormat;
+}
+
+inline QPaintDevice* QGLContext::device() const
+{
+    return d->paintDevice;
+}
+
+inline bool QGLContext::deviceIsPixmap() const
+{
+    return d->paintDevice->devType() == QInternal::Pixmap;
+}
+
+
+inline bool QGLContext::windowCreated() const
+{
+    return d->crWin;
+}
+
+
+inline void QGLContext::setWindowCreated( bool on )
+{
+    d->crWin = on;
+}
+
+inline bool QGLContext::initialized() const
+{
+    return d->initDone;
+}
+
+inline void QGLContext::setInitialized( bool on )
+{
+    d->initDone = on;
+}
+
+inline const QGLContext* QGLContext::currentContext()
+{
+    return currentCtx;
+}
+
+//
+// QGLWidget inline functions
+//
+
+inline QGLFormat QGLWidget::format() const
+{
+    return glcx->format();
+}
+
+inline const QGLContext *QGLWidget::context() const
+{
+    return glcx;
+}
+
+inline bool QGLWidget::doubleBuffer() const
+{
+    return glcx->format().doubleBuffer();
+}
+
+inline void QGLWidget::setAutoBufferSwap( bool on )
+{
+    autoSwap = on;
+}
+
+inline bool QGLWidget::autoBufferSwap() const
+{
+    return autoSwap;
+}
+
+#endif