infinipaint/src/DrawingProgram/Layers/DrawingProgramLayerManager.cpp

#include "DrawingProgramLayerManager.hpp"
#include "../../World.hpp"

DrawingProgramLayerManager::DrawingProgramLayerManager(DrawingProgram& drawProg):
    drawP(drawProg), // initialize drawP first for next objects to be initialized properly
    listGUI(*this)
{}

void DrawingProgramLayerManager::init() {
    if(drawP.world.netObjMan.is_server()) {
        layerTreeRoot = drawP.world.netObjMan.make_obj_from_ptr<DrawingProgramLayerListItem>(new DrawingProgramLayerListItem(drawP.world.netObjMan, "ROOT", true));
        layerTreeRoot->get_folder().set_component_list_callbacks(*this); // Only need to call set_component_list_callbacks on root, and the rest will get the callbacks set as well
        editingLayer = layerTreeRoot->get_folder().folderList->emplace_back_direct(layerTreeRoot->get_folder().folderList, drawP.world.netObjMan, "First Layer", false)->obj;
    }
}

void DrawingProgramLayerManager::write_components_server(cereal::PortableBinaryOutputArchive& a) {
    layerTreeRoot.write_create_message(a);
}

void DrawingProgramLayerManager::read_components_client(cereal::PortableBinaryInputArchive& a) {
    layerTreeRoot = drawP.world.netObjMan.read_create_message<DrawingProgramLayerListItem>(a, nullptr);
    layerTreeRoot->commit_update_dont_invalidate_cache(*this);
    layerTreeRoot->set_component_list_callbacks(*this);
}

bool DrawingProgramLayerManager::is_a_layer_being_edited() {
    return !editingLayer.expired();
}

uint32_t DrawingProgramLayerManager::edited_layer_component_count() {
    return editingLayer.lock()->get_layer().components->size();
}

void DrawingProgramLayerManager::draw(SkCanvas* canvas, const DrawData& drawData) {
    if(layerTreeRoot)
        layerTreeRoot->draw(canvas, drawData);
}

std::vector<CanvasComponentContainer::ObjInfoSharedPtr> DrawingProgramLayerManager::get_flattened_component_list() const {
    std::vector<CanvasComponentContainer::ObjInfoSharedPtr> toRet;
    layerTreeRoot->get_flattened_component_list(toRet);
    return toRet;
}

std::vector<DrawingProgramLayerListItem*> DrawingProgramLayerManager::get_flattened_layer_list() {
    std::vector<DrawingProgramLayerListItem*> toRet;
    layerTreeRoot->get_flattened_layer_list(toRet);
    return toRet;
}

bool DrawingProgramLayerManager::layer_tree_root_exists() {
    return layerTreeRoot;
}

const DrawingProgramLayerListItem& DrawingProgramLayerManager::get_layer_root() {
    return *layerTreeRoot;
}

void DrawingProgramLayerManager::erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& compsToErase) {
    std::unordered_map<DrawingProgramLayerListItem*, std::unordered_set<NetworkingObjects::NetObjID>> idsToEraseInSpecificLayers;
    for(auto& c : compsToErase)
        idsToEraseInSpecificLayers[c->obj->parentLayer].emplace(c->obj.get_net_id());
    for(auto& [layerListItem, netObjSetToErase] : idsToEraseInSpecificLayers) {
        auto& layerComponentList = layerListItem->get_layer().components;
        layerComponentList->erase_unordered_set(layerComponentList, netObjSetToErase);
    }
}

bool DrawingProgramLayerManager::component_passes_layer_selector(const CanvasComponentContainer::ObjInfoSharedPtr& c, LayerSelector layerSelector) {
    switch(layerSelector) {
        case LayerSelector::ALL_VISIBLE_LAYERS:
            return c->obj->parentLayer->get_visible();
        case LayerSelector::LAYER_BEING_EDITED:
            return is_a_layer_being_edited() && c->obj->parentLayer == editingLayer.lock().get();
    }
    return false;
}

std::vector<CanvasComponentContainer::ObjInfoSharedPtr> DrawingProgramLayerManager::add_many_components_to_layer_being_edited(const std::vector<std::pair<uint32_t, CanvasComponentContainer*>>& newObjs) {
    auto editLayerPtr = editingLayer.lock();
    if(!editLayerPtr)
        return {};
    return editLayerPtr->get_layer().components->insert_ordered_list_and_send_create(editLayerPtr->get_layer().components, newObjs);
}

CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramLayerManager::add_component_to_layer_being_edited(CanvasComponentContainer* newObj) {
    auto editLayerPtr = editingLayer.lock();
    if(!editLayerPtr)
        return nullptr;
    return editLayerPtr->get_layer().components->push_back_and_send_create(editLayerPtr->get_layer().components, newObj);
}