pytqt/sip/qtgl/qgl.sip

// This is the SIP interface definition for TQGL, TQGLContext, TQGLFormat and
// TQGLWidget.
//
// Copyright (c) 2007
// 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
// 
// This file is part of PyTQt.
// 
// This copy of PyTQt is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2, or (at your option) any later
// version.
// 
// PyTQt is supplied in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
// 
// You should have received a copy of the GNU General Public License along with
// PyTQt; see the file LICENSE.  If not, write to the Free Software Foundation,
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


%ExportedDoc
<Sect2><Title>TQGL</Title>
<Para>
<Literal>TQGL</Literal> is fully implemented.
</Para>
</Sect2>
 
<Sect2><Title>TQGLContext</Title>
<Para>
<Literal>TQGLContext</Literal> is fully implemented.
</Para>
</Sect2>
 
<Sect2><Title>TQGLFormat</Title>
<Para>
<Literal>TQGLFormat</Literal> is fully implemented.
</Para>
</Sect2>
 
<Sect2><Title>TQGLWidget</Title>
<Para>
<Literal>TQGLWidget</Literal> is fully implemented.
</Para>
</Sect2>
%End


%If (TQt_2_00 -)

const int TQGL_VERSION;
const char *TQGL_VERSION_STR;

const char *qGLVersion();


class TQGL
{
%TypeHeaderCode
#include <qgl.h>
%End

public:
	enum FormatOption {
		DoubleBuffer,
		DepthBuffer,
		Rgba,
		AlphaChannel,
		AccumBuffer,
		StencilBuffer,
		StereoBuffers,
		DirectRendering,
		HasOverlay,
		SingleBuffer,
		NoDepthBuffer,
		ColorIndex,
		NoAlphaChannel,
		NoAccumBuffer,
		NoStencilBuffer,
		NoStereoBuffers,
		IndirectRendering,
		NoOverlay
	};
};


class TQGLFormat : TQGL
{
%TypeHeaderCode
#include <qgl.h>
%End

public:
	TQGLFormat();
	TQGLFormat(int,int = 0);

	bool doubleBuffer() const;
	void setDoubleBuffer(bool);
	bool depth() const;
	void setDepth(bool);
	bool rgba() const;
	void setRgba(bool);
	bool alpha() const;
	void setAlpha(bool);
	bool accum() const;
	void setAccum(bool);
	bool stencil() const;
	void setStencil(bool);
	bool stereo() const;
	void setStereo(bool);
	bool directRendering() const;
	void setDirectRendering(bool);
	bool hasOverlay() const;
	void setOverlay(bool);

	int plane() const;
	void setPlane(int);

	void setOption(FormatOption);
	bool testOption(FormatOption) const;
    
	static TQGLFormat defaultFormat();
	static void setDefaultFormat(const TQGLFormat &);

	static TQGLFormat defaultOverlayFormat();
	static void setDefaultOverlayFormat(const TQGLFormat &);

	static bool hasOpenGL();
	static bool hasOpenGLOverlays();
};


class TQGLContext : TQGL
{
%TypeHeaderCode
#include <qgl.h>
%End

public:
	TQGLContext(const TQGLFormat &,TQPaintDevice *);
%If (TQt_3_2_0 -)
	TQGLContext(const TQGLFormat &);
%End

	virtual bool create(const TQGLContext * = 0);
	bool isValid() const;
	bool isSharing() const;
	virtual void reset();

	TQGLFormat format() const;
%If (TQt_3_0_0 -)
	TQGLFormat requestedFormat() const;
%End
	virtual void setFormat(const TQGLFormat &);

	virtual void makeCurrent();
	virtual void swapBuffers() const;

	TQPaintDevice *device() const;

	TQColor overlayTransparentColor() const;

	static const TQGLContext *currentContext();

protected:
	virtual bool chooseContext(const TQGLContext * = 0);
	virtual void doneCurrent();
    
%If (WS_X11)
	virtual void *tryVisual(const TQGLFormat &,int = 1);
	virtual void *chooseVisual();
%End

	bool deviceIsPixmap() const;
	bool windowCreated() const;
	void setWindowCreated(bool);
	bool initialized() const;
	void setInitialized(bool);
%If (TQt_3_1_0 -)
	void generateFontDisplayLists(const TQFont &,int);
%End

	uint colorIndex(const TQColor &) const;
%If (TQt_3_2_0 -)
	void setValid(bool);
	void setDevice(TQPaintDevice *);
%End

private:
	TQGLContext();
	TQGLContext(const TQGLContext &);
};


class TQGLWidget : TQWidget, TQGL
{
%TypeHeaderCode
#include <qgl.h>
%End

public:
	TQGLWidget(TQWidget * /TransferThis/ = 0,const char * = 0,
		  const TQGLWidget * = 0,WFlags = 0);
%If (TQt_3_2_0 -)
	TQGLWidget(TQGLContext * /Transfer/,TQWidget * /TransferThis/ = 0,const char * = 0,
		  const TQGLWidget * = 0,WFlags = 0);
%End
	TQGLWidget(const TQGLFormat &,TQWidget * /TransferThis/ = 0,
		  const char * = 0,const TQGLWidget * = 0,WFlags = 0);

%ConvertToSubClassCode
	sipClass = (sipCpp->inherits(sipName_TQGLWidget) ? sipClass_TQGLWidget : NULL);
%End

	void qglColor(const TQColor &) const;
	void qglClearColor(const TQColor &) const;

	bool isValid() const;
	bool isSharing() const;
	virtual void makeCurrent();
%If (TQt_3_2_0 -)
	void doneCurrent();
%End

	bool doubleBuffer() const;
	virtual void swapBuffers();

	TQGLFormat format() const;

	const TQGLContext *context() const;

	virtual TQPixmap renderPixmap(int = 0,int = 0,bool = 0);
%If (TQt_3_0_0 -)
	virtual TQImage grabFrameBuffer(bool = 0);
%End

	virtual void makeOverlayCurrent();
	const TQGLContext *overlayContext() const;

	static TQImage convertToGLFormat(const TQImage &);

	void setMouseTracking(bool);

%If (TQt_3_0_0 -)
        virtual void reparent(TQWidget * /GetWrapper/,WFlags,const TQPoint &,
			      bool = 0);
%MethodCode
		if (sipCpp -> parent() != a0)
			if (a0)
				sipTransferTo(sipSelf,a0Wrapper);
			else
				sipTransferBack(sipSelf);

		Py_BEGIN_ALLOW_THREADS
		sipSelfWasArg ? sipCpp->TQGLWidget::reparent(a0, a1, *a2, a3) : sipCpp->reparent(a0, a1, *a2, a3);
		Py_END_ALLOW_THREADS
%End

	const TQGLColormap &colormap() const;
	void setColormap(const TQGLColormap &);
%End

%If (TQt_3_1_0 -)
	void renderText(int,int,const TQString &,const TQFont & = TQFont(),
			int = 2000);
	void renderText(double,double,double,const TQString &,
			const TQFont & = TQFont(),int = 2000);
%End

public slots:
	virtual void updateGL();
	virtual void updateOverlayGL();

protected:
	virtual void initializeGL();
	virtual void resizeGL(int,int);
	virtual void paintGL();

	virtual void initializeOverlayGL();
	virtual void resizeOverlayGL(int,int);
	virtual void paintOverlayGL();

	void setAutoBufferSwap(bool);
	bool autoBufferSwap() const;

	void paintEvent(TQPaintEvent *);
	void resizeEvent(TQResizeEvent *);

	virtual void glInit();
	virtual void glDraw();

private:
	TQGLWidget(const TQGLWidget &);
};

%End