Do rename qt=>tqt on source files, directories and libraries.

Rename pyuic=>pytquic, pylupdate=>pytqlupdate.
Do rename qt=>tqt on constants and variables.
Do rename QT=>TQT on constants.

Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

1 files changed, 749 insertions, 0 deletions

diff --git a/sip/tqtcanvas/tqcanvas.sip b/sip/tqtcanvas/tqcanvas.sip
new file mode 100644
index 0000000..2fc5c0b
--- /dev/null
+++ b/sip/tqtcanvas/tqcanvas.sip
@@ -0,0 +1,749 @@
+// This is the SIP interface definition for TQCanvas, TQCanvasEllipse,
+// TQCanvasItem, TQCanvasItemList, TQCanvasLine, TQCanvasPixmap,
+// TQCanvasPixmapArray, TQCanvasPolygon, TQCanvasPolygonalItem, TQCanvasRectangle,
+// TQCanvasSpline, TQCanvasSprite, TQCanvasText and TQCanvasView.
+//
+// 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>TQCanvas (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvas</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasEllipse (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasEllipse</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasItem (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasItem</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasItemList (TQt v2.2+)</Title>
+<Para>
+This class isn't implemented.  Whenever a <Literal>TQCanvasItemList</Literal> is
+the return type of a function or the type of an argument, a Python list of
+<Literal>TQCanvasItem</Literal> instances is used instead.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasLine (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasLine</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasPixmap (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasPixmap</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasPixmapArray (TQt v2.2+)</Title>
+<FuncSynopsis>
+	<FuncDef><Function>TQPixmapArray</Function></FuncDef>
+	<ParamDef>TQPtrList&lt;TQPixmap&gt; <Parameter>pixmaps</Parameter></ParamDef>
+	<ParamDef>TQPtrList&lt;TQPoint&gt; <Parameter>hotspots</Parameter></ParamDef>
+</FuncSynopsis>
+<Para>
+The <Literal>pixmaps</Literal> argument is a Python list of TQPixmap instances,
+and the <Literal>hotspots</Literal> argument is a Python list of TQPoint
+instances.  (TQt v2.2.0 - TQt v2.3.1)
+</Para>
+
+<FuncSynopsis>
+	<FuncDef><Function>TQPixmapArray</Function></FuncDef>
+	<ParamDef>TQValueList&lt;TQPixmap&gt; <Parameter>pixmaps</Parameter></ParamDef>
+	<ParamDef>TQPointArray <Parameter>hotspots</Parameter> = TQPointArray()</ParamDef>
+</FuncSynopsis>
+<Para>
+The <Literal>pixmaps</Literal> argument is a Python list of TQPixmap instances.
+(TQt v3+)
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasPolygon (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasPolygon</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasPolygonalItem (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasPolygonalItem</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasRectangle (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasRectangle</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasSpline (TQt v3.0+)</Title>
+<Para>
+<Literal>TQCanvasSpline</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasSprite (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasSprite</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasText (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasText</Literal> is fully implemented.
+</Para>
+</Sect2>
+
+<Sect2><Title>TQCanvasView (TQt v2.2+)</Title>
+<Para>
+<Literal>TQCanvasView</Literal> is fully implemented.
+</Para>
+</Sect2>
+%End
+
+
+%MappedType TQCanvasItemList
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+%ConvertFromTypeCode
+	// Convert to a Python list of TQCanvasItem instances.
+
+	int i;
+	PyObject *l;
+
+	// Create the list.
+
+	if ((l = PyList_New(sipCpp -> count())) == NULL)
+		return NULL;
+
+	// Get it.
+
+	i = 0;
+
+	for (TQCanvasItemList::Iterator it = sipCpp -> begin(); it != sipCpp -> end(); ++it)
+	{
+		PyObject *ci;
+
+		if ((ci = sipConvertFromInstance(*it,sipClass_TQCanvasItem,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 TQCanvasItemList not yet implemented");
+
+	*sipIsErr = 1;
+
+	return 0;
+%End
+};
+
+
+class TQCanvasItem : TQt
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasItem(TQCanvas * /TransferThis/);
+
+%ConvertToSubClassCode
+	Py_BEGIN_ALLOW_THREADS
+
+	// Use the numeric type values for compatibility with TQt v2.
+	switch (sipCpp -> rtti())
+	{
+	case 1:
+		sipClass = sipClass_TQCanvasSprite;
+		break;
+
+	case 2:
+		sipClass = sipClass_TQCanvasPolygonalItem;
+		break;
+
+	case 3:
+		sipClass = sipClass_TQCanvasText;
+		break;
+
+	case 4:
+		sipClass = sipClass_TQCanvasPolygon;
+		break;
+
+	case 5:
+		sipClass = sipClass_TQCanvasRectangle;
+		break;
+
+	case 6:
+		sipClass = sipClass_TQCanvasEllipse;
+		break;
+
+	case 7:
+		sipClass = sipClass_TQCanvasLine;
+		break;
+
+	case 8:
+		sipClass = sipClass_TQCanvasSpline;
+		break;
+
+	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 TQCanvasItem *) const = 0;
+
+	TQCanvasItemList collisions(bool) const;
+
+	virtual void setCanvas(TQCanvas * /GetWrapper/);
+%MethodCode
+		if (sipCpp -> canvas() != a0)
+        {
+			if (a0)
+				sipTransferTo(sipSelf,a0Wrapper);
+			else
+				sipTransferBack(sipSelf);
+        }
+
+		Py_BEGIN_ALLOW_THREADS
+		sipSelfWasArg ? sipCpp->TQCanvasItem::setCanvas(a0) : sipCpp->setCanvas(a0);
+		Py_END_ALLOW_THREADS
+%End
+
+	virtual void draw(TQPainter &) = 0;
+
+	void show();
+	void hide();
+
+	virtual void setVisible(bool);
+	bool isVisible() const;
+	virtual void setSelected(bool);
+	bool isSelected() const;
+	virtual void setEnabled(bool);
+	bool isEnabled() const;
+	virtual void setActive(bool);
+	bool isActive() const;
+
+	enum RttiValues {
+		Rtti_Item,
+		Rtti_Sprite,
+		Rtti_PolygonalItem,
+		Rtti_Text,
+		Rtti_Polygon,
+		Rtti_Rectangle,
+		Rtti_Ellipse,
+		Rtti_Line,
+		Rtti_Spline
+	};
+
+	virtual int rtti() const;
+
+	virtual TQRect boundingRect() const = 0;
+	virtual TQRect boundingRectAdvanced() const;
+
+	TQCanvas *canvas() const;
+
+protected:
+	void update();
+
+private:
+	virtual bool collidesWith(const TQCanvasSprite *,
+				  const TQCanvasPolygonalItem *,
+				  const TQCanvasRectangle *,
+				  const TQCanvasEllipse *,
+				  const TQCanvasText *) const = 0;
+};
+
+
+class TQCanvas : TQObject
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvas(TQObject * /TransferThis/ = 0,const char * = 0);
+	TQCanvas(int,int);
+	TQCanvas(TQPixmap,int,int,int,int);
+
+%ConvertToSubClassCode
+	static struct class_graph {
+		const char *name;
+		sipWrapperType **type;
+		int yes, no;
+	} graph[] = {
+		{sipName_TQCanvasView,	&sipClass_TQCanvasView,	-1, 1},
+		{sipName_TQCanvas,	&sipClass_TQCanvas,	-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(TQPixmap,int,int,int,int);
+	virtual void setBackgroundPixmap(const TQPixmap &);
+	TQPixmap backgroundPixmap() const;
+
+	virtual void setBackgroundColor(const TQColor &);
+	TQColor 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;
+	TQSize size() const;
+	TQRect rect() const;
+	bool onCanvas(int,int) const;
+	bool onCanvas(const TQPoint &) const;
+	bool validChunk(int,int) const;
+	bool validChunk(const TQPoint &) const;
+
+	int chunkSize() const;
+	virtual void retune(int,int = 100);
+
+	// These next three are marked as internal in the TQt v2.x
+	// documentation.
+//	bool sameChunk() const;
+//	virtual void setChangedChunk(int,int);
+//	virtual void setChangedChunkContaining(int,int);
+	virtual void setAllChanged();
+	virtual void setChanged(const TQRect &);
+	virtual void setUnchanged(const TQRect &);
+
+	TQCanvasItemList allItems();
+	TQCanvasItemList collisions(const TQPoint &) const;
+	TQCanvasItemList collisions(const TQRect &) const;
+	TQCanvasItemList collisions(const TQPointArray &,const TQCanvasItem *,
+				   bool) const;
+
+	void drawArea(const TQRect &,TQPainter *,bool = 0);
+
+	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(TQPainter &,const TQRect &);
+	virtual void drawForeground(TQPainter &,const TQRect &);
+
+private:
+	TQCanvas(const TQCanvas &);
+};
+
+
+class TQCanvasView : TQScrollView
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasView(TQWidget * /TransferThis/ = 0,const char * = 0,WFlags = 0);
+	TQCanvasView(TQCanvas *,TQWidget * /TransferThis/ = 0,const char * = 0,
+		    WFlags = 0);
+
+	TQCanvas* canvas() const;
+	void setCanvas(TQCanvas *);
+
+	const TQWMatrix &worldMatrix() const;
+	const TQWMatrix &inverseWorldMatrix() const;
+	bool setWorldMatrix(const TQWMatrix &);
+
+protected:
+	void drawContents(TQPainter *,int,int,int,int);
+	TQSize sizeHint() const;
+
+private:
+	TQCanvasView(const TQCanvasView &);
+};
+
+
+class TQCanvasPixmap : TQPixmap
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasPixmap(const TQString &);
+	TQCanvasPixmap(const TQImage &);
+	TQCanvasPixmap(const TQPixmap &,const TQPoint &);
+
+	int offsetX() const;
+	int offsetY() const;
+	void setOffset(int,int);
+
+private:
+	TQCanvasPixmap(const TQCanvasPixmap &);
+};
+
+
+class TQCanvasPixmapArray
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasPixmapArray();
+	TQCanvasPixmapArray(const TQString &,int = 0);
+	TQCanvasPixmapArray(TQValueList<TQPixmap>,TQPointArray = TQPointArray());
+
+	bool readPixmaps(const TQString &,int = 0) /ReleaseGIL/;
+	bool readCollisionMasks(const TQString &) /ReleaseGIL/;
+
+	bool isValid() const;
+
+	TQCanvasPixmap *image(int) const;
+	void setImage(int,TQCanvasPixmap * /Transfer/);
+	uint count() const;
+
+private:
+	TQCanvasPixmapArray(const TQCanvasPixmapArray &);
+};
+
+
+class TQCanvasSprite : TQCanvasItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasSprite(TQCanvasPixmapArray *,TQCanvas * /TransferThis/);
+
+	void setSequence(TQCanvasPixmapArray *);
+
+	void move(double,double);
+	virtual void move(double,double,int);
+	void setFrame(int);
+
+	enum FrameAnimationType {
+		Cycle,
+		Oscillate
+	};
+
+	virtual void setFrameAnimation(FrameAnimationType = Cycle,int = 1,
+				       int = 0);
+	int frame() const;
+	int frameCount() const;
+
+	int rtti() const;
+
+	bool collidesWith(const TQCanvasItem *) const;
+
+	TQRect boundingRect() const;
+
+	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;
+	TQCanvasPixmap *image() const;
+	virtual TQCanvasPixmap *imageAdvanced() const;
+	TQCanvasPixmap *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(TQPainter &);
+
+private:
+	TQCanvasSprite(const TQCanvasSprite &);
+};
+
+
+class TQCanvasPolygonalItem : TQCanvasItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasPolygonalItem(TQCanvas * /TransferThis/);
+
+	bool collidesWith(const TQCanvasItem *) const;
+
+	virtual void setPen(TQPen);
+	virtual void setBrush(TQBrush);
+
+	TQPen pen() const;
+	TQBrush brush() const;
+
+	virtual TQPointArray areaPoints() const = 0;
+	virtual TQPointArray areaPointsAdvanced() const;
+	TQRect boundingRect() const;
+
+	int rtti() const;
+
+protected:
+	void draw(TQPainter &);
+	virtual void drawShape(TQPainter &) = 0;
+
+	bool winding() const;
+	void setWinding(bool);
+
+	void invalidate();
+	bool isValid() const;
+};
+
+
+class TQCanvasRectangle : TQCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasRectangle(TQCanvas * /TransferThis/);
+	TQCanvasRectangle(const TQRect &,TQCanvas * /TransferThis/);
+	TQCanvasRectangle(int,int,int,int,TQCanvas * /TransferThis/);
+
+	int width() const;
+	int height() const;
+	void setSize(int,int);
+	TQSize size() const;
+	TQPointArray areaPoints() const;
+	TQRect rect() const;
+
+	bool collidesWith(const TQCanvasItem *) const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(TQPainter &);
+	TQPointArray chunks() const;
+};
+
+
+class TQCanvasPolygon : TQCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasPolygon(TQCanvas * /TransferThis/);
+
+	void setPoints(TQPointArray);
+	TQPointArray points() const;
+	void moveBy(double,double);
+
+	TQPointArray areaPoints() const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(TQPainter &);
+};
+
+
+class TQCanvasSpline : TQCanvasPolygon
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasSpline(TQCanvas * /TransferThis/);
+
+	void setControlPoints(TQPointArray,bool = 1);
+	TQPointArray controlPoints() const;
+	bool closed() const;
+
+	int rtti() const;
+};
+
+
+class TQCanvasLine : TQCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasLine(TQCanvas * /TransferThis/);
+
+	void setPoints(int,int,int,int);
+
+	TQPoint startPoint() const;
+	TQPoint endPoint() const;
+
+	int rtti() const;
+
+	void setPen(TQPen);
+	void moveBy(double,double);
+
+protected:
+	void drawShape(TQPainter &);
+	TQPointArray areaPoints() const;
+};
+
+
+class TQCanvasEllipse : TQCanvasPolygonalItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasEllipse(TQCanvas * /TransferThis/);
+	TQCanvasEllipse(int,int,TQCanvas * /TransferThis/);
+	TQCanvasEllipse(int,int,int,int,TQCanvas * /TransferThis/);
+
+	int width() const;
+	int height() const;
+	void setSize(int,int);
+	void setAngles(int,int);
+	int angleStart() const;
+	int angleLength() const;
+	TQPointArray areaPoints() const;
+
+	bool collidesWith(const TQCanvasItem *) const;
+
+	int rtti() const;
+
+protected:
+	void drawShape(TQPainter &);
+};
+
+
+class TQCanvasText : TQCanvasItem
+{
+%TypeHeaderCode
+#include <tqcanvas.h>
+%End
+
+public:
+	TQCanvasText(TQCanvas * /TransferThis/);
+	TQCanvasText(const TQString &,TQCanvas * /TransferThis/);
+	TQCanvasText(const TQString &,TQFont,TQCanvas * /TransferThis/);
+
+	void setText(const TQString &);
+	void setFont(const TQFont &);
+	void setColor(const TQColor &);
+	TQString text() const;
+	TQFont font() const;
+	TQColor color() const;
+
+	void moveBy(double,double);
+
+	int textFlags() const;
+	void setTextFlags(int);
+
+	TQRect boundingRect() const;
+
+	bool collidesWith(const TQCanvasItem *) const;
+
+	int rtti() const;
+
+protected:
+	virtual void draw(TQPainter &);
+
+private:
+	TQCanvasText(const TQCanvasText &);
+};