Initial import of python-qt3

1 files changed, 857 insertions, 0 deletions

diff --git a/sip/qtcanvas/qcanvas.sip b/sip/qtcanvas/qcanvas.sip
new file mode 100644
index 0000000..f9ce8e2
--- /dev/null
+++ b/sip/qtcanvas/qcanvas.sip
@@ -0,0 +1,857 @@
+// This is the SIP interface definition for QCanvas, QCanvasEllipse,
+// QCanvasItem, QCanvasItemList, QCanvasLine, QCanvasPixmap,
+// QCanvasPixmapArray, QCanvasPolygon, QCanvasPolygonalItem, QCanvasRectangle,
+// QCanvasSpline, QCanvasSprite, QCanvasText and QCanvasView.
+//
+// Copyright (c) 2007
+// 	Riverbank Computing Limited <info@riverbankcomputing.co.uk>
+// 
+// This file is part of PyQt.
+// 
+// This copy of PyQt 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.
+// 
+// PyQt 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
+// PyQt; 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>QCanvas (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvas</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasEllipse (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasEllipse</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasItem (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasItem</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasItemList (Qt v2.2+)</Title>
+<Para>
+This class isn't implemented.  Whenever a <Literal>QCanvasItemList</Literal> is
+the return type of a function or the type of an argument, a Python list of
+<Literal>QCanvasItem</Literal> instances is used instead.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasLine (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasLine</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasPixmap (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasPixmap</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasPixmapArray (Qt v2.2+)</Title>
+<FuncSynopsis>
+	<FuncDef><Function>QPixmapArray</Function></FuncDef>
+	<ParamDef>QList&lt;QPixmap&gt; <Parameter>pixmaps</Parameter></ParamDef>
+	<ParamDef>QList&lt;QPoint&gt; <Parameter>hotspots</Parameter></ParamDef>
+</FuncSynopsis>
+<Para>
+The <Literal>pixmaps</Literal> argument is a Python list of QPixmap instances,
+and the <Literal>hotspots</Literal> argument is a Python list of QPoint
+instances.  (Qt v2.2.0 - Qt v2.3.1)
+</Para>
+
+<FuncSynopsis>
+	<FuncDef><Function>QPixmapArray</Function></FuncDef>
+	<ParamDef>QValueList&lt;QPixmap&gt; <Parameter>pixmaps</Parameter></ParamDef>
+	<ParamDef>QPointArray <Parameter>hotspots</Parameter> = QPointArray()</ParamDef>
+</FuncSynopsis>
+<Para>
+The <Literal>pixmaps</Literal> argument is a Python list of QPixmap instances.
+(Qt v3+)
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasPolygon (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasPolygon</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasPolygonalItem (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasPolygonalItem</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasRectangle (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasRectangle</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasSpline (Qt v3.0+)</Title>
+<Para>
+<Literal>QCanvasSpline</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasSprite (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasSprite</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasText (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasText</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>QCanvasView (Qt v2.2+)</Title>
+<Para>
+<Literal>QCanvasView</Literal> is fully implemented.
+</Para>
+</Sect2>
+%End
+
+
+%If (Qt_2_2_0 -)
+
+%MappedType QCanvasItemList
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+%ConvertFromTypeCode
+	// Convert to a Python list of QCanvasItem instances.
+
+	int i;
+	PyObject *l;
+
+	// Create the list.
+
+	if ((l = PyList_New(sipCpp -> count())) == NULL)
+		return NULL;
+
+	// Get it.
+
+	i = 0;
+
+	for (QCanvasItemList::Iterator it = sipCpp -> begin(); it != sipCpp -> end(); ++it)
+	{
+		PyObject *ci;
+
+		if ((ci = sipConvertFromInstance(*it,sipClass_QCanvasItem,sipTransferObj)) == NULL || PyList_SetItem(l,i,ci) < 0)
+		{
+			Py_XDECREF(ci);
+			Py_DECREF(l);
+
+			return NULL;
+		}
+
+		++i;
+	}
+
+	return l;
+%End
+
+%ConvertToTypeCode
+	// At the moment this will never be called, so provide a null
+	// implementation.
+
+	if (sipIsErr == NULL)
+		return PyList_Check(sipPy);
+
+	PyErr_Format(PyExc_TypeError,"Converting to QCanvasItemList not yet implemented");
+
+	*sipIsErr = 1;
+
+	return 0;
+%End
+};
+
+
+class QCanvasItem : Qt
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasItem(QCanvas * /TransferThis/);
+
+%ConvertToSubClassCode
+	Py_BEGIN_ALLOW_THREADS
+
+	// Use the numeric type values for compatibility with Qt v2.
+	switch (sipCpp -> rtti())
+	{
+	case 1:
+		sipClass = sipClass_QCanvasSprite;
+		break;
+
+	case 2:
+		sipClass = sipClass_QCanvasPolygonalItem;
+		break;
+
+	case 3:
+		sipClass = sipClass_QCanvasText;
+		break;
+
+	case 4:
+		sipClass = sipClass_QCanvasPolygon;
+		break;
+
+	case 5:
+		sipClass = sipClass_QCanvasRectangle;
+		break;
+
+	case 6:
+		sipClass = sipClass_QCanvasEllipse;
+		break;
+
+	case 7:
+		sipClass = sipClass_QCanvasLine;
+		break;
+
+#if QT_VERSION >= 0x030000
+	case 8:
+		sipClass = sipClass_QCanvasSpline;
+		break;
+#endif
+
+	default:
+		sipClass = 0;
+	}
+
+	Py_END_ALLOW_THREADS
+%End
+
+	double x() const;
+	double y() const;
+	double z() const;
+
+	virtual void moveBy(double,double);
+	void move(double,double);
+	void setX(double);
+	void setY(double);
+	void setZ(double);
+
+	bool animated() const;
+	virtual void setAnimated(bool);
+	virtual void setVelocity(double,double);
+	void setXVelocity(double);
+	void setYVelocity(double);
+	double xVelocity() const;
+	double yVelocity() const;
+	virtual void advance(int);
+
+	virtual bool collidesWith(const QCanvasItem *) const = 0;
+
+	QCanvasItemList collisions(bool) const;
+
+	virtual void setCanvas(QCanvas * /GetWrapper/);
+%MethodCode
+		if (sipCpp -> canvas() != a0)
+        {
+			if (a0)
+				sipTransferTo(sipSelf,a0Wrapper);
+			else
+				sipTransferBack(sipSelf);
+        }
+
+		Py_BEGIN_ALLOW_THREADS
+		sipSelfWasArg ? sipCpp->QCanvasItem::setCanvas(a0) : sipCpp->setCanvas(a0);
+		Py_END_ALLOW_THREADS
+%End
+
+	virtual void draw(QPainter &) = 0;
+
+	void show();
+	void hide();
+
+	virtual void setVisible(bool);
+%If (- Qt_3_0_0)
+	bool visible() const;
+%End
+%If (Qt_3_0_0 -)
+	bool isVisible() const;
+%End
+	virtual void setSelected(bool);
+%If (- Qt_3_0_0)
+	bool selected() const;
+%End
+%If (Qt_3_0_0 -)
+	bool isSelected() const;
+%End
+	virtual void setEnabled(bool);
+%If (- Qt_3_0_0)
+	bool enabled() const;
+%End
+%If (Qt_3_0_0 -)
+	bool isEnabled() const;
+%End
+	virtual void setActive(bool);
+%If (- Qt_3_0_0)
+	bool active() const;
+%End
+%If (Qt_3_0_0 -)
+	bool isActive() const;
+%End
+
+%If (Qt_3_0_0 -)
+	enum RttiValues {
+		Rtti_Item,
+		Rtti_Sprite,
+		Rtti_PolygonalItem,
+		Rtti_Text,
+		Rtti_Polygon,
+		Rtti_Rectangle,
+		Rtti_Ellipse,
+		Rtti_Line,
+		Rtti_Spline
+	};
+%End
+
+	virtual int rtti() const;
+
+	virtual QRect boundingRect() const = 0;
+	virtual QRect boundingRectAdvanced() const;
+
+	QCanvas *canvas() const;
+
+protected:
+%If (Qt_3_0_0 -)
+	void update();
+%End
+
+private:
+	virtual bool collidesWith(const QCanvasSprite *,
+				  const QCanvasPolygonalItem *,
+				  const QCanvasRectangle *,
+				  const QCanvasEllipse *,
+				  const QCanvasText *) const = 0;
+};
+
+
+class QCanvas : QObject
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvas(QObject * /TransferThis/ = 0,const char * = 0);
+	QCanvas(int,int);
+	QCanvas(QPixmap,int,int,int,int);
+
+%ConvertToSubClassCode
+	static struct class_graph {
+		const char *name;
+		sipWrapperType **type;
+		int yes, no;
+	} graph[] = {
+		{sipName_QCanvasView,	&sipClass_QCanvasView,	-1, 1},
+		{sipName_QCanvas,	&sipClass_QCanvas,	-1, -1},
+	};
+
+	int i = 0;
+
+	sipClass = NULL;
+
+	do
+	{
+		struct class_graph *cg = &graph[i];
+
+		if (cg->name != NULL && sipCpp->inherits(cg->name))
+		{
+			sipClass = *cg->type;
+			i = cg->yes;
+		}
+		else
+			i = cg->no;
+	}
+	while (i >= 0);
+%End
+
+	virtual void setTiles(QPixmap,int,int,int,int);
+	virtual void setBackgroundPixmap(const QPixmap &);
+	QPixmap backgroundPixmap() const;
+
+	virtual void setBackgroundColor(const QColor &);
+	QColor backgroundColor() const;
+
+	virtual void setTile(int,int,int);
+	int tile(int,int) const;
+
+	int tilesHorizontally() const;
+	int tilesVertically() const;
+
+	int tileWidth() const;
+	int tileHeight() const;
+
+	virtual void resize(int,int);
+	int width() const;
+	int height() const;
+	QSize size() const;
+%If (Qt_3_0_0 -)
+	QRect rect() const;
+%End
+	bool onCanvas(int,int) const;
+	bool onCanvas(const QPoint &) const;
+	bool validChunk(int,int) const;
+	bool validChunk(const QPoint &) const;
+
+	int chunkSize() const;
+	virtual void retune(int,int = 100);
+
+	// These next three are marked as internal in the Qt v2.x
+	// documentation.
+//	bool sameChunk() const;
+//	virtual void setChangedChunk(int,int);
+//	virtual void setChangedChunkContaining(int,int);
+	virtual void setAllChanged();
+	virtual void setChanged(const QRect &);
+%If (Qt_3_0_0 -)
+	virtual void setUnchanged(const QRect &);
+%End
+
+	QCanvasItemList allItems();
+	QCanvasItemList collisions(const QPoint &) const;
+	QCanvasItemList collisions(const QRect &) const;
+	QCanvasItemList collisions(const QPointArray &,const QCanvasItem *,
+				   bool) const;
+
+%If (Qt_3_0_0 -)
+	void drawArea(const QRect &,QPainter *,bool = 0);
+%End
+
+	virtual void setAdvancePeriod(int);
+	virtual void setUpdatePeriod(int);
+
+	virtual void setDoubleBuffering(bool);
+
+signals:
+	void resized();
+
+public slots:
+	virtual void advance();
+	virtual void update();
+
+protected:
+	virtual void drawBackground(QPainter &,const QRect &);
+	virtual void drawForeground(QPainter &,const QRect &);
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvas(const QCanvas &);
+%End
+};
+
+
+class QCanvasView : QScrollView
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+%If (- Qt_3_0_0)
+	QCanvasView(QCanvas * = 0,QWidget * /TransferThis/ = 0,
+		    const char * = 0,WFlags = 0);
+%End
+%If (Qt_3_0_0 -)
+	QCanvasView(QWidget * /TransferThis/ = 0,const char * = 0,WFlags = 0);
+	QCanvasView(QCanvas *,QWidget * /TransferThis/ = 0,const char * = 0,
+		    WFlags = 0);
+%End
+
+	QCanvas* canvas() const;
+	void setCanvas(QCanvas *);
+
+%If (Qt_3_0_0 -)
+	const QWMatrix &worldMatrix() const;
+	const QWMatrix &inverseWorldMatrix() const;
+	bool setWorldMatrix(const QWMatrix &);
+%End
+
+protected:
+	void drawContents(QPainter *,int,int,int,int);
+	QSize sizeHint() const;
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvasView(const QCanvasView &);
+%End
+};
+
+
+class QCanvasPixmap : QPixmap
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasPixmap(const QString &);
+	QCanvasPixmap(const QImage &);
+%If (- Qt_3_0_0)
+	QCanvasPixmap(const QPixmap &,QPoint);
+%End
+%If (Qt_3_0_0 -)
+	QCanvasPixmap(const QPixmap &,const QPoint &);
+%End
+
+	int offsetX() const;
+	int offsetY() const;
+	void setOffset(int,int);
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvasPixmap(const QCanvasPixmap &);
+%End
+};
+
+
+class QCanvasPixmapArray
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasPixmapArray();
+	QCanvasPixmapArray(const QString &,int = 0);
+%If (- Qt_3_0_0)
+	QCanvasPixmapArray(QPtrList<QPixmap>,QPtrList<QPoint>);
+%End
+%If (Qt_3_0_0 -)
+	QCanvasPixmapArray(QValueList<QPixmap>,QPointArray = QPointArray());
+%End
+
+	bool readPixmaps(const QString &,int = 0) /ReleaseGIL/;
+	bool readCollisionMasks(const QString &) /ReleaseGIL/;
+
+%If (Qt_3_0_0 -)
+	bool isValid() const;
+%End
+
+	QCanvasPixmap *image(int) const;
+	void setImage(int,QCanvasPixmap * /Transfer/);
+	uint count() const;
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvasPixmapArray(const QCanvasPixmapArray &);
+%End
+};
+
+
+class QCanvasSprite : QCanvasItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasSprite(QCanvasPixmapArray *,QCanvas * /TransferThis/);
+
+	void setSequence(QCanvasPixmapArray *);
+
+	void move(double,double);
+	virtual void move(double,double,int);
+	void setFrame(int);
+
+%If (Qt_3_0_0 -)
+	enum FrameAnimationType {
+		Cycle,
+		Oscillate
+	};
+
+	virtual void setFrameAnimation(FrameAnimationType = Cycle,int = 1,
+				       int = 0);
+%End
+	int frame() const;
+	int frameCount() const;
+
+%If (- Qt_3_0_0)
+	virtual int rtti() const;
+%End
+%If (Qt_3_0_0 -)
+	int rtti() const;
+%End
+
+	bool collidesWith(const QCanvasItem *) const;
+
+	QRect boundingRect() const;
+
+%If (Qt_3_0_0 -)
+	int width() const;
+	int height() const;
+
+	int leftEdge() const;
+	int topEdge() const;
+	int rightEdge() const;
+	int bottomEdge() const;
+
+	int leftEdge(int) const;
+	int topEdge(int) const;
+	int rightEdge(int) const;
+	int bottomEdge(int) const;
+	QCanvasPixmap *image() const;
+	virtual QCanvasPixmap *imageAdvanced() const;
+	QCanvasPixmap *image(int) const;
+	// This is really virtual, but we want to use the super-class's virtual
+	// handler.  Having to do this is really a SIP bug.
+	void advance(int);
+
+	void draw(QPainter &);
+%End
+
+protected:
+%If (- Qt_3_0_0)
+	void draw(QPainter &);
+	int width() const;
+	int height() const;
+	int absX() const;
+	int absY() const;
+	int absX2() const;
+	int absY2() const;
+	int absX(int) const;
+	int absY(int) const;
+	int absX2(int) const;
+	int absY2(int) const;
+	QCanvasPixmap *image() const;
+	virtual QCanvasPixmap *imageAdvanced() const;
+	QCanvasPixmap *image(int) const;
+%End
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvasSprite(const QCanvasSprite &);
+%End
+};
+
+
+class QCanvasPolygonalItem : QCanvasItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasPolygonalItem(QCanvas * /TransferThis/);
+
+	bool collidesWith(const QCanvasItem *) const;
+
+	virtual void setPen(QPen);
+	virtual void setBrush(QBrush);
+
+	QPen pen() const;
+	QBrush brush() const;
+
+	virtual QPointArray areaPoints() const = 0;
+	virtual QPointArray areaPointsAdvanced() const;
+	QRect boundingRect() const;
+
+	int rtti() const;
+
+protected:
+	void draw(QPainter &);
+	virtual void drawShape(QPainter &) = 0;
+
+	bool winding() const;
+	void setWinding(bool);
+
+%If (Qt_3_1_0 -)
+	void invalidate();
+	bool isValid() const;
+%End
+};
+
+
+class QCanvasRectangle : QCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasRectangle(QCanvas * /TransferThis/);
+	QCanvasRectangle(const QRect &,QCanvas * /TransferThis/);
+	QCanvasRectangle(int,int,int,int,QCanvas * /TransferThis/);
+
+	int width() const;
+	int height() const;
+	void setSize(int,int);
+	QSize size() const;
+	QPointArray areaPoints() const;
+	QRect rect() const;
+
+	bool collidesWith(const QCanvasItem *) const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(QPainter &);
+	QPointArray chunks() const;
+};
+
+
+class QCanvasPolygon : QCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasPolygon(QCanvas * /TransferThis/);
+
+	void setPoints(QPointArray);
+	QPointArray points() const;
+	void moveBy(double,double);
+
+	QPointArray areaPoints() const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(QPainter &);
+};
+
+
+%If (Qt_3_0_0 -)
+
+class QCanvasSpline : QCanvasPolygon
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasSpline(QCanvas * /TransferThis/);
+
+	void setControlPoints(QPointArray,bool = 1);
+	QPointArray controlPoints() const;
+	bool closed() const;
+
+	int rtti() const;
+};
+
+%End
+
+
+class QCanvasLine : QCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasLine(QCanvas * /TransferThis/);
+
+	void setPoints(int,int,int,int);
+
+	QPoint startPoint() const;
+	QPoint endPoint() const;
+
+	int rtti() const;
+
+	void setPen(QPen);
+%If (Qt_3_3_0 -)
+	void moveBy(double,double);
+%End
+
+protected:
+	void drawShape(QPainter &);
+	QPointArray areaPoints() const;
+};
+
+
+class QCanvasEllipse : QCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasEllipse(QCanvas * /TransferThis/);
+	QCanvasEllipse(int,int,QCanvas * /TransferThis/);
+	QCanvasEllipse(int,int,int,int,QCanvas * /TransferThis/);
+
+	int width() const;
+	int height() const;
+	void setSize(int,int);
+	void setAngles(int,int);
+	int angleStart() const;
+	int angleLength() const;
+	QPointArray areaPoints() const;
+
+	bool collidesWith(const QCanvasItem *) const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(QPainter &);
+};
+
+
+class QCanvasText : QCanvasItem
+{
+%TypeHeaderCode
+#include <qcanvas.h>
+%End
+
+public:
+	QCanvasText(QCanvas * /TransferThis/);
+	QCanvasText(const QString &,QCanvas * /TransferThis/);
+	QCanvasText(const QString &,QFont,QCanvas * /TransferThis/);
+
+	void setText(const QString &);
+	void setFont(const QFont &);
+	void setColor(const QColor &);
+	QString text() const;
+	QFont font() const;
+	QColor color() const;
+
+	void moveBy(double,double);
+
+	int textFlags() const;
+	void setTextFlags(int);
+
+	QRect boundingRect() const;
+
+	bool collidesWith(const QCanvasItem *) const;
+
+%If (- Qt_3_0_0)
+	virtual int rtti() const;
+%End
+%If (Qt_3_0_0 -)
+	int rtti() const;
+%End
+
+protected:
+	virtual void draw(QPainter &);
+
+private:
+%If (Qt_3_1_0 -)
+	QCanvasText(const QCanvasText &);
+%End
+};
+
+%End