From bd0f3345a938b35ce6a12f6150373b0955b8dd12 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:24:15 -0500 Subject: Add Qt3 development HEAD version --- src/canvas/qcanvas.h | 816 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 816 insertions(+) create mode 100644 src/canvas/qcanvas.h (limited to 'src/canvas/qcanvas.h') diff --git a/src/canvas/qcanvas.h b/src/canvas/qcanvas.h new file mode 100644 index 0000000..0e0338c --- /dev/null +++ b/src/canvas/qcanvas.h @@ -0,0 +1,816 @@ +/********************************************************************** +** +** Definition of QCanvas classes +** +** Created : 991211 +** +** Copyright (C) 1999-2008 Trolltech ASA. All rights reserved. +** +** This file is part of the canvas module of the Qt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free Qt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.QPL +** included in the packaging of this file. Licensees holding valid Qt +** Commercial licenses may use this file in accordance with the Qt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#ifndef QCANVAS_H +#define QCANVAS_H + +#ifndef QT_H +#include "qscrollview.h" +#include "qpixmap.h" +#include "qptrlist.h" +#include "qbrush.h" +#include "qpen.h" +#include "qvaluelist.h" +#include "qpointarray.h" +#endif // QT_H + +#if !defined( QT_MODULE_CANVAS ) || defined( QT_LICENSE_PROFESSIONAL ) || defined( QT_INTERNAL_CANVAS ) +#define QM_EXPORT_CANVAS +#define QM_TEMPLATE_EXTERN_CANVAS +#else +#define QM_EXPORT_CANVAS Q_EXPORT +#define QM_TEMPLATE_EXTERN_CANVAS Q_TEMPLATE_EXTERN +#endif + +#ifndef QT_NO_CANVAS + + +class QCanvasSprite; +class QCanvasPolygonalItem; +class QCanvasRectangle; +class QCanvasPolygon; +class QCanvasEllipse; +class QCanvasText; +class QCanvasLine; +class QCanvasChunk; +class QCanvas; +class QCanvasItem; +class QCanvasView; +class QCanvasPixmap; + +#if defined(Q_TEMPLATEDLL) && ( !defined(Q_CC_BOR) || !defined(QT_MAKEDLL) || defined(Q_EXPORT_TEMPLATES) ) +// MOC_SKIP_BEGIN +QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QValueListIterator< QCanvasItem* >; +QM_TEMPLATE_EXTERN_CANVAS template class QM_EXPORT_CANVAS QValueList< QCanvasItem* >; +// MOC_SKIP_END +#endif + +class QM_EXPORT_CANVAS QCanvasItemList : public QValueList { +public: + void sort(); + void drawUnique( QPainter& painter ); + QCanvasItemList operator+(const QCanvasItemList &l) const; +}; + + +class QCanvasItemExtra; + +class QM_EXPORT_CANVAS QCanvasItem : public Qt +{ +public: + QCanvasItem(QCanvas* canvas); + virtual ~QCanvasItem(); + + double x() const + { return myx; } + double y() const + { return myy; } + double z() const + { return myz; } // (depth) + + virtual void moveBy(double dx, double dy); + void move(double x, double y); + void setX(double a) { move(a,y()); } + void setY(double a) { move(x(),a); } + void setZ(double a) { myz=a; changeChunks(); } + + bool animated() const; + virtual void setAnimated(bool y); + virtual void setVelocity( double vx, double vy); + void setXVelocity( double vx ) { setVelocity(vx,yVelocity()); } + void setYVelocity( double vy ) { setVelocity(xVelocity(),vy); } + double xVelocity() const; + double yVelocity() const; + virtual void advance(int stage); + + virtual bool collidesWith( const QCanvasItem* ) const=0; + + QCanvasItemList collisions(bool exact /* NO DEFAULT */ ) const; + + virtual void setCanvas(QCanvas*); + + virtual void draw(QPainter&)=0; + + void show(); + void hide(); + + virtual void setVisible(bool yes); + bool isVisible() const + { return (bool)vis; } + virtual void setSelected(bool yes); + bool isSelected() const + { return (bool)sel; } + virtual void setEnabled(bool yes); + bool isEnabled() const + { return (bool)ena; } + virtual void setActive(bool yes); + bool isActive() const + { return (bool)act; } +#ifndef QT_NO_COMPAT + bool visible() const + { return (bool)vis; } + bool selected() const + { return (bool)sel; } + bool enabled() const + { return (bool)ena; } + bool active() const + { return (bool)act; } +#endif + + enum RttiValues { + Rtti_Item = 0, + Rtti_Sprite = 1, + Rtti_PolygonalItem = 2, + Rtti_Text = 3, + Rtti_Polygon = 4, + Rtti_Rectangle = 5, + Rtti_Ellipse = 6, + Rtti_Line = 7, + Rtti_Spline = 8 + }; + + virtual int rtti() const; + static int RTTI; + + virtual QRect boundingRect() const=0; + virtual QRect boundingRectAdvanced() const; + + QCanvas* canvas() const + { return cnv; } + +protected: + void update() { changeChunks(); } + +private: + // For friendly subclasses... + + friend class QCanvasPolygonalItem; + friend class QCanvasSprite; + friend class QCanvasRectangle; + friend class QCanvasPolygon; + friend class QCanvasEllipse; + friend class QCanvasText; + friend class QCanvasLine; + + virtual QPointArray chunks() const; + virtual void addToChunks(); + virtual void removeFromChunks(); + virtual void changeChunks(); + virtual bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const = 0; + // End of friend stuff + + QCanvas* cnv; + static QCanvas* current_canvas; + double myx,myy,myz; + QCanvasItemExtra *ext; + QCanvasItemExtra& extra(); + uint ani:1; + uint vis:1; + uint val:1; + uint sel:1; + uint ena:1; + uint act:1; +}; + + +class QCanvasData; + +class QM_EXPORT_CANVAS QCanvas : public QObject +{ + Q_OBJECT +public: + QCanvas( QObject* parent = 0, const char* name = 0 ); + QCanvas(int w, int h); + QCanvas( QPixmap p, int h, int v, int tilewidth, int tileheight ); + + virtual ~QCanvas(); + + virtual void setTiles( QPixmap tiles, int h, int v, + int tilewidth, int tileheight ); + virtual void setBackgroundPixmap( const QPixmap& p ); + QPixmap backgroundPixmap() const; + + virtual void setBackgroundColor( const QColor& c ); + QColor backgroundColor() const; + + virtual void setTile( int x, int y, int tilenum ); + int tile( int x, int y ) const + { return grid[x+y*htiles]; } + + int tilesHorizontally() const + { return htiles; } + int tilesVertically() const + { return vtiles; } + + int tileWidth() const + { return tilew; } + int tileHeight() const + { return tileh; } + + virtual void resize(int width, int height); + int width() const + { return awidth; } + int height() const + { return aheight; } + QSize size() const + { return QSize(awidth,aheight); } + QRect rect() const + { return QRect( 0, 0, awidth, aheight ); } + bool onCanvas( int x, int y ) const + { return x>=0 && y>=0 && x=0 && y>=0 && x, QPtrList hotspots); + + QCanvasPixmapArray(QValueList, QPointArray hotspots = QPointArray() ); + ~QCanvasPixmapArray(); + +#ifndef QT_NO_IMAGEIO + bool readPixmaps(const QString& datafilenamepattern, int framecount=0); + bool readCollisionMasks(const QString& filenamepattern); +#endif + + // deprecated + bool operator!(); // Failure check. + bool isValid() const; + + QCanvasPixmap* image(int i) const + { return img ? img[i] : 0; } + void setImage(int i, QCanvasPixmap* p); + uint count() const + { return (uint)framecount; } + +private: +#if defined(Q_DISABLE_COPY) + QCanvasPixmapArray( const QCanvasPixmapArray & ); + QCanvasPixmapArray &operator=( const QCanvasPixmapArray & ); +#endif +#ifndef QT_NO_IMAGEIO + bool readPixmaps(const QString& datafilenamepattern, int framecount, bool maskonly); +#endif + + void reset(); + int framecount; + QCanvasPixmap** img; +}; + + +class QM_EXPORT_CANVAS QCanvasSprite : public QCanvasItem +{ +public: + QCanvasSprite(QCanvasPixmapArray* array, QCanvas* canvas); + + void setSequence(QCanvasPixmapArray* seq); + + virtual ~QCanvasSprite(); + + void move(double x, double y); + virtual void move(double x, double y, int frame); + void setFrame(int); + enum FrameAnimationType { Cycle, Oscillate }; + virtual void setFrameAnimation(FrameAnimationType=Cycle, int step=1, int state=0); + int frame() const + { return frm; } + int frameCount() const + { return images->count(); } + + int rtti() const; + static int RTTI; + + bool collidesWith( const QCanvasItem* ) const; + + QRect boundingRect() const; + + // is there a reason for these to be protected? Lars +//protected: + + int width() const; + int height() const; + + int leftEdge() const; + int topEdge() const; + int rightEdge() const; + int bottomEdge() const; + + int leftEdge(int nx) const; + int topEdge(int ny) const; + int rightEdge(int nx) const; + int bottomEdge(int ny) const; + QCanvasPixmap* image() const + { return images->image(frm); } + virtual QCanvasPixmap* imageAdvanced() const; + QCanvasPixmap* image(int f) const + { return images->image(f); } + virtual void advance(int stage); + +public: + void draw(QPainter& painter); + +private: +#if defined(Q_DISABLE_COPY) + QCanvasSprite( const QCanvasSprite & ); + QCanvasSprite &operator=( const QCanvasSprite & ); +#endif + void addToChunks(); + void removeFromChunks(); + void changeChunks(); + + int frm; + ushort anim_val; + uint anim_state:2; + uint anim_type:14; + bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const; + + friend bool qt_testCollision( const QCanvasSprite* s1, + const QCanvasSprite* s2 ); + + QCanvasPixmapArray* images; +}; + +class QPolygonalProcessor; + +class QM_EXPORT_CANVAS QCanvasPolygonalItem : public QCanvasItem +{ +public: + QCanvasPolygonalItem(QCanvas* canvas); + virtual ~QCanvasPolygonalItem(); + + bool collidesWith( const QCanvasItem* ) const; + + virtual void setPen(QPen p); + virtual void setBrush(QBrush b); + + QPen pen() const + { return pn; } + QBrush brush() const + { return br; } + + virtual QPointArray areaPoints() const=0; + virtual QPointArray areaPointsAdvanced() const; + QRect boundingRect() const; + + int rtti() const; + static int RTTI; + +protected: + void draw(QPainter &); + virtual void drawShape(QPainter &) = 0; + + bool winding() const; + void setWinding(bool); + + void invalidate(); + bool isValid() const + { return (bool)val; } + +private: + void scanPolygon( const QPointArray& pa, int winding, + QPolygonalProcessor& process ) const; + QPointArray chunks() const; + + bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const; + + QBrush br; + QPen pn; + uint wind:1; +}; + + +class QM_EXPORT_CANVAS QCanvasRectangle : public QCanvasPolygonalItem +{ +public: + QCanvasRectangle(QCanvas* canvas); + QCanvasRectangle(const QRect&, QCanvas* canvas); + QCanvasRectangle(int x, int y, int width, int height, QCanvas* canvas); + + ~QCanvasRectangle(); + + int width() const; + int height() const; + void setSize(int w, int h); + QSize size() const + { return QSize(w,h); } + QPointArray areaPoints() const; + QRect rect() const + { return QRect(int(x()),int(y()),w,h); } + + bool collidesWith( const QCanvasItem* ) const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + QPointArray chunks() const; + +private: + bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const; + + int w, h; +}; + + +class QM_EXPORT_CANVAS QCanvasPolygon : public QCanvasPolygonalItem +{ +public: + QCanvasPolygon(QCanvas* canvas); + ~QCanvasPolygon(); + void setPoints(QPointArray); + QPointArray points() const; + void moveBy(double dx, double dy); + + QPointArray areaPoints() const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + QPointArray poly; +}; + + +class QM_EXPORT_CANVAS QCanvasSpline : public QCanvasPolygon +{ +public: + QCanvasSpline(QCanvas* canvas); + ~QCanvasSpline(); + + void setControlPoints(QPointArray, bool closed=TRUE); + QPointArray controlPoints() const; + bool closed() const; + + int rtti() const; + static int RTTI; + +private: + void recalcPoly(); + QPointArray bez; + bool cl; +}; + + +class QM_EXPORT_CANVAS QCanvasLine : public QCanvasPolygonalItem +{ +public: + QCanvasLine(QCanvas* canvas); + ~QCanvasLine(); + void setPoints(int x1, int y1, int x2, int y2); + + QPoint startPoint() const + { return QPoint(x1,y1); } + QPoint endPoint() const + { return QPoint(x2,y2); } + + int rtti() const; + static int RTTI; + + void setPen(QPen p); + void moveBy(double dx, double dy); + +protected: + void drawShape(QPainter &); + QPointArray areaPoints() const; + +private: + int x1,y1,x2,y2; +}; + + +class QM_EXPORT_CANVAS QCanvasEllipse : public QCanvasPolygonalItem +{ + +public: + QCanvasEllipse( QCanvas* canvas ); + QCanvasEllipse( int width, int height, QCanvas* canvas ); + QCanvasEllipse( int width, int height, int startangle, int angle, + QCanvas* canvas ); + + ~QCanvasEllipse(); + + int width() const; + int height() const; + void setSize(int w, int h); + void setAngles(int start, int length); + int angleStart() const + { return a1; } + int angleLength() const + { return a2; } + QPointArray areaPoints() const; + + bool collidesWith( const QCanvasItem* ) const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + +private: + bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const; + int w, h; + int a1, a2; +}; + + +class QCanvasTextExtra; + +class QM_EXPORT_CANVAS QCanvasText : public QCanvasItem +{ +public: + QCanvasText(QCanvas* canvas); + QCanvasText(const QString&, QCanvas* canvas); + QCanvasText(const QString&, QFont, QCanvas* canvas); + + virtual ~QCanvasText(); + + void setText( const QString& ); + void setFont( const QFont& ); + void setColor( const QColor& ); + QString text() const; + QFont font() const; + QColor color() const; + + void moveBy(double dx, double dy); + + int textFlags() const + { return flags; } + void setTextFlags(int); + + QRect boundingRect() const; + + bool collidesWith( const QCanvasItem* ) const; + + int rtti() const; + static int RTTI; + +protected: + virtual void draw(QPainter&); + +private: +#if defined(Q_DISABLE_COPY) + QCanvasText( const QCanvasText & ); + QCanvasText &operator=( const QCanvasText & ); +#endif + void addToChunks(); + void removeFromChunks(); + void changeChunks(); + + void setRect(); + QRect brect; + QString txt; + int flags; + QFont fnt; + QColor col; + QCanvasTextExtra* extra; + + bool collidesWith( const QCanvasSprite*, + const QCanvasPolygonalItem*, + const QCanvasRectangle*, + const QCanvasEllipse*, + const QCanvasText* ) const; +}; + +#define Q_DEFINED_QCANVAS +#include "qwinexport.h" +#endif // QT_NO_CANVAS + +#endif // QCANVAS_H -- cgit v1.2.3