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 <cmath>
#include "cownedobject.h"
#include "opp_pooledstring.h"
 
namespace omnetpp {
 
class cCanvas;
class cProperty;
class cProperties;
class cObjectFactory;
class cHasher;
 
//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 = 0, y = 0;
 
            Point() {}
            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;
            double getAngle() const {return std::atan2(y,x);}
            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 = 0, y = 0, width = 0, height = 0;
 
            Rectangle() {}
            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 = 0, green = 0, blue = 0;
 
            Color() {}
            Color(uint8_t red, uint8_t green, uint8_t blue) : red(red), green(green), blue(blue) {}
            Color(const char *color) {*this = parseColor(color);}
            Color(const Color& other) = default;
            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 = 0;  
            uint8_t style = FONT_NONE;  
 
 
            Font() {}
            Font(std::string typeface, int pointSize=-1, uint8_t style=FONT_NONE) : typeface(typeface), pointSize(pointSize), style(style) {}
            Font(const Font& other) = default;
            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 };
 
        enum Alignment { ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER };
 
        struct SIM_API Transform {
            double a = 1, b = 0, c = 0, d = 1, t1 = 0, t2 = 0;
 
            Transform() {}
            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) = default;
            Transform& operator=(const Transform& t) = default;
            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 = 0, green = 0, blue = 0, alpha = 0;
 
            RGBA() {}
            RGBA(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) : red(red), green(green), blue(blue), alpha(alpha) {}
            explicit RGBA(const Color& color, double opacity=1) : red(color.red), green(color.green), blue(color.blue), alpha(toAlpha(opacity)) {}
            RGBA(const RGBA& other) = default;
            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;}
            static uint8_t toAlpha(double opacity) {return opacity<=0 ? 0 : opacity>=1.0 ? 255 : (uint8_t)(opacity*255+0.5);}
            std::string str() const;
        };
 
        class SIM_API Pixmap {
            private:
                int width = 0, height = 0; // zero is allowed
                RGBA *data = nullptr;
            private:
                void allocate(int width, int height);
            public:
                Pixmap() {}
                Pixmap(int width, int height, const RGBA& fill=RGBA(BLACK,0));
                Pixmap(int width, int height, const Color& color, double opacity=1) : Pixmap(width, height, RGBA(color, opacity)) {}
                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, RGBA::toAlpha(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 = RGBA::toAlpha(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;
        int id;
        bool visible = true; // treated as structural change, for simpler handling
        bool hasTooltip = false;
        double zIndex = 0;
        opp_pooledstring tooltip;
        cObject *associatedObject = nullptr;
        Transform transform;
        std::vector<cFigure*> children;
        opp_pooledstring tags;
        uint64_t tagBits = 0;  // bit-to-tagname mapping is stored in cCanvas. Note: change to std::bitset if 64 tags are not enough
        uint8_t localChanges = 0;
        uint8_t subtreeChanges = 0;
        mutable bool cachedHashValid = false; // separate flag needed because zero hash is also a valid value
        mutable uint32_t cachedHash = 0;
 
    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);
        virtual void hashTo(cHasher& hasher) const;
 
    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);
        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);
        static Alignment parseAlignment(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 refreshTagBitsRec(cCanvas *ownerCanvas);
        int64_t getTagBits() const {return tagBits;}
        void setTagBits(uint64_t tagBits) {this->tagBits = tagBits;}
        uint32_t getHash() const;
        void clearCachedHash(); // for debugging
 
    private:
        void copy(const cFigure& other);
 
    public:
        explicit cFigure(const char *name=nullptr);
 
        cFigure(const cFigure& other) : cOwnedObject(other) {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 hasTooltip ? tooltip.c_str() : nullptr;}
 
        virtual void setTooltip(const char *tooltip);
 
        virtual cObject *getAssociatedObject() const {return associatedObject;}
 
        virtual void setAssociatedObject(cObject *obj);
 
        virtual const char *getTags() const {return tags.c_str();}
 
        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);
 
        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;
        virtual void hashTo(cHasher& hasher) const 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 = LINE_SOLID;
        double lineWidth = 1;
        double lineOpacity = 1;
        CapStyle capStyle = CAP_BUTT;
        Arrowhead startArrowhead = ARROW_NONE, endArrowhead = ARROW_NONE;
        bool zoomLineWidth = false;
    private:
        void copy(const cAbstractLineFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cAbstractLineFigure(const char *name=nullptr) : cFigure(name), lineColor(BLACK) {}
        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;
        virtual void hashTo(cHasher& hasher) 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 = 0, endAngle = 0; // in radians, CCW, 0=east
    private:
        void copy(const cArcFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cArcFigure(const char *name=nullptr) : cAbstractLineFigure(name) {}
        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 = false;
        JoinStyle joinStyle = JOIN_MITER;
    private:
        void copy(const cPolylineFigure& other);
        void checkIndex(int i) const;
        void checkInsIndex(int i) const;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cPolylineFigure(const char *name=nullptr) : cAbstractLineFigure(name) {}
        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 setNumPoints(int size); // primarily for sim_std.msg
 
        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 = true;
        bool filled = false;
        Color lineColor;
        Color fillColor;
        LineStyle lineStyle = LINE_SOLID;
        double lineWidth = 1;
        double lineOpacity = 1;
        double fillOpacity = 1;
        bool zoomLineWidth = false;
    private:
        void copy(const cAbstractShapeFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cAbstractShapeFigure(const char *name=nullptr) : cFigure(name),  lineColor(BLACK), fillColor(BLUE) {}
        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 = 0, cornerRy = 0;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    private:
        void copy(const cRectangleFigure& other);
    public:
        explicit cRectangleFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        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;
        virtual void hashTo(cHasher& hasher) 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 = 0, innerRy = 0;
    private:
        void copy(const cRingFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cRingFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        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 = 0, endAngle = 0; // in radians, CCW, 0=east
    private:
        void copy(const cPieSliceFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cPieSliceFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        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 = false;
        JoinStyle joinStyle = JOIN_MITER;
        FillRule fillRule = FILL_EVENODD;
    private:
        void copy(const cPolygonFigure& other);
        void checkIndex(int i) const;
        void checkInsIndex(int i) const;
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cPolygonFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        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 setNumPoints(int size); // primarily for sim_std.msg
 
        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 = JOIN_MITER;
        CapStyle capStyle = CAP_BUTT;
        Point offset;
        FillRule fillRule = FILL_EVENODD;
 
    private:
        void copy(const cPathFigure& other);
        void addItem(PathItem *item);
        void doClearPath();
 
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
 
    public:
        explicit cPathFigure(const char *name=nullptr) : cAbstractShapeFigure(name) {}
        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 = 1;
        bool halo = false;
        Font font;
        std::string text;
        Anchor anchor = ANCHOR_NW;
        Alignment alignment = ALIGN_LEFT;
    private:
        void copy(const cAbstractTextFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    public:
        explicit cAbstractTextFigure(const char *name=nullptr) : cFigure(name), color(BLACK) {}
        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 Alignment getAlignment() const  {return alignment;}
 
        virtual void setAlignment(Alignment alignment);
 
        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:
        double angle = 0.0; // in radians, positive is CCW, 0 is "horizontal" or "unrotated"
    private:
        void copy(const cLabelFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
    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 void parse(cProperty *property) override;
        virtual const char *getRendererClassName() const override {return "LabelFigureRenderer";}
 
        virtual double getAngle() const  {return angle;}
        virtual void setAngle(double angle);
};
 
class SIM_API cAbstractImageFigure : public cFigure
{
    private:
        Point position;
        Anchor anchor = ANCHOR_CENTER;  // note: do not use the ANCHOR_BASELINE_START/MIDDLE/END constants, as they are for text items
        double width = 0, height = 0; // zero or negative values mean using the image's own size
        Interpolation interpolation = INTERPOLATION_FAST;
        double opacity = 1;
        Color tintColor;
        double tintAmount = 0; // in the range 0..1
    private:
        void copy(const cAbstractImageFigure& other);
    protected:
        virtual const char **getAllowedPropertyKeys() const override;
        virtual void hashTo(cHasher& hasher) const override;
        virtual Point getDefaultSize() const = 0;
    public:
        explicit cAbstractImageFigure(const char *name=nullptr) : cFigure(name),  tintColor(BLUE) { }
        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 void hashTo(cHasher& hasher) 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 void hashTo(cHasher& hasher) 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 minAnimationSpeed = DBL_MAX; // minimum of the values in animationSpeedMap cached, or DBL_MAX for none
        double animationHoldEndTime = 0; // 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 getMinAnimationSpeed() const {return minAnimationSpeed;} // for e.g. Qtenv; DBL_MAX if none
        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 uint32_t getHash() const;
 
        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);}
 
        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