diff options
Diffstat (limited to 'sip/tqtcanvas/tqcanvas.sip')
| -rw-r--r-- | sip/tqtcanvas/tqcanvas.sip | 749 |
1 files changed, 749 insertions, 0 deletions
diff --git a/sip/tqtcanvas/tqcanvas.sip b/sip/tqtcanvas/tqcanvas.sip new file mode 100644 index 0000000..2fc5c0b --- /dev/null +++ b/sip/tqtcanvas/tqcanvas.sip @@ -0,0 +1,749 @@ +// 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<TQPixmap> <Parameter>pixmaps</Parameter></ParamDef> + <ParamDef>TQPtrList<TQPoint> <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<TQPixmap> <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 &); +}; |