Add cairo interface.

src/visual_elements/CMakeLists.txt

@@ -0,0 +1,19 @@
+list(APPEND visual_elements_LIB_INCLUDES
+    GeometryElement.cpp
+    RectangleElement.cpp
+    TextElement.cpp
+    VisualLayer.cpp
+)
+
+add_library(visual_elements SHARED ${visual_elements_LIB_INCLUDES})
+
+target_include_directories(visual_elements PUBLIC
+                          "${PROJECT_SOURCE_DIR}/src/core/"
+                          "${PROJECT_SOURCE_DIR}/src/geometry/"
+                          )
+
+target_link_libraries(visual_elements PUBLIC core geometry)
+
+set_property(TARGET visual_elements PROPERTY FOLDER src)
+
+set_target_properties( visual_elements PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON ) 

src/visual_elements/GeometryElement.cpp

@@ -0,0 +1,39 @@
+#include "GeometryElement.h"
+
+GeometryElement::GeometryElement()
+    : mFillColor(Color::Create(255, 255, 255)),
+      mStrokeColor(Color::Create(0, 0, 0)),
+      mStrokeThickness(1),
+      mType(Type::Path)
+{
+
+}
+
+Color* GeometryElement::GetFillColor() const
+{
+    return mFillColor.get();
+}
+Color* GeometryElement::GetStrokeColor() const
+{
+    return mStrokeColor.get();
+}
+
+unsigned GeometryElement::GetStrokeThickness() const
+{
+    return mStrokeThickness;
+}
+
+void GeometryElement::SetFillColor(ColorUPtr color)
+{
+    mFillColor = std::move(color);
+}
+
+void GeometryElement::SetStrokeColor(ColorUPtr color)
+{
+    mStrokeColor = std::move(color);
+}
+
+void GeometryElement::SetStrokeThickness(unsigned thickness)
+{
+    mStrokeThickness = thickness;
+}

src/visual_elements/GeometryElement.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "Color.h"
+
+class GeometryElement
+{
+public:
+    enum class Type
+    {
+        Path,
+        Rectangle,
+        Circle,
+        Arc
+    };
+
+private:
+    ColorUPtr mFillColor;
+    ColorUPtr mStrokeColor;
+    unsigned mStrokeThickness;
+    Type mType;
+
+public:
+
+    GeometryElement();
+    virtual ~GeometryElement() = default;
+
+    Color* GetFillColor() const;
+    Color* GetStrokeColor() const;
+    unsigned GetStrokeThickness() const;
+    virtual Type GetType() = 0;
+
+    void SetFillColor(ColorUPtr color);
+    void SetStrokeColor(ColorUPtr color);
+    void SetStrokeThickness(unsigned thickness);
+};
+
+using GeometryElementUPtr = std::unique_ptr<GeometryElement>;

src/visual_elements/RectangleElement.cpp

@@ -0,0 +1,36 @@
+#include "RectangleElement.h"
+
+RectangleElement::RectangleElement(const DiscretePoint& loc,
+            unsigned width, unsigned height)
+    : mLocation(loc),
+      mWidth(width),
+      mHeight(height)
+{
+
+}
+
+std::unique_ptr<RectangleElement> RectangleElement::Create(const DiscretePoint& loc,
+        unsigned width, unsigned height)
+{
+    return std::make_unique<RectangleElement>(loc, width, height);
+}
+
+GeometryElement::Type RectangleElement::GetType()
+{
+    return GeometryElement::Type::Rectangle;
+}
+
+DiscretePoint RectangleElement::GetLocation() const
+{
+    return mLocation;
+}
+
+unsigned RectangleElement::GetWidth() const
+{
+    return mWidth;
+}
+
+unsigned RectangleElement::GetHeight() const
+{
+    return mHeight;
+}

src/visual_elements/RectangleElement.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+
+#include "GeometryElement.h"
+#include "DiscretePoint.h"
+
+class RectangleElement : public GeometryElement
+{
+    DiscretePoint mLocation;
+    unsigned mWidth;
+    unsigned mHeight;
+
+public:
+
+    RectangleElement(const DiscretePoint& loc, unsigned width, unsigned height);
+    static std::unique_ptr<RectangleElement> Create(const DiscretePoint& loc,
+            unsigned width, unsigned height);
+    GeometryElement::Type GetType() override;
+
+    DiscretePoint GetLocation() const;
+    unsigned GetWidth() const;
+    unsigned GetHeight() const;
+};
+
+using RectangleElementUPtr = std::unique_ptr<RectangleElement>;
+
+

src/visual_elements/TextElement.cpp

@@ -0,0 +1,62 @@
+#include "TextElement.h"
+
+#include "Color.h"
+
+TextElement::TextElement(const std::string& content, const DiscretePoint& loc)
+    : mContent(content),
+      mLocation(loc),
+      mFontLabel("fixed"),
+      mFillColor(Color::Create(255, 255, 255)),
+      mStrokeColor(Color::Create(0, 0, 0))
+{
+// https://en.wikipedia.org/wiki/Fixed_(typeface)#:~:text=misc%2Dfixed%20is%20a%20collection,to%20a%20single%20font%20family.
+}
+
+TextElement::~TextElement()
+{
+
+}
+
+std::unique_ptr<TextElement> TextElement::Create(const std::string& content, const DiscretePoint& loc)
+{
+    return std::make_unique<TextElement>(content, loc);
+}
+
+Color* TextElement::GetFillColor() const
+{
+    return mFillColor.get();
+}
+Color* TextElement::GetStrokeColor() const
+{
+    return mStrokeColor.get();
+}
+
+DiscretePoint TextElement::GetLocation() const
+{
+    return mLocation;
+}
+
+std::string TextElement::GetFontLabel() const
+{
+    return mFontLabel;
+}
+
+std::string TextElement::GetContent() const
+{
+    return mContent;
+}
+
+void TextElement::SetContent(const std::string& content)
+{
+    mContent = content;
+}
+
+void TextElement::SetFillColor(ColorUPtr color)
+{
+    mFillColor = std::move(color);
+}
+
+void TextElement::SetStrokeColor(ColorUPtr color)
+{
+    mStrokeColor = std::move(color);
+}

src/visual_elements/TextElement.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "DiscretePoint.h"
+
+#include <memory>
+#include <string>
+
+class Color;
+
+class TextElement
+{
+    std::string mContent;
+    DiscretePoint mLocation;
+    std::string mFontLabel;
+    std::unique_ptr<Color> mFillColor;
+    std::unique_ptr<Color> mStrokeColor;
+
+public:
+
+    TextElement(const std::string& content, const DiscretePoint& loc);
+
+    ~TextElement();
+
+    static std::unique_ptr<TextElement> Create(const std::string& content, const DiscretePoint& loc);
+
+    Color* GetFillColor() const;
+    Color* GetStrokeColor() const;
+
+    DiscretePoint GetLocation() const;
+    std::string GetContent() const;
+    std::string GetFontLabel() const;
+    void SetContent(const std::string& content);
+    void SetFillColor(std::unique_ptr<Color> color);
+    void SetStrokeColor(std::unique_ptr<Color> color);
+};
+
+using TextElementUPtr = std::unique_ptr<TextElement>;

src/visual_elements/VisualLayer.cpp

@@ -0,0 +1,46 @@
+#include "VisualLayer.h"
+
+#include "GeometryElement.h"
+#include "TextElement.h"
+
+VisualLayer::VisualLayer()
+    : mShape(),
+      mText()
+{
+
+}
+
+std::unique_ptr<VisualLayer> VisualLayer::Create()
+{
+    return std::make_unique<VisualLayer>();
+}
+
+bool VisualLayer::HasShape() const
+{
+    return bool(mShape);
+}
+
+bool VisualLayer::HasText() const
+{
+    return bool(mText);
+}
+
+GeometryElement* VisualLayer::GetShape() const
+{
+    return mShape.get();
+}
+
+TextElement* VisualLayer::GetText() const
+{
+    return mText.get();
+}
+
+void VisualLayer::SetShape(GeometryElementUPtr shape)
+{
+    mShape = std::move(shape);
+}
+
+void VisualLayer::SetText(TextElementUPtr text)
+{
+    mText = std::move(text);
+}

src/visual_elements/VisualLayer.h

@@ -0,0 +1,25 @@
+#pragma once
+#include <memory>
+
+class GeometryElement;
+class TextElement;
+
+class VisualLayer
+{
+    std::unique_ptr<GeometryElement> mShape;
+    std::unique_ptr<TextElement> mText;
+
+public:
+
+    VisualLayer();
+
+    static std::unique_ptr<VisualLayer> Create();
+
+    GeometryElement* GetShape() const;
+    TextElement* GetText() const;
+    bool HasShape() const;
+    bool HasText() const;
+    void SetShape(std::unique_ptr<GeometryElement> shape);
+    void SetText(std::unique_ptr<TextElement> text);
+};
+using VisualLayerUPtr = std::unique_ptr<VisualLayer>;