All tools now converted to use new net objects

src/CanvasComponents/BrushStrokeCanvasComponent.cpp

@@ -29,8 +29,8 @@ void BrushStrokeCanvasComponent::load_file(cereal::PortableBinaryInputArchive& a
     a(d->points, d->color, d->hasRoundCaps);
 }
 
-CanvasComponent::CompType BrushStrokeCanvasComponent::get_type() const {
-    return CompType::BRUSHSTROKE;
+CanvasComponentType BrushStrokeCanvasComponent::get_type() const {
+    return CanvasComponentType::BRUSHSTROKE;
 }
 
 void BrushStrokeCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const {
@@ -46,6 +46,11 @@ void BrushStrokeCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData
     canvas->restore();
 }
 
+void BrushStrokeCanvasComponent::set_data_from(const CanvasComponent& other) {
+    auto& otherStroke = static_cast<const BrushStrokeCanvasComponent&>(other);
+    d = otherStroke.d;
+}
+
 void BrushStrokeCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
     if(!d->points.empty()) {
         std::vector<BrushStrokeCanvasComponentPoint> points = smooth_points(0, d->points.size() - 1, DEFAULT_SMOOTHNESS);

src/CanvasComponents/BrushStrokeCanvasComponent.hpp

@@ -17,7 +17,7 @@ class BrushStrokeCanvasComponent : public CanvasComponent {
     public:
         constexpr static float DRAW_MINIMUM_LIMIT = 0.3;
 
-        virtual CompType get_type() const override;
+        virtual CanvasComponentType get_type() const override;
         virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load(cereal::PortableBinaryInputArchive& a) override;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
@@ -30,6 +30,7 @@ class BrushStrokeCanvasComponent : public CanvasComponent {
         };
         std::shared_ptr<Data> d = std::make_shared<Data>(); // It's a pointer here since brush strokes cant be edited
 
+        virtual void set_data_from(const CanvasComponent& other) override;
     private:
         virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override;
         virtual void initialize_draw_data(DrawingProgram& drawP) override;

src/CanvasComponents/CanvasComponent.cpp

@@ -8,17 +8,17 @@
 void CanvasComponent::update(DrawingProgram& drawP) {
 }
 
-CanvasComponent* CanvasComponent::allocate_comp(CanvasComponent::CompType type) {
+CanvasComponent* CanvasComponent::allocate_comp(CanvasComponentType type) {
     switch(type) {
-        case CanvasComponent::CompType::BRUSHSTROKE:
+        case CanvasComponentType::BRUSHSTROKE:
             return new BrushStrokeCanvasComponent;
-        case CanvasComponent::CompType::RECTANGLE:
+        case CanvasComponentType::RECTANGLE:
             return new RectangleCanvasComponent;
-        case CanvasComponent::CompType::ELLIPSE:
+        case CanvasComponentType::ELLIPSE:
             return new EllipseCanvasComponent;
-        case CanvasComponent::CompType::TEXTBOX:
+        case CanvasComponentType::TEXTBOX:
             return new TextBoxCanvasComponent;
-        case CanvasComponent::CompType::IMAGE:
+        case CanvasComponentType::IMAGE:
             return new ImageCanvasComponent;
     }
     return nullptr;

src/CanvasComponents/CanvasComponent.hpp

@@ -4,28 +4,22 @@
 #include <Helpers/VersionNumber.hpp>
 #include <include/core/SkCanvas.h>
 #include <Helpers/SCollision.hpp>
+#include "CanvasComponentType.hpp"
+#include "CanvasComponentContainer.hpp"
 
 class DrawingProgram;
-class DrawData;
-class CanvasComponentContainer;
 
 class CanvasComponent {
     public:
-        enum class CompType : uint8_t {
-            BRUSHSTROKE = 0,
-            RECTANGLE,
-            ELLIPSE,
-            TEXTBOX,
-            IMAGE
-        };
-        virtual CompType get_type() const = 0;
+        virtual CanvasComponentType get_type() const = 0;
         virtual ~CanvasComponent();
-        static CanvasComponent* allocate_comp(CanvasComponent::CompType type);
+        static CanvasComponent* allocate_comp(CanvasComponentType type);
         virtual void save(cereal::PortableBinaryOutputArchive& a) const = 0;
         virtual void load(cereal::PortableBinaryInputArchive& a) = 0;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const = 0;
         virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) = 0;
 
+        virtual void set_data_from(const CanvasComponent& other) = 0;
     protected:
         friend class CanvasComponentContainer;
         friend class CanvasComponentAllocator;

src/CanvasComponents/CanvasComponentAllocator.cpp

@@ -1,21 +1,24 @@
 #include "CanvasComponentAllocator.hpp"
 #include "CanvasComponentContainer.hpp"
 #include "../DrawingProgram/DrawingProgram.hpp"
+#include "../World.hpp"
+#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
+#include "CanvasComponent.hpp"
 
 CanvasComponentAllocator::CanvasComponentAllocator() {}
 
-CanvasComponentAllocator::CanvasComponentAllocator(CanvasComponent::CompType typeToAllocate) {
+CanvasComponentAllocator::CanvasComponentAllocator(CanvasComponentType typeToAllocate) {
     comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
 }
 
-void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan) {
-    delayUpdateMan.register_class<CanvasComponentAllocator>(objMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<CanvasComponentAllocator>{
+void CanvasComponentAllocator::register_class(World& world, NetworkingObjects::NetObjManager& objMan) {
+    world.delayedUpdateObjectManager.register_class<CanvasComponentAllocator>(objMan, NetworkingObjects::DelayUpdateSerializedClassManager::CustomConstructors<CanvasComponentAllocator>{
         .writeConstructor = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
             a(o.comp->get_type());
             a(*o.comp);
         },
-        .readConstructor = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
-            CanvasComponent::CompType typeToAllocate;
+        .readConstructor = [](CanvasComponentAllocator& o, cereal::PortableBinaryInputArchive& a) {
+            CanvasComponentType typeToAllocate;
             a(typeToAllocate);
             o.comp = std::unique_ptr<CanvasComponent>(CanvasComponent::allocate_comp(typeToAllocate));
             a(*o.comp);
@@ -23,7 +26,7 @@ void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingO
         .writeUpdate = [](const CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
             a(*o.comp);
         },
-        .readUpdate = [](CanvasComponentAllocator& o, cereal::PortableBinaryOutputArchive& a) {
+        .readUpdate = [](CanvasComponentAllocator& o, cereal::PortableBinaryInputArchive& a) {
             a(*o.comp);
         },
         .allocateCopy = [](const CanvasComponentAllocator& o) {
@@ -33,9 +36,9 @@ void CanvasComponentAllocator::register_class(DrawingProgram& drawP, NetworkingO
             return theCopy;
         },
         .assignmentFunc = [](CanvasComponentAllocator& o, const CanvasComponentAllocator& o2) {
-            // Assignment still needs to be implemented
+            o.comp->set_data_from(*o2.comp);
         },
-        .postUpdateFunc = [&drawP](CanvasComponentAllocator& o) {
+        .postUpdateFunc = [&drawP = world.drawProg](CanvasComponentAllocator& o) {
             o.comp->compContainer->commit_update(drawP);
         }
     });

src/CanvasComponents/CanvasComponentAllocator.hpp

@@ -1,15 +1,16 @@
 #pragma once
 #include <memory>
-#include "CanvasComponent.hpp"
+#include "CanvasComponentType.hpp"
 #include <Helpers/NetworkingObjects/NetObjTemporaryPtr.hpp>
 #include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
 
-class DrawingProgram;
+class World;
+class CanvasComponent;
 
 class CanvasComponentAllocator {
     public:
         CanvasComponentAllocator();
-        CanvasComponentAllocator(CanvasComponent::CompType typeToAllocate);
+        CanvasComponentAllocator(CanvasComponentType typeToAllocate);
         std::unique_ptr<CanvasComponent> comp;
-        static void register_class(DrawingProgram& drawP, NetworkingObjects::DelayUpdateSerializedClassManager& delayUpdateMan, NetworkingObjects::NetObjManager& objMan);
+        static void register_class(World& world, NetworkingObjects::NetObjManager& objMan);
 };

src/CanvasComponents/CanvasComponentContainer.cpp

@@ -3,13 +3,14 @@
 #include "../DrawData.hpp"
 #include "../DrawingProgram/DrawingProgram.hpp"
 #include "../World.hpp"
+#include "CanvasComponent.hpp"
 #include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
 
 using namespace NetworkingObjects;
 
 CanvasComponentContainer::CanvasComponentContainer() { }
 
-CanvasComponentContainer::CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponent::CompType type) {
+CanvasComponentContainer::CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponentType type) {
     compAllocator = objMan.make_obj_direct<CanvasComponentAllocator>(type);
 }
 

src/CanvasComponents/CanvasComponentContainer.hpp

@@ -1,13 +1,13 @@
 #pragma once
 #include "../CoordSpaceHelper.hpp"
-#include "CanvasComponent.hpp"
 #include <Helpers/NetworkingObjects/NetObjManagerTypeList.hpp>
+#include "CanvasComponentType.hpp"
 #include "../VersionConstants.hpp"
 #include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
 #include <Helpers/NetworkingObjects/NetObjOwnerPtr.hpp>
+#include "CanvasComponentAllocator.hpp"
 
 class DrawingProgram;
-class CanvasComponentAllocator;
 class DrawingProgramCacheBVHNode;
 
 class CanvasComponentContainer {
@@ -26,7 +26,7 @@ class CanvasComponentContainer {
         constexpr static int COMP_MIPMAP_LEVEL_TWO = 5;
         
         CanvasComponentContainer();
-        CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponent::CompType type);
+        CanvasComponentContainer(NetworkingObjects::NetObjManager& objMan, CanvasComponentType type);
         static void register_class(NetworkingObjects::NetObjManager& t);
         static void delay_post_assignment_update(DrawingProgram& drawP, CanvasComponent& comp);
         void save_file(cereal::PortableBinaryOutputArchive& a) const;
@@ -61,7 +61,7 @@ class CanvasComponentContainer {
         };
 
         unsigned get_mipmap_level(const DrawData& drawData) const;
-        CanvasComponent* allocate_comp(CanvasComponent::CompType type);
+        CanvasComponent* allocate_comp(CanvasComponentType type);
         void canvas_do_transform(SkCanvas* canvas, const TransformDrawData& transformData) const;
         TransformDrawData calculate_draw_transform(const DrawData& drawData) const;
         void calculate_world_bounds();

src/CanvasComponents/CanvasComponentType.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <cstdint>
+
+enum class CanvasComponentType : uint8_t {
+    BRUSHSTROKE = 0,
+    RECTANGLE,
+    ELLIPSE,
+    TEXTBOX,
+    IMAGE
+};

src/CanvasComponents/EllipseCanvasComponent.cpp

@@ -1,11 +1,12 @@
 #include "EllipseCanvasComponent.hpp"
+#include "CanvasComponent.hpp"
 #include "Helpers/ConvertVec.hpp"
 #include "Helpers/SCollision.hpp"
 #include <include/core/SkPathBuilder.h>
 #include "../DrawCollision.hpp"
 
-CanvasComponent::CompType EllipseCanvasComponent::get_type() const {
-    return CompType::ELLIPSE;
+CanvasComponentType EllipseCanvasComponent::get_type() const {
+    return CanvasComponentType::ELLIPSE;
 }
 
 void EllipseCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@@ -51,6 +52,11 @@ void EllipseCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
     create_collider();
 }
 
+void EllipseCanvasComponent::set_data_from(const CanvasComponent& other) {
+    auto& otherEllipse = static_cast<const EllipseCanvasComponent&>(other);
+    d = otherEllipse.d;
+}
+
 bool EllipseCanvasComponent::collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const {
     return collisionTree.is_collide(checkAgainst);
 }

src/CanvasComponents/EllipseCanvasComponent.hpp

@@ -5,11 +5,12 @@
 
 class EllipseCanvasComponent : public CanvasComponent {
     public:
-        virtual CompType get_type() const override;
+        virtual CanvasComponentType get_type() const override;
         virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load(cereal::PortableBinaryInputArchive& a) override;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
+        virtual void set_data_from(const CanvasComponent& other) override;
 
         // User input data
         struct Data {

src/CanvasComponents/ImageCanvasComponent.cpp

@@ -9,8 +9,8 @@
 #include "../DrawCollision.hpp"
 #include "CanvasComponentContainer.hpp"
 
-CanvasComponent::CompType ImageCanvasComponent::get_type() const {
-    return CompType::IMAGE;
+CanvasComponentType ImageCanvasComponent::get_type() const {
+    return CanvasComponentType::IMAGE;
 }
 
 void ImageCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@@ -48,6 +48,11 @@ void ImageCanvasComponent::draw_download_progress_bar(SkCanvas* canvas, const Dr
     }
 }
 
+void ImageCanvasComponent::set_data_from(const CanvasComponent& other) {
+    auto& otherImage = static_cast<const ImageCanvasComponent&>(other);
+    d = otherImage.d;
+}
+
 void ImageCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData) const {
     ResourceDisplay* display = drawData.rMan->get_display_data(d.imageID);
     if(display)

src/CanvasComponents/ImageCanvasComponent.hpp

@@ -10,7 +10,8 @@ class ImageCanvasComponent : public CanvasComponent {
         virtual void load(cereal::PortableBinaryInputArchive& a) override;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
-        virtual CompType get_type() const override;
+        virtual CanvasComponentType get_type() const override;
+        virtual void set_data_from(const CanvasComponent& other) override;
 
         void draw_download_progress_bar(SkCanvas* canvas, const DrawData& drawData, float progress) const;
 

src/CanvasComponents/RectangleCanvasComponent.cpp

@@ -7,8 +7,8 @@
 #include "../SharedTypes.hpp"
 #include "../DrawCollision.hpp"
 
-CanvasComponent::CompType RectangleCanvasComponent::get_type() const {
-    return CompType::RECTANGLE;
+CanvasComponentType RectangleCanvasComponent::get_type() const {
+    return CanvasComponentType::RECTANGLE;
 }
 
 void RectangleCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@@ -45,6 +45,11 @@ void RectangleCanvasComponent::draw(SkCanvas* canvas, const DrawData& drawData)
     }
 }
 
+void RectangleCanvasComponent::set_data_from(const CanvasComponent& other) {
+    auto& otherRect = static_cast<const RectangleCanvasComponent&>(other);
+    d = otherRect.d;
+}
+
 void RectangleCanvasComponent::initialize_draw_data(DrawingProgram& drawP) {
     create_draw_data();
     create_collider();

src/CanvasComponents/RectangleCanvasComponent.hpp

@@ -10,7 +10,8 @@ class RectangleCanvasComponent : public CanvasComponent {
         virtual void load(cereal::PortableBinaryInputArchive& a) override;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
-        virtual CompType get_type() const override;
+        virtual CanvasComponentType get_type() const override;
+        virtual void set_data_from(const CanvasComponent& other) override;
 
         // User input data
         struct Data {

src/CanvasComponents/TextBoxCanvasComponent.cpp

@@ -21,8 +21,8 @@ TextBoxCanvasComponent::TextBoxCanvasComponent():
     textBox->set_initial_text_style_modifier(std::make_shared<FontFamiliesTextStyleModifier>(std::vector<SkString>{SkString{"Roboto"}}));
 }
 
-CanvasComponent::CompType TextBoxCanvasComponent::get_type() const {
-    return CompType::TEXTBOX;
+CanvasComponentType TextBoxCanvasComponent::get_type() const {
+    return CanvasComponentType::TEXTBOX;
 }
 
 void TextBoxCanvasComponent::save(cereal::PortableBinaryOutputArchive& a) const {
@@ -58,6 +58,13 @@ void TextBoxCanvasComponent::load_file(cereal::PortableBinaryInputArchive& a, Ve
     }
 }
 
+void TextBoxCanvasComponent::set_data_from(const CanvasComponent& other) {
+    auto& otherTextBox = static_cast<const TextBoxCanvasComponent&>(other);
+    d = otherTextBox.d;
+    *cursor = *otherTextBox.cursor;
+    textBox->set_rich_text_data(otherTextBox.textBox->get_rich_text_data());
+}
+
 void TextBoxCanvasComponent::init_text_box(DrawingProgram& drawP) {
     textBox->set_font_data(drawP.world.main.fonts); // Getting a segfault relating to the paragraph cache means that the font collection hasn't been set yet
     textBox->set_width(d.p2.x() - d.p1.x() - TEXTBOX_PADDING * 2.0f);

src/CanvasComponents/TextBoxCanvasComponent.hpp

@@ -10,11 +10,12 @@ class TextBoxCanvasComponent : public CanvasComponent {
         constexpr static float TEXTBOX_PADDING = 5.0f;
 
         TextBoxCanvasComponent();
-        virtual CompType get_type() const override;
+        virtual CanvasComponentType get_type() const override;
         virtual void save(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load(cereal::PortableBinaryInputArchive& a) override;
         virtual void save_file(cereal::PortableBinaryOutputArchive& a) const override;
         virtual void load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) override;
+        virtual void set_data_from(const CanvasComponent& other) override;
 
         // User input data
         struct Data {
@@ -26,6 +27,8 @@ class TextBoxCanvasComponent : public CanvasComponent {
         } d;
 
     private:
+        friend class TextBoxEditTool;
+
         virtual void draw(SkCanvas* canvas, const DrawData& drawData) const override;
         virtual void initialize_draw_data(DrawingProgram& drawP) override;
         virtual bool collides_within_coords(const SCollision::ColliderCollection<float>& checkAgainst) const override;