You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
857 lines
16 KiB
Plaintext
857 lines
16 KiB
Plaintext
// 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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<QPixmap> <Parameter>pixmaps</Parameter></ParamDef>
|
|
<ParamDef>QList<QPoint> <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<QPixmap> <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>
|
|
#include "sipqtcanvasQCanvasItem.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 {
|
|
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
|