Starting work on drawing program layers

src/DrawingProgram/Layers/DrawingProgramLayer.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
+#include "../../CanvasComponents/CanvasComponent.hpp"
+
+class DrawingProgramLayerListItem;
+
+class DrawingProgramLayer {
+    public:
+        CanvasComponentContainer::NetListOwnerPtr components;
+};

src/DrawingProgram/Layers/DrawingProgramLayerFolder.hpp

@@ -0,0 +1,10 @@
+#pragma once
+#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
+
+class DrawingProgramLayerListItem;
+
+class DrawingProgramLayerFolder {
+    public:
+        NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>> folderList;
+        bool isFolderOpen = false;
+};

src/DrawingProgram/Layers/DrawingProgramLayerListItem.cpp

@@ -0,0 +1,115 @@
+#include "DrawingProgramLayerListItem.hpp"
+#include "DrawingProgramLayerFolder.hpp"
+#include <cereal/types/string.hpp>
+#include "DrawingProgramLayer.hpp"
+#include "../../World.hpp"
+
+using namespace NetworkingObjects;
+
+DrawingProgramLayerListItem::DrawingProgramLayerListItem() {}
+
+DrawingProgramLayerListItem::DrawingProgramLayerListItem(NetworkingObjects::NetObjManager& netObjMan, const std::string& initName, bool isFolder) {
+    if(isFolder) {
+        folderData = std::make_unique<DrawingProgramLayerFolder>();
+        folderData->folderList = netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>>();
+    }
+    else {
+        layerData = std::make_unique<DrawingProgramLayer>();
+        layerData->components = netObjMan.make_obj<CanvasComponentContainer::NetList>();
+    }
+    nameData = netObjMan.make_obj<NameData>();
+    nameData->name = initName;
+    displayData = netObjMan.make_obj<DisplayData>();
+}
+
+void DrawingProgramLayerListItem::reassign_netobj_ids_call() {
+    if(folderData)
+        folderData->folderList.reassign_ids();
+    else
+        layerData->components.reassign_ids();
+    nameData.reassign_ids();
+    displayData.reassign_ids();
+}
+
+bool DrawingProgramLayerListItem::is_folder() const {
+    return folderData != nullptr;
+}
+
+DrawingProgramLayerFolder& DrawingProgramLayerListItem::get_folder() const {
+    return *folderData;
+}
+
+DrawingProgramLayer& DrawingProgramLayerListItem::get_layer() const {
+    return *layerData;
+}
+
+void DrawingProgramLayerListItem::set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const {
+    if(nameData && nameData->name != newName) {
+        nameData->name = newName;
+        delayedNetObjMan.send_update_to_all<NameData>(nameData, false);
+    }
+}
+
+const std::string& DrawingProgramLayerListItem::get_name() const {
+    return nameData->name;
+}
+
+void DrawingProgramLayerListItem::set_alpha(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, float newAlpha) const {
+    if(displayData && displayData->alpha != newAlpha) {
+        displayData->alpha = newAlpha;
+        delayedNetObjMan.send_update_to_all<DisplayData>(displayData, false);
+    }
+}
+
+float DrawingProgramLayerListItem::get_alpha() const {
+    return displayData->alpha;
+}
+
+void DrawingProgramLayerListItem::set_visible(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, bool newVisible) const {
+    if(displayData && displayData->visible != newVisible) {
+        displayData->visible = newVisible;
+        delayedNetObjMan.send_update_to_all<DisplayData>(displayData, false);
+    }
+}
+
+bool DrawingProgramLayerListItem::get_visible() const {
+    return displayData->visible;
+}
+
+void DrawingProgramLayerListItem::register_class(World& w) {
+    w.netObjMan.register_class<DrawingProgramLayerListItem, DrawingProgramLayerListItem, DrawingProgramLayerListItem, DrawingProgramLayerListItem>({
+        .writeConstructorFuncClient = write_constructor_func,
+        .readConstructorFuncClient = read_constructor_func,
+        .readUpdateFuncClient = nullptr,
+        .writeConstructorFuncServer = write_constructor_func,
+        .readConstructorFuncServer = read_constructor_func,
+        .readUpdateFuncServer = nullptr,
+    });
+    w.delayedUpdateObjectManager.register_class<NameData>(w.netObjMan);
+    w.delayedUpdateObjectManager.register_class<DisplayData>(w.netObjMan);
+}
+
+void DrawingProgramLayerListItem::write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryOutputArchive& a) {
+    a(o->is_folder());
+    if(o->is_folder())
+        o->folderData->folderList.write_create_message(a);
+    else
+        o->layerData->components.write_create_message(a);
+    o->nameData.write_create_message(a);
+    o->displayData.write_create_message(a);
+}
+
+void DrawingProgramLayerListItem::read_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c) {
+    bool isFolder;
+    a(isFolder);
+    if(isFolder) {
+        o->folderData = std::make_unique<DrawingProgramLayerFolder>();
+        o->folderData->folderList = o.get_obj_man()->read_create_message<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>>(a, c);
+    }
+    else {
+        o->layerData = std::make_unique<DrawingProgramLayer>();
+        o->layerData->components = o.get_obj_man()->read_create_message<CanvasComponentContainer::NetList>(a, c);
+    }
+    o->nameData = o.get_obj_man()->read_create_message<NameData>(a, c);
+    o->displayData = o.get_obj_man()->read_create_message<DisplayData>(a, c);
+}

src/DrawingProgram/Layers/DrawingProgramLayerListItem.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include <Helpers/NetworkingObjects/NetObjManager.hpp>
+#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
+#include <Helpers/NetworkingObjects/DelayUpdateSerializedClassManager.hpp>
+#include "DrawingProgramLayerFolder.hpp"
+#include "DrawingProgramLayer.hpp"
+
+class DrawingProgramLayerFolder;
+class DrawingProgramLayer;
+class World;
+
+class DrawingProgramLayerListItem {
+    public:
+        DrawingProgramLayerListItem();
+        DrawingProgramLayerListItem(NetworkingObjects::NetObjManager& netObjMan, const std::string& initName, bool isFolder);
+        bool is_folder() const;
+        DrawingProgramLayerFolder& get_folder() const;
+        DrawingProgramLayer& get_layer() const;
+        static void register_class(World& w);
+        void reassign_netobj_ids_call();
+
+        void set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const;
+        const std::string& get_name() const;
+
+        void set_alpha(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, float newAlpha) const;
+        float get_alpha() const;
+
+        void set_visible(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, bool newVisible) const;
+        bool get_visible() const;
+    private:
+        static void write_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryOutputArchive& a);
+        static void read_constructor_func(const NetworkingObjects::NetObjTemporaryPtr<DrawingProgramLayerListItem>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c);
+        std::unique_ptr<DrawingProgramLayerFolder> folderData;
+        std::unique_ptr<DrawingProgramLayer> layerData;
+        struct NameData {
+            std::string name;
+            template <typename Archive> void serialize(Archive& a) {
+                a(name);
+            }
+        };
+        struct DisplayData {
+            float alpha = 1.0f;
+            bool visible = true;
+            template <typename Archive> void serialize(Archive& a) {
+                a(alpha, visible);
+            }
+        };
+        NetworkingObjects::NetObjOwnerPtr<NameData> nameData;
+        NetworkingObjects::NetObjOwnerPtr<DisplayData> displayData;
+};