diff options
Diffstat (limited to '3rdparty/QtPropertyBrowser/examples/canvas_variant/qtcanvas.h')
| -rw-r--r-- | 3rdparty/QtPropertyBrowser/examples/canvas_variant/qtcanvas.h | 778 |
1 files changed, 778 insertions, 0 deletions
diff --git a/3rdparty/QtPropertyBrowser/examples/canvas_variant/qtcanvas.h b/3rdparty/QtPropertyBrowser/examples/canvas_variant/qtcanvas.h new file mode 100644 index 00000000..e6d90db4 --- /dev/null +++ b/3rdparty/QtPropertyBrowser/examples/canvas_variant/qtcanvas.h @@ -0,0 +1,778 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of a Qt Solutions component. +** +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +****************************************************************************/ + +#ifndef QTCANVAS_H +#define QTCANVAS_H + +#include <QPixmap> +#include <QBrush> +#include <QPen> +#include <QPolygon> +#include <QScrollArea> + +class QtCanvasSprite; +class QtCanvasPolygonalItem; +class QtCanvasRectangle; +class QtCanvasPolygon; +class QtCanvasEllipse; +class QtCanvasText; +class QtCanvasLine; +class QtCanvasChunk; +class QtCanvas; +class QtCanvasItem; +class QtCanvasView; +class QtCanvasPixmap; + +typedef QList<QtCanvasItem *> QtCanvasItemList; + + +class QtCanvasItemExtra; + +class QtCanvasItem +{ +public: + QtCanvasItem(QtCanvas* canvas); + virtual ~QtCanvasItem(); + + 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 QtCanvasItem*) const=0; + + QtCanvasItemList collisions(bool exact /* NO DEFAULT */) const; + + virtual void setCanvas(QtCanvas*); + + 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; } + bool visible() const + { return (bool)vis; } + bool selected() const + { return (bool)sel; } + bool enabled() const + { return (bool)ena; } + bool active() const + { return (bool)act; } + + 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; + + QtCanvas* canvas() const + { return cnv; } + +protected: + void update() { changeChunks(); } + +private: + // For friendly subclasses... + + friend class QtCanvasPolygonalItem; + friend class QtCanvasSprite; + friend class QtCanvasRectangle; + friend class QtCanvasPolygon; + friend class QtCanvasEllipse; + friend class QtCanvasText; + friend class QtCanvasLine; + + virtual QPolygon chunks() const; + virtual void addToChunks(); + virtual void removeFromChunks(); + virtual void changeChunks(); + virtual bool collidesWith(const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const = 0; + // End of friend stuff + + QtCanvas* cnv; + static QtCanvas* current_canvas; + double myx,myy,myz; + QtCanvasItemExtra *ext; + QtCanvasItemExtra& extra(); + uint ani:1; + uint vis:1; + uint val:1; + uint sel:1; + uint ena:1; + uint act:1; +}; + + +class QtCanvasData; + +class QtCanvas : public QObject +{ + Q_OBJECT +public: + QtCanvas(QObject* parent = 0); + QtCanvas(int w, int h); + QtCanvas(QPixmap p, int h, int v, int tilewidth, int tileheight); + + virtual ~QtCanvas(); + + 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<awidth && y<aheight; } + bool onCanvas(const QPoint& p) const + { return onCanvas(p.x(),p.y()); } + bool validChunk(int x, int y) const + { return x>=0 && y>=0 && x<chwidth && y<chheight; } + bool validChunk(const QPoint& p) const + { return validChunk(p.x(),p.y()); } + + int chunkSize() const + { return chunksize; } + virtual void retune(int chunksize, int maxclusters=100); + + bool sameChunk(int x1, int y1, int x2, int y2) const + { return x1/chunksize==x2/chunksize && y1/chunksize==y2/chunksize; } + virtual void setChangedChunk(int i, int j); + virtual void setChangedChunkContaining(int x, int y); + virtual void setAllChanged(); + virtual void setChanged(const QRect& area); + virtual void setUnchanged(const QRect& area); + + // These call setChangedChunk. + void addItemToChunk(QtCanvasItem*, int i, int j); + void removeItemFromChunk(QtCanvasItem*, int i, int j); + void addItemToChunkContaining(QtCanvasItem*, int x, int y); + void removeItemFromChunkContaining(QtCanvasItem*, int x, int y); + + QtCanvasItemList allItems(); + QtCanvasItemList collisions(const QPoint&) const; + QtCanvasItemList collisions(const QRect&) const; + QtCanvasItemList collisions(const QPolygon& pa, const QtCanvasItem* item, + bool exact) const; + + void drawArea(const QRect&, QPainter* p, bool double_buffer=false); + + // These are for QtCanvasView to call + virtual void addView(QtCanvasView*); + virtual void removeView(QtCanvasView*); + + void drawCanvasArea(const QRect&, QPainter* p=0, bool double_buffer=true); + void drawViewArea(QtCanvasView* view, QPainter* p, const QRect& r, bool dbuf); + + // These are for QtCanvasItem to call + virtual void addItem(QtCanvasItem*); + virtual void addAnimation(QtCanvasItem*); + virtual void removeItem(QtCanvasItem*); + virtual void removeAnimation(QtCanvasItem*); + + virtual void setAdvancePeriod(int ms); + virtual void setUpdatePeriod(int ms); + +signals: + void resized(); + +public slots: + virtual void advance(); + virtual void update(); + +protected: + virtual void drawBackground(QPainter&, const QRect& area); + virtual void drawForeground(QPainter&, const QRect& area); + +private: + void init(int w, int h, int chunksze=16, int maxclust=100); + + QtCanvasChunk& chunk(int i, int j) const; + QtCanvasChunk& chunkContaining(int x, int y) const; + + QRect changeBounds(); + + int awidth,aheight; + int chunksize; + int maxclusters; + int chwidth,chheight; + QtCanvasChunk* chunks; + + QtCanvasData* d; + + void initTiles(QPixmap p, int h, int v, int tilewidth, int tileheight); + ushort *grid; + ushort htiles; + ushort vtiles; + ushort tilew; + ushort tileh; + bool oneone; + QPixmap pm; + QTimer* update_timer; + QColor bgcolor; + bool debug_redraw_areas; + + friend void qt_unview(QtCanvas* c); + + Q_DISABLE_COPY(QtCanvas) +}; + +class QtCanvasViewData; + +class QtCanvasView : public QScrollArea +{ + Q_OBJECT + Q_PROPERTY(bool highQualityRendering READ highQualityRendering WRITE setHighQualityRendering) +public: + + QtCanvasView(QWidget* parent=0); + QtCanvasView(QtCanvas* viewing, QWidget* parent=0); + ~QtCanvasView(); + + QtCanvas* canvas() const + { return viewing; } + void setCanvas(QtCanvas* v); + + const QMatrix &worldMatrix() const; + const QMatrix &inverseWorldMatrix() const; + bool setWorldMatrix(const QMatrix &); + + virtual QSize sizeHint() const; + + bool highQualityRendering() const; +public slots: + void setHighQualityRendering(bool enable); + +protected: + friend class QtCanvasWidget; + virtual void drawContents(QPainter *p, int cx, int cy, int cw, int ch); + + virtual void contentsMousePressEvent( QMouseEvent* ); + virtual void contentsMouseReleaseEvent( QMouseEvent* ); + virtual void contentsMouseDoubleClickEvent( QMouseEvent* ); + virtual void contentsMouseMoveEvent( QMouseEvent* ); + virtual void contentsDragEnterEvent( QDragEnterEvent * ); + virtual void contentsDragMoveEvent( QDragMoveEvent * ); + virtual void contentsDragLeaveEvent( QDragLeaveEvent * ); + virtual void contentsDropEvent( QDropEvent * ); + virtual void contentsWheelEvent( QWheelEvent * ); + virtual void contentsContextMenuEvent( QContextMenuEvent * ); + +private: + friend class QtCanvas; + void drawContents(QPainter*); + QtCanvas* viewing; + QtCanvasViewData* d; + +private slots: + void updateContentsSize(); + +private: + Q_DISABLE_COPY(QtCanvasView) +}; + + +class QtCanvasPixmap : public QPixmap +{ +public: +#ifndef QT_NO_IMAGEIO + QtCanvasPixmap(const QString& datafilename); +#endif + QtCanvasPixmap(const QImage& image); + QtCanvasPixmap(const QPixmap&, const QPoint& hotspot); + ~QtCanvasPixmap(); + + int offsetX() const + { return hotx; } + int offsetY() const + { return hoty; } + void setOffset(int x, int y) { hotx = x; hoty = y; } + +private: + Q_DISABLE_COPY(QtCanvasPixmap) + + void init(const QImage&); + void init(const QPixmap& pixmap, int hx, int hy); + + friend class QtCanvasSprite; + friend class QtCanvasPixmapArray; + friend bool qt_testCollision(const QtCanvasSprite* s1, const QtCanvasSprite* s2); + + int hotx,hoty; + + QImage* collision_mask; +}; + + +class QtCanvasPixmapArray +{ +public: + QtCanvasPixmapArray(); +#ifndef QT_NO_IMAGEIO + QtCanvasPixmapArray(const QString& datafilenamepattern, int framecount=0); +#endif + QtCanvasPixmapArray(const QList<QPixmap> &pixmaps, const QPolygon &hotspots = QPolygon()); + ~QtCanvasPixmapArray(); + +#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; + + QtCanvasPixmap* image(int i) const + { return img ? img[i] : 0; } + void setImage(int i, QtCanvasPixmap* p); + uint count() const + { return (uint)framecount; } + +private: + Q_DISABLE_COPY(QtCanvasPixmapArray) + +#ifndef QT_NO_IMAGEIO + bool readPixmaps(const QString& datafilenamepattern, int framecount, bool maskonly); +#endif + + void reset(); + int framecount; + QtCanvasPixmap** img; +}; + + +class QtCanvasSprite : public QtCanvasItem +{ +public: + QtCanvasSprite(QtCanvasPixmapArray* array, QtCanvas* canvas); + + void setSequence(QtCanvasPixmapArray* seq); + + virtual ~QtCanvasSprite(); + + 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 QtCanvasItem*) 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; + QtCanvasPixmap* image() const + { return images->image(frm); } + virtual QtCanvasPixmap* imageAdvanced() const; + QtCanvasPixmap* image(int f) const + { return images->image(f); } + virtual void advance(int stage); + +public: + void draw(QPainter& painter); + +private: + Q_DISABLE_COPY(QtCanvasSprite) + + void addToChunks(); + void removeFromChunks(); + void changeChunks(); + + int frm; + ushort anim_val; + uint anim_state:2; + uint anim_type:14; + bool collidesWith(const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const; + + friend bool qt_testCollision(const QtCanvasSprite* s1, + const QtCanvasSprite* s2); + + QtCanvasPixmapArray* images; +}; + +class QPolygonalProcessor; + +class QtCanvasPolygonalItem : public QtCanvasItem +{ +public: + QtCanvasPolygonalItem(QtCanvas* canvas); + virtual ~QtCanvasPolygonalItem(); + + bool collidesWith(const QtCanvasItem*) const; + + virtual void setPen(QPen p); + virtual void setBrush(QBrush b); + + QPen pen() const + { return pn; } + QBrush brush() const + { return br; } + + virtual QPolygon areaPoints() const=0; + virtual QPolygon 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 QPolygon& pa, int winding, + QPolygonalProcessor& process) const; + QPolygon chunks() const; + + bool collidesWith(const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const; + + QBrush br; + QPen pn; + uint wind:1; +}; + + +class QtCanvasRectangle : public QtCanvasPolygonalItem +{ +public: + QtCanvasRectangle(QtCanvas* canvas); + QtCanvasRectangle(const QRect&, QtCanvas* canvas); + QtCanvasRectangle(int x, int y, int width, int height, QtCanvas* canvas); + + ~QtCanvasRectangle(); + + int width() const; + int height() const; + void setSize(int w, int h); + QSize size() const + { return QSize(w,h); } + QPolygon areaPoints() const; + QRect rect() const + { return QRect(int(x()),int(y()),w,h); } + + bool collidesWith(const QtCanvasItem*) const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + QPolygon chunks() const; + +private: + bool collidesWith( const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const; + + int w, h; +}; + + +class QtCanvasPolygon : public QtCanvasPolygonalItem +{ +public: + QtCanvasPolygon(QtCanvas* canvas); + ~QtCanvasPolygon(); + void setPoints(QPolygon); + QPolygon points() const; + void moveBy(double dx, double dy); + + QPolygon areaPoints() const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + QPolygon poly; +}; + + +class QtCanvasSpline : public QtCanvasPolygon +{ +public: + QtCanvasSpline(QtCanvas* canvas); + ~QtCanvasSpline(); + + void setControlPoints(QPolygon, bool closed=true); + QPolygon controlPoints() const; + bool closed() const; + + int rtti() const; + static int RTTI; + +private: + void recalcPoly(); + QPolygon bez; + bool cl; +}; + + +class QtCanvasLine : public QtCanvasPolygonalItem +{ +public: + QtCanvasLine(QtCanvas* canvas); + ~QtCanvasLine(); + 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 &); + QPolygon areaPoints() const; + +private: + int x1,y1,x2,y2; +}; + + +class QtCanvasEllipse : public QtCanvasPolygonalItem +{ + +public: + QtCanvasEllipse(QtCanvas* canvas); + QtCanvasEllipse(int width, int height, QtCanvas* canvas); + QtCanvasEllipse(int width, int height, int startangle, int angle, + QtCanvas* canvas); + + ~QtCanvasEllipse(); + + 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; } + QPolygon areaPoints() const; + + bool collidesWith(const QtCanvasItem*) const; + + int rtti() const; + static int RTTI; + +protected: + void drawShape(QPainter &); + +private: + bool collidesWith(const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const; + int w, h; + int a1, a2; +}; + + +class QtCanvasTextExtra; + +class QtCanvasText : public QtCanvasItem +{ +public: + QtCanvasText(QtCanvas* canvas); + QtCanvasText(const QString&, QtCanvas* canvas); + QtCanvasText(const QString&, QFont, QtCanvas* canvas); + + virtual ~QtCanvasText(); + + 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 QtCanvasItem*) const; + + int rtti() const; + static int RTTI; + +protected: + virtual void draw(QPainter&); + +private: + Q_DISABLE_COPY(QtCanvasText) + + void addToChunks(); + void removeFromChunks(); + void changeChunks(); + + void setRect(); + QRect brect; + QString txt; + int flags; + QFont fnt; + QColor col; + QtCanvasTextExtra* extra; + + bool collidesWith(const QtCanvasSprite*, + const QtCanvasPolygonalItem*, + const QtCanvasRectangle*, + const QtCanvasEllipse*, + const QtCanvasText*) const; +}; + +#endif // QTCANVAS_H |