kgamecanvas.h

Go to the documentation of this file.

/*  Originally created for KBoard
    Copyright 2006 Maurizio Monge <maurizio.monge@gmail.com>

BSD License
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. 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.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 __KGAMECANVAS_H__
#define __KGAMECANVAS_H__

/*
 *  Author: Maurizio Monge <maurizio.monge@gmail.com>
 */

#include <QtCore/QList>
#include <QtCore/QPoint>
#include <QtGui/QPicture>
#include <QtGui/QPixmap>
#include <QtGui/QPainter>
#include <QtCore/QRect>
#include <QtGui/QRegion>
#include <QtGui/QWidget>
#include <libkdegames_export.h>

class KGameCanvasItem;

class KDEGAMES_EXPORT KGameCanvasAbstract
{
protected:
    friend class KGameCanvasItem;

    QList<KGameCanvasItem*> m_items;
    QList<KGameCanvasItem*> m_animated_items;

public:
    KGameCanvasAbstract();

    virtual ~KGameCanvasAbstract();

    const QList<KGameCanvasItem*>* items() const { return &m_items; }

    KGameCanvasItem* itemAt(const QPoint &pos) const;

    KGameCanvasItem* itemAt(int x, int y) const { return itemAt(QPoint(x,y)); }

    QList<KGameCanvasItem*> itemsAt(const QPoint &pos) const;

    QList<KGameCanvasItem*> itemsAt(int x, int y) const { return itemsAt(QPoint(x,y)); }

    virtual void ensureAnimating() = 0;

    virtual void ensurePendingUpdate() = 0;

    virtual void invalidate(const QRect& r, bool translate = true) = 0;

    virtual void invalidate(const QRegion& r, bool translate = true) = 0;

    virtual class KGameCanvasWidget* topLevelCanvas() = 0;

    virtual QPoint canvasPosition() const = 0;
};


class KDEGAMES_EXPORT KGameCanvasItem
{
private:
    friend class KGameCanvasAbstract;
    friend class KGameCanvasWidget;
    friend class KGameCanvasGroup;
    friend class KGameCanvasAdapter;

    bool m_visible;
    bool m_animated;
    int  m_opacity;
    QPoint m_pos;
    KGameCanvasAbstract *m_canvas;

    bool m_changed;
    QRect m_last_rect;

    static QPixmap* transparence_pixmap_cache;
    static QPixmap* getTransparenceCache(const QSize &s);
    virtual void paintInternal(QPainter* p, const QRect& prect, const QRegion& preg,
                                          const QPoint &delta, double cumulative_opacity);

    void updateAfterRestack(int from, int to);

    /* function to update pending changes, called from parent */
    virtual void updateChanges();

public:
    KGameCanvasItem(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasItem();

    virtual void changed();

    bool visible() const { return m_visible; }

    void setVisible(bool v);

    bool animated() const { return m_animated; }

    void setAnimated(bool a);

    int opacity() const { return m_opacity; }

    void setOpacity(int o);

    void hide(){ setVisible(false); }

    void show(){ setVisible(true); }

    void raise();

    void lower();

    void stackOver(KGameCanvasItem* ref);

    void stackUnder(KGameCanvasItem* ref);

    KGameCanvasAbstract *canvas() const { return m_canvas; }

    KGameCanvasWidget *topLevelCanvas() const { return m_canvas ? m_canvas->topLevelCanvas() : NULL; }

    void putInCanvas(KGameCanvasAbstract *canvas);

    QPoint pos() const { return m_pos; }

    QPoint absolutePosition() const;

    void moveTo(const QPoint &newpos);

    void moveTo(int x, int y) { moveTo( QPoint(x,y)); }

    virtual void paint(QPainter* p) = 0;

    virtual QRect rect() const = 0;

    virtual bool layered() const;

    virtual void advance(int msecs);
};


class KDEGAMES_EXPORT KGameCanvasDummy : public KGameCanvasItem
{
public:
    KGameCanvasDummy(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasDummy();

    virtual void paint(QPainter* p);

    virtual QRect rect() const;
};


class KDEGAMES_EXPORT KGameCanvasGroup : public KGameCanvasItem, public KGameCanvasAbstract
{
private:
    mutable bool m_child_rect_changed;
    mutable QRect m_last_child_rect;

    virtual void paintInternal(QPainter* p, const QRect& prect, const QRegion& preg,
                                          const QPoint& delta, double cumulative_opacity);

    virtual void ensureAnimating();
    virtual void ensurePendingUpdate();
    virtual void invalidate(const QRect& r, bool translate = true);
    virtual void invalidate(const QRegion& r, bool translate = true);
    virtual void updateChanges();
    virtual void changed();

public:
    KGameCanvasGroup(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasGroup();

    virtual void paint(QPainter* p);

    virtual QRect rect() const;

    virtual void advance(int msecs);

    KGameCanvasWidget* topLevelCanvas();

    virtual QPoint canvasPosition() const;
};

class KDEGAMES_EXPORT KGameCanvasPicture : public KGameCanvasItem
{
private:
    QPicture m_picture;

public:
    KGameCanvasPicture(const QPicture& picture, KGameCanvasAbstract* canvas = NULL);

    KGameCanvasPicture(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasPicture();

    QPicture picture() const { return m_picture; }

    void setPicture(const QPicture& picture);

    virtual void paint(QPainter* p);
    virtual QRect rect() const;
};

class KDEGAMES_EXPORT KGameCanvasPixmap : public KGameCanvasItem
{
private:
    QPixmap m_pixmap;

public:
    KGameCanvasPixmap(const QPixmap& pixmap, KGameCanvasAbstract* canvas = NULL);

    KGameCanvasPixmap(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasPixmap();

    QPixmap pixmap() const { return m_pixmap; }

    void setPixmap(const QPixmap& pixmap);

    virtual void paint(QPainter* p);
    virtual QRect rect() const;
    virtual bool layered() const { return false; }
};

class KDEGAMES_EXPORT  KGameCanvasTiledPixmap : public KGameCanvasItem
{
private:
    QPixmap m_pixmap;
    QSize m_size;
    QPoint m_origin;
    bool m_move_orig;

public:
    KGameCanvasTiledPixmap(const QPixmap& pixmap, const QSize &size, const QPoint &origin,
                            bool move_orig, KGameCanvasAbstract* canvas = NULL);

    KGameCanvasTiledPixmap(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasTiledPixmap();

    QPixmap pixmap() const { return m_pixmap; }

    void setPixmap(const QPixmap& pixmap);

    void setSize(const QSize &size);

    QPoint origin() const { return m_move_orig ? m_origin + pos() : m_origin; }

    void setOrigin(const QPoint &size);

    bool moveOrigin(){ return m_move_orig; }

    void setMoveOrigin(bool move_orig);

    virtual void paint(QPainter* p);
    virtual QRect rect() const;
    virtual bool layered() const { return false; }
};


class KDEGAMES_EXPORT  KGameCanvasRectangle : public KGameCanvasItem
{
private:
    QColor m_color;
    QSize m_size;

public:
    KGameCanvasRectangle(const QColor& color, const QSize &size, KGameCanvasAbstract* canvas = NULL);

    KGameCanvasRectangle(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasRectangle();

    QColor color() const { return m_color; }

    void setColor(const QColor& color);

    void setSize(const QSize &size);

    virtual void paint(QPainter* p);
    virtual QRect rect() const;
    virtual bool layered() const { return false; }
};

class KDEGAMES_EXPORT KGameCanvasText : public KGameCanvasItem
{
public:
    enum HPos {
        HStart,
        HLeft,
        HRight,
        HCenter
    };

    enum VPos {
        VBaseline,
        VTop,
        VBottom,
        VCenter
    };

private:
    QString m_text;
    QColor m_color;
    QFont m_font;
    HPos m_hpos;
    VPos m_vpos;
    QRect m_bounding_rect;

    QPoint offsetToDrawPos() const;
    void calcBoundingRect();

public:
    KGameCanvasText(const QString& text, const QColor& color,
                    const QFont& font, HPos hp, VPos vp,
                    KGameCanvasAbstract* canvas = NULL);

    KGameCanvasText(KGameCanvasAbstract* canvas = NULL);

    virtual ~KGameCanvasText();

    QString text() const { return m_text; }

    void setText(const QString& text);

    QColor color() const { return m_color; }

    void setColor(const QColor& color);

    QFont font() const { return m_font; }

    void setFont(const QFont& font);

    HPos hPositioning() const { return m_hpos; }

    VPos vPositioning() const { return m_vpos; }

    void setPositioning(HPos hp, VPos vp);

    virtual void paint(QPainter* p);
    virtual QRect rect() const;
    virtual bool layered() const { return false; }
};

class KDEGAMES_EXPORT KGameCanvasWidget : public QWidget, public KGameCanvasAbstract
{
Q_OBJECT
private:
    friend class KGameCanvasItem;
    friend class AnimationNotifier;

    class  KGameCanvasWidgetPrivate *priv;

    virtual void ensureAnimating();
    virtual void ensurePendingUpdate();
    virtual void invalidate(const QRect& r, bool translate = true);
    virtual void invalidate(const QRegion& r, bool translate = true);

    virtual void paintEvent(QPaintEvent *event);

private Q_SLOTS:
    void processAnimations();
    void updateChanges();

public:
    KGameCanvasWidget(QWidget* parent = NULL);

    virtual ~KGameCanvasWidget();

    void setAnimationDelay(int d);

    int mSecs();

    KGameCanvasWidget* topLevelCanvas();

    virtual QPoint canvasPosition() const;
};

class KDEGAMES_EXPORT KGameCanvasAdapter : public KGameCanvasAbstract
{
    QRect m_child_rect;
    bool m_child_rect_valid;
    QRect m_invalidated_rect;

    virtual void ensureAnimating() { }
    virtual void ensurePendingUpdate();
    virtual void invalidate(const QRect& r, bool translate = true);
    virtual void invalidate(const QRegion& r, bool translate = true);

    QRect childRect();
public:
    KGameCanvasAdapter();

    virtual class KGameCanvasWidget* topLevelCanvas() { return 0; }

    virtual QPoint canvasPosition() const { return QPoint(0, 0); }

    virtual void render(QPainter* p);

    virtual void updateParent(const QRect& rect) = 0;
};

#endif //__KGRGAMECANVAS_H__

---