/****************************************************************************

**

** 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 the Qt3Support module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef Q3CANVAS_H

#define Q3CANVAS_H

#include <Qt3Support/q3scrollview.h>

#include <QtGui/qpixmap.h>

#include <Qt3Support/q3ptrlist.h>

#include <QtGui/qbrush.h>

#include <QtGui/qpen.h>

#include <Qt3Support/q3valuelist.h>

#include <Qt3Support/q3pointarray.h>

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(Qt3Support)

class Q3CanvasSprite;

class Q3CanvasPolygonalItem;

class Q3CanvasRectangle;

class Q3CanvasPolygon;

class Q3CanvasEllipse;

class Q3CanvasText;

class Q3CanvasLine;

class Q3CanvasChunk;

class Q3Canvas;

class Q3CanvasItem;

class Q3CanvasView;

class Q3CanvasPixmap;

class Q_COMPAT_EXPORT Q3CanvasItemList : public Q3ValueList<Q3CanvasItem*> {

public:

    void sort();

    void drawUnique(QPainter& painter);

    Q3CanvasItemList operator+(const Q3CanvasItemList &l) const;

};

class Q3CanvasItemExtra;

class Q_COMPAT_EXPORT Q3CanvasItem

{

public:

    Q3CanvasItem(Q3Canvas* canvas);

    virtual ~Q3CanvasItem();

    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 Q3CanvasItem*) const=0;

    Q3CanvasItemList collisions(bool exact /* NO DEFAULT */) const;

    virtual void setCanvas(Q3Canvas*);

    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;

    Q3Canvas* canvas() const

	{ return cnv; }

protected:

    void update() { changeChunks(); }

private:

    // For friendly subclasses...

    friend class Q3CanvasPolygonalItem;

    friend class Q3CanvasSprite;

    friend class Q3CanvasRectangle;

    friend class Q3CanvasPolygon;

    friend class Q3CanvasEllipse;

    friend class Q3CanvasText;

    friend class Q3CanvasLine;

    virtual Q3PointArray chunks() const;

    virtual void addToChunks();

    virtual void removeFromChunks();

    virtual void changeChunks();

    virtual bool collidesWith(const Q3CanvasSprite*,

			       const Q3CanvasPolygonalItem*,

			       const Q3CanvasRectangle*,

			       const Q3CanvasEllipse*,

			       const Q3CanvasText*) const = 0;

    // End of friend stuff

    Q3Canvas* cnv;

    static Q3Canvas* current_canvas;

    double myx,myy,myz;

    Q3CanvasItemExtra *ext;

    Q3CanvasItemExtra& extra();

    uint ani:1;

    uint vis:1;

    uint val:1;

    uint sel:1;

    uint ena:1;

    uint act:1;

};

class Q3CanvasData;

class Q_COMPAT_EXPORT Q3Canvas : public QObject

{

    Q_OBJECT

public:

    Q3Canvas(QObject* parent = 0, const char* name = 0);

    Q3Canvas(int w, int h);

    Q3Canvas(QPixmap p, int h, int v, int tilewidth, int tileheight);

    virtual ~Q3Canvas();

    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(Q3CanvasItem*, int i, int j);

    void removeItemFromChunk(Q3CanvasItem*, int i, int j);

    void addItemToChunkContaining(Q3CanvasItem*, int x, int y);

    void removeItemFromChunkContaining(Q3CanvasItem*, int x, int y);

    Q3CanvasItemList allItems();

    Q3CanvasItemList collisions(const QPoint&) const;

    Q3CanvasItemList collisions(const QRect&) const;

    Q3CanvasItemList collisions(const Q3PointArray& pa, const Q3CanvasItem* item,

				bool exact) const;

    void drawArea(const QRect&, QPainter* p, bool double_buffer=false);

    // These are for Q3CanvasView to call

    virtual void addView(Q3CanvasView*);

    virtual void removeView(Q3CanvasView*);

    void drawCanvasArea(const QRect&, QPainter* p=0, bool double_buffer=true);

    void drawViewArea(Q3CanvasView* view, QPainter* p, const QRect& r, bool dbuf);

    // These are for Q3CanvasItem to call

    virtual void addItem(Q3CanvasItem*);

    virtual void addAnimation(Q3CanvasItem*);

    virtual void removeItem(Q3CanvasItem*);

    virtual void removeAnimation(Q3CanvasItem*);

    virtual void setAdvancePeriod(int ms);

    virtual void setUpdatePeriod(int ms);

    virtual void setDoubleBuffering(bool y);

Q_SIGNALS:

    void resized();

public Q_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);

    Q3CanvasChunk& chunk(int i, int j) const;

    Q3CanvasChunk& chunkContaining(int x, int y) const;

    QRect changeBounds(const QRect& inarea);

    void ensureOffScrSize(int osw, int osh);

    QPixmap offscr;

    int awidth,aheight;

    int chunksize;

    int maxclusters;

    int chwidth,chheight;

    Q3CanvasChunk* chunks;

    Q3CanvasData* 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;

    bool dblbuf;

    friend void qt_unview(Q3Canvas* c);

    Q_DISABLE_COPY(Q3Canvas)

};

class Q3CanvasViewData;

class Q_COMPAT_EXPORT Q3CanvasView : public Q3ScrollView

{

    Q_OBJECT

public:

    Q3CanvasView(QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0);

    Q3CanvasView(Q3Canvas* viewing, QWidget* parent=0, const char* name=0, Qt::WindowFlags f=0);

    ~Q3CanvasView();

    Q3Canvas* canvas() const

	{ return viewing; }

    void setCanvas(Q3Canvas* v);

    const QMatrix &worldMatrix() const;

    const QMatrix &inverseWorldMatrix() const;

    bool setWorldMatrix(const QMatrix &);

protected:

    void drawContents(QPainter *p, int cx, int cy, int cw, int ch);

    QSize sizeHint() const;

private:

    friend class Q3Canvas;

    void drawContents(QPainter*);

    Q3Canvas* viewing;

    Q3CanvasViewData* d;

    friend void qt_unview(Q3Canvas* c);

private Q_SLOTS:

    void updateContentsSize();

private:

    Q_DISABLE_COPY(Q3CanvasView)

};

class Q_COMPAT_EXPORT Q3CanvasPixmap : public QPixmap

{

public:

#ifndef QT_NO_IMAGEIO

    Q3CanvasPixmap(const QString& datafilename);

#endif

    Q3CanvasPixmap(const QImage& image);

    Q3CanvasPixmap(const QPixmap&, const QPoint& hotspot);

    ~Q3CanvasPixmap();

    int offsetX() const

	{ return hotx; }

    int offsetY() const

	{ return hoty; }

    void setOffset(int x, int y) { hotx = x; hoty = y; }

private:

    Q_DISABLE_COPY(Q3CanvasPixmap)

    void init(const QImage&);

    void init(const QPixmap& pixmap, int hx, int hy);

    friend class Q3CanvasSprite;

    friend class Q3CanvasPixmapArray;

    friend bool qt_testCollision(const Q3CanvasSprite* s1, const Q3CanvasSprite* s2);

    int hotx,hoty;

    QImage* collision_mask;

};

class Q_COMPAT_EXPORT Q3CanvasPixmapArray

{

public:

    Q3CanvasPixmapArray();

#ifndef QT_NO_IMAGEIO

    Q3CanvasPixmapArray(const QString& datafilenamepattern, int framecount=0);

#endif

    // this form is deprecated

    Q3CanvasPixmapArray(Q3PtrList<QPixmap>, Q3PtrList<QPoint> hotspots);

    Q3CanvasPixmapArray(Q3ValueList<QPixmap>, Q3PointArray hotspots = Q3PointArray());

    ~Q3CanvasPixmapArray();

#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;

    Q3CanvasPixmap* image(int i) const

	{ return img ? img[i] : 0; }

    void setImage(int i, Q3CanvasPixmap* p);

    uint count() const

	{ return (uint)framecount; }

private:

    Q_DISABLE_COPY(Q3CanvasPixmapArray)

#ifndef QT_NO_IMAGEIO

    bool readPixmaps(const QString& datafilenamepattern, int framecount, bool maskonly);

#endif

    void reset();

    int framecount;

    Q3CanvasPixmap** img;

};

class Q_COMPAT_EXPORT Q3CanvasSprite : public Q3CanvasItem

{

public:

    Q3CanvasSprite(Q3CanvasPixmapArray* array, Q3Canvas* canvas);

    void setSequence(Q3CanvasPixmapArray* seq);

    virtual ~Q3CanvasSprite();

    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 Q3CanvasItem*) 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;

    Q3CanvasPixmap* image() const

	{ return images->image(frm); }

    virtual Q3CanvasPixmap* imageAdvanced() const;

    Q3CanvasPixmap* image(int f) const

	{ return images->image(f); }

    virtual void advance(int stage);

public:

    void draw(QPainter& painter);

private:

    Q_DISABLE_COPY(Q3CanvasSprite)

    void addToChunks();

    void removeFromChunks();

    void changeChunks();

    int frm;

    ushort anim_val;

    uint anim_state:2;

    uint anim_type:14;

    bool collidesWith(const Q3CanvasSprite*,

		       const Q3CanvasPolygonalItem*,

		       const Q3CanvasRectangle*,

		       const Q3CanvasEllipse*,

		       const Q3CanvasText*) const;

    friend bool qt_testCollision(const Q3CanvasSprite* s1,

				  const Q3CanvasSprite* s2);

    Q3CanvasPixmapArray* images;

};