You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
pytqt/sip/tqtcanvas/tqcanvas.sip

750 lines
15 KiB

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