Update shapes rendering

TBD: Line, Text, Polyline (fill)

src/Graphics.hpp

@@ -10,7 +10,6 @@
 #include "graphics/Polygon.hpp"
 #include "graphics/Polyline.hpp"
 #include "graphics/Rect.hpp"
-#include "graphics/Shape.hpp"
 #include "graphics/Text.hpp"
 
 #endif  // GRAPHICS_HPP_

src/Parser.hpp

@@ -1,11 +1,25 @@
 #ifndef PARSER_HPP_
 #define PARSER_HPP_
 
+#include <algorithm>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <sstream>
 #include <string>
 #include <vector>
 
 #include "../external/rapidxml/rapidxml.hpp"
-#include "Graphics.hpp"
+#include "graphics/Circle.hpp"
+#include "graphics/Color.hpp"
+#include "graphics/Ellipse.hpp"
+#include "graphics/Group.hpp"
+#include "graphics/Line.hpp"
+#include "graphics/Path.hpp"
+#include "graphics/Polygon.hpp"
+#include "graphics/Polyline.hpp"
+#include "graphics/Rect.hpp"
+#include "graphics/Text.hpp"
 
 using namespace rapidxml;
 

src/graphics/Renderer.cpp → src/Renderer.cpp

@@ -11,8 +11,39 @@ Renderer* Renderer::getInstance(Gdiplus::Graphics& graphics) {
     return instance;
 }
 
-void Renderer::draw(Shape* shape) const {
-    if (shape->getClass() == "Polyline") {
+void Renderer::draw(SVGElement* shape) const {
+    std::cout << shape->getClass() << std::endl;
+    if (shape->getClass() == "Group") {
+        Group* group = dynamic_cast< Group* >(shape);
+        for (auto elem : group->getElements()) {
+            std::cout << elem->getClass() << std::endl;
+            if (elem->getClass() == "Polyline") {
+                Plyline* polyline = dynamic_cast< Plyline* >(elem);
+                drawPolyline(polyline);
+            } else if (elem->getClass() == "Text") {
+                Text* text = dynamic_cast< Text* >(elem);
+                drawText(text);
+            } else if (elem->getClass() == "Rect") {
+                Rect* rectangle = dynamic_cast< Rect* >(elem);
+                drawRectangle(rectangle);
+            } else if (elem->getClass() == "Circle") {
+                Circle* circle = dynamic_cast< Circle* >(elem);
+                drawCircle(circle);
+            } else if (elem->getClass() == "Ellipse") {
+                Ell* ellipse = dynamic_cast< Ell* >(elem);
+                drawEllipse(ellipse);
+            } else if (elem->getClass() == "Line") {
+                Line* line = dynamic_cast< Line* >(elem);
+                drawLine(line);
+            } else if (elem->getClass() == "Polygon") {
+                Plygon* polygon = dynamic_cast< Plygon* >(elem);
+                drawPolygon(polygon);
+            } else if (elem->getClass() == "Path") {
+                Path* path = dynamic_cast< Path* >(elem);
+                drawPath(path);
+            }
+        }
+    } else if (shape->getClass() == "Polyline") {
         Plyline* polyline = dynamic_cast< Plyline* >(shape);
         drawPolyline(polyline);
     } else if (shape->getClass() == "Text") {
@@ -50,45 +81,78 @@ void Renderer::drawLine(Line* line) const {
 
 void Renderer::drawRectangle(Rect* rectangle) const {
     mColor fill_color = rectangle->getFillColor();
-    Gdiplus::SolidBrush RectFill(
-        Gdiplus::Color(fill_color.a, fill_color.r, fill_color.g, fill_color.b));
-    graphics.FillRectangle(&RectFill, rectangle->getPosition().x,
-                           rectangle->getPosition().y, rectangle->getWidth(),
-                           rectangle->getHeight());
     mColor outline_color = rectangle->getOutlineColor();
+
     Gdiplus::Pen RectOutline(Gdiplus::Color(outline_color.a, outline_color.r,
                                             outline_color.g, outline_color.b),
                              rectangle->getOutlineThickness());
+    Gdiplus::SolidBrush RectFill(
+        Gdiplus::Color(fill_color.a, fill_color.r, fill_color.g, fill_color.b));
     graphics.DrawRectangle(&RectOutline, rectangle->getPosition().x,
                            rectangle->getPosition().y, rectangle->getWidth(),
                            rectangle->getHeight());
+    graphics.FillRectangle(&RectFill, rectangle->getPosition().x,
+                           rectangle->getPosition().y, rectangle->getWidth(),
+                           rectangle->getHeight());
 }
 
-void Renderer::drawCircle(Circle* circle) const {}
+void Renderer::drawCircle(Circle* circle) const {
+    mColor fill_color = circle->getFillColor();
+    mColor outline_color = circle->getOutlineColor();
+    Gdiplus::Pen circleOutline(Gdiplus::Color(outline_color.a, outline_color.r,
+                                              outline_color.g, outline_color.b),
+                               circle->getOutlineThickness());
+    Gdiplus::SolidBrush circleFill(
+        Gdiplus::Color(fill_color.a, fill_color.r, fill_color.g, fill_color.b));
+    graphics.DrawEllipse(&circleOutline,
+                         circle->getPosition().x - circle->getRadius().x,
+                         circle->getPosition().y - circle->getRadius().y,
+                         circle->getRadius().x * 2, circle->getRadius().x * 2);
+    graphics.FillEllipse(&circleFill,
+                         circle->getPosition().x - circle->getRadius().x,
+                         circle->getPosition().y - circle->getRadius().y,
+                         circle->getRadius().x * 2, circle->getRadius().y * 2);
+}
 
-void Renderer::drawEllipse(Ell* ellipse) const {}
+void Renderer::drawEllipse(Ell* ellipse) const {
+    mColor fill_color = ellipse->getFillColor();
+    mColor outline_color = ellipse->getOutlineColor();
+    Gdiplus::Pen ellipseOutline(
+        Gdiplus::Color(outline_color.a, outline_color.r, outline_color.g,
+                       outline_color.b),
+        ellipse->getOutlineThickness());
+    Gdiplus::SolidBrush ellipseFill(
+        Gdiplus::Color(fill_color.a, fill_color.r, fill_color.g, fill_color.b));
+
+    graphics.DrawEllipse(
+        &ellipseOutline, ellipse->getPosition().x - ellipse->getRadius().x,
+        ellipse->getPosition().y - ellipse->getRadius().y,
+        ellipse->getRadius().x * 2, ellipse->getRadius().y * 2);
+    graphics.FillEllipse(
+        &ellipseFill, ellipse->getPosition().x - ellipse->getRadius().x,
+        ellipse->getPosition().y - ellipse->getRadius().y,
+        ellipse->getRadius().x * 2, ellipse->getRadius().y * 2);
+}
 
 void Renderer::drawPolygon(Plygon* polygon) const {
     mColor fill_color = polygon->getFillColor();
+    mColor outline_color = polygon->getOutlineColor();
+    Gdiplus::Pen polygonOutline(
+        Gdiplus::Color(outline_color.a, outline_color.r, outline_color.g,
+                       outline_color.b),
+        polygon->getOutlineThickness());
     Gdiplus::SolidBrush polygonFill(
         Gdiplus::Color(fill_color.a, fill_color.r, fill_color.g, fill_color.b));
 
-    std::vector< Gdiplus::PointF > points;
+    Gdiplus::PointF* points = new Gdiplus::PointF[polygon->getPoints().size()];
+    int idx = 0;
     const std::vector< Vector2Df >& vertices = polygon->getPoints();
-    for (const Vector2Df& vertex : vertices) {
-        points.push_back(Gdiplus::PointF(vertex.x, vertex.y));
+    for (const Vector2Df vertex : vertices) {
+        points[idx++] = Gdiplus::PointF(vertex.x, vertex.y);
     }
 
-    graphics.FillPolygon(&polygonFill, &points[0],
-                         static_cast< int >(points.size()));
-
-    mColor outline_color = polygon->getOutlineColor();
-    Gdiplus::Pen polygonOutline(
-        Gdiplus::Color(outline_color.a, outline_color.r, outline_color.g,
-                       outline_color.b),
-        polygon->getOutlineThickness());
-    graphics.DrawPolygon(&polygonOutline, &points[0],
-                         static_cast< int >(points.size()));
+    graphics.DrawPolygon(&polygonOutline, points, idx);
+    graphics.FillPolygon(&polygonFill, points, idx);
 }
 
 void Renderer::drawText(Text* text) const {

src/graphics/Renderer.hpp → src/Renderer.hpp

@@ -7,7 +7,17 @@
 #include <gdiplus.h>
 
 //clang-format on
-#include "Graphics.hpp"
+
+#include "graphics/Circle.hpp"
+#include "graphics/Color.hpp"
+#include "graphics/Ellipse.hpp"
+#include "graphics/Group.hpp"
+#include "graphics/Line.hpp"
+#include "graphics/Path.hpp"
+#include "graphics/Polygon.hpp"
+#include "graphics/Polyline.hpp"
+#include "graphics/Rect.hpp"
+#include "graphics/Text.hpp"
 
 class Renderer {
 public:
@@ -16,7 +26,7 @@ class Renderer {
     void operator=(const Renderer&) = delete;
 
     Gdiplus::Graphics& graphics;
-    void draw(Shape* shape) const;
+    void draw(SVGElement* shape) const;
 
 private:
     void drawLine(Line* line) const;

src/graphics/Circle.cpp

@@ -5,6 +5,3 @@ Circle::Circle(float radius, const Vector2Df &center, mColor fill,
     : Ell(Vector2Df(radius, radius), center, fill, stroke, stroke_width) {}
 
 std::string Circle::getClass() const { return "Circle"; }
-
-// void Circle::render(Renderer &renderer) const { renderer.renderCircle(*this);
-// }

src/graphics/Circle.hpp

@@ -31,13 +31,6 @@ class Circle : public Ell {
      *
      */
     std::string getClass() const override;
-
-    // /**
-    //  * @brief Renders the shape using the given renderer.
-    //  *
-    //  * @param renderer The renderer to be used for rendering the shape.
-    //  */
-    // void render(Renderer &renderer) const override;
 };
 
 #endif  // CIRCLE_HPP_

src/graphics/Group.cpp

@@ -12,11 +12,11 @@ Group::~Group() {
 
 std::string Group::getClass() const { return "Group"; }
 
-// void Group::render(Renderer& renderer) const {
-//     for (auto shape : shapes) {
-//         shape->render(renderer);
-//     }
-// }
+void Group::render(Renderer& renderer) const {
+    for (auto shape : shapes) {
+        renderer.draw(shape);
+    }
+}
 
 Attributes Group::getAttributes() const { return attributes; }
 

src/graphics/Group.hpp

@@ -3,10 +3,12 @@
 
 #include <vector>
 
+#include "Renderer.hpp"
 #include "SVGElement.hpp"
 
 typedef std::vector< std::pair< std::string, std::string > > Attributes;
 
+class Renderer;
 class Group : public SVGElement {
 public:
     Group();
@@ -17,7 +19,7 @@ class Group : public SVGElement {
 
     std::string getClass() const override;
 
-    // void render(Renderer& renderer) const override;
+    void render(Renderer& renderer) const;
 
     Attributes getAttributes() const;
 

src/graphics/Rect.cpp

@@ -15,8 +15,6 @@ Rect::Rect(float width, float height, Vector2Df position, Vector2Df radius,
 
 std::string Rect::getClass() const { return "Rect"; }
 
-// void Rect::render(Renderer &renderer) const { renderer.renderRect(*this); }
-
 void Rect::setWidth(float width) {
     this->width = width;
     points[1].x = width;

src/graphics/SVGElement.hpp

@@ -5,7 +5,6 @@
 
 #include "Color.hpp"
 #include "Vector2D.hpp"
-class Renderer;
 
 /**
  * @brief Represents an element in an SVG file.
@@ -33,16 +32,6 @@ class SVGElement {
      */
     virtual std::string getClass() const = 0;
 
-    // /**
-    //  * @brief Renders the shape using the given renderer.
-    //  *
-    //  * @param renderer The renderer to be used for rendering the shape.
-    //  *
-    //  * @note This function is pure virtual and must be implemented by derived
-    //  * classes.
-    //  */
-    // virtual void render(Renderer& renderer) const = 0;
-
     /**
      * @brief Sets the fill color of the shape.
      *