// 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