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

Started working on tree listing

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-20 16:38:51 +03:00
parent b91321560e
commit 180c930474
18 changed files with 315 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

3
CMakeLists.txt
View file

@ -48,9 +48,9 @@ set(sources "src/main.cpp"
"src/Toolbar.cpp"
"src/World.cpp"
"src/FileHelpers.cpp"
"src/BookmarkManager.cpp"
"src/VersionConstants.cpp"
"src/Bookmarks/BookmarkListItem.cpp"
"src/Bookmarks/BookmarkManager.cpp"
"src/ResourceDisplay/ResourceDisplay.cpp"
"src/ResourceDisplay/SvgResourceDisplay.cpp"
"src/ResourceDisplay/ImageResourceDisplay.cpp"
@ -101,6 +101,7 @@ set(sources "src/main.cpp"
"src/GUIStuff/Elements/RotateWheel.cpp"
"src/GUIStuff/Elements/TextParagraph.cpp"
"src/GUIStuff/Elements/FontPicker.cpp"
"src/GUIStuff/Elements/TreeListing.cpp"
"include/sago/platform_folders.cpp"
"include/Helpers/Networking/NetLibrary.cpp"
"include/Helpers/Networking/NetServer.cpp"

64
data/icons/droparrowclose.svg Normal file
View file

@ -0,0 +1,64 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
width="32"
height="32"
viewBox="0 0 8.4666666 8.4666666"
version="1.1"
id="svg1"
inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
sodipodi:docname="droparrowsideways.svg"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns="http://www.w3.org/2000/svg"
xmlns:svg="http://www.w3.org/2000/svg">
<sodipodi:namedview
id="namedview1"
pagecolor="#ffffff"
bordercolor="#000000"
borderopacity="0.25"
inkscape:showpageshadow="2"
inkscape:pageopacity="0.0"
inkscape:pagecheckerboard="0"
inkscape:deskcolor="#d1d1d1"
inkscape:document-units="px"
showgrid="true"
inkscape:zoom="8.138833"
inkscape:cx="21.686156"
inkscape:cy="4.4232386"
inkscape:window-width="2286"
inkscape:window-height="1214"
inkscape:window-x="0"
inkscape:window-y="0"
inkscape:window-maximized="0"
inkscape:current-layer="layer1">
<inkscape:grid
id="grid1"
units="px"
originx="0"
originy="0"
spacingx="0.26458333"
spacingy="0.26458333"
empcolor="#0099e5"
empopacity="0.30196078"
color="#0099e5"
opacity="0.14901961"
empspacing="5"
enabled="true"
visible="true"
dotted="false" />
</sodipodi:namedview>
<defs
id="defs1" />
<g
inkscape:label="Layer 1"
inkscape:groupmode="layer"
id="layer1">
<path
style="fill:none;stroke:#000000;stroke-width:0.79375;stroke-linecap:round;stroke-linejoin:round"
d="M 2.6458332,7.4083329 V 1.0583332 l 3.7041665,3.1749999 z"
id="path1"
sodipodi:nodetypes="cccc" />
</g>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 1.8 KiB

8
include/Helpers/NetworkingObjects/NetObjManager.hpp
View file

@ -35,7 +35,7 @@ namespace NetworkingObjects {
typeList.get_type_index_data<T>(isServer).readConstructorFunc(NetObjTemporaryPtr(newPtr).template cast<void>(), a, clientReceivedFrom);
return newPtr;
}
template <typename T> NetObjTemporaryPtr<T> read_get_obj_ref_from_message(cereal::PortableBinaryInputArchive& a) {
template <typename T> NetObjTemporaryPtr<T> read_get_obj_temporary_ref_from_message(cereal::PortableBinaryInputArchive& a) {
NetObjID id;
a(id);
auto it = objectData.find(id);
@ -62,12 +62,6 @@ namespace NetworkingObjects {
template <typename T> NetObjOwnerPtr<T> make_obj_from_ptr(T* p) {
return emplace_raw_ptr<T>(NetObjID::random_gen(), p);
}
template <typename T> NetObjOwnerPtr<T> get_obj_from_id(NetObjID id) {
auto it = objectData.find(id);
if(it == objectData.end())
throw std::runtime_error("[NetObjManager::get_obj_from_id] ID doesn't exist");
return NetObjOwnerPtr<T>(this, id, static_cast<T*>(it->second.p));
}
template <typename T> NetObjTemporaryPtr<T> get_obj_temporary_ref_from_id(NetObjID id) {
auto it = objectData.find(id);
if(it == objectData.end())

40
src/BookmarkManager.cpp
View file

@ -1,40 +0,0 @@
#include "BookmarkManager.hpp"
#include "Helpers/Networking/NetLibrary.hpp"
#include "Helpers/NetworkingObjects/NetObjOrderedList.hpp"
#include "World.hpp"
#include "MainProgram.hpp"
#include <algorithm>
void Bookmark::scale_up(const WorldScalar& scaleUpAmount) {
coords.scale_about(WorldVec{0, 0}, scaleUpAmount, true);
}
BookmarkManager::BookmarkManager(World& w):
world(w)
{}
void BookmarkManager::init() {
// NOTE: Should find a way for bookmarks added from the network to take into account the client's canvasScale
// Have the canvasScale variable come with the ClientData object, and the grid scale commands can be part of
// the client data class
if(world.netObjMan.is_server())
bookmarks = world.netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<Bookmark>>();
}
void BookmarkManager::add_bookmark(const std::string& name) {
bookmarks->emplace_back_direct(bookmarks, Bookmark{name, world.drawData.cam.c, world.main.window.size.cast<int32_t>()});
}
void BookmarkManager::remove_bookmark(uint32_t bookmarkIndex) {
bookmarks->erase(bookmarks, bookmarkIndex);
}
void BookmarkManager::jump_to_bookmark(uint32_t bookmarkIndex) {
auto& b = bookmarks->at(bookmarkIndex);
world.drawData.cam.smooth_move_to(world, b->obj->coords, b->obj->windowSize.cast<float>());
}
void BookmarkManager::scale_up(const WorldScalar& scaleUpAmount) {
for(uint32_t i = 0; i < bookmarks->size(); i++)
bookmarks->at(i)->obj->scale_up(scaleUpAmount);
}

47
src/BookmarkManager.hpp
View file

@ -1,47 +0,0 @@
#pragma once
#include <Helpers/Serializers.hpp>
#include <cereal/types/string.hpp>
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include "SharedTypes.hpp"
#include "CoordSpaceHelper.hpp"
struct Bookmark {
std::string name;
CoordSpaceHelper coords;
Vector<int32_t, 2> windowSize;
template <class Archive> void serialize(Archive& a) {
a(name, coords, windowSize);
}
void scale_up(const WorldScalar& scaleUpAmount);
};
class World;
class BookmarkManager {
public:
BookmarkManager(World& w);
void init();
void add_bookmark(const std::string& name);
void remove_bookmark(uint32_t bookmarkIndex);
void jump_to_bookmark(uint32_t bookmarkIndex);
void scale_up(const WorldScalar& scaleUpAmount);
template <typename Archive> void save(Archive& a) const {
a(bookmarks->size());
for(uint32_t i = 0; i < bookmarks->size(); i++)
a(*bookmarks->at(i));
}
template <typename Archive> void load(Archive& a) {
uint32_t newSize = bookmarks->size();
for(uint32_t i = 0; i < newSize; i++) {
Bookmark b;
a(b);
bookmarks->emplace_back_direct(bookmarks, b);
}
}
NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<Bookmark>> bookmarks;
private:
World& world;
};

31
src/Bookmarks/BookmarkListItem.cpp
View file

@ -1,20 +1,27 @@
#include "BookmarkListItem.hpp"
#include <cereal/types/string.hpp>
#include "../World.hpp"
using namespace NetworkingObjects;
void BookmarkData::jump_to(World& world) {
world.drawData.cam.smooth_move_to(world, coords, windowSize.cast<float>());
}
BookmarkListItem::BookmarkListItem() {}
BookmarkListItem::BookmarkListItem(NetworkingObjects::NetObjManager& netObjMan, const std::string& initName, bool isFolder, const BookmarkData& initBookmarkData) {
name = initName;
if(isFolder)
folderList = netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>();
if(isFolder) {
folderData = std::make_unique<BookmarkFolderData>();
folderData->folderList = netObjMan.make_obj<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>();
}
else
bookmarkData = std::make_unique<BookmarkData>(initBookmarkData);
}
bool BookmarkListItem::is_folder() const {
return folderList;
return folderData != nullptr;
}
const BookmarkData& BookmarkListItem::get_bookmark_data() const {
@ -22,13 +29,21 @@ const BookmarkData& BookmarkListItem::get_bookmark_data() const {
}
const NetObjOwnerPtr<NetObjOrderedList<BookmarkListItem>>& BookmarkListItem::get_folder_list() const {
return folderList;
return folderData->folderList;
}
const std::string& BookmarkListItem::get_name() const {
return name;
}
bool BookmarkListItem::is_folder_open() const {
return folderData->isFolderOpen;
}
void BookmarkListItem::set_folder_open(bool newIsFolderOpen) {
folderData->isFolderOpen = newIsFolderOpen;
}
void BookmarkListItem::set_name(const NetworkingObjects::NetObjTemporaryPtr<BookmarkListItem>& o, const std::string& newName) {
o->name = newName;
o.send_update_to_all(RELIABLE_COMMAND_CHANNEL, [](const NetObjTemporaryPtr<BookmarkListItem>& o, cereal::PortableBinaryOutputArchive& a) {
@ -57,7 +72,7 @@ void BookmarkListItem::register_class(NetObjManager& netObjMan) {
void BookmarkListItem::write_constructor_data(const NetObjTemporaryPtr<BookmarkListItem>& o, cereal::PortableBinaryOutputArchive& a) {
a(o->name, o->is_folder());
if(o->is_folder())
o->folderList.write_create_message(a);
o->folderData->folderList.write_create_message(a);
else
a(*o->bookmarkData);
}
@ -66,8 +81,10 @@ void BookmarkListItem::read_constructor_data(const NetworkingObjects::NetObjTemp
a(o->name);
bool isFolder;
a(isFolder);
if(isFolder)
o->folderList = o.get_obj_man()->read_create_message<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>(a, c);
if(isFolder) {
o->folderData = std::make_unique<BookmarkFolderData>();
o->folderData->folderList = o.get_obj_man()->read_create_message<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>(a, c);
}
else {
o->bookmarkData = std::make_unique<BookmarkData>();
a(*o->bookmarkData);

9
src/Bookmarks/BookmarkListItem.hpp
View file

@ -10,6 +10,7 @@ struct BookmarkData {
template <class Archive> void serialize(Archive& a) {
a(coords, windowSize);
}
void jump_to(World& world);
};
class BookmarkListItem {
@ -19,13 +20,19 @@ class BookmarkListItem {
bool is_folder() const;
const BookmarkData& get_bookmark_data() const;
const NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& get_folder_list() const;
bool is_folder_open() const;
void set_folder_open(bool newIsFolderOpen);
const std::string& get_name() const;
static void register_class(NetworkingObjects::NetObjManager& netObjMan);
static void set_name(const NetworkingObjects::NetObjTemporaryPtr<BookmarkListItem>& o, const std::string& newName); // Set once after editing is finished
private:
struct BookmarkFolderData {
NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>> folderList;
bool isFolderOpen = false;
};
static void write_constructor_data(const NetworkingObjects::NetObjTemporaryPtr<BookmarkListItem>& o, cereal::PortableBinaryOutputArchive& a);
static void read_constructor_data(const NetworkingObjects::NetObjTemporaryPtr<BookmarkListItem>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c);
NetworkingObjects::NetObjOwnerPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>> folderList;
std::unique_ptr<BookmarkFolderData> folderData;
std::unique_ptr<BookmarkData> bookmarkData;
std::string name;
};

55
src/Bookmarks/BookmarkManager.cpp Normal file
View file

@ -0,0 +1,55 @@
#include "BookmarkManager.hpp"
#include "../World.hpp"
#include "../MainProgram.hpp"
BookmarkManager::BookmarkManager(World& w):
world(w)
{}
void BookmarkManager::init() {
// NOTE: Should find a way for bookmarks added from the network to take into account the client's canvasScale
// Have the canvasScale variable come with the ClientData object, and the grid scale commands can be part of
// the client data class
if(world.netObjMan.is_server()) {
bookmarkListRoot = world.netObjMan.make_obj_from_ptr<BookmarkListItem>(new BookmarkListItem(world.netObjMan, "ROOT", true, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 1", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 2", false, {}));
auto folder1Ptr = bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Folder 1", true, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark A", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark B", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark C", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark D", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark E", false, {}));
auto folderAPtr = folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Folder A", true, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 1", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 2", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 3", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 4", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 5", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 6", false, {}));
folderAPtr->obj->get_folder_list()->push_back_and_send_create(folderAPtr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 7", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark F", false, {}));
folder1Ptr->obj->get_folder_list()->push_back_and_send_create(folder1Ptr->obj->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark G", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 3", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 4", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 5", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 6", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 7", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 8", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 9", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 10", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 11", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 12", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 13", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 14", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 15", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 16", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 17", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 18", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 19", false, {}));
bookmarkListRoot->get_folder_list()->push_back_and_send_create(bookmarkListRoot->get_folder_list(), new BookmarkListItem(world.netObjMan, "Bookmark 20", false, {}));
}
}
void BookmarkManager::scale_up(const WorldScalar& scaleUpAmount) {
}

24
src/Bookmarks/BookmarkManager.hpp Normal file
View file

@ -0,0 +1,24 @@
#pragma once
#include <Helpers/Serializers.hpp>
#include <cereal/types/string.hpp>
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include "BookmarkListItem.hpp"
class World;
class BookmarkManager {
public:
BookmarkManager(World& w);
void init();
void scale_up(const WorldScalar& scaleUpAmount);
template <typename Archive> void save(Archive& a) const {
}
template <typename Archive> void load(Archive& a) {
}
NetworkingObjects::NetObjOwnerPtr<BookmarkListItem> bookmarkListRoot;
private:
World& world;
};

1
src/GUIStuff/Elements/CheckBox.cpp
View file

@ -1,7 +1,6 @@
#include "CheckBox.hpp"
#include <include/core/SkPath.h>
#include <include/core/SkPathBuilder.h>
#include <iostream>
namespace GUIStuff {

102
src/GUIStuff/Elements/TreeListing.cpp Normal file
View file

@ -0,0 +1,102 @@
#include "TreeListing.hpp"
#include "../GUIManager.hpp"
#include "Helpers/ConvertVec.hpp"
constexpr float ENTRY_HEIGHT = 25.0f;
namespace GUIStuff {
void TreeListing::update(UpdateInputData& io, GUIManager& gui, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList) {
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_GROW(0)}
}
}) {
gui.scroll_bar_area("scroll area", true, [&](float scrollContentHeight, float containerHeight, float& scrollAmount) {
size_t itemCount = 0;
size_t itemCountToStartAt = -scrollAmount / ENTRY_HEIGHT;
size_t itemCountToEndAt = (containerHeight - scrollAmount) / ENTRY_HEIGHT;
itemCountToEndAt++;
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(ENTRY_HEIGHT * itemCountToStartAt)}
}
}) {}
recursive_gui(io, gui, bookmarkList, itemCount, itemCountToStartAt, itemCountToEndAt, 0);
if(itemCount > itemCountToEndAt) {
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(ENTRY_HEIGHT * (itemCount - itemCountToEndAt))}
}
}) {}
}
});
}
}
void TreeListing::recursive_gui(UpdateInputData& io, GUIManager& gui, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList, size_t& itemCount, size_t itemCountToStartAt, size_t itemCountToEndAt, size_t listDepth) {
std::optional<NetworkingObjects::NetObjID> toDelete;
for(auto& bookmarkItem : bookmarkList->get_data()) {
if(itemCount >= itemCountToStartAt && itemCount < itemCountToEndAt) {
gui.push_id(itemCount);
bool buttonClicked = false;
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(ENTRY_HEIGHT)},
.childAlignment = {.x = CLAY_ALIGN_X_LEFT, .y = CLAY_ALIGN_Y_CENTER}
},
.backgroundColor = convert_vec4<Clay_Color>((objSelected.has_value() && objSelected.value() == bookmarkItem->obj.get_net_id()) ? io.theme->backColor1 : io.theme->backColor2),
}) {
if(listDepth != 0) {
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_FIXED(ENTRY_HEIGHT * listDepth), .height = CLAY_SIZING_FIXED(ENTRY_HEIGHT)}
},
}) {}
}
if(bookmarkItem->obj->is_folder()) {
if(gui.svg_icon_button_transparent("ico", bookmarkItem->obj->is_folder_open() ? "data/icons/droparrow.svg" : "data/icons/droparrowclose.svg", false, ENTRY_HEIGHT)) {
bookmarkItem->obj->set_folder_open(!bookmarkItem->obj->is_folder_open());
buttonClicked = true;
}
}
else {
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_FIXED(ENTRY_HEIGHT), .height = CLAY_SIZING_FIXED(ENTRY_HEIGHT)},
.padding = CLAY_PADDING_ALL(2)
}
}) {
gui.svg_icon("ico", "data/icons/bookmark.svg");
}
}
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_GROW(0)},
.childAlignment = {.x = CLAY_ALIGN_X_LEFT, .y = CLAY_ALIGN_Y_CENTER}
}
}) {
gui.text_label(bookmarkItem->obj->get_name());
}
if(gui.svg_icon_button_transparent("delete", "data/icons/trash.svg", false, ENTRY_HEIGHT)) {
toDelete = bookmarkItem->obj.get_net_id();
buttonClicked = true;
}
if(Clay_Hovered() && io.mouse.leftClick && !buttonClicked)
objSelected = bookmarkItem->obj.get_net_id();
}
gui.pop_id();
}
itemCount++;
if(bookmarkItem->obj->is_folder() && bookmarkItem->obj->is_folder_open())
recursive_gui(io, gui, bookmarkItem->obj->get_folder_list(), itemCount, itemCountToStartAt, itemCountToEndAt, listDepth + 1);
}
if(toDelete.has_value())
bookmarkList->erase(bookmarkList, toDelete.value());
}
void TreeListing::clay_draw(SkCanvas* canvas, UpdateInputData& io, Clay_RenderCommand* command) {
}
}

19
src/GUIStuff/Elements/TreeListing.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include "Element.hpp"
#include "../../Bookmarks/BookmarkListItem.hpp"
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
namespace GUIStuff {
class GUIManager;
class TreeListing : public Element {
public:
void update(UpdateInputData& io, GUIManager& gui, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList);
virtual void clay_draw(SkCanvas* canvas, UpdateInputData& io, Clay_RenderCommand* command) override;
private:
void recursive_gui(UpdateInputData& io, GUIManager& gui, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList, size_t& itemCount, size_t itemCountToStartAt, size_t itemCountToEndAt, size_t listDepth);
std::optional<NetworkingObjects::NetObjID> objSelected;
};
}

6
src/GUIStuff/GUIManager.cpp
View file

@ -897,6 +897,12 @@ void GUIManager::list_popup_menu(const std::string& id, Vector2f popupPos, const
}
}
void GUIManager::tree_listing(const std::string& id, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList) {
push_id(id);
insert_element<TreeListing>()->update(*io, *this, bookmarkList);
pop_id();
}
void GUIManager::obstructing_window() {
if(Clay_Hovered())
io->hoverObstructed = true;

3
src/GUIStuff/GUIManager.hpp
View file

@ -9,6 +9,7 @@
#include "Elements/ColorPicker.hpp"
#include "Elements/SelectableButton.hpp"
#include "Elements/TextBox.hpp"
#include "Elements/TreeListing.hpp"
#include <any>
#include "GUIManagerID.hpp"
#include <filesystem>
@ -101,6 +102,8 @@ class GUIManager {
void paint_circle_popup_menu(const std::string& id, const Vector2f& centerPos, const PaintCircleMenu::Data& val, const std::function<void()>& elemUpdate = nullptr);
void list_popup_menu(const std::string& id, Vector2f popupPos, const std::function<void()>& elemUpdate);
void tree_listing(const std::string& id, const NetworkingObjects::NetObjTemporaryPtr<NetworkingObjects::NetObjOrderedList<BookmarkListItem>>& bookmarkList);
void obstructing_window();
template <typename NewElement> NewElement* insert_element() {

59
src/Toolbar.cpp
View file

@ -800,65 +800,10 @@ void Toolbar::bookmark_menu(bool justOpened) {
.floating = {.offset = {.x = 0, .y = static_cast<float>(io->theme->padding1)}, .attachPoints = {.element = CLAY_ATTACH_POINT_RIGHT_TOP, .parent = CLAY_ATTACH_POINT_RIGHT_BOTTOM}, .attachTo = CLAY_ATTACH_TO_PARENT}
}) {
gui.obstructing_window();
float entryHeight = 25.0f;
gui.text_label_centered("Bookmarks");
if(main.world->bMan.bookmarks->empty())
gui.text_label_centered("No bookmarks yet...");
uint32_t toDelete = std::numeric_limits<uint32_t>::max();
gui.scroll_bar_many_entries_area("bookmark menu entries", entryHeight, main.world->bMan.bookmarks->size(), true, [&](size_t i, bool isListHovered) {
const Bookmark& bookmark = *main.world->bMan.bookmarks->at(i)->obj;
bool selectedEntry = i == bookMenu.selectedBookmark;
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_FIXED(entryHeight)},
.childGap = 2,
.childAlignment = { .x = CLAY_ALIGN_X_LEFT, .y = CLAY_ALIGN_Y_CENTER},
.layoutDirection = CLAY_LEFT_TO_RIGHT
},
.backgroundColor = selectedEntry ? convert_vec4<Clay_Color>(io->theme->backColor1) : convert_vec4<Clay_Color>(io->theme->backColor2)
}) {
gui.text_label(bookmark.name);
bool miniButtonClicked = false;
CLAY_AUTO_ID({
.layout = {
.sizing = {.width = CLAY_SIZING_GROW(0), .height = CLAY_SIZING_GROW(0)},
.childGap = 1,
.childAlignment = {.x = CLAY_ALIGN_X_RIGHT, .y = CLAY_ALIGN_Y_CENTER},
.layoutDirection = CLAY_LEFT_TO_RIGHT
}
}) {
if(gui.svg_icon_button_transparent("bookmark jump button", "data/icons/jump.svg", false, entryHeight, false)) {
miniButtonClicked = true;
main.world->bMan.jump_to_bookmark(i);
}
if(gui.svg_icon_button_transparent("delete trash", "data/icons/trash.svg", false, entryHeight, false)) {
miniButtonClicked = true;
toDelete = i;
}
}
if(Clay_Hovered() && io->mouse.leftClick && isListHovered && !miniButtonClicked) {
bookMenu.newName = bookmark.name;
bookMenu.selectedBookmark = i;
if(io->mouse.leftClick >= 2)
main.world->bMan.jump_to_bookmark(i);
}
}
});
if(toDelete != std::numeric_limits<uint32_t>::max())
main.world->bMan.remove_bookmark(toDelete);
gui.left_to_right_line_layout([&]() {
bool addByEnter = false;
gui.input_text("bookmark text input", &bookMenu.newName, true, [&](GUIStuff::SelectionHelper& s) {
addByEnter = s.selected && io->key.enter;
});
if((gui.svg_icon_button("bookmark add button", "data/icons/plus.svg", false, GUIStuff::GUIManager::SMALL_BUTTON_SIZE) || addByEnter) && !bookMenu.newName.empty())
main.world->bMan.add_bookmark(bookMenu.newName);
});
if(io->mouse.leftClick && !Clay_Hovered() && !justOpened) {
bookMenu.newName.clear();
gui.tree_listing("bookmark listing", main.world->bMan.bookmarkListRoot->get_folder_list());
if(io->mouse.leftClick && !Clay_Hovered() && !justOpened)
bookMenu.popupOpen = false;
bookMenu.selectedBookmark = std::numeric_limits<uint32_t>::max();
}
}
gui.pop_id();
}

2
src/Toolbar.hpp
View file

@ -190,8 +190,6 @@ class Toolbar {
struct BookmarkMenu {
bool popupOpen = false;
std::string newName;
uint32_t selectedBookmark = std::numeric_limits<uint32_t>::max();
} bookMenu;
struct GridMenu {

8
src/World.cpp
View file

@ -110,8 +110,8 @@ void World::init_client_data_list_callbacks() {
}
void World::init_net_obj_type_list() {
NetworkingObjects::register_generic_serialized_class<Bookmark>(netObjMan);
NetworkingObjects::register_ordered_list_class<Bookmark>(netObjMan);
BookmarkListItem::register_class(netObjMan);
NetworkingObjects::register_ordered_list_class<BookmarkListItem>(netObjMan);
delayedUpdateObjectManager.register_class<WorldGrid>(netObjMan);
NetworkingObjects::register_ordered_list_class<WorldGrid>(netObjMan);
CanvasComponentAllocator::register_class(*this, netObjMan);
@ -139,7 +139,7 @@ void World::init_server_callbacks() {
{
cereal::PortableBinaryOutputArchive a(*ss);
a(CLIENT_INITIAL_DATA, name, clientDataObjPtr.get_net_id());
bMan.bookmarks.write_create_message(a);
//bMan.bookmarks.write_create_message(a);
gridMan.grids.write_create_message(a);
drawProg.write_components_server(a);
canvasTheme.write_create_message(a);
@ -170,7 +170,7 @@ void World::init_client_callbacks() {
NetworkingObjects::NetObjID clientDataObjID;
message(fileDisplayName, clientDataObjID);
set_name(fileDisplayName);
bMan.bookmarks = netObjMan.read_create_message<NetworkingObjects::NetObjOrderedList<Bookmark>>(message, nullptr);
//bMan.bookmarks = netObjMan.read_create_message<NetworkingObjects::NetObjOrderedList<Bookmark>>(message, nullptr);
gridMan.grids = netObjMan.read_create_message<NetworkingObjects::NetObjOrderedList<WorldGrid>>(message, nullptr);
drawProg.read_components_client(message);
canvasTheme.read_create_message(message);

2
src/World.hpp
View file

@ -3,7 +3,7 @@
#include <Helpers/NetworkingObjects/NetObjOrderedList.hpp>
#include "Helpers/NetworkingObjects/NetObjUnorderedSet.hpp"
#include "UndoManager.hpp"
#include "BookmarkManager.hpp"
#include "Bookmarks/BookmarkManager.hpp"
#include "ResourceManager.hpp"
#include "ConnectionManager.hpp"
#include "DrawingProgram/DrawingProgram.hpp"