ccanvas.h

//==========================================================================
//   CCANVAS.H  -  header for
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __OMNETPP_CCANVAS_H
#define __OMNETPP_CCANVAS_H

#include <string>
#include <map>
#include <vector>
#include "cownedobject.h"

namespace omnetpp {

class cCanvas;
class cProperty;
class cProperties;
class cObjectFactory;

//TODO: doc: default values as precise enum names
//TODO: doc: @figure attributes for each figure type
//TODO: doc: revise class descriptions

class SIM_API cFigure : public cOwnedObject
{
    public:
        struct SIM_API Point {
            double x, y;

            Point() : x(0), y(0) {}
            Point(double x, double y) : x(x), y(y) {}
            Point operator + (const Point& p) const;
            Point operator - (const Point& p) const;
            Point operator * (double s) const;
            Point operator / (double s) const;
            double operator * (const Point& p) const;
            double distanceTo(const Point& p) const;
            double getLength() const;
            Point& translate(double dx, double dy) {x += dx; y += dy; return *this;}
            bool operator==(const Point& other) const {return x == other.x && y == other.y;}
            std::string str() const;
        };

        struct SIM_API Rectangle {
            double x, y, width, height;

            Rectangle() : x(0), y(0), width(0), height(0) {}
            Rectangle(double x, double y, double width, double height) : x(x), y(y), width(width), height(height) {}
            Point getCenter() const;
            Point getSize() const;
            Rectangle& translate(double dx, double dy) {x += dx; y += dy; return *this;}
            bool operator==(const Rectangle& other) const {return x == other.x && y == other.y && width == other.width && height == other.height;}
            std::string str() const;
        };

        struct SIM_API Color {
            uint8_t red, green, blue;

            Color() : red(0), green(0), blue(0) {}
            Color(uint8_t red, uint8_t green, uint8_t blue) : red(red), green(green), blue(blue) {}
            Color(const char *color) {*this = parseColor(color);}
            bool operator==(const Color& other) const {return red == other.red && green == other.green && blue == other.blue;}
            std::string str() const;
        };

        static const Color BLACK;
        static const Color WHITE;
        static const Color GREY;
        static const Color RED;
        static const Color GREEN;
        static const Color BLUE;
        static const Color YELLOW;
        static const Color CYAN;
        static const Color MAGENTA;

        static const int NUM_GOOD_DARK_COLORS;
        static const int NUM_GOOD_LIGHT_COLORS;
        static const Color GOOD_DARK_COLORS[14];
        static const Color GOOD_LIGHT_COLORS[10];

        struct SIM_API Font {
            std::string typeface; 
            int pointSize;  
            uint8_t style;  


            Font() : pointSize(0), style(FONT_NONE) {}
            Font(std::string typeface, int pointSize=-1, uint8_t style=FONT_NONE) : typeface(typeface), pointSize(pointSize), style(style) {}
            bool operator==(const Font& other) const {return typeface == other.typeface && pointSize == other.pointSize && style == other.style;}
            std::string str() const;
        };

        enum FontStyle { FONT_NONE=0, FONT_BOLD=1, FONT_ITALIC=2, FONT_UNDERLINE=4 };

        enum LineStyle { LINE_SOLID, LINE_DOTTED, LINE_DASHED };

        enum CapStyle { CAP_BUTT, CAP_SQUARE, CAP_ROUND };

        enum JoinStyle { JOIN_BEVEL, JOIN_MITER, JOIN_ROUND };

        enum FillRule { FILL_EVENODD, FILL_NONZERO };

        enum Arrowhead { ARROW_NONE, ARROW_SIMPLE, ARROW_TRIANGLE, ARROW_BARBED };

        enum Interpolation { INTERPOLATION_NONE, INTERPOLATION_FAST, INTERPOLATION_BEST };

        enum Anchor {ANCHOR_CENTER, ANCHOR_N, ANCHOR_E, ANCHOR_S, ANCHOR_W, ANCHOR_NW, ANCHOR_NE, ANCHOR_SE, ANCHOR_SW, ANCHOR_BASELINE_START, ANCHOR_BASELINE_MIDDLE, ANCHOR_BASELINE_END };

        //TODO enum Alignment { ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER }; // note: multi-line text is always left-aligned in tkpath

        struct SIM_API Transform {
            double a, b, c, d, t1, t2;

            Transform() : a(1), b(0), c(0), d(1), t1(0), t2(0) {}
            Transform(double a, double b, double c, double d, double t1, double t2) : a(a), b(b), c(c), d(d), t1(t1), t2(t2) {}
            Transform(const Transform& t) : a(t.a), b(t.b), c(t.c), d(t.d), t1(t.t1), t2(t.t2) {}
            Transform& operator=(const Transform& t) {a=t.a; b=t.b; c=t.c; d=t.d; t1=t.t1; t2=t.t2; return *this;}
            Transform& translate(double dx, double dy);
            Transform& translate(const Point& p) {return translate(p.x, p.y);}
            Transform& scale(double s) {return scale(s,s);}
            Transform& scale(double sx, double sy);
            Transform& scale(double sx, double sy, double cx, double cy);
            Transform& scale(double sx, double sy, const Point& c) {return scale(sx, sy, c.x, c.y);}
            Transform& rotate(double phi);
            Transform& rotate(double phi, double cx, double cy);
            Transform& rotate(double phi, const Point& c) {return rotate(phi, c.x, c.y);}
            Transform& skewx(double coeff); // note: if you want to skew by an angle, use coeff = tan(phi)
            Transform& skewy(double coeff);
            Transform& skewx(double coeff, double cy);
            Transform& skewy(double coeff, double cx);
            Transform& multiply(const Transform& t); // left-multiply: *this = t * (*this)
            Transform& rightMultiply(const Transform& t); // *this = (*this) * t
            Point applyTo(const Point& p) const;
            bool operator==(const Transform& o) const {return a == o.a && b == o.b && c == o.c && d == o.d && t1 == o.t1 && t2 == o.t2;}
            std::string str() const;
        };

        struct SIM_API RGBA {
            uint8_t red, green, blue, alpha;

            RGBA() : red(0), green(0), blue(0), alpha(0) {}
            RGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) : red(red), green(green), blue(blue), alpha(alpha) {}
            void set(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {red=r; green=g; blue=b; alpha=a;}
            void operator=(const Color& color) {red = color.red; green = color.green; blue = color.blue; alpha = 255;}
            operator Color() const {return Color(red, green, blue);}
            bool operator==(const RGBA& o) const {return red == o.red && green == o.green && blue == o.blue && alpha == o.alpha;}
            std::string str() const;
        };

        class SIM_API Pixmap {
            private:
                int width, height; // zero is allowed
                RGBA *data;
            private:
                void allocate(int width, int height);
                static uint8_t alpha(double opacity) {return opacity<=0 ? 0 : opacity>=1.0 ? 255 : (uint8_t)(opacity*255+0.5);}
            public:
                Pixmap();
                Pixmap(int width, int height); // filled with transparent black
                Pixmap(int width, int height, const RGBA& fill);
                Pixmap(int width, int height, const Color& color, double opacity=1);
                Pixmap(const Pixmap& other);
                ~Pixmap();
                Pixmap& operator=(const Pixmap& other);
                void setSize(int width, int height, const RGBA& fill_);  // nondestructive
                void setSize(int width, int height, const Color& color, double opacity);  // nondestructive
                void fill(const RGBA& fill_);
                void fill(const Color& color, double opacity);
                int getWidth() const {return width;}
                int getHeight() const {return height;}
                RGBA& pixel(int x, int y);
                const RGBA pixel(int x, int y) const {return const_cast<Pixmap*>(this)->pixel(x,y);}
                void setPixel(int x, int y, const Color& color, double opacity=1.0) {RGBA& p = pixel(x,y); p.set(color.red, color.green, color.blue, alpha(opacity));}
                const Color getColor(int x, int y) const {return (Color)pixel(x,y);}
                void setColor(int x, int y, const Color& color) {RGBA& p = pixel(x,y); p.red = color.red; p.green = color.green; p.blue = color.blue;}
                double getOpacity(int x, int y) const {return pixel(x,y).alpha / 255.0;}
                void setOpacity(int x, int y, double opacity) {pixel(x,y).alpha = alpha(opacity);}
                const uint8_t *buffer() const {return (uint8_t*)data;} // direct access for low-level manipulation
                std::string str() const;
        };

        // internal:
        enum {
            CHANGE_STRUCTURAL = 1, // child added, removed, or reordered, shown/hidden
            CHANGE_TRANSFORM = 2, // transform change
            CHANGE_GEOMETRY = 4, // geometry information (bounds, position, start/end angle, etc)
            CHANGE_VISUAL = 8,  // styling
            CHANGE_INPUTDATA = 16,  // text, image name or pixmap data, value to be displayed, etc
            CHANGE_TAGS = 32,  // figure tags
            CHANGE_ZINDEX = 64,  // zIndex
            CHANGE_OTHER = 128  // tooltip, associated object
        };

    private:
        static int lastId;
        static cStringPool stringPool;
        int id;
        double zIndex;
        bool visible; // treated as structural change, for simpler handling
        const char *tooltip; // stringpool'd
        cObject *associatedObject;
        Transform transform;
        std::vector<cFigure*> children;
        const char *tags; // stringpool'd
        uint64_t tagBits;  // bit-to-tagname mapping is stored in cCanvas. Note: change to std::bitset if 64 tags are not enough
        uint8_t localChanges;
        uint8_t subtreeChanges;

    protected:
        // internal:
        virtual void validatePropertyKeys(cProperty *property) const; // relies on isAllowedPropertyKey()
        virtual bool isAllowedPropertyKey(const char *key) const; // allows "x-*" keys, plus the ones returned by getAllowedPropertyKeys()
        virtual cFigure *getRootFigure() const;
        void fireStructuralChange() {fire(CHANGE_STRUCTURAL);}
        void fireTransformChange() {fire(CHANGE_TRANSFORM);}
        void fireGeometryChange() {fire(CHANGE_GEOMETRY);}
        void fireVisualChange() {fire(CHANGE_VISUAL);}
        void fireInputDataChange() {fire(CHANGE_INPUTDATA);}
        virtual void fire(uint8_t flags);

    protected:
        // helpers for parse(cProperty*)
        static Point parsePoint(cProperty *property, const char *key, int index);
        static std::vector<Point> parsePoints(cProperty *property, const char *key);
        _OPPDEPRECATED static Rectangle parseBounds(cProperty *property) {return parseBounds(property, Rectangle());} //TODO use parseBounds(property, getBounds()) instead
        static Rectangle parseBounds(cProperty *property, const Rectangle& defaults);
        static Transform parseTransform(cProperty *property, const char *key);
        static Font parseFont(cProperty *property, const char *key);
        static Rectangle computeBoundingBox(const Point& position, const Point& size, double ascent, Anchor anchor);
        static void concatArrays(const char **dest, const char **first, const char **second); // concatenates nullptr-terminated arrays

    public:
        // helpers for class descriptors and parse(cProperty*)
        static Point parsePoint(const char *s); // parse Point::str() format
        static Rectangle parseRectangle(const char *s); // parse Rectangle::str() format
        static Transform parseTransform(const char *s);  // parse Transform::str() format
        static Font parseFont(const char *s);  // parse Font::str() format
        static Color parseColor(const char *s);
        static bool parseBool(const char *s);
        static LineStyle parseLineStyle(const char *s);
        static CapStyle parseCapStyle(const char *s);
        static JoinStyle parseJoinStyle(const char *s);
        static FillRule parseFillRule(const char *s);
        static Arrowhead parseArrowhead(const char *s);
        static Interpolation parseInterpolation(const char *s);
        static Anchor parseAnchor(const char *s);

    public:
        // internal, mostly used by runtime GUIs:
        virtual void updateParentTransform(Transform& transform) {transform.rightMultiply(getTransform());}
        virtual void callRefreshDisplay(); // call refreshDisplay(), and recurse to its children
        uint8_t getLocalChangeFlags() const {return localChanges;}
        uint8_t getSubtreeChangeFlags() const {return subtreeChanges;}
        void clearChangeFlags();
        void refreshTagBits();
        void refreshTagBitsRec();
        int64_t getTagBits() const {return tagBits;}
        void setTagBits(uint64_t tagBits) {this->tagBits = tagBits;}

    private:
        void copy(const cFigure& other);

    public:
        explicit cFigure(const char *name=nullptr);

        cFigure(const cFigure& other) : cOwnedObject(other), tooltip(nullptr), tags(nullptr) {copy(other);}

        virtual ~cFigure();

        cFigure& operator=(const cFigure& other);

        virtual cFigure *dup() const override {throw cRuntimeError(this, E_CANTDUP);}

        virtual void forEachChild(cVisitor *v) override;

        virtual std::string str() const override;

        int getId() const {return id;}

        virtual bool isVisible() const {return visible;}

        virtual void setVisible(bool visible);

        virtual const Transform& getTransform() const {return transform;}

        virtual void setTransform(const Transform& transform);

        virtual void resetTransform() {setTransform(Transform());}

        virtual double getZIndex() const {return zIndex;}

        virtual void setZIndex(double zIndex);

        virtual double getEffectiveZIndex() const;

        virtual const char *getTooltip() const {return tooltip;}

        virtual void setTooltip(const char *tooltip);

        virtual cObject *getAssociatedObject() const {return associatedObject;}

        virtual void setAssociatedObject(cObject *obj);

        virtual const char *getTags() const {return tags;}

        virtual void setTags(const char *tags);

        virtual cFigure *getParentFigure() const {return dynamic_cast<cFigure*>(getOwner());}

        virtual cCanvas *getCanvas() const;

        virtual int getNumFigures() const {return children.size();}

        virtual cFigure *getFigure(int pos) const;

        virtual cFigure *getFigure(const char *name) const;

        virtual int findFigure(const char *name) const;

        virtual int findFigure(const cFigure *figure) const;

        virtual bool containsFigures() const {return !children.empty();}

        virtual cFigure *findFigureRecursively(const char *name) const;

        virtual cFigure *getFigureByPath(const char *path) const;

        virtual void addFigure(cFigure *figure);

        virtual void addFigure(cFigure *figure, int pos);

        _OPPDEPRECATED void addFigureAbove(cFigure *figure, cFigure *referenceFigure) {figure->insertAbove(referenceFigure);}

        _OPPDEPRECATED void addFigureBelow(cFigure *figure, cFigure *referenceFigure) {figure->insertBelow(referenceFigure);}

        virtual cFigure *removeFigure(cFigure *figure);

        virtual cFigure *removeFigure(int pos);

        virtual cFigure *removeFromParent();

        virtual bool isAbove(const cFigure *figure) const;

        virtual bool isBelow(const cFigure *figure) const;

        virtual void insertAbove(cFigure *referenceFigure);

        virtual void insertBelow(cFigure *referenceFigure);

        virtual void insertAfter(const cFigure *referenceFigure);

        virtual void insertBefore(const cFigure *referenceFigure);

        virtual void raiseAbove(cFigure *figure);

        virtual void lowerBelow(cFigure *figure);

        virtual void raiseToTop();

        virtual void lowerToBottom();

        virtual cFigure *dupTree() const;

        virtual void translate(double dx, double dy) {transform.translate(dx,dy); fireTransformChange();}
        virtual void scale(double s) {transform.scale(s); fireTransformChange();}
        virtual void scale(double sx, double sy) {transform.scale(sx,sy); fireTransformChange();}
        virtual void scale(double sx, double sy, double cx, double cy) {transform.scale(sx,sy,cx,cy); fireTransformChange();}
        virtual void scale(double sx, double sy, const Point& c) {scale(sx, sy, c.x, c.y);}
        virtual void rotate(double phi) {transform.rotate(phi); fireTransformChange();}
        virtual void rotate(double phi, double cx, double cy) {transform.rotate(phi,cx,cy); fireTransformChange();}
        virtual void rotate(double phi, const Point& c) {rotate(phi, c.x, c.y);}
        virtual void skewx(double coeff) {transform.skewx(coeff); fireTransformChange();}
        virtual void skewy(double coeff) {transform.skewy(coeff); fireTransformChange();}
        virtual void skewx(double coeff, double cy) {transform.skewx(coeff,cy); fireTransformChange();}
        virtual void skewy(double coeff, double cx) {transform.skewy(coeff,cx); fireTransformChange();}

        virtual void parse(cProperty *property);

        virtual const char **getAllowedPropertyKeys() const;

        virtual void moveLocal(double dx, double dy) = 0;

        virtual void move(double dx, double dy);

        virtual void refreshDisplay() {}

        virtual const char *getRendererClassName() const = 0;
};

// import the namespace to be able to use the stream write operators
namespace canvas_stream_ops {
#define STREAMOP(CLASS)  inline std::ostream& operator<<(std::ostream& os, const CLASS& x) { return os << x.str(); }
STREAMOP(cFigure::Point);
STREAMOP(cFigure::Rectangle);
STREAMOP(cFigure::Color);
STREAMOP(cFigure::Font);
STREAMOP(cFigure::Transform);
STREAMOP(cFigure::RGBA);
STREAMOP(cFigure::Pixmap);
#undef STREAMOP
};


class SIM_API cGroupFigure : public cFigure
{
    private:
        void copy(const cGroupFigure& other) {}
    public:
        explicit cGroupFigure(const char *name=nullptr) : cFigure(name) {}
        cGroupFigure(const cGroupFigure& other) : cFigure(other) {copy(other);}
        cGroupFigure& operator=(const cGroupFigure& other);

        virtual cGroupFigure *dup() const override  {return new cGroupFigure(*this);}
        virtual std::string str() const override;
        virtual const char *getRendererClassName() const override {return "GroupFigureRenderer";}
        virtual void moveLocal(double dx, double dy) override {}
};

class SIM_API cPanelFigure : public cFigure
{
    private:
        Point position;
        Point anchorPoint;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void parse(cProperty *property) override;
    private:
        void copy(const cPanelFigure& other);
    public:
        explicit cPanelFigure(const char *name=nullptr) : cFigure(name) {}
        cPanelFigure(const cPanelFigure& other) : cFigure(other) {copy(other);}
        cPanelFigure& operator=(const cPanelFigure& other);

        virtual cPanelFigure *dup() const override  {return new cPanelFigure(*this);}
        virtual std::string str() const override;
        virtual const char *getRendererClassName() const override {return "";} // non-visual figure
        virtual void updateParentTransform(Transform& transform) override;
        virtual void move(double dx, double dy) override { moveLocal(dx, dy); }
        virtual void moveLocal(double dx, double dy) override {position.x += dx; position.y += dy; fireTransformChange();}

        virtual const Point& getPosition() const  {return position;}
        virtual void setPosition(const Point& position)  {this->position = position; fireTransformChange();}

        virtual const Point& getAnchorPoint() const  {return anchorPoint;}
        virtual void setAnchorPoint(const Point& anchorPoint)  {this->anchorPoint = anchorPoint; fireTransformChange();}

};

class SIM_API cAbstractLineFigure : public cFigure
{
    private:
        Color lineColor;
        LineStyle lineStyle;
        double lineWidth;
        double lineOpacity;
        CapStyle capStyle;
        Arrowhead startArrowhead, endArrowhead;
        bool zoomLineWidth;
    private:
        void copy(const cAbstractLineFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cAbstractLineFigure(const char *name=nullptr) : cFigure(name), lineColor(BLACK), lineStyle(LINE_SOLID), lineWidth(1), lineOpacity(1), capStyle(CAP_BUTT), startArrowhead(ARROW_NONE), endArrowhead(ARROW_NONE), zoomLineWidth(false) {}
        cAbstractLineFigure(const cAbstractLineFigure& other) : cFigure(other) {copy(other);}
        cAbstractLineFigure& operator=(const cAbstractLineFigure& other);

        virtual cAbstractLineFigure *dup() const override {throw cRuntimeError(this, E_CANTDUP);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;

        virtual const Color& getLineColor() const  {return lineColor;}

        virtual void setLineColor(const Color& lineColor);

        virtual double getLineWidth() const  {return lineWidth;}

        virtual void setLineWidth(double lineWidth);

        virtual double getLineOpacity() const  {return lineOpacity;}

        virtual void setLineOpacity(double lineOpacity);

        virtual LineStyle getLineStyle() const  {return lineStyle;}

        virtual void setLineStyle(LineStyle lineStyle);

        virtual CapStyle getCapStyle() const {return capStyle;}

        virtual void setCapStyle(CapStyle capStyle);

        virtual Arrowhead getStartArrowhead() const  {return startArrowhead;}

        virtual void setStartArrowhead(Arrowhead startArrowhead);

        virtual Arrowhead getEndArrowhead() const  {return endArrowhead;}

        virtual void setEndArrowhead(Arrowhead endArrowhead);

        virtual bool getZoomLineWidth() const {return zoomLineWidth;}

        virtual void setZoomLineWidth(bool zoomLineWidth);
};

class SIM_API cLineFigure : public cAbstractLineFigure
{
    private:
        Point start, end;
    private:
        void copy(const cLineFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cLineFigure(const char *name=nullptr) : cAbstractLineFigure(name) {}
        cLineFigure(const cLineFigure& other) : cAbstractLineFigure(other) {copy(other);}
        cLineFigure& operator=(const cLineFigure& other);

        virtual cLineFigure *dup() const override  {return new cLineFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "LineFigureRenderer";}

        virtual const Point& getStart() const  {return start;}

        virtual void setStart(const Point& start);

        virtual const Point& getEnd() const  {return end;}

        virtual void setEnd(const Point& end);
};

class SIM_API cArcFigure : public cAbstractLineFigure
{
    private:
        Rectangle bounds; // bounding box of the oval that arc is part of
        double startAngle, endAngle; // in radians, CCW, 0=east
    private:
        void copy(const cArcFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cArcFigure(const char *name=nullptr) : cAbstractLineFigure(name), startAngle(0), endAngle(0) {}
        cArcFigure(const cArcFigure& other) : cAbstractLineFigure(other) {copy(other);}
        cArcFigure& operator=(const cArcFigure& other);

        virtual cArcFigure *dup() const override  {return new cArcFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "ArcFigureRenderer";}

        virtual const Rectangle& getBounds() const  {return bounds;}

        virtual void setBounds(const Rectangle& bounds);

        virtual void setPosition(const Point& position, Anchor anchor);

        virtual double getStartAngle() const {return startAngle;}

        virtual void setStartAngle(double startAngle);

        virtual double getEndAngle() const {return endAngle;}

        virtual void setEndAngle(double endAngle);
};

class SIM_API cPolylineFigure : public cAbstractLineFigure
{
    private:
        std::vector<Point> points;
        bool smooth;
        JoinStyle joinStyle;
    private:
        void copy(const cPolylineFigure& other);
        void checkIndex(int i) const;
        void checkInsIndex(int i) const;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cPolylineFigure(const char *name=nullptr) : cAbstractLineFigure(name), smooth(false), joinStyle(JOIN_MITER) {}
        cPolylineFigure(const cPolylineFigure& other) : cAbstractLineFigure(other) {copy(other);}
        cPolylineFigure& operator=(const cPolylineFigure& other);

        virtual cPolylineFigure *dup() const override  {return new cPolylineFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "PolylineFigureRenderer";}

        virtual const std::vector<Point>& getPoints() const  {return points;}

        virtual void setPoints(const std::vector<Point>& points);

        virtual int getNumPoints() const {return points.size();}

        virtual const Point& getPoint(int i) const {checkIndex(i); return points[i];}

        virtual void setPoint(int i, const Point& point);

        virtual void addPoint(const Point& point);

        virtual void removePoint(int i);

        virtual void insertPoint(int i, const Point& point);

        virtual bool getSmooth() const {return smooth;}

        virtual void setSmooth(bool smooth);

        virtual JoinStyle getJoinStyle() const {return joinStyle;}

        virtual void setJoinStyle(JoinStyle joinStyle);
};

class SIM_API cAbstractShapeFigure : public cFigure
{
    private:
        bool outlined;
        bool filled;
        Color lineColor;
        Color fillColor;
        LineStyle lineStyle;
        double lineWidth;
        double lineOpacity;
        double fillOpacity;
        bool zoomLineWidth;
    private:
        void copy(const cAbstractShapeFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cAbstractShapeFigure(const char *name=nullptr) : cFigure(name), outlined(true), filled(false), lineColor(BLACK), fillColor(BLUE), lineStyle(LINE_SOLID), lineWidth(1), lineOpacity(1), fillOpacity(1), zoomLineWidth(false) {}
        cAbstractShapeFigure(const cAbstractShapeFigure& other) : cFigure(other) {copy(other);}
        cAbstractShapeFigure& operator=(const cAbstractShapeFigure& other);

        virtual cAbstractShapeFigure *dup() const override {throw cRuntimeError(this, E_CANTDUP);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;

        virtual bool isFilled() const  {return filled;}

        virtual void setFilled(bool filled);

        virtual bool isOutlined() const  {return outlined;}

        virtual void setOutlined(bool outlined);

        virtual const Color& getLineColor() const  {return lineColor;}

        virtual void setLineColor(const Color& lineColor);

        virtual const Color& getFillColor() const  {return fillColor;}

        virtual void setFillColor(const Color& fillColor);

        virtual LineStyle getLineStyle() const  {return lineStyle;}

        virtual void setLineStyle(LineStyle lineStyle);

        virtual double getLineWidth() const  {return lineWidth;}

        virtual void setLineWidth(double lineWidth);

        virtual double getLineOpacity() const  {return lineOpacity;}

        virtual void setLineOpacity(double lineOpacity);

        virtual double getFillOpacity() const  {return fillOpacity;}

        virtual void setFillOpacity(double fillOpacity);

        virtual bool getZoomLineWidth() const {return zoomLineWidth;}

        virtual void setZoomLineWidth(bool zoomLineWidth);
};

class SIM_API cRectangleFigure : public cAbstractShapeFigure
{
    private:
        Rectangle bounds;
        double cornerRx, cornerRy;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    private:
        void copy(const cRectangleFigure& other);
    public:
        explicit cRectangleFigure(const char *name=nullptr) : cAbstractShapeFigure(name), cornerRx(0), cornerRy(0) {}
        cRectangleFigure(const cRectangleFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        cRectangleFigure& operator=(const cRectangleFigure& other);

        virtual cRectangleFigure *dup() const override  {return new cRectangleFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "RectangleFigureRenderer";}

        virtual const Rectangle& getBounds() const  {return bounds;}

        virtual void setBounds(const Rectangle& bounds);

        virtual void setPosition(const Point& position, Anchor anchor);

        virtual void setCornerRadius(double r)  {setCornerRx(r);setCornerRy(r);}

        virtual double getCornerRx() const  {return cornerRx;}

        virtual void setCornerRx(double rx);

        virtual double getCornerRy() const  {return cornerRy;}

        virtual void setCornerRy(double ry);
};

class SIM_API cOvalFigure : public cAbstractShapeFigure
{
    private:
        Rectangle bounds; // bounding box
    private:
        void copy(const cOvalFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cOvalFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        cOvalFigure(const cOvalFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        cOvalFigure& operator=(const cOvalFigure& other);

        virtual cOvalFigure *dup() const override  {return new cOvalFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "OvalFigureRenderer";}

        virtual const Rectangle& getBounds() const  {return bounds;}

        virtual void setBounds(const Rectangle& bounds);

        virtual void setPosition(const Point& position, Anchor anchor);
};

class SIM_API cRingFigure : public cAbstractShapeFigure
{
    private:
        Rectangle bounds; // bounding box
        double innerRx, innerRy;
    private:
        void copy(const cRingFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cRingFigure(const char *name=nullptr) : cAbstractShapeFigure(name), innerRx(0), innerRy(0) {}
        cRingFigure(const cRingFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        cRingFigure& operator=(const cRingFigure& other);

        virtual cRingFigure *dup() const override  {return new cRingFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "RingFigureRenderer";}

        virtual const Rectangle& getBounds() const  {return bounds;}

        virtual void setBounds(const Rectangle& bounds);

        virtual void setPosition(const Point& position, Anchor anchor);

        virtual void setInnerRadius(double r)   {setInnerRx(r);setInnerRy(r);}

        virtual double getInnerRx() const  {return innerRx;}

        virtual void setInnerRx(double rx);

        virtual double getInnerRy() const  {return innerRy;}

        virtual void setInnerRy(double ry);
};

class SIM_API cPieSliceFigure : public cAbstractShapeFigure
{
    private:
        Rectangle bounds; // bounding box of the oval that the pie slice is part of
        double startAngle, endAngle; // in radians, CCW, 0=east
    private:
        void copy(const cPieSliceFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cPieSliceFigure(const char *name=nullptr) : cAbstractShapeFigure(name), startAngle(0), endAngle(0) {}
        cPieSliceFigure(const cPieSliceFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        cPieSliceFigure& operator=(const cPieSliceFigure& other);

        virtual cPieSliceFigure *dup() const override  {return new cPieSliceFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "PieSliceFigureRenderer";}

        virtual const Rectangle& getBounds() const  {return bounds;}

        virtual void setBounds(const Rectangle& bounds);

        virtual void setPosition(const Point& position, Anchor anchor);

        virtual double getStartAngle() const {return startAngle;}

        virtual void setStartAngle(double startAngle);

        virtual double getEndAngle() const {return endAngle;}

        virtual void setEndAngle(double endAngle);
};

class SIM_API cPolygonFigure : public cAbstractShapeFigure
{
    private:
        std::vector<Point> points;
        bool smooth;
        JoinStyle joinStyle;
        FillRule fillRule;
    private:
        void copy(const cPolygonFigure& other);
        void checkIndex(int i) const;
        void checkInsIndex(int i) const;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cPolygonFigure(const char *name=nullptr) : cAbstractShapeFigure(name), smooth(false), joinStyle(JOIN_MITER), fillRule(FILL_EVENODD) {}
        cPolygonFigure(const cPolygonFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        cPolygonFigure& operator=(const cPolygonFigure& other);

        virtual cPolygonFigure *dup() const override  {return new cPolygonFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "PolygonFigureRenderer";}

        virtual const std::vector<Point>& getPoints() const  {return points;}

        virtual void setPoints(const std::vector<Point>& points);

        virtual int getNumPoints() const {return points.size();}

        virtual const Point& getPoint(int i) const {checkIndex(i); return points[i];}

        virtual void setPoint(int i, const Point& point);

        virtual void addPoint(const Point& point);

        virtual void removePoint(int i);

        virtual void insertPoint(int i, const Point& point);

        virtual bool getSmooth() const {return smooth;}

        virtual void setSmooth(bool smooth);

        virtual JoinStyle getJoinStyle() const {return joinStyle;}

        virtual void setJoinStyle(JoinStyle joinStyle);

        virtual FillRule getFillRule() const {return fillRule;}

        virtual void setFillRule(FillRule fillRule);
};

class SIM_API cPathFigure : public cAbstractShapeFigure
{
    public:
        struct PathItem { char code; }; 
        struct MoveTo : PathItem { double x; double y; };  
        struct MoveRel : PathItem { double dx; double dy; };  
        struct LineTo : PathItem { double x; double y; };  
        struct LineRel : PathItem { double dx; double dy; };  
        struct HorizontalLineTo : PathItem { double x; };  
        struct HorizontalLineRel : PathItem { double dx; };  
        struct VerticalLineTo : PathItem { double y; };  
        struct VerticalLineRel : PathItem { double dy; };  
        struct ArcTo : PathItem { double rx; double ry; double phi; bool largeArc; bool sweep; double x; double y; }; 
        struct ArcRel : PathItem { double rx; double ry; double phi; bool largeArc; bool sweep; double dx; double dy; }; 
        struct CurveTo : PathItem { double x1; double y1; double x; double y; }; 
        struct CurveRel : PathItem { double dx1; double dy1; double dx; double dy; }; 
        struct SmoothCurveTo : PathItem { double x; double y; }; 
        struct SmoothCurveRel : PathItem { double dx; double dy; }; 
        struct CubicBezierCurveTo : PathItem { double x1; double y1; double x2; double y2; double x; double y; }; 
        struct CubicBezierCurveRel : PathItem { double dx1; double dy1; double dx2; double dy2; double dx; double dy; }; 
        struct SmoothCubicBezierCurveTo : PathItem { double x2; double y2; double x; double y; }; 
        struct SmoothCubicBezierCurveRel : PathItem { double dx2; double dy2; double dx; double dy; }; 
        struct ClosePath : PathItem { }; 

    private:
        std::vector<PathItem*> path;
        mutable std::string cachedPathString;
        JoinStyle joinStyle;
        CapStyle capStyle;
        Point offset;
        FillRule fillRule;

    private:
        void copy(const cPathFigure& other);
        void addItem(PathItem *item);
        void doClearPath();

    protected:
        virtual const char **getAllowedPropertyKeys() const override;

    public:
        explicit cPathFigure(const char *name=nullptr) : cAbstractShapeFigure(name), joinStyle(JOIN_MITER), capStyle(CAP_BUTT), fillRule(FILL_EVENODD) {}
        cPathFigure(const cPathFigure& other) : cAbstractShapeFigure(other) {copy(other);}
        virtual ~cPathFigure() {doClearPath();}
        cPathFigure& operator=(const cPathFigure& other);

        virtual cPathFigure *dup() const override  {return new cPathFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;
        virtual const char *getRendererClassName() const override {return "PathFigureRenderer";}

        virtual JoinStyle getJoinStyle() const {return joinStyle;}

        virtual void setJoinStyle(JoinStyle joinStyle);

        virtual CapStyle getCapStyle() const {return capStyle;}

        virtual void setCapStyle(CapStyle capStyle);

        virtual FillRule getFillRule() const {return fillRule;}

        virtual void setFillRule(FillRule fillRule);

        virtual const Point& getOffset() const {return offset;}

        virtual void setOffset(const Point& offset);

        virtual const char *getPath() const;

        virtual void setPath(const char *path);

        virtual int getNumPathItems() const {return path.size();}

        virtual const PathItem *getPathItem(int k) const {return path[k];}

        virtual void clearPath();

        virtual void addMoveTo(double x, double y);  // M x y

        virtual void addMoveRel(double dx, double dy);  // m dx dy

        virtual void addLineTo(double x, double y);  // L x y

        virtual void addLineRel(double dx, double dy);  // l dx dy

        virtual void addHorizontalLineTo(double x);  // H x

        virtual void addHorizontalLineRel(double dx);  // h dx

        virtual void addVerticalLineTo(double y);  // V y

        virtual void addVerticalLineRel(double dy);  // v dy

        virtual void addArcTo(double rx, double ry, double phi, bool largeArc, bool sweep, double x, double y); // A rx ry phi largeArc sweep x y

        virtual void addArcRel(double rx, double ry, double phi, bool largeArc, bool sweep, double dx, double dy); // a rx ry phi largeArc sweep dx dy

        virtual void addCurveTo(double x1, double y1, double x, double y); // Q x1 y1 x y

        virtual void addCurveRel(double dx1, double dy1, double dx, double dy); // q dx1 dy1 dx dy

        virtual void addSmoothCurveTo(double x, double y); // T x y

        virtual void addSmoothCurveRel(double dx, double dy); // t dx dy

        virtual void addCubicBezierCurveTo(double x1, double y1, double x2, double y2, double x, double y); // C x1 y1 x2 y2 x y

        virtual void addCubicBezierCurveRel(double dx1, double dy1, double dx2, double dy2, double dx, double dy); // c dx1 dy1 dx2 dy2 dx dy

        virtual void addSmoothCubicBezierCurveTo(double x2, double y2, double x, double y); // S x2 y2 x y

        virtual void addSmoothCubicBezierCurveRel(double dx2, double dy2, double dx, double dy); // s dx2 dy2 dx dy

        virtual void addClosePath(); // Z
};

class SIM_API cAbstractTextFigure : public cFigure
{
    private:
        Point position;
        Color color;  // note: tkpath's text supports separate colors and opacity for fill and outline -- ignore because probably SWT doesn't support it!
        double opacity;
        bool halo;
        Font font;
        std::string text;
        Anchor anchor;
    private:
        void copy(const cAbstractTextFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
    public:
        explicit cAbstractTextFigure(const char *name=nullptr) : cFigure(name), color(BLACK), opacity(1), halo(false), anchor(ANCHOR_NW) {}
        cAbstractTextFigure(const cAbstractTextFigure& other) : cFigure(other) {copy(other);}
        cAbstractTextFigure& operator=(const cAbstractTextFigure& other);

        virtual cAbstractTextFigure *dup() const override {throw cRuntimeError(this, E_CANTDUP);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;

        virtual const Point& getPosition() const  {return position;}

        virtual void setPosition(const Point& position);

        virtual Anchor getAnchor() const  {return anchor;}

        virtual void setAnchor(Anchor anchor);

        virtual Rectangle getBounds() const;

        virtual const Color& getColor() const  {return color;}

        virtual void setColor(const Color& color);

        virtual double getOpacity() const  {return opacity;}

        virtual void setOpacity(double opacity);

        virtual bool getHalo() const  {return halo;}

        virtual void setHalo(bool enabled);

        virtual const Font& getFont() const  {return font;}

        virtual void setFont(Font font);

        virtual const char *getText() const  {return text.c_str();}

        virtual void setText(const char* text);
};

class SIM_API cTextFigure : public cAbstractTextFigure
{
    private:
        void copy(const cTextFigure& other) {}
    public:
        explicit cTextFigure(const char *name=nullptr) : cAbstractTextFigure(name) {}
        cTextFigure(const cTextFigure& other) : cAbstractTextFigure(other) {copy(other);}
        cTextFigure& operator=(const cTextFigure& other);

        virtual cTextFigure *dup() const override  {return new cTextFigure(*this);}
        virtual const char *getRendererClassName() const override {return "TextFigureRenderer";}
};

class SIM_API cLabelFigure : public cAbstractTextFigure
{
    private:
        void copy(const cLabelFigure& other) {}
    public:
        explicit cLabelFigure(const char *name=nullptr) : cAbstractTextFigure(name) {}
        cLabelFigure(const cLabelFigure& other) : cAbstractTextFigure(other) {copy(other);}
        cLabelFigure& operator=(const cLabelFigure& other);

        virtual cLabelFigure *dup() const override  {return new cLabelFigure(*this);}
        virtual const char *getRendererClassName() const override {return "LabelFigureRenderer";}
};

class SIM_API cAbstractImageFigure : public cFigure
{
    private:
        Point position;
        Anchor anchor;  // note: do not use the ANCHOR_BASELINE_START/MIDDLE/END constants, as they are for text items
        double width, height; // zero or negative values mean using the image's own size
        Interpolation interpolation;
        double opacity;
        Color tintColor;
        double tintAmount; // in the range 0..1
    private:
        void copy(const cAbstractImageFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual Point getDefaultSize() const = 0;
    public:
        explicit cAbstractImageFigure(const char *name=nullptr) : cFigure(name), anchor(ANCHOR_CENTER), width(0), height(0), interpolation(INTERPOLATION_FAST), opacity(1), tintColor(BLUE), tintAmount(0) { }
        cAbstractImageFigure(const cAbstractImageFigure& other) : cFigure(other) {copy(other);}
        cAbstractImageFigure& operator=(const cAbstractImageFigure& other);

        virtual cAbstractImageFigure *dup() const override {throw cRuntimeError(this, E_CANTDUP);}
        virtual void parse(cProperty *property) override;
        virtual void moveLocal(double dx, double dy) override;

        virtual const Point& getPosition() const  {return position;}

        virtual void setPosition(const Point& position);

        virtual Anchor getAnchor() const  {return anchor;}

        virtual void setAnchor(Anchor anchor);

        virtual double getWidth() const  {return width;}

        virtual void setWidth(double width);

        virtual double getHeight() const  {return height;}

        virtual void setHeight(double height); // zero means "unset"

        virtual void setSize(double width, double height) {setWidth(width); setHeight(height);}

        virtual Rectangle getBounds() const;

        virtual Interpolation getInterpolation() const {return interpolation;}

        virtual void setInterpolation(Interpolation interpolation);

        virtual double getOpacity() const  {return opacity;}

        virtual void setOpacity(double opacity);

        virtual const Color& getTintColor() const  {return tintColor;}

        virtual void setTintColor(const Color& tintColor);

        virtual double getTintAmount() const  {return tintAmount;}

        virtual void setTintAmount(double tintAmount);
};

class SIM_API cImageFigure : public cAbstractImageFigure
{
    private:
        std::string imageName;
    private:
        void copy(const cImageFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual Point getDefaultSize() const override;
    public:
        explicit cImageFigure(const char *name=nullptr) : cAbstractImageFigure(name) {}
        cImageFigure(const cImageFigure& other) : cAbstractImageFigure(other) {copy(other);}
        cImageFigure& operator=(const cImageFigure& other);

        virtual cImageFigure *dup() const override  {return new cImageFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual const char *getRendererClassName() const override {return "ImageFigureRenderer";}

        virtual const char *getImageName() const  {return imageName.c_str();}

        virtual void setImageName(const char* imageName);

        virtual int getImageNaturalWidth() const {return getDefaultSize().x;}

        virtual int getImageNaturalHeight() const  {return getDefaultSize().y;}
};

class SIM_API cIconFigure : public cImageFigure
{
    private:
        void copy(const cIconFigure& other) {}
    public:
        explicit cIconFigure(const char *name=nullptr) : cImageFigure(name) {}
        cIconFigure(const cIconFigure& other) : cImageFigure(other) {copy(other);}
        cIconFigure& operator=(const cIconFigure& other);

        virtual cIconFigure *dup() const override  {return new cIconFigure(*this);}
        virtual const char *getRendererClassName() const override {return "IconFigureRenderer";}
};

class SIM_API cPixmapFigure : public cAbstractImageFigure
{
    private:
        Pixmap pixmap;
    private:
        void copy(const cPixmapFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual Point getDefaultSize() const override;
    public:
        explicit cPixmapFigure(const char *name=nullptr) : cAbstractImageFigure(name) {}
        cPixmapFigure(const cPixmapFigure& other) : cAbstractImageFigure(other) {copy(other);}
        virtual ~cPixmapFigure() {}
        cPixmapFigure& operator=(const cPixmapFigure& other);

        virtual cPixmapFigure *dup() const override  {return new cPixmapFigure(*this);}
        virtual std::string str() const override;
        virtual void parse(cProperty *property) override;
        virtual const char *getRendererClassName() const override {return "PixmapFigureRenderer";}

        virtual const Pixmap& getPixmap() const {return pixmap;}

        virtual void setPixmap(const Pixmap& pixmap);

        virtual int getPixmapHeight() const {return pixmap.getHeight();}
        virtual int getPixmapWidth() const {return pixmap.getWidth();}
        virtual void setPixmapSize(int width, int height, const RGBA& fill); // nondestructive, set *newly added* pixels with this color and opacity
        virtual void setPixmapSize(int width, int height, const Color& color, double opacity);  // nondestructive, fills *newly added* pixels with this color and opacity
        virtual void fillPixmap(const RGBA& fill);
        virtual void fillPixmap(const Color& color, double opacity);
        virtual const RGBA getPixel(int x, int y) const {return pixmap.pixel(x, y);}
        virtual void setPixel(int x, int y, const RGBA& argb);
        virtual void setPixel(int x, int y, const Color& color, double opacity = 1.0);
        virtual const Color getPixelColor(int x, int y) const {return pixmap.getColor(x,y);}
        virtual void setPixelColor(int x, int y, const Color& color);
        virtual double getPixelOpacity(int x, int y) const {return pixmap.getOpacity(x,y);}
        virtual void setPixelOpacity(int x, int y, double opacity);
};

class SIM_API cCanvas : public cOwnedObject
{
    private:
        cFigure::Color backgroundColor;
        cFigure *rootFigure;
        std::map<std::string,int> tagBitIndex;  // tag-to-bitindex
        static std::map<std::string,cObjectFactory*> figureFactories;
        std::map<const cObject*,double> animationSpeedMap;  // maps source to animationSpeed
        double animationHoldEndTime; // the effective one will be the maximum endTime of all visible canvases
    public:
        // internal:
        virtual cFigure *parseFigure(cProperty *property) const;
        virtual cFigure *createFigure(const char *type) const;
        static bool containsCanvasItems(cProperties *properties);
        virtual void addFiguresFrom(cProperties *properties);
        virtual uint64_t parseTags(const char *s);
        virtual std::string getTags(uint64_t tagBits);
        const std::map<const cObject*,double>& getAnimationSpeedMap() const {return animationSpeedMap;}  // for e.g. Qtenv
        double getAnimationHoldEndTime() const {return animationHoldEndTime;}  // for e.g. Qtenv
    private:
        void copy(const cCanvas& other);
    public:
        explicit cCanvas(const char *name = nullptr);
        cCanvas(const cCanvas& other) : cOwnedObject(other), rootFigure(nullptr) {copy(other);}
        virtual ~cCanvas();
        cCanvas& operator=(const cCanvas& other);

        virtual cCanvas *dup() const override  {return new cCanvas(*this);}
        virtual void forEachChild(cVisitor *v) override;
        virtual std::string str() const override;

        virtual const cFigure::Color& getBackgroundColor() const {return backgroundColor;}

        virtual void setBackgroundColor(const cFigure::Color& color) {this->backgroundColor = color;}

        virtual cFigure *getRootFigure() const {return rootFigure;}

        virtual void addFigure(cFigure *figure) {rootFigure->addFigure(figure);}

        virtual void addFigure(cFigure *figure, int pos) {rootFigure->addFigure(figure, pos);}

        _OPPDEPRECATED void addFigureAbove(cFigure *figure, cFigure *referenceFigure) {figure->insertAbove(referenceFigure);}

        _OPPDEPRECATED void addFigureBelow(cFigure *figure, cFigure *referenceFigure) {figure->insertBelow(referenceFigure);}

        virtual cFigure *removeFigure(cFigure *figure) {return rootFigure->removeFigure(figure);}

        virtual cFigure *removeFigure(int pos) {return rootFigure->removeFigure(pos);}

        virtual int findFigure(const char *name) const  {return rootFigure->findFigure(name);}

        virtual int findFigure(cFigure *figure) const  {return rootFigure->findFigure(figure);}

        virtual bool hasFigures() const {return rootFigure->containsFigures();}

        virtual int getNumFigures() const {return rootFigure->getNumFigures();}

        virtual cFigure *getFigure(int pos) const {return rootFigure->getFigure(pos);}

        virtual cFigure *getFigure(const char *name) const  {return rootFigure->getFigure(name);}

        virtual cFigure *getSubmodulesLayer() const;

        virtual cFigure *findFigureRecursively(const char *name) const {return rootFigure->findFigureRecursively(name);}

        virtual cFigure *getFigureByPath(const char *path) const {return rootFigure->getFigureByPath(path);}

        virtual std::string getAllTags() const;

        virtual std::vector<std::string> getAllTagsAsVector() const;

        virtual void setAnimationSpeed(double animationSpeed, const cObject *source);

        virtual double getAnimationSpeed(const cObject *source);

        virtual void holdSimulationFor(double animationTimeDelta);
};

}  // namespace omnetpp


#endif