copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions 1

Changed net object ordered list implementation

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-30 19:46:08 +03:00
parent 879655fbb8
commit fda8fcc166
60 changed files with 816 additions and 785 deletions
Download patch file Download diff file Expand all files Collapse all files

835
include/Helpers/NetworkingObjects/NetObjOrderedList.hpp
View file

File diff suppressed because it is too large Load diff

36
src/Bookmarks/BookmarkManager.cpp
View file

@ -43,10 +43,11 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
NetObjOrderedList<BookmarkListItem>& bookmarkParentFolder = *world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(parentId)->get_folder_list();
if(bookmarkParentFolder.size() <= index)
return std::nullopt;
auto itemAtIndex = bookmarkParentFolder.at(index);
return GUIStuff::TreeListing::DisplayData::ObjInList{
.id = bookmarkParentFolder.at(index)->obj.get_net_id(),
.isDirectory = bookmarkParentFolder.at(index)->obj->is_folder(),
.isDirectoryOpen = bookmarkParentFolder.at(index)->obj->is_folder() ? bookmarkParentFolder.at(index)->obj->is_folder_open() : false
.id = itemAtIndex->obj.get_net_id(),
.isDirectory = itemAtIndex->obj->is_folder(),
.isDirectoryOpen = itemAtIndex->obj->is_folder() ? itemAtIndex->obj->is_folder_open() : false
};
},
.getIndexOfObjInList = [&](const GUIStuff::TreeListing::ParentObjectIDPair& idPair) {
@ -92,28 +93,30 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
},
.moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) {
world.netObjMan.send_multi_update_messsage([&]() {
std::unordered_map<NetObjID, std::unordered_set<NetObjID>> toEraseMap;
std::unordered_map<NetObjID, std::vector<NetObjOrderedListIterator<BookmarkListItem>>> toEraseMap;
uint32_t newIndex = index;
std::vector<NetObjOwnerPtr<BookmarkListItem>> toInsertObjPtrs;
auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listObj)->get_folder_list();
for(size_t i = 0; i < objsToInsert.size(); i++) {
toEraseMap[objsToInsert[i].parent].emplace(objsToInsert[i].object);
auto& parentListPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(objsToInsert[i].parent)->get_folder_list();
toEraseMap[objsToInsert[i].parent].emplace_back(parentListPtr->get(objsToInsert[i].object));
if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index)
newIndex--;
}
for(auto& [listToEraseFrom, setToErase] : toEraseMap) {
auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(listToEraseFrom)->get_folder_list();
listToEraseFromPtr->erase_unordered_set(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
listToEraseFromPtr->erase_list(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
}
std::vector<std::pair<uint32_t, NetObjOwnerPtr<BookmarkListItem>>> toInsert;
std::vector<std::pair<NetObjOrderedListIterator<BookmarkListItem>, NetObjOwnerPtr<BookmarkListItem>>> toInsert;
auto insertIt = listPtr->at(newIndex);
for(uint32_t i = 0; i < objsToInsert.size(); i++) {
auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<BookmarkListItem>& objPtr) {
return objPtr.get_net_id() == id;
});
toInsert.emplace_back(newIndex + i, std::move(*it));
toInsert.emplace_back(insertIt, std::move(*it));
toInsert.back().second.reassign_ids();
}
listPtr->insert_ordered_list_and_send_create(listPtr, toInsert);
@ -138,7 +141,7 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
if(toDeleteObject.has_value()) {
auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(toDeleteParent.value())->get_folder_list();
folderList->erase(folderList, toDeleteObject.value());
folderList->erase(folderList, folderList->get(toDeleteObject.value()));
}
}
@ -169,30 +172,29 @@ void BookmarkManager::setup_list_gui(const std::string& id) {
}
}
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> BookmarkManager::try_to_create_in_proper_position(BookmarkListItem* newItem) {
std::optional<NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem>> BookmarkManager::try_to_create_in_proper_position(BookmarkListItem* newItem) {
using namespace NetworkingObjects;
if(selectionData.orderedObjsSelected.empty())
return nullptr;
return std::nullopt;
auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back();
NetObjTemporaryPtr<BookmarkListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.parent);
if(!parentPtr)
return nullptr;
return std::nullopt;
NetObjTemporaryPtr<BookmarkListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<BookmarkListItem>(backObjParentObjectPair.object);
if(!objectPtr)
return nullptr;
return std::nullopt;
if(objectPtr->is_folder()) {
objectPtr->set_folder_open(true);
return objectPtr->get_folder_list()->push_back_and_send_create(objectPtr->get_folder_list(), newItem);
}
uint32_t insertPos = parentPtr->get_folder_list()->get(objectPtr.get_net_id())->pos;
return parentPtr->get_folder_list()->insert_and_send_create(parentPtr->get_folder_list(), insertPos + 1, newItem);
return parentPtr->get_folder_list()->insert_and_send_create(parentPtr->get_folder_list(), std::next(parentPtr->get_folder_list()->get(objectPtr.get_net_id())), newItem);
}
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> BookmarkManager::create_in_proper_position(BookmarkListItem* newItem) {
NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem> BookmarkManager::create_in_proper_position(BookmarkListItem* newItem) {
auto toRet = try_to_create_in_proper_position(newItem);
if(!toRet)
return bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), newItem);
return toRet;
return toRet.value();
}
void BookmarkManager::scale_up(const WorldScalar& scaleUpAmount) {

4
src/Bookmarks/BookmarkManager.hpp
View file

@ -23,8 +23,8 @@ class BookmarkManager {
NetworkingObjects::NetObjOwnerPtr<BookmarkListItem> bookmarkListRoot;
private:
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> create_in_proper_position(BookmarkListItem* newItem);
NetworkingObjects::NetObjOrderedListObjectInfoPtr<BookmarkListItem> try_to_create_in_proper_position(BookmarkListItem* newItem);
NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem> create_in_proper_position(BookmarkListItem* newItem);
std::optional<NetworkingObjects::NetObjOrderedListIterator<BookmarkListItem>> try_to_create_in_proper_position(BookmarkListItem* newItem);
GUIStuff::TreeListing::SelectionData selectionData;
std::unordered_set<NetworkingObjects::NetObjID> oldSelection;
std::string nameToEdit;

14
src/CanvasComponents/CanvasComponentContainer.cpp
View file

@ -74,25 +74,19 @@ void CanvasComponentContainer::draw(SkCanvas* canvas, const DrawData& drawData)
}
}
void CanvasComponentContainer::set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo) {
objInfo = ownerObjInfo;
}
void CanvasComponentContainer::commit_update(DrawingProgram& drawP) {
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo);
drawP.preupdate_component(&(*objInfo));
get_comp().initialize_draw_data(drawP);
calculate_world_bounds();
drawP.preupdate_component(lockedObjInfo);
drawP.preupdate_component(&(*objInfo));
}
void CanvasComponentContainer::commit_transform(DrawingProgram& drawP) {
auto lockedObjInfo = objInfo.lock();
if(worldAABB.has_value()) // This is the only point where worldAABB could be nullopt
drawP.preupdate_component(lockedObjInfo);
drawP.preupdate_component(&(*objInfo));
calculate_world_bounds();
drawP.preupdate_component(lockedObjInfo);
drawP.preupdate_component(&(*objInfo));
}
void CanvasComponentContainer::commit_update_dont_invalidate_cache(DrawingProgram& drawP) {

6
src/CanvasComponents/CanvasComponentContainer.hpp
View file

@ -16,8 +16,7 @@ class CanvasComponentContainer {
typedef NetworkingObjects::NetObjOrderedList<CanvasComponentContainer> NetList;
typedef NetworkingObjects::NetObjOwnerPtr<NetList> NetListOwnerPtr;
typedef NetworkingObjects::NetObjOrderedListObjectInfo<CanvasComponentContainer> ObjInfo;
typedef std::shared_ptr<ObjInfo> ObjInfoSharedPtr;
typedef std::weak_ptr<ObjInfo> ObjInfoWeakPtr;
typedef NetworkingObjects::NetObjOrderedListIterator<CanvasComponentContainer> ObjInfoIterator;
constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_COLLISIONS = 14;
constexpr static int COMP_MAX_SHIFT_BEFORE_STOP_SCALING = 14;
@ -50,12 +49,12 @@ class CanvasComponentContainer {
bool collides_with_world_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld) const;
bool collides_with_cam_coords(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
bool collides_with(const CoordSpaceHelper& camCoords, const SCollision::ColliderCollection<WorldScalar>& checkAgainstWorld, const SCollision::ColliderCollection<float>& checkAgainstCam) const;
void set_owner_obj_info(const ObjInfoSharedPtr& ownerObjInfo);
void send_comp_update(DrawingProgram& drawP, bool finalUpdate);
std::weak_ptr<DrawingProgramCacheBVHNode> cacheParentBvhNode;
DrawingProgramLayerListItem* parentLayer = nullptr;
CoordSpaceHelper coords;
ObjInfoIterator objInfo;
private:
friend class BrushStrokeCanvasComponent;
friend class ImageCanvasComponent;
@ -75,7 +74,6 @@ class CanvasComponentContainer {
TransformDrawData calculate_draw_transform(const DrawData& drawData) const;
void calculate_world_bounds();
ObjInfoWeakPtr objInfo;
std::optional<SCollision::AABB<WorldScalar>> worldAABB;
NetworkingObjects::NetObjOwnerPtr<CanvasComponentAllocator> compAllocator;
};

2
src/CanvasComponents/ImageCanvasComponent.cpp
View file

@ -79,7 +79,7 @@ void ImageCanvasComponent::update(DrawingProgram& drawP) {
ResourceDisplay* display = drawP.world.drawData.rMan->get_display_data(d.imageID);
if(display) {
if(display->update_draw())
drawP.invalidate_cache_at_component(compContainer->objInfo.lock());
drawP.invalidate_cache_at_component(&(*compContainer->objInfo));
}
}

8
src/DrawingProgram/DrawingProgram.cpp
View file

@ -288,12 +288,12 @@ void DrawingProgram::update() {
rebuild_cache();
}
void DrawingProgram::invalidate_cache_at_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) {
void DrawingProgram::invalidate_cache_at_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(!selection.is_selected(objToCheck))
drawCache.invalidate_cache_at_aabb(objToCheck->obj->get_world_bounds());
}
void DrawingProgram::preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) {
void DrawingProgram::preupdate_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(!selection.is_selected(objToCheck))
drawCache.preupdate_component(objToCheck);
}
@ -395,7 +395,7 @@ void DrawingProgram::update_downloading_dropped_files() {
if(display->get_type() == ResourceDisplay::Type::FILE) {
Logger::get().log("WORLDFATAL", "Failed to parse image from URL");
auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components;
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj.get_net_id());
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj->objInfo);
}
else {
Vector2f imTrueDim = display->get_dimensions();
@ -414,7 +414,7 @@ void DrawingProgram::update_downloading_dropped_files() {
case FileDownloader::DownloadData::Status::FAILURE: {
Logger::get().log("WORLDFATAL", "Failed to download data from URL");
auto& parentLayerComponents = downFile.comp->obj->parentLayer->get_layer().components;
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj.get_net_id());
parentLayerComponents->erase(parentLayerComponents, downFile.comp->obj->objInfo);
return true;
}
case FileDownloader::DownloadData::Status::IN_PROGRESS:

8
src/DrawingProgram/DrawingProgram.hpp
View file

@ -50,8 +50,8 @@ class DrawingProgram {
void switch_to_tool_ptr(std::unique_ptr<DrawingProgramToolBase> newTool);
void modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGrid>& gridToModify);
void invalidate_cache_at_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck);
void preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck);
void invalidate_cache_at_component(CanvasComponentContainer::ObjInfo* objToCheck);
void preupdate_component(CanvasComponentContainer::ObjInfo* objToCheck);
private:
void drag_drop_update();
void add_file_to_canvas_by_path_execute(const std::filesystem::path& filePath, Vector2f dropPos);
@ -76,7 +76,7 @@ class DrawingProgram {
DrawingProgramSelection selection;
std::unique_ptr<DrawingProgramToolBase> toolToSwitchToAfterUpdate;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> updateableComponents;
std::unordered_set<CanvasComponentContainer::ObjInfo*> updateableComponents;
bool temporaryEraser = false;
bool temporaryPan = false;
@ -103,7 +103,7 @@ class DrawingProgram {
} controls;
struct DroppedDownloadingFile {
CanvasComponentContainer::ObjInfoSharedPtr comp;
CanvasComponentContainer::ObjInfo* comp;
Vector2f windowSizeWhenDropped;
std::shared_ptr<FileDownloader::DownloadData> downData;
};

28
src/DrawingProgram/DrawingProgramCache.cpp
View file

@ -17,12 +17,12 @@ DrawingProgramCache::DrawingProgramCache(DrawingProgram& initDrawP):
drawP(initDrawP)
{}
void DrawingProgramCache::add_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) {
void DrawingProgramCache::add_component(CanvasComponentContainer::ObjInfo* c) {
unsortedComponents.emplace_back(c);
invalidate_cache_at_aabb(c->obj->get_world_bounds());
}
void DrawingProgramCache::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) {
void DrawingProgramCache::erase_component(CanvasComponentContainer::ObjInfo* c) {
auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock();
if(cacheParentBvhNodeLock) {
std::erase(cacheParentBvhNodeLock->components, c);
@ -54,11 +54,11 @@ bool DrawingProgramCache::unsorted_components_exist() const {
return !unsortedComponents.empty();
}
void DrawingProgramCache::build(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToExclude) {
void DrawingProgramCache::build(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToExclude) {
internal_build(drawP.layerMan.get_flattened_component_list(), objsToExclude);
}
void DrawingProgramCache::internal_build(std::vector<CanvasComponentContainer::ObjInfoSharedPtr> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToNotInclude) {
void DrawingProgramCache::internal_build(std::vector<CanvasComponentContainer::ObjInfo*> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToNotInclude) {
std::erase_if(componentsToBuild, [&objsToNotInclude](auto& c) {
return objsToNotInclude.contains(c);
});
@ -74,9 +74,9 @@ void DrawingProgramCache::clear_own_cached_surfaces() {
});
}
CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramCache::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
CanvasComponentContainer::ObjInfo* DrawingProgramCache::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC);
CanvasComponentContainer::ObjInfoSharedPtr p;
CanvasComponentContainer::ObjInfo* p = nullptr;
traverse_bvh_run_function(cCWorld.bounds, [&](const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode) {
node_loop_components(bvhNode, [&](const auto& c) {
if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with_world_coords(drawP.world.drawData.cam.c, cCWorld))
@ -87,7 +87,7 @@ CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramCache::get_front_object
return p;
}
void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f) {
void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(CanvasComponentContainer::ObjInfo* comp)> f) {
if(bvhNode) {
std::erase_if(bvhNode->components, [&f](const auto& comp) {
if(f(comp)) {
@ -101,14 +101,14 @@ void DrawingProgramCache::node_loop_erase_if_components(const std::shared_ptr<Dr
std::erase_if(unsortedComponents, f);
}
void DrawingProgramCache::node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f) {
void DrawingProgramCache::node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(CanvasComponentContainer::ObjInfo* comp)> f) {
if(bvhNode)
std::for_each(bvhNode->components.begin(), bvhNode->components.end(), f);
else
std::for_each(unsortedComponents.begin(), unsortedComponents.end(), f);
}
void DrawingProgramCache::preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& c) {
void DrawingProgramCache::preupdate_component(CanvasComponentContainer::ObjInfo* c) {
// Can be called even if object isn't in cache yet. In that case, it'll just invalidate the cache at the object's AABB
auto cacheParentBvhNodeLock = c->obj->cacheParentBvhNode.lock();
if(cacheParentBvhNodeLock) {
@ -119,7 +119,7 @@ void DrawingProgramCache::preupdate_component(const CanvasComponentContainer::Ob
invalidate_cache_at_aabb(c->obj->get_world_bounds());
}
void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& components) {
void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfo*>& components) {
if(components.empty())
return;
@ -138,7 +138,7 @@ void DrawingProgramCache::build_bvh_node(const std::shared_ptr<DrawingProgramCac
WorldVec boundsCenter = bvhNode->bounds.center();
std::array<std::vector<CanvasComponentContainer::ObjInfoSharedPtr>, 4> parts;
std::array<std::vector<CanvasComponentContainer::ObjInfo*>, 4> parts;
for(auto& c : components) {
const auto& cAABB = c->obj->get_world_bounds();
@ -338,11 +338,11 @@ void DrawingProgramCache::recursive_draw_layer_item_to_canvas(const DrawingProgr
layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(layerListItem.get_blend_mode()));
canvas->saveLayer(nullptr, &layerPaint);
if(layerListItem.is_folder()) {
for(auto& p : layerListItem.get_folder().folderList->get_data() | std::views::reverse)
recursive_draw_layer_item_to_canvas(*p->obj, canvas, drawData, drawBounds, nodesToDraw);
for(auto& p : *layerListItem.get_folder().folderList | std::views::reverse)
recursive_draw_layer_item_to_canvas(*p.obj, canvas, drawData, drawBounds, nodesToDraw);
}
else {
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> compsToDraw;
std::vector<CanvasComponentContainer::ObjInfo*> compsToDraw;
for(auto& c : unsortedComponents) {
if(c->obj->parentLayer == &layerListItem && (!drawBounds.has_value() || SCollision::collide(drawBounds.value(), c->obj->get_world_bounds())))
compsToDraw.emplace_back(c);

22
src/DrawingProgram/DrawingProgramCache.hpp
View file

@ -8,7 +8,7 @@ struct DrawingProgramCacheBVHNode {
CoordSpaceHelper coords;
Vector2i resolution;
private:
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> components;
std::vector<CanvasComponentContainer::ObjInfo*> components;
std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>> children;
friend class DrawingProgramCache;
};
@ -20,22 +20,22 @@ class DrawingProgramCache {
static constexpr size_t MAXIMUM_DRAW_CACHE_SURFACES = 40;
DrawingProgramCache(DrawingProgram& initDrawP);
void add_component(const CanvasComponentContainer::ObjInfoSharedPtr& c);
void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& c);
void add_component(CanvasComponentContainer::ObjInfo* c);
void erase_component(CanvasComponentContainer::ObjInfo* c);
void clear_own_cached_surfaces();
void preupdate_component(const CanvasComponentContainer::ObjInfoSharedPtr& c);
void build(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToExclude);
void preupdate_component(CanvasComponentContainer::ObjInfo* c);
void build(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToExclude);
void traverse_bvh_run_function(const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void traverse_bvh_run_function_starting_at_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const SCollision::AABB<WorldScalar>& aabb, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void traverse_bvh_run_function_starting_at_node_no_collision_check(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>& node)> f);
void node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f);
void node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(const CanvasComponentContainer::ObjInfoSharedPtr& comp)> f);
void node_loop_erase_if_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<bool(CanvasComponentContainer::ObjInfo* comp)> f);
void node_loop_components(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, std::function<void(CanvasComponentContainer::ObjInfo* comp)> f);
bool should_rebuild() const;
void draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds);
bool unsorted_components_exist() const;
void invalidate_cache_at_aabb(const SCollision::AABB<WorldScalar>& aabb);
void refresh_all_draw_cache(const DrawData& drawData);
CanvasComponentContainer::ObjInfoSharedPtr get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
CanvasComponentContainer::ObjInfo* get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
~DrawingProgramCache();
private:
struct NodeCache {
@ -46,14 +46,14 @@ class DrawingProgramCache {
};
static std::unordered_map<std::shared_ptr<DrawingProgramCacheBVHNode>, NodeCache> nodeCacheMap;
void internal_build(std::vector<CanvasComponentContainer::ObjInfoSharedPtr> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& objsToNotInclude);
void build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& components);
void internal_build(std::vector<CanvasComponentContainer::ObjInfo*> componentsToBuild, const std::unordered_set<CanvasComponentContainer::ObjInfo*>& objsToNotInclude);
void build_bvh_node(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const std::vector<CanvasComponentContainer::ObjInfo*>& components);
void build_bvh_node_coords_and_resolution(DrawingProgramCacheBVHNode& node);
void refresh_draw_cache(const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode, const DrawData& drawData);
void draw_cache_image_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode);
void recursive_draw_layer_item_to_canvas(const DrawingProgramLayerListItem& layerListItem, SkCanvas* canvas, const DrawData& drawData, const std::optional<SCollision::AABB<WorldScalar>>& drawBounds, const std::vector<std::shared_ptr<DrawingProgramCacheBVHNode>>& nodesToDraw);
std::shared_ptr<DrawingProgramCacheBVHNode> bvhRoot;
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> unsortedComponents;
std::vector<CanvasComponentContainer::ObjInfo*> unsortedComponents;
DrawingProgram& drawP;
};

48
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -23,9 +23,9 @@ DrawingProgramSelection::DrawingProgramSelection(DrawingProgram& initDrawP):
{}
void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> selectedComponents;
std::unordered_set<CanvasComponentContainer::ObjInfo*> selectedComponents;
if(frontObjectOnly) {
CanvasComponentContainer::ObjInfoSharedPtr a = drawP.drawCache.get_front_object_colliding_with_in_editing_layer(cC);
CanvasComponentContainer::ObjInfo* a = drawP.drawCache.get_front_object_colliding_with_in_editing_layer(cC);
if(a) {
selectedComponents.emplace(a);
drawP.drawCache.erase_component(a);
@ -40,7 +40,7 @@ void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCo
void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
if(frontObjectOnly) {
CanvasComponentContainer::ObjInfoSharedPtr p = get_front_object_colliding_with_in_editing_layer(cC);
CanvasComponentContainer::ObjInfo* p = get_front_object_colliding_with_in_editing_layer(cC);
if(p) {
drawP.drawCache.add_component(p);
selectedSet.erase(p);
@ -60,7 +60,7 @@ void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const
calculate_aabb();
}
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingProgramSelection::erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector) {
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingProgramSelection::erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfo*>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector) {
auto toRet = [&](const auto& bvhNode) {
if(bvhNode && (bvhNode->coords.inverseScale << 9) < drawP.world.drawData.cam.c.inverseScale &&
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.min)) &&
@ -69,7 +69,7 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) {
drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds);
drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto& c) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
selectedComponents.emplace(c);
return true;
@ -80,7 +80,7 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
});
return false;
}
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto& c) {
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
selectedComponents.emplace(c);
drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());
@ -94,12 +94,12 @@ std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> DrawingP
return toRet;
}
void DrawingProgramSelection::add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection) {
void DrawingProgramSelection::add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection) {
selectedSet.insert(newSelection.begin(), newSelection.end());
calculate_aabb();
}
void DrawingProgramSelection::set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection) {
void DrawingProgramSelection::set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection) {
selectedSet = newSelection;
calculate_aabb();
}
@ -117,7 +117,7 @@ bool DrawingProgramSelection::is_something_selected() {
return !selectedSet.empty();
}
bool DrawingProgramSelection::is_selected(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) {
bool DrawingProgramSelection::is_selected(CanvasComponentContainer::ObjInfo* objToCheck) {
return selectedSet.contains(objToCheck);
}
@ -149,15 +149,15 @@ bool DrawingProgramSelection::mouse_collided_with_rotate_handle_point() {
void DrawingProgramSelection::commit_transform_selection() {
auto selectedSetTemp = selectedSet;
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> a(selectedSet.begin(), selectedSet.end());
std::vector<std::pair<CanvasComponentContainer::ObjInfoSharedPtr, CoordSpaceHelper>> transformsFrom;
std::vector<CanvasComponentContainer::ObjInfo*> a(selectedSet.begin(), selectedSet.end());
std::vector<std::pair<CanvasComponentContainer::ObjInfo*, CoordSpaceHelper>> transformsFrom;
for(auto& transformedObj : a)
transformsFrom.emplace_back(transformedObj, transformedObj->obj->coords);
for(auto& comp : a) {
comp->obj->coords = selectionTransformCoords.other_coord_space_from_this_space(comp->obj->coords);
comp->obj->commit_transform(drawP);
}
std::vector<std::pair<CanvasComponentContainer::ObjInfoSharedPtr, CoordSpaceHelper>> transformsTo;
std::vector<std::pair<CanvasComponentContainer::ObjInfo*, CoordSpaceHelper>> transformsTo;
std::vector<std::pair<NetworkingObjects::NetObjID, CoordSpaceHelper>> transformsToSend;
for(auto& transformedObj : a) {
transformsToSend.emplace_back(transformedObj->obj.get_net_id(), transformedObj->obj->coords);
@ -296,7 +296,7 @@ void DrawingProgramSelection::delete_all() {
}
}
void DrawingProgramSelection::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck) {
void DrawingProgramSelection::erase_component(CanvasComponentContainer::ObjInfo* objToCheck) {
if(is_selected(objToCheck)) {
selectedSet.erase(objToCheck);
if(selectedSet.empty())
@ -304,9 +304,9 @@ void DrawingProgramSelection::erase_component(const CanvasComponentContainer::Ob
}
}
CanvasComponentContainer::ObjInfoSharedPtr DrawingProgramSelection::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
CanvasComponentContainer::ObjInfo* DrawingProgramSelection::get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC) {
auto cCWorld = drawP.world.drawData.cam.c.collider_to_world<SCollision::ColliderCollection<WorldScalar>, SCollision::ColliderCollection<float>>(cC);
CanvasComponentContainer::ObjInfoSharedPtr p;
CanvasComponentContainer::ObjInfo* p = nullptr;
for(auto& c : selectedSet) {
if(drawP.layerMan.component_passes_layer_selector(c, DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED) && (!p || c->pos >= p->pos) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC))
p = c;
@ -319,7 +319,7 @@ void DrawingProgramSelection::selection_to_clipboard() {
std::unordered_set<NetworkingObjects::NetObjID> resourceSet;
for(auto& c : selectedSet)
c->obj->get_comp().get_used_resources(resourceSet);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> compVecSort(selectedSet.begin(), selectedSet.end());
std::vector<CanvasComponentContainer::ObjInfo*> compVecSort(selectedSet.begin(), selectedSet.end());
std::vector<DrawingProgramLayerListItem*> flattenedLayerList = drawP.layerMan.get_flattened_layer_list();
std::unordered_map<DrawingProgramLayerListItem*, size_t> flattenedLayerListOrder;
for(size_t i = 0; i < flattenedLayerList.size(); i++)
@ -342,7 +342,7 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
if(!drawP.is_selection_allowing_tool(drawP.drawTool->get_type()))
drawP.switch_to_tool(DrawingProgramToolType::EDIT);
std::vector<std::pair<uint32_t, CanvasComponentContainer*>> placedComponents;
std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>> placedComponents;
WorldVec mousePos = drawP.world.drawData.cam.c.from_space(pasteScreenPos);
WorldVec moveVec = drawP.world.main.clipboard.pos - mousePos;
WorldMultiplier scaleMultiplier = WorldMultiplier(drawP.world.main.clipboard.inverseScale) / WorldMultiplier(drawP.world.drawData.cam.c.inverseScale);
@ -362,10 +362,12 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
newComponentContainer->get_comp().remap_resource_ids(resourceRemapIDs);
newComponentContainer->coords.translate(-moveVec);
newComponentContainer->coords.scale_about(mousePos, scaleMultiplier);
placedComponents.emplace_back(drawP.layerMan.edited_layer_component_count() + placedComponents.size(), newComponentContainer);
placedComponents.emplace_back(drawP.layerMan.get_edited_layer_end_iterator(), newComponentContainer);
}
auto newlyInsertedObjects = drawP.layerMan.add_many_components_to_layer_being_edited(placedComponents);
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> compSetInserted(newlyInsertedObjects.begin(), newlyInsertedObjects.end());
auto newlyInsertedObjectIts = drawP.layerMan.add_many_components_to_layer_being_edited(placedComponents);
std::unordered_set<CanvasComponentContainer::ObjInfo*> compSetInserted;
for(auto& it : newlyInsertedObjectIts)
compSetInserted.emplace(&(*it));
set_to_selection(compSetInserted);
//drawP.add_undo_place_components(compSetInserted);
}
@ -375,7 +377,7 @@ bool DrawingProgramSelection::is_being_transformed() {
return transformOpHappening != TransformOperation::NONE;
}
const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& DrawingProgramSelection::get_selected_set() {
const std::unordered_set<CanvasComponentContainer::ObjInfo*>& DrawingProgramSelection::get_selected_set() {
return selectedSet;
}
@ -459,8 +461,8 @@ void DrawingProgramSelection::draw_components_recursive(const DrawingProgramLaye
//layerPaint.setBlendMode(serialized_blend_mode_to_sk_blend_mode(displayData->blendMode)); // For selection, everything should just be in default blend mode (SrcOver)
canvas->saveLayer(nullptr, &layerPaint);
if(layerItem.is_folder()) {
for(auto& p : layerItem.get_folder().folderList->get_data() | std::views::reverse)
draw_components_recursive(*p->obj, canvas, drawData);
for(auto& p : *layerItem.get_folder().folderList | std::views::reverse)
draw_components_recursive(*p.obj, canvas, drawData);
}
else {
for(auto& c : selectedSet) { // Loop on selected set and not layer component list, since i'm assuming selected set will be small

16
src/DrawingProgram/DrawingProgramSelection.hpp
View file

@ -10,19 +10,19 @@ class DrawingProgramSelection {
DrawingProgramSelection(DrawingProgram& initDrawP);
void add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck);
void erase_component(CanvasComponentContainer::ObjInfo* objToCheck);
bool is_something_selected();
bool is_selected(const CanvasComponentContainer::ObjInfoSharedPtr& objToCheck);
bool is_selected(CanvasComponentContainer::ObjInfo* objToCheck);
void draw_components(SkCanvas* canvas, const DrawData& drawData);
void draw_gui(SkCanvas* canvas, const DrawData& drawData);
bool is_being_transformed();
void update();
void deselect_all();
void paste_clipboard(Vector2f pasteScreenPos);
const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& get_selected_set();
const std::unordered_set<CanvasComponentContainer::ObjInfo*>& get_selected_set();
void delete_all();
void selection_to_clipboard();
CanvasComponentContainer::ObjInfoSharedPtr get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
CanvasComponentContainer::ObjInfo* get_front_object_colliding_with_in_editing_layer(const SCollision::ColliderCollection<float>& cC);
private:
void draw_components_recursive(const DrawingProgramLayerListItem& layerItem, SkCanvas* canvas, const DrawData& drawData);
bool mouse_collided_with_selection_aabb();
@ -34,16 +34,16 @@ class DrawingProgramSelection {
void rebuild_cam_space();
Vector2f get_rotation_point_pos_from_angle(double angle);
void set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection);
void add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& newSelection);
void set_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection);
void add_to_selection(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& newSelection);
void calculate_aabb();
void reset_all();
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector);
std::function<bool(const std::shared_ptr<DrawingProgramCacheBVHNode>&)> erase_select_objects_in_bvh_func(std::unordered_set<CanvasComponentContainer::ObjInfo*>& selectedComponents, const SCollision::ColliderCollection<float>& cC, const SCollision::ColliderCollection<WorldScalar>& cCWorld, DrawingProgramLayerManager::LayerSelector layerSelector);
SCollision::ColliderCollection<float> camSpaceSelection;
std::array<WorldVec, 4> selectionRectPoints;
CoordSpaceHelperTransform selectionTransformCoords;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> selectedSet;
std::unordered_set<CanvasComponentContainer::ObjInfo*> selectedSet;
SCollision::AABB<WorldScalar> initialSelectionAABB;
DrawingProgram& drawP;

35
src/DrawingProgram/Layers/DrawingProgramLayer.cpp
View file

@ -4,39 +4,40 @@
#include <Helpers/Parallel.hpp>
void DrawingProgramLayer::draw(SkCanvas* canvas, const DrawData& drawData) const {
for(auto& p : components->get_data())
p->obj->draw(canvas, drawData);
for(auto& p : *components)
p.obj->draw(canvas, drawData);
}
void DrawingProgramLayer::set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const {
components->set_insert_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) {
c->obj->set_owner_obj_info(c);
components->set_insert_callback([&](const CanvasComponentContainer::ObjInfoIterator& c) {
c->obj->objInfo = c;
c->obj->parentLayer = &layerListItem;
c->obj->commit_update(layerMan.drawP); // Run commit update on insert so that world bounds are calculated
layerMan.drawP.drawCache.add_component(c);
layerMan.drawP.drawCache.add_component(&(*c));
if(c->obj->get_comp().get_type() == CanvasComponentType::IMAGE)
layerMan.drawP.updateableComponents.emplace(c);
layerMan.drawP.updateableComponents.emplace(&(*c));
});
components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c) {
layerMan.drawP.selection.erase_component(c);
layerMan.drawP.drawCache.erase_component(c);
layerMan.drawP.drawTool->erase_component(c);
components->set_erase_callback([&](const CanvasComponentContainer::ObjInfoIterator& c) {
layerMan.drawP.selection.erase_component(&(*c));
layerMan.drawP.drawCache.erase_component(&(*c));
layerMan.drawP.drawTool->erase_component(&(*c));
std::erase_if(layerMan.drawP.droppedDownloadingFiles, [&c](auto& downloadingFile) {
return downloadingFile.comp == c;
return downloadingFile.comp == &(*c);
});
layerMan.drawP.updateableComponents.erase(c);
layerMan.drawP.updateableComponents.erase(&(*c));
});
components->set_move_callback([&](const CanvasComponentContainer::ObjInfoSharedPtr& c, uint32_t oldPos) {
components->set_move_callback([&](const CanvasComponentContainer::ObjInfoIterator& c, uint32_t oldPos) {
layerMan.drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());
});
}
void DrawingProgramLayer::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const {
parallel_loop_container(components->get_data(), [&layerMan](auto& comp) {
comp->obj->commit_update_dont_invalidate_cache(layerMan.drawP);
parallel_loop_container(*components, [&layerMan](auto& comp) {
comp.obj->commit_update_dont_invalidate_cache(layerMan.drawP);
});
}
void DrawingProgramLayer::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const {
objList.insert(objList.begin(), components->get_data().begin(), components->get_data().end());
void DrawingProgramLayer::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
for(auto& p : *components)
objList.emplace_back(&p);
}

3
src/DrawingProgram/Layers/DrawingProgramLayer.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include "../../CanvasComponents/CanvasComponent.hpp"
#include <vector>
class DrawingProgramLayerListItem;
class DrawingProgramLayerManager;
@ -10,7 +11,7 @@ class DrawingProgramLayer {
void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_component_list_callbacks(DrawingProgramLayerListItem& layerListItem, DrawingProgramLayerManager& layerMan) const;
void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
CanvasComponentContainer::NetListOwnerPtr components;
};

18
src/DrawingProgram/Layers/DrawingProgramLayerFolder.cpp
View file

@ -4,24 +4,24 @@
#include <Helpers/Parallel.hpp>
void DrawingProgramLayerFolder::draw(SkCanvas* canvas, const DrawData& drawData) const {
for(auto& p : folderList->get_data() | std::views::reverse)
p->obj->draw(canvas, drawData);
for(auto& p : (*folderList) | std::views::reverse)
p.obj->draw(canvas, drawData);
}
void DrawingProgramLayerFolder::set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const {
folderList->set_insert_callback([&](auto& c) {
c->obj->set_component_list_callbacks(layerMan);
});
for(auto& listItem : folderList->get_data())
listItem->obj->set_component_list_callbacks(layerMan);
for(auto& listItem : *folderList)
listItem.obj->set_component_list_callbacks(layerMan);
}
void DrawingProgramLayerFolder::commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const {
for(auto& listItem : folderList->get_data())
listItem->obj->commit_update_dont_invalidate_cache(layerMan);
for(auto& listItem : *folderList)
listItem.obj->commit_update_dont_invalidate_cache(layerMan);
}
void DrawingProgramLayerFolder::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const {
for(auto& listItem : folderList->get_data())
listItem->obj->get_flattened_component_list(objList);
void DrawingProgramLayerFolder::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
for(auto& listItem : (*folderList) | std::views::reverse)
listItem.obj->get_flattened_component_list(objList);
}

2
src/DrawingProgram/Layers/DrawingProgramLayerFolder.hpp
View file

@ -12,7 +12,7 @@ class DrawingProgramLayerFolder {
void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_component_list_callbacks(DrawingProgramLayerManager& layerMan) const;
void commit_update_dont_invalidate_cache(DrawingProgramLayerManager& layerMan) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<DrawingProgramLayerListItem>> folderList;
bool isFolderOpen = false;

10
src/DrawingProgram/Layers/DrawingProgramLayerListItem.cpp
View file

@ -46,7 +46,7 @@ void DrawingProgramLayerListItem::commit_update_dont_invalidate_cache(DrawingPro
layerData->commit_update_dont_invalidate_cache(layerMan);
}
void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const {
void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const {
if(folderData)
folderData->get_flattened_component_list(objList);
else
@ -55,8 +55,8 @@ void DrawingProgramLayerListItem::get_flattened_component_list(std::vector<Canva
void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList) {
if(folderData) {
for(auto& c : folderData->folderList->get_data())
c->obj->get_flattened_layer_list(objList);
for(auto& c : *folderData->folderList)
c.obj->get_flattened_layer_list(objList);
}
else
objList.emplace_back(this);
@ -65,8 +65,8 @@ void DrawingProgramLayerListItem::get_flattened_layer_list(std::vector<DrawingPr
uint32_t DrawingProgramLayerListItem::get_component_count() const {
if(folderData) {
uint32_t toRet = 0;
for(auto& c : folderData->folderList->get_data())
toRet += c->obj->get_component_count();
for(auto& c : *folderData->folderList)
toRet += c.obj->get_component_count();
return toRet;
}
else

2
src/DrawingProgram/Layers/DrawingProgramLayerListItem.hpp
View file

@ -26,7 +26,7 @@ class DrawingProgramLayerListItem {
void draw(SkCanvas* canvas, const DrawData& drawData) const;
void set_name(NetworkingObjects::DelayUpdateSerializedClassManager& delayedNetObjMan, const std::string& newName) const;
const std::string& get_name() const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfoSharedPtr>& objList) const;
void get_flattened_component_list(std::vector<CanvasComponentContainer::ObjInfo*>& objList) const;
void get_flattened_layer_list(std::vector<DrawingProgramLayerListItem*>& objList);
void set_alpha(DrawingProgramLayerManager& layerMan, float newAlpha) const;

25
src/DrawingProgram/Layers/DrawingProgramLayerManager.cpp
View file

@ -1,5 +1,6 @@
#include "DrawingProgramLayerManager.hpp"
#include "../../World.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
DrawingProgramLayerManager::DrawingProgramLayerManager(DrawingProgram& drawProg):
drawP(drawProg), // initialize drawP first for next objects to be initialized properly
@ -32,13 +33,17 @@ uint32_t DrawingProgramLayerManager::edited_layer_component_count() {
return editingLayer.lock()->get_layer().components->size();
}
CanvasComponentContainer::ObjInfoIterator DrawingProgramLayerManager::get_edited_layer_end_iterator() {
return editingLayer.lock()->get_layer().components->end();
}
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;
std::vector<CanvasComponentContainer::ObjInfo*> DrawingProgramLayerManager::get_flattened_component_list() const {
std::vector<CanvasComponentContainer::ObjInfo*> toRet;
layerTreeRoot->get_flattened_component_list(toRet);
return toRet;
}
@ -57,17 +62,17 @@ 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;
void DrawingProgramLayerManager::erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& compsToErase) {
std::unordered_map<DrawingProgramLayerListItem*, std::vector<CanvasComponentContainer::ObjInfoIterator>> idsToEraseInSpecificLayers;
for(auto& c : compsToErase)
idsToEraseInSpecificLayers[c->obj->parentLayer].emplace(c->obj.get_net_id());
idsToEraseInSpecificLayers[c->obj->parentLayer].emplace_back(c->obj->objInfo);
for(auto& [layerListItem, netObjSetToErase] : idsToEraseInSpecificLayers) {
auto& layerComponentList = layerListItem->get_layer().components;
layerComponentList->erase_unordered_set(layerComponentList, netObjSetToErase);
layerComponentList->erase_list(layerComponentList, netObjSetToErase);
}
}
bool DrawingProgramLayerManager::component_passes_layer_selector(const CanvasComponentContainer::ObjInfoSharedPtr& c, LayerSelector layerSelector) {
bool DrawingProgramLayerManager::component_passes_layer_selector(CanvasComponentContainer::ObjInfo* c, LayerSelector layerSelector) {
switch(layerSelector) {
case LayerSelector::ALL_VISIBLE_LAYERS:
return c->obj->parentLayer->get_visible();
@ -77,16 +82,16 @@ bool DrawingProgramLayerManager::component_passes_layer_selector(const CanvasCom
return false;
}
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> DrawingProgramLayerManager::add_many_components_to_layer_being_edited(const std::vector<std::pair<uint32_t, CanvasComponentContainer*>>& newObjs) {
std::vector<CanvasComponentContainer::ObjInfoIterator> DrawingProgramLayerManager::add_many_components_to_layer_being_edited(const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, 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) {
CanvasComponentContainer::ObjInfo* 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);
return &(*editLayerPtr->get_layer().components->push_back_and_send_create(editLayerPtr->get_layer().components, newObj));
}

12
src/DrawingProgram/Layers/DrawingProgramLayerManager.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include "DrawingProgramLayerListItem.hpp"
#include "DrawingProgramLayerManagerGUI.hpp"
#include <unordered_set>
class DrawingProgramLayerManager {
private:
@ -23,16 +24,17 @@ class DrawingProgramLayerManager {
void write_components_server(cereal::PortableBinaryOutputArchive& a);
void read_components_client(cereal::PortableBinaryInputArchive& a);
bool is_a_layer_being_edited();
void erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr>& compsToErase);
void erase_component_set(const std::unordered_set<CanvasComponentContainer::ObjInfo*>& compsToErase);
uint32_t edited_layer_component_count();
bool component_passes_layer_selector(const CanvasComponentContainer::ObjInfoSharedPtr& c, LayerSelector layerSelector);
CanvasComponentContainer::ObjInfoIterator get_edited_layer_end_iterator();
bool component_passes_layer_selector(CanvasComponentContainer::ObjInfo* c, LayerSelector layerSelector);
bool layer_tree_root_exists();
const DrawingProgramLayerListItem& get_layer_root();
CanvasComponentContainer::ObjInfoSharedPtr add_component_to_layer_being_edited(CanvasComponentContainer* newObj);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> add_many_components_to_layer_being_edited(const std::vector<std::pair<uint32_t, CanvasComponentContainer*>>& newObjs);
std::vector<CanvasComponentContainer::ObjInfoSharedPtr> get_flattened_component_list() const;
CanvasComponentContainer::ObjInfo* add_component_to_layer_being_edited(CanvasComponentContainer* newObj);
std::vector<CanvasComponentContainer::ObjInfoIterator> add_many_components_to_layer_being_edited(const std::vector<std::pair<CanvasComponentContainer::ObjInfoIterator, CanvasComponentContainer*>>& newObjs);
std::vector<CanvasComponentContainer::ObjInfo*> get_flattened_component_list() const;
std::vector<DrawingProgramLayerListItem*> get_flattened_layer_list();
DrawingProgramLayerManagerGUI listGUI;
};

34
src/DrawingProgram/Layers/DrawingProgramLayerManagerGUI.cpp
View file

@ -1,9 +1,11 @@
#include "DrawingProgramLayerManagerGUI.hpp"
#include "DrawingProgramLayerListItem.hpp"
#include "DrawingProgramLayerManager.hpp"
#include "../DrawingProgram.hpp"
#include "../../World.hpp"
#include "../../MainProgram.hpp"
#include "Helpers/ConvertVec.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
#include "SerializedBlendMode.hpp"
DrawingProgramLayerManagerGUI::DrawingProgramLayerManagerGUI(DrawingProgramLayerManager& drawLayerMan):
@ -97,28 +99,29 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
},
.moveObjectsToListAtIndex = [&](NetObjID listObj, size_t index, const std::vector<GUIStuff::TreeListing::ParentObjectIDPair>& objsToInsert) {
world.netObjMan.send_multi_update_messsage([&]() {
std::unordered_map<NetObjID, std::unordered_set<NetObjID>> toEraseMap;
std::unordered_map<NetObjID, std::vector<NetObjOrderedListIterator<DrawingProgramLayerListItem>>> toEraseMap;
uint32_t newIndex = index;
std::vector<NetObjOwnerPtr<DrawingProgramLayerListItem>> toInsertObjPtrs;
auto& listPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listObj)->get_folder().folderList;
for(size_t i = 0; i < objsToInsert.size(); i++) {
toEraseMap[objsToInsert[i].parent].emplace(objsToInsert[i].object);
toEraseMap[objsToInsert[i].parent].emplace_back(listPtr->get(objsToInsert[i].object));
if(newIndex != 0 && objsToInsert[i].parent == listObj && listPtr->get(objsToInsert[i].object)->pos <= index)
newIndex--;
}
for(auto& [listToEraseFrom, setToErase] : toEraseMap) {
auto& listToEraseFromPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(listToEraseFrom)->get_folder().folderList;
listToEraseFromPtr->erase_unordered_set(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
listToEraseFromPtr->erase_list(listToEraseFromPtr, setToErase, &toInsertObjPtrs);
}
std::vector<std::pair<uint32_t, NetObjOwnerPtr<DrawingProgramLayerListItem>>> toInsert;
std::vector<std::pair<NetObjOrderedListIterator<DrawingProgramLayerListItem>, NetObjOwnerPtr<DrawingProgramLayerListItem>>> toInsert;
auto insertIt = listPtr->at(newIndex);
for(uint32_t i = 0; i < objsToInsert.size(); i++) {
auto it = std::find_if(toInsertObjPtrs.begin(), toInsertObjPtrs.end(), [id = objsToInsert[i].object](NetObjOwnerPtr<DrawingProgramLayerListItem>& objPtr) {
return objPtr.get_net_id() == id;
});
toInsert.emplace_back(newIndex + i, std::move(*it));
toInsert.emplace_back(insertIt, std::move(*it));
toInsert.back().second.reassign_ids();
}
listPtr->insert_ordered_list_and_send_create(listPtr, toInsert);
@ -151,7 +154,7 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
if(toDeleteObject.has_value()) {
auto& folderList = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(toDeleteParent.value())->get_folder().folderList;
folderList->erase(folderList, toDeleteObject.value());
folderList->erase(folderList, folderList->get(toDeleteObject.value()));
}
}
@ -194,29 +197,28 @@ void DrawingProgramLayerManagerGUI::setup_list_gui(const std::string& id, bool&
}
}
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem) {
std::optional<NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem>> DrawingProgramLayerManagerGUI::try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem) {
using namespace NetworkingObjects;
auto& world = layerMan.drawP.world;
if(selectionData.orderedObjsSelected.empty())
return nullptr;
return std::nullopt;
auto& backObjParentObjectPair = selectionData.orderedObjsSelected.back();
NetObjTemporaryPtr<DrawingProgramLayerListItem> parentPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.parent);
if(!parentPtr)
return nullptr;
return std::nullopt;
NetObjTemporaryPtr<DrawingProgramLayerListItem> objectPtr = world.netObjMan.get_obj_temporary_ref_from_id<DrawingProgramLayerListItem>(backObjParentObjectPair.object);
if(!objectPtr)
return nullptr;
return std::nullopt;
if(objectPtr->is_folder()) {
objectPtr->get_folder().isFolderOpen = true;
return objectPtr->get_folder().folderList->insert_and_send_create(objectPtr->get_folder().folderList, 0, newItem);
return objectPtr->get_folder().folderList->insert_and_send_create(objectPtr->get_folder().folderList, objectPtr->get_folder().folderList->begin(), newItem);
}
uint32_t insertPos = parentPtr->get_folder().folderList->get(objectPtr.get_net_id())->pos;
return parentPtr->get_folder().folderList->insert_and_send_create(parentPtr->get_folder().folderList, insertPos, newItem);
return parentPtr->get_folder().folderList->insert_and_send_create(parentPtr->get_folder().folderList, parentPtr->get_folder().folderList->get(objectPtr.get_net_id()), newItem);
}
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::create_in_proper_position(DrawingProgramLayerListItem* newItem) {
NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem> DrawingProgramLayerManagerGUI::create_in_proper_position(DrawingProgramLayerListItem* newItem) {
auto toRet = try_to_create_in_proper_position(newItem);
if(!toRet)
return layerMan.layerTreeRoot->get_folder().folderList->insert_and_send_create(layerMan.layerTreeRoot->get_folder().folderList, 0, newItem);
return toRet;
return layerMan.layerTreeRoot->get_folder().folderList->insert_and_send_create(layerMan.layerTreeRoot->get_folder().folderList, layerMan.layerTreeRoot->get_folder().folderList->begin(), newItem);
return toRet.value();
}

4
src/DrawingProgram/Layers/DrawingProgramLayerManagerGUI.hpp
View file

@ -13,8 +13,8 @@ class DrawingProgramLayerManagerGUI {
void refresh_gui_data();
void setup_list_gui(const std::string& id, bool& hoveringOverDropdown);
private:
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem);
NetworkingObjects::NetObjOrderedListObjectInfoPtr<DrawingProgramLayerListItem> create_in_proper_position(DrawingProgramLayerListItem* newItem);
std::optional<NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem>> try_to_create_in_proper_position(DrawingProgramLayerListItem* newItem);
NetworkingObjects::NetObjOrderedListIterator<DrawingProgramLayerListItem> create_in_proper_position(DrawingProgramLayerListItem* newItem);
GUIStuff::TreeListing::SelectionData selectionData;
std::unordered_set<NetworkingObjects::NetObjID> oldSelection;

19
src/DrawingProgram/Tools/BrushTool.cpp
View file

@ -26,11 +26,9 @@ void BrushTool::switch_tool(DrawingProgramToolType newTool) {
commit_stroke();
}
void BrushTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
isDrawing = false;
void BrushTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr;
}
}
bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) {
@ -59,7 +57,7 @@ void BrushTool::tool_update() {
if(drawP.controls.cursorHoveringOverCanvas)
drawP.world.main.input.hideCursor = true;
if(!isDrawing)
if(!objInfoBeingEdited)
penSmoothingData.clear();
if(drawP.world.main.input.pen.isDown && drawP.controls.leftClickHeld && drawP.world.main.toolbar.tabletOptions.pressureAffectsBrushWidth) {
@ -89,9 +87,8 @@ void BrushTool::tool_update() {
isPenDown = true;
if(isPenDown) {
if(!isDrawing) {
if(!objInfoBeingEdited) {
if(drawP.layerMan.is_a_layer_being_edited()) {
isDrawing = true;
CanvasComponentContainer* newBrushStrokeContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::BRUSHSTROKE);
BrushStrokeCanvasComponent& newBrushStroke = static_cast<BrushStrokeCanvasComponent&>(newBrushStrokeContainer->get_comp());
@ -148,10 +145,8 @@ void BrushTool::tool_update() {
containerPtr->commit_update(drawP);
}
}
else if(isDrawing) {
isDrawing = false;
else if(objInfoBeingEdited)
commit_stroke();
}
}
void BrushTool::commit_stroke() {
@ -179,7 +174,7 @@ bool BrushTool::right_click_popup_gui(Vector2f popupPos) {
}
bool BrushTool::prevent_undo_or_redo() {
return isDrawing;
return objInfoBeingEdited;
}
void BrushTool::draw(SkCanvas* canvas, const DrawData& drawData) {
@ -189,7 +184,7 @@ void BrushTool::draw(SkCanvas* canvas, const DrawData& drawData) {
linePaint.setStroke(true);
linePaint.setStrokeWidth(0.0f);
float width;
if(isDrawing)
if(objInfoBeingEdited)
width = drawP.controls.relativeWidth * penWidth * 0.5f;
else
width = drawP.controls.relativeWidth * 0.5f;

5
src/DrawingProgram/Tools/BrushTool.hpp
View file

@ -20,7 +20,7 @@ class BrushTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
@ -37,8 +37,7 @@ class BrushTool : public DrawingProgramToolBase {
};
std::deque<SmoothingPoint> penSmoothingData;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
bool isDrawing = false;
CanvasComponentContainer::ObjInfo* objInfoBeingEdited = nullptr;
bool hasRoundCaps = true;
bool drawingMinimumRelativeToSize = true;
bool midwayInterpolation = true;

2
src/DrawingProgram/Tools/DrawingProgramToolBase.hpp
View file

@ -28,7 +28,7 @@ class DrawingProgramToolBase {
DrawingProgramToolBase(DrawingProgram& initDrawP);
virtual DrawingProgramToolType get_type() = 0;
virtual void gui_toolbox() = 0;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) = 0;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) = 0;
virtual bool right_click_popup_gui(Vector2f popupPos) = 0;
virtual void tool_update() = 0;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;

27
src/DrawingProgram/Tools/EditTool.cpp
View file

@ -24,7 +24,7 @@ DrawingProgramToolType EditTool::get_type() {
void EditTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
if(isEditing) {
if(objInfoBeingEdited) {
bool editHappened = compEditTool->edit_gui(objInfoBeingEdited);
if(editHappened)
objInfoBeingEdited->obj->commit_update(drawP);
@ -36,13 +36,13 @@ void EditTool::gui_toolbox() {
}
}
void EditTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void EditTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(erasedComp == objInfoBeingEdited)
switch_tool(get_type());
}
bool EditTool::right_click_popup_gui(Vector2f popupPos) {
if(isEditing)
if(objInfoBeingEdited)
return compEditTool->right_click_popup_gui(objInfoBeingEdited, popupPos);
else
return drawP.selection_action_menu(popupPos);
@ -61,14 +61,13 @@ void EditTool::switch_tool(DrawingProgramToolType newTool) {
}
pointHandles.clear();
pointDragging = nullptr;
isEditing = false;
if(!drawP.is_selection_allowing_tool(newTool))
drawP.selection.deselect_all();
}
void EditTool::edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
isEditing = true;
void EditTool::edit_start(CanvasComponentContainer::ObjInfo* comp) {
bool isEditing = true;
switch(comp->obj->get_comp().get_type()) {
case CanvasComponentType::TEXTBOX: {
compEditTool = std::make_unique<TextBoxEditTool>(drawP);
@ -97,12 +96,12 @@ void EditTool::edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp
}
}
bool EditTool::is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool EditTool::is_editable(CanvasComponentContainer::ObjInfo* comp) {
return comp->obj->get_comp().get_type() != CanvasComponentType::BRUSHSTROKE;
}
void EditTool::tool_update() {
if(!isEditing) {
if(!objInfoBeingEdited) {
SCollision::AABB<WorldScalar> mouseAABB{drawP.world.get_mouse_world_pos() - WorldVec{0.5f, 0.5f}, drawP.world.get_mouse_world_pos() + WorldVec{0.5f, 0.5f}};
SCollision::ColliderCollection<WorldScalar> cMouseAABB;
cMouseAABB.aabb.emplace_back(mouseAABB);
@ -116,7 +115,7 @@ void EditTool::tool_update() {
if(drawP.controls.leftClick) {
bool modifySelection = !drawP.selection.is_being_transformed();
if(drawP.world.main.input.mouse.leftClicks >= 2 && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held) {
CanvasComponentContainer::ObjInfoSharedPtr selectedObjectToEdit = drawP.selection.get_front_object_colliding_with_in_editing_layer(camCMouseAABB);
CanvasComponentContainer::ObjInfo* selectedObjectToEdit = drawP.selection.get_front_object_colliding_with_in_editing_layer(camCMouseAABB);
if(selectedObjectToEdit && is_editable(selectedObjectToEdit)) {
drawP.selection.deselect_all();
@ -181,14 +180,12 @@ void EditTool::tool_update() {
}
bool EditTool::prevent_undo_or_redo() {
return isEditing;
return objInfoBeingEdited;
}
void EditTool::draw(SkCanvas* canvas, const DrawData& drawData) {
if(isEditing) {
if(objInfoBeingEdited) {
for(HandleData& h : pointHandles)
drawP.draw_drag_circle(canvas, drawData.cam.c.to_space((objInfoBeingEdited->obj->coords.from_space(*h.p))), {0.1f, 0.9f, 0.9f, 1.0f}, drawData);
}
if(objInfoBeingEdited) {
for(HandleData& h : pointHandles)
drawP.draw_drag_circle(canvas, drawData.cam.c.to_space((objInfoBeingEdited->obj->coords.from_space(*h.p))), {0.1f, 0.9f, 0.9f, 1.0f}, drawData);
}
}

9
src/DrawingProgram/Tools/EditTool.hpp
View file

@ -20,19 +20,18 @@ class EditTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
void add_point_handle(const HandleData& handle);
void edit_start(const CanvasComponentContainer::ObjInfoSharedPtr& comp);
bool is_editable(const CanvasComponentContainer::ObjInfoSharedPtr& comp);
void edit_start(CanvasComponentContainer::ObjInfo* comp);
bool is_editable(CanvasComponentContainer::ObjInfo* comp);
std::unique_ptr<DrawingProgramEditToolBase> compEditTool;
std::vector<HandleData> pointHandles;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
bool isEditing = false;
CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
HandleData* pointDragging = nullptr;
std::any prevData;
};

2
src/DrawingProgram/Tools/EditTools/DrawingProgramEditToolBase.cpp
View file

@ -5,7 +5,7 @@ DrawingProgramEditToolBase::DrawingProgramEditToolBase(DrawingProgram& initDrawP
drawP(initDrawP)
{}
bool DrawingProgramEditToolBase::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) {
bool DrawingProgramEditToolBase::right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar;
t.paint_popup(popupPos);
return true;

10
src/DrawingProgram/Tools/EditTools/DrawingProgramEditToolBase.hpp
View file

@ -9,11 +9,11 @@ class EditTool;
class DrawingProgramEditToolBase {
public:
DrawingProgramEditToolBase(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer, std::any& prevData) = 0;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& compContainer) = 0;
virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos);
virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* compContainer, std::any& prevData) = 0;
virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* compContainer, std::any& prevData) = 0;
virtual bool edit_update(CanvasComponentContainer::ObjInfo* compContainer) = 0;
virtual bool edit_gui(CanvasComponentContainer::ObjInfo* compContainer) = 0;
virtual bool right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos);
virtual ~DrawingProgramEditToolBase();
protected:
DrawingProgram& drawP;

8
src/DrawingProgram/Tools/EditTools/EllipseDrawEditTool.cpp
View file

@ -11,7 +11,7 @@ EllipseDrawEditTool::EllipseDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool EllipseDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool EllipseDrawEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar;
@ -42,7 +42,7 @@ bool EllipseDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoShared
return editHappened;
}
void EllipseDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void EllipseDrawEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<EllipseCanvasComponent&>(comp->obj->get_comp());
prevData = a.d;
@ -50,9 +50,9 @@ void EllipseDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentCo
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
}
void EllipseDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void EllipseDrawEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
}
bool EllipseDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool EllipseDrawEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true;
}

8
src/DrawingProgram/Tools/EditTools/EllipseDrawEditTool.hpp
View file

@ -10,10 +10,10 @@ class DrawingProgram;
class EllipseDrawEditTool : public DrawingProgramEditToolBase {
public:
EllipseDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
private:
void commit();

8
src/DrawingProgram/Tools/EditTools/ImageEditTool.cpp
View file

@ -16,17 +16,17 @@ ImageEditTool::ImageEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
void ImageEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void ImageEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
}
void ImageEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void ImageEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
}
bool ImageEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool ImageEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true;
}
bool ImageEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool ImageEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
ImageCanvasComponent& a = static_cast<ImageCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool image");

8
src/DrawingProgram/Tools/EditTools/ImageEditTool.hpp
View file

@ -7,8 +7,8 @@ class DrawingProgram;
class ImageEditTool : public DrawingProgramEditToolBase {
public:
ImageEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
};

8
src/DrawingProgram/Tools/EditTools/RectDrawEditTool.cpp
View file

@ -9,7 +9,7 @@ RectDrawEditTool::RectDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool RectDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool RectDrawEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool rectangle");
@ -40,16 +40,16 @@ bool RectDrawEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr
return editHappened;
}
void RectDrawEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void RectDrawEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<RectangleCanvasComponent&>(comp->obj->get_comp());
prevData = a.d;
editTool.add_point_handle({&a.d.p1, nullptr, &a.d.p2});
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
}
void RectDrawEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void RectDrawEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
}
bool RectDrawEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool RectDrawEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true;
}

8
src/DrawingProgram/Tools/EditTools/RectDrawEditTool.hpp
View file

@ -9,10 +9,10 @@ class DrawingProgram;
class RectDrawEditTool : public DrawingProgramEditToolBase {
public:
RectDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual void edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
private:
std::optional<RectangleCanvasComponent::Data> oldData;
};

10
src/DrawingProgram/Tools/EditTools/TextBoxEditTool.cpp
View file

@ -20,7 +20,7 @@ TextBoxEditTool::TextBoxEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool TextBoxEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool TextBoxEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar;
@ -152,7 +152,7 @@ bool TextBoxEditTool::edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr&
return oldInputChangedTextBox;
}
bool TextBoxEditTool::right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) {
bool TextBoxEditTool::right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) {
Toolbar& t = drawP.world.main.toolbar;
bool shouldClose = false;
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
@ -250,7 +250,7 @@ void TextBoxEditTool::set_styles_at_selection(TextBoxCanvasComponent& a) {
currentPStyle = a.textBox->get_paragraph_style_data_at(start.fParagraphIndex);
}
void TextBoxEditTool::commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void TextBoxEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
a.d.editing = false;
comp->obj->commit_update(drawP);
@ -263,7 +263,7 @@ TextBoxEditTool::TextBoxEditToolAllData TextBoxEditTool::get_all_data(const Text
};
}
void TextBoxEditTool::edit_start(EditTool& editTool, const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) {
void TextBoxEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
auto& cur = a.cursor;
auto& textbox = a.textBox;
@ -280,7 +280,7 @@ void TextBoxEditTool::edit_start(EditTool& editTool, const CanvasComponentContai
editTool.add_point_handle({&a.d.p2, &a.d.p1, nullptr});
}
bool TextBoxEditTool::edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) {
bool TextBoxEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
SCollision::ColliderCollection<float> mousePointCollection;

10
src/DrawingProgram/Tools/EditTools/TextBoxEditTool.hpp
View file

@ -10,11 +10,11 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
public:
TextBoxEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool,const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual void commit_edit_updates(const CanvasComponentContainer::ObjInfoSharedPtr& comp, std::any& prevData) override;
virtual bool edit_update(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool edit_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp) override;
virtual bool right_click_popup_gui(const CanvasComponentContainer::ObjInfoSharedPtr& comp, Vector2f popupPos) override;
virtual void edit_start(EditTool& editTool,CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual void commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) override;
virtual bool edit_update(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool edit_gui(CanvasComponentContainer::ObjInfo* comp) override;
virtual bool right_click_popup_gui(CanvasComponentContainer::ObjInfo* comp, Vector2f popupPos) override;
private:
struct TextBoxEditToolAllData {
TextBoxCanvasComponent::Data textboxData;

75
src/DrawingProgram/Tools/EllipseDrawTool.cpp
View file

@ -29,11 +29,9 @@ void EllipseDrawTool::gui_toolbox() {
t.gui.pop_id();
}
void EllipseDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
void EllipseDrawTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool EllipseDrawTool::right_click_popup_gui(Vector2f popupPos) {
@ -47,53 +45,46 @@ void EllipseDrawTool::switch_tool(DrawingProgramToolType newTool) {
}
void EllipseDrawTool::tool_update() {
switch(drawStage) {
case 0: {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::ELLIPSE);
EllipseCanvasComponent& newEllipse = static_cast<EllipseCanvasComponent&>(newContainer->get_comp());
if(objInfoBeingEdited) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::ELLIPSE);
EllipseCanvasComponent& newEllipse = static_cast<EllipseCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos;
newEllipse.d.strokeColor = drawP.controls.foregroundColor;
newEllipse.d.fillColor = drawP.controls.backgroundColor;
newEllipse.d.strokeWidth = drawP.controls.relativeWidth;
newEllipse.d.p1 = startAt;
newEllipse.d.p2 = startAt;
newEllipse.d.p2 = ensure_points_have_distance(newEllipse.d.p1, newEllipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newEllipse.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c;
startAt = drawP.world.main.input.mouse.pos;
newEllipse.d.strokeColor = drawP.controls.foregroundColor;
newEllipse.d.fillColor = drawP.controls.backgroundColor;
newEllipse.d.strokeWidth = drawP.controls.relativeWidth;
newEllipse.d.p1 = startAt;
newEllipse.d.p2 = startAt;
newEllipse.d.p2 = ensure_points_have_distance(newEllipse.d.p1, newEllipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newEllipse.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
}
case 1: {
if(drawP.controls.leftClickHeld) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
EllipseCanvasComponent& ellipse = static_cast<EllipseCanvasComponent&>(containerPtr->get_comp());
ellipse.d.p1 = cwise_vec_min(startAt, newPos);
ellipse.d.p2 = cwise_vec_max(startAt, newPos);
ellipse.d.p2 = ensure_points_have_distance(ellipse.d.p1, ellipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
else {
if(drawP.controls.leftClickHeld) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
else {
commit();
drawStage = 0;
}
break;
EllipseCanvasComponent& ellipse = static_cast<EllipseCanvasComponent&>(containerPtr->get_comp());
ellipse.d.p1 = cwise_vec_min(startAt, newPos);
ellipse.d.p2 = cwise_vec_max(startAt, newPos);
ellipse.d.p2 = ensure_points_have_distance(ellipse.d.p1, ellipse.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
else
commit();
}
}
bool EllipseDrawTool::prevent_undo_or_redo() {
return (drawStage == 1);
return objInfoBeingEdited;
}
void EllipseDrawTool::commit() {

5
src/DrawingProgram/Tools/EllipseDrawTool.hpp
View file

@ -12,7 +12,7 @@ class EllipseDrawTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
@ -22,6 +22,5 @@ class EllipseDrawTool : public DrawingProgramToolBase {
Vector2f startAt;
int fillStrokeMode = 1;
int drawStage = 0;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
};

6
src/DrawingProgram/Tools/EraserTool.cpp
View file

@ -31,7 +31,7 @@ bool EraserTool::right_click_popup_gui(Vector2f popupPos) {
return true;
}
void EraserTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void EraserTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
erasedComponents.erase(erasedComp);
}
@ -57,7 +57,7 @@ void EraserTool::tool_update() {
SCollision::collide(cC, drawP.world.drawData.cam.c.to_space(bvhNode->bounds.bottom_left()))) {
drawP.drawCache.invalidate_cache_at_aabb(bvhNode->bounds);
drawP.drawCache.traverse_bvh_run_function_starting_at_node_no_collision_check(bvhNode, [&](const auto& bvhNodeChild) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto& c) {
drawP.drawCache.node_loop_erase_if_components(bvhNodeChild, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector)) {
erasedComponents.emplace(c);
return true;
@ -68,7 +68,7 @@ void EraserTool::tool_update() {
});
return false;
}
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto& c) {
drawP.drawCache.node_loop_erase_if_components(bvhNode, [&](auto c) {
if(drawP.layerMan.component_passes_layer_selector(c, drawP.controls.layerSelector) && c->obj->collides_with(drawP.world.drawData.cam.c, cCWorld, cC)) {
erasedComponents.emplace(c);
drawP.drawCache.invalidate_cache_at_aabb(c->obj->get_world_bounds());

4
src/DrawingProgram/Tools/EraserTool.hpp
View file

@ -12,11 +12,11 @@ class EraserTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
std::unordered_set<CanvasComponentContainer::ObjInfoSharedPtr> erasedComponents; // Pointers will be erased from this set if theyre erased in the main list (done by callback)
std::unordered_set<CanvasComponentContainer::ObjInfo*> erasedComponents; // Pointers will be erased from this set if theyre erased in the main list (done by callback)
};

2
src/DrawingProgram/Tools/EyeDropperTool.cpp
View file

@ -44,7 +44,7 @@ bool EyeDropperTool::right_click_popup_gui(Vector2f popupPos) {
return true;
}
void EyeDropperTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void EyeDropperTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void EyeDropperTool::tool_update() {

2
src/DrawingProgram/Tools/EyeDropperTool.hpp
View file

@ -10,7 +10,7 @@ class EyeDropperTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/GridModifyTool.cpp
View file

@ -33,7 +33,7 @@ DrawingProgramToolType GridModifyTool::get_type() {
return DrawingProgramToolType::GRIDMODIFY;
}
void GridModifyTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void GridModifyTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void GridModifyTool::gui_toolbox() {

2
src/DrawingProgram/Tools/GridModifyTool.hpp
View file

@ -13,7 +13,7 @@ class GridModifyTool : public DrawingProgramToolBase {
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/LassoSelectTool.cpp
View file

@ -54,7 +54,7 @@ bool LassoSelectTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos);
}
void LassoSelectTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void LassoSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void LassoSelectTool::switch_tool(DrawingProgramToolType newTool) {

2
src/DrawingProgram/Tools/LassoSelectTool.hpp
View file

@ -13,7 +13,7 @@ class LassoSelectTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;

2
src/DrawingProgram/Tools/PanCanvasTool.cpp
View file

@ -25,7 +25,7 @@ bool PanCanvasTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos);
}
void PanCanvasTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void PanCanvasTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void PanCanvasTool::tool_update() {

2
src/DrawingProgram/Tools/PanCanvasTool.hpp
View file

@ -9,7 +9,7 @@ class PanCanvasTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;

78
src/DrawingProgram/Tools/RectDrawTool.cpp
View file

@ -27,11 +27,9 @@ void RectDrawTool::gui_toolbox() {
t.gui.pop_id();
}
void RectDrawTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
void RectDrawTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
@ -42,57 +40,49 @@ bool RectDrawTool::right_click_popup_gui(Vector2f popupPos) {
void RectDrawTool::switch_tool(DrawingProgramToolType newTool) {
commit();
drawStage = 0;
}
void RectDrawTool::tool_update() {
switch(drawStage) {
case 0: {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::RECTANGLE);
RectangleCanvasComponent& newRectangle = static_cast<RectangleCanvasComponent&>(newContainer->get_comp());
if(objInfoBeingEdited) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::RECTANGLE);
RectangleCanvasComponent& newRectangle = static_cast<RectangleCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos;
newRectangle.d.strokeColor = drawP.controls.foregroundColor;
newRectangle.d.fillColor = drawP.controls.backgroundColor;
newRectangle.d.cornerRadius = relativeRadiusWidth;
newRectangle.d.strokeWidth = drawP.controls.relativeWidth;
newRectangle.d.p1 = startAt;
newRectangle.d.p2 = startAt;
newRectangle.d.p2 = ensure_points_have_distance(newRectangle.d.p1, newRectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newRectangle.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
startAt = drawP.world.main.input.mouse.pos;
newRectangle.d.strokeColor = drawP.controls.foregroundColor;
newRectangle.d.fillColor = drawP.controls.backgroundColor;
newRectangle.d.cornerRadius = relativeRadiusWidth;
newRectangle.d.strokeWidth = drawP.controls.relativeWidth;
newRectangle.d.p1 = startAt;
newRectangle.d.p2 = startAt;
newRectangle.d.p2 = ensure_points_have_distance(newRectangle.d.p1, newRectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newRectangle.d.fillStrokeMode = static_cast<uint8_t>(fillStrokeMode);
newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
}
case 1: {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(drawP.controls.leftClickHeld) {
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
RectangleCanvasComponent& rectangle = static_cast<RectangleCanvasComponent&>(containerPtr->get_comp());
rectangle.d.p1 = cwise_vec_min(startAt, newPos);
rectangle.d.p2 = cwise_vec_max(startAt, newPos);
rectangle.d.p2 = ensure_points_have_distance(rectangle.d.p1, rectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
else {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
if(drawP.controls.leftClickHeld) {
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
else {
commit();
drawStage = 0;
}
break;
RectangleCanvasComponent& rectangle = static_cast<RectangleCanvasComponent&>(containerPtr->get_comp());
rectangle.d.p1 = cwise_vec_min(startAt, newPos);
rectangle.d.p2 = cwise_vec_max(startAt, newPos);
rectangle.d.p2 = ensure_points_have_distance(rectangle.d.p1, rectangle.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
else
commit();
}
}
bool RectDrawTool::prevent_undo_or_redo() {
return (drawStage == 1);
return objInfoBeingEdited;
}
void RectDrawTool::commit() {

5
src/DrawingProgram/Tools/RectDrawTool.hpp
View file

@ -11,7 +11,7 @@ class RectDrawTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
@ -22,6 +22,5 @@ class RectDrawTool : public DrawingProgramToolBase {
Vector2f startAt;
float relativeRadiusWidth = 10.0f;
int fillStrokeMode = 1;
int drawStage = 0;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
};

2
src/DrawingProgram/Tools/RectSelectTool.cpp
View file

@ -28,7 +28,7 @@ void RectSelectTool::gui_toolbox() {
t.gui.pop_id();
}
void RectSelectTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void RectSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
bool RectSelectTool::right_click_popup_gui(Vector2f popupPos) {

2
src/DrawingProgram/Tools/RectSelectTool.hpp
View file

@ -10,7 +10,7 @@ class RectSelectTool : public DrawingProgramToolBase {
RectSelectTool(DrawingProgram& initDrawP);
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;

2
src/DrawingProgram/Tools/ScreenshotTool.cpp
View file

@ -116,7 +116,7 @@ bool ScreenshotTool::right_click_popup_gui(Vector2f popupPos) {
return true;
}
void ScreenshotTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void ScreenshotTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void ScreenshotTool::take_screenshot(const std::filesystem::path& filePath) {

2
src/DrawingProgram/Tools/ScreenshotTool.hpp
View file

@ -13,7 +13,7 @@ class ScreenshotTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;

80
src/DrawingProgram/Tools/TextBoxTool.cpp
View file

@ -26,11 +26,9 @@ void TextBoxTool::gui_toolbox() {
t.gui.pop_id();
}
void TextBoxTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
if(objInfoBeingEdited == erasedComp) {
void TextBoxTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr;
drawStage = 0;
}
}
bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
@ -41,58 +39,52 @@ bool TextBoxTool::right_click_popup_gui(Vector2f popupPos) {
void TextBoxTool::switch_tool(DrawingProgramToolType newTool) {
commit();
drawStage = 0;
}
void TextBoxTool::tool_update() {
switch(drawStage) {
case 0: {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
startAt = drawP.world.main.input.mouse.pos;
endAt = startAt;
if(objInfoBeingEdited) {
if(drawP.controls.leftClick && drawP.layerMan.is_a_layer_being_edited()) {
startAt = drawP.world.main.input.mouse.pos;
endAt = startAt;
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::TEXTBOX);
TextBoxCanvasComponent& newTextBox = static_cast<TextBoxCanvasComponent&>(newContainer->get_comp());
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::TEXTBOX);
TextBoxCanvasComponent& newTextBox = static_cast<TextBoxCanvasComponent&>(newContainer->get_comp());
newTextBox.d.p1 = newTextBox.d.p2 = startAt;
newTextBox.d.p2 = ensure_points_have_distance(newTextBox.d.p1, newTextBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newTextBox.d.editing = true;
newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
drawStage = 1;
}
break;
newTextBox.d.p1 = newTextBox.d.p2 = startAt;
newTextBox.d.p2 = ensure_points_have_distance(newTextBox.d.p1, newTextBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
newTextBox.d.editing = true;
newContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newContainer);
}
case 1: {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp());
}
else {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp());
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
endAt = newPos;
textBox.d.p1 = cwise_vec_min(endAt, startAt);
textBox.d.p2 = cwise_vec_max(endAt, startAt);
textBox.d.p2 = ensure_points_have_distance(textBox.d.p1, textBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
if(!drawP.controls.leftClickHeld) {
auto editTool = std::make_unique<EditTool>(drawP);
editTool->edit_start(objInfoBeingEdited);
drawP.toolToSwitchToAfterUpdate = std::move(editTool);
return;
}
else {
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
break;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
float height = std::fabs(startAt.y() - newPos.y());
newPos.x() = startAt.x() + (((newPos.x() - startAt.x()) < 0.0f ? -1.0f : 1.0f) * height);
}
endAt = newPos;
textBox.d.p1 = cwise_vec_min(endAt, startAt);
textBox.d.p2 = cwise_vec_max(endAt, startAt);
textBox.d.p2 = ensure_points_have_distance(textBox.d.p1, textBox.d.p2, MINIMUM_DISTANCE_BETWEEN_BOUNDS);
if(!drawP.controls.leftClickHeld) {
auto editTool = std::make_unique<EditTool>(drawP);
editTool->edit_start(objInfoBeingEdited);
drawP.toolToSwitchToAfterUpdate = std::move(editTool);
return;
}
else {
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
}
}
bool TextBoxTool::prevent_undo_or_redo() {
return (drawStage == 1);
return objInfoBeingEdited;
}
void TextBoxTool::commit() {

4
src/DrawingProgram/Tools/TextBoxTool.hpp
View file

@ -11,7 +11,7 @@ class TextBoxTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
@ -22,5 +22,5 @@ class TextBoxTool : public DrawingProgramToolBase {
Vector2f startAt;
Vector2f endAt;
int drawStage = 0;
CanvasComponentContainer::ObjInfoSharedPtr objInfoBeingEdited;
CanvasComponentContainer::ObjInfo* objInfoBeingEdited;
};

2
src/DrawingProgram/Tools/ZoomCanvasTool.cpp
View file

@ -25,7 +25,7 @@ bool ZoomCanvasTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos);
}
void ZoomCanvasTool::erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) {
void ZoomCanvasTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
void ZoomCanvasTool::tool_update() {

2
src/DrawingProgram/Tools/ZoomCanvasTool.hpp
View file

@ -9,7 +9,7 @@ class ZoomCanvasTool : public DrawingProgramToolBase {
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual bool right_click_popup_gui(Vector2f popupPos) override;
virtual void erase_component(const CanvasComponentContainer::ObjInfoSharedPtr& erasedComp) override;
virtual void erase_component(CanvasComponentContainer::ObjInfo* erasedComp) override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;

2
src/GridManager.cpp
View file

@ -23,7 +23,7 @@ void GridManager::add_default_grid(const std::string& newName) {
void GridManager::remove_grid(uint32_t indexToRemove) {
if(grids)
grids->erase(grids, indexToRemove);
grids->erase(grids, grids->at(indexToRemove));
}
void GridManager::draw_back(SkCanvas* canvas, const DrawData& drawData) {