// 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 &);
};