diff options
Diffstat (limited to 'sip/qtcanvas/qcanvas.sip')
| -rw-r--r-- | sip/qtcanvas/qcanvas.sip | 857 |
1 files changed, 857 insertions, 0 deletions
diff --git a/sip/qtcanvas/qcanvas.sip b/sip/qtcanvas/qcanvas.sip new file mode 100644 index 0000000..f9ce8e2 --- /dev/null +++ b/sip/qtcanvas/qcanvas.sip @@ -0,0 +1,857 @@ +// 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<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> +%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 |