add os inspector and minor stuff

external/toxcore/CMakeLists.txt

@@ -1,21 +1,27 @@
-cmake_minimum_required(VERSION 3.9...3.16 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.13...3.16 FATAL_ERROR)
 
 set(EXPERIMENTAL_API ON CACHE BOOL "" FORCE)
 set(UNITTEST OFF CACHE BOOL "" FORCE)
 set(BOOTSTRAP_DAEMON OFF CACHE BOOL "" FORCE)
+#set(BUILD_TOXAV ON CACHE BOOL "")
 
 add_subdirectory(./c-toxcore)
 
-# the ideal case
+#message("II BUILD_TOXAV: ${BUILD_TOXAV}")
-#add_library(toxcore ALIAS toxcore_static)
 
 # the sad case
 add_library(toxcore INTERFACE)
 
 if (TARGET toxcore_static)
 	target_link_libraries(toxcore INTERFACE toxcore_static)
+
+	# the ideal case
+	#add_library(toxcore ALIAS toxcore_static)
 else()
 	target_link_libraries(toxcore INTERFACE toxcore_shared)
+
+	# the ideal case
+	#add_library(toxcore ALIAS toxcore_shared)
 endif()
 
 # HACK: "install" api headers into binary dir
@@ -64,3 +70,8 @@ elseif(sodium_FOUND)
 else()
 	message(SEND_ERROR "missing libsodium")
 endif()
+
+#if(BUILD_TOXAV)
+#    set_target_properties(toxcore PROPERTIES TOX_HAS_TOXAV ON)
+#endif()
+

src/CMakeLists.txt

@@ -86,6 +86,10 @@ target_sources(tomato PUBLIC
 	./chat_gui/settings_window.hpp
 	./chat_gui/settings_window.cpp
 
+	./imgui_entt_entity_editor.hpp
+	./object_store_ui.hpp
+	./object_store_ui.cpp
+
 	./tox_ui_utils.hpp
 	./tox_ui_utils.cpp
 

src/image_loader.hpp

@@ -27,6 +27,8 @@ struct ImageLoaderI {
 
 		// only positive values are valid
 		ImageResult crop(int32_t c_x, int32_t c_y, int32_t c_w, int32_t c_h) const;
+
+		// TODO: scale
 	};
 	virtual ImageResult loadFromMemoryRGBA(const uint8_t* data, uint64_t data_size) = 0;
 };

src/imgui_entt_entity_editor.hpp

@@ -0,0 +1,319 @@
+// for the license, see the end of the file
+#pragma once
+
+#include "entt/entity/fwd.hpp"
+#include <map>
+#include <set>
+#include <functional>
+#include <string>
+
+#include <entt/entt.hpp>
+#include <imgui.h>
+
+#ifndef MM_IEEE_ASSERT
+	#define MM_IEEE_ASSERT(x) assert(x)
+#endif
+
+#define MM_IEEE_IMGUI_PAYLOAD_TYPE_ENTITY "MM_IEEE_ENTITY"
+
+#ifndef MM_IEEE_ENTITY_WIDGET
+	#define MM_IEEE_ENTITY_WIDGET ::MM::EntityWidget
+#endif
+
+namespace MM {
+
+template <class EntityType>
+inline void EntityWidget(EntityType& e, entt::basic_registry<EntityType>& reg, bool dropTarget = false)
+{
+	ImGui::PushID(static_cast<int>(entt::to_integral(e)));
+
+	if (reg.valid(e)) {
+		ImGui::Text("ID: %d", entt::to_integral(e));
+	} else {
+		ImGui::Text("Invalid Entity");
+	}
+
+	if (reg.valid(e)) {
+		if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceAllowNullID)) {
+			ImGui::SetDragDropPayload(MM_IEEE_IMGUI_PAYLOAD_TYPE_ENTITY, &e, sizeof(e));
+			ImGui::Text("ID: %d", entt::to_integral(e));
+			ImGui::EndDragDropSource();
+		}
+	}
+
+	if (dropTarget && ImGui::BeginDragDropTarget()) {
+		if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(MM_IEEE_IMGUI_PAYLOAD_TYPE_ENTITY)) {
+			e = *(EntityType*)payload->Data;
+		}
+
+		ImGui::EndDragDropTarget();
+	}
+
+	ImGui::PopID();
+}
+
+template <class Component, class EntityType>
+void ComponentEditorWidget([[maybe_unused]] entt::basic_registry<EntityType>& registry, [[maybe_unused]] EntityType entity) {}
+
+template <class Component, class EntityType>
+void ComponentAddAction(entt::basic_registry<EntityType>& registry, EntityType entity)
+{
+	registry.template emplace<Component>(entity);
+}
+
+template <class Component, class EntityType>
+void ComponentRemoveAction(entt::basic_registry<EntityType>& registry, EntityType entity)
+{
+	registry.template remove<Component>(entity);
+}
+
+template <class EntityType>
+class EntityEditor {
+public:
+	using Registry = entt::basic_registry<EntityType>;
+	using ComponentTypeID = entt::id_type;
+
+	struct ComponentInfo {
+		using Callback = std::function<void(Registry&, EntityType)>;
+		std::string name;
+		Callback widget, create, destroy;
+	};
+
+	bool show_window = true;
+
+private:
+	std::map<ComponentTypeID, ComponentInfo> component_infos;
+
+	bool entityHasComponent(Registry& registry, EntityType& entity, ComponentTypeID type_id)
+	{
+		const auto* storage_ptr = registry.storage(type_id);
+		return storage_ptr != nullptr && storage_ptr->contains(entity);
+	}
+
+public:
+	template <class Component>
+	ComponentInfo& registerComponent(const ComponentInfo& component_info)
+	{
+		auto index = entt::type_hash<Component>::value();
+		auto insert_info = component_infos.insert_or_assign(index, component_info);
+		MM_IEEE_ASSERT(insert_info.second);
+		return std::get<ComponentInfo>(*insert_info.first);
+	}
+
+	template <class Component>
+	ComponentInfo& registerComponent(const std::string& name, typename ComponentInfo::Callback widget)
+	{
+		return registerComponent<Component>(ComponentInfo{
+			name,
+			widget,
+			ComponentAddAction<Component, EntityType>,
+			ComponentRemoveAction<Component, EntityType>,
+		});
+	}
+
+	template <class Component>
+	ComponentInfo& registerComponent(const std::string& name)
+	{
+		return registerComponent<Component>(name, ComponentEditorWidget<Component, EntityType>);
+	}
+
+	void renderEditor(Registry& registry, EntityType& e)
+	{
+		ImGui::TextUnformatted("Editing:");
+		ImGui::SameLine();
+
+		MM_IEEE_ENTITY_WIDGET(e, registry, true);
+
+		if (ImGui::Button("New")) {
+			e = registry.create();
+		}
+		if (registry.valid(e)) {
+			ImGui::SameLine();
+
+			if (ImGui::Button("Clone")) {
+				auto old_e = e;
+				e = registry.create();
+
+				// create a copy of an entity component by component
+				for (auto &&curr: registry.storage()) {
+					if (auto &storage = curr.second; storage.contains(old_e)) {
+						// TODO: do something with the return value. returns false on failure.
+						storage.push(e, storage.value(old_e));
+					}
+				}
+			}
+			ImGui::SameLine();
+
+			ImGui::Dummy({10, 0}); // space destroy a bit, to not accidentally click it
+			ImGui::SameLine();
+
+			// red button
+			ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.65f, 0.15f, 0.15f, 1.f));
+			ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.8f, 0.3f, 0.3f, 1.f));
+			ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.f, 0.2f, 0.2f, 1.f));
+			if (ImGui::Button("Destroy")) {
+				registry.destroy(e);
+				e = entt::null;
+			}
+			ImGui::PopStyleColor(3);
+		}
+
+		ImGui::Separator();
+
+		if (registry.valid(e)) {
+			ImGui::PushID(static_cast<int>(entt::to_integral(e)));
+			std::map<ComponentTypeID, ComponentInfo> has_not;
+			for (auto& [component_type_id, ci] : component_infos) {
+				if (entityHasComponent(registry, e, component_type_id)) {
+					ImGui::PushID(component_type_id);
+					if (ImGui::Button("-")) {
+						ci.destroy(registry, e);
+						ImGui::PopID();
+						continue; // early out to prevent access to deleted data
+					} else {
+						ImGui::SameLine();
+					}
+
+					if (ImGui::CollapsingHeader(ci.name.c_str())) {
+						ImGui::Indent(30.f);
+						ImGui::PushID("Widget");
+						ci.widget(registry, e);
+						ImGui::PopID();
+						ImGui::Unindent(30.f);
+					}
+					ImGui::PopID();
+				} else {
+					has_not[component_type_id] = ci;
+				}
+			}
+
+			if (!has_not.empty()) {
+				if (ImGui::Button("+ Add Component")) {
+					ImGui::OpenPopup("Add Component");
+				}
+
+				if (ImGui::BeginPopup("Add Component")) {
+					ImGui::TextUnformatted("Available:");
+					ImGui::Separator();
+
+					for (auto& [component_type_id, ci] : has_not) {
+						ImGui::PushID(component_type_id);
+						if (ImGui::Selectable(ci.name.c_str())) {
+							ci.create(registry, e);
+						}
+						ImGui::PopID();
+					}
+					ImGui::EndPopup();
+				}
+			}
+			ImGui::PopID();
+		}
+	}
+
+	void renderEntityList(Registry& registry, std::set<ComponentTypeID>& comp_list)
+	{
+		ImGui::Text("Components Filter:");
+		ImGui::SameLine();
+		if (ImGui::SmallButton("clear")) {
+			comp_list.clear();
+		}
+
+		ImGui::Indent();
+
+		for (const auto& [component_type_id, ci] : component_infos) {
+			bool is_in_list = comp_list.count(component_type_id);
+			bool active = is_in_list;
+
+			ImGui::Checkbox(ci.name.c_str(), &active);
+
+			if (is_in_list && !active) { // remove
+				comp_list.erase(component_type_id);
+			} else if (!is_in_list && active) { // add
+				comp_list.emplace(component_type_id);
+			}
+		}
+
+		ImGui::Unindent();
+		ImGui::Separator();
+
+		if (comp_list.empty()) {
+			ImGui::Text("Orphans:");
+			for (EntityType e : registry.template storage<EntityType>()) {
+				if (registry.orphan(e)) {
+					MM_IEEE_ENTITY_WIDGET(e, registry, false);
+				}
+			}
+		} else {
+			entt::basic_runtime_view<entt::basic_sparse_set<EntityType>> view{};
+			for (const auto type : comp_list) {
+				auto* storage_ptr = registry.storage(type);
+				if (storage_ptr != nullptr) {
+					view.iterate(*storage_ptr);
+				}
+			}
+
+			// TODO: add support for exclude
+
+			ImGui::Text("%lu Entities Matching:", view.size_hint());
+
+			if (ImGui::BeginChild("entity list")) {
+				for (auto e : view) {
+					MM_IEEE_ENTITY_WIDGET(e, registry, false);
+				}
+			}
+			ImGui::EndChild();
+		}
+	}
+
+	// displays both, editor and list
+	// uses static internally, use only as a quick way to get going!
+	void renderSimpleCombo(Registry& registry, EntityType& e)
+	{
+		if (show_window) {
+			ImGui::SetNextWindowSize(ImVec2(550, 400), ImGuiCond_FirstUseEver);
+			if (ImGui::Begin("Entity Editor", &show_window)) {
+				if (ImGui::BeginChild("list", {200, 0}, true)) {
+					static std::set<ComponentTypeID> comp_list;
+					renderEntityList(registry, comp_list);
+				}
+				ImGui::EndChild();
+
+				ImGui::SameLine();
+
+				if (ImGui::BeginChild("editor")) {
+					renderEditor(registry, e);
+				}
+				ImGui::EndChild();
+
+			}
+			ImGui::End();
+		}
+	}
+
+};
+
+} // MM
+
+// MIT License
+
+// Copyright (c) 2019-2022 Erik Scholz
+// Copyright (c) 2020 Gnik Droy
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+

src/main_screen.cpp

@@ -35,6 +35,7 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	msg_tc(mil, sdlrtu),
 	cg(conf, rmm, cr, sdlrtu, contact_tc, msg_tc, theme),
 	sw(conf),
+	osui(os),
 	tuiu(tc, conf),
 	tdch(tpi)
 {
@@ -248,6 +249,7 @@ Screen* MainScreen::render(float time_delta, bool&) {
 
 	const float cg_interval = cg.render(time_delta); // render
 	sw.render(); // render
+	osui.render();
 	tuiu.render(); // render
 	tdch.render(); // render
 

src/main_screen.hpp

@@ -29,6 +29,7 @@
 
 #include "./chat_gui4.hpp"
 #include "./chat_gui/settings_window.hpp"
+#include "./object_store_ui.hpp"
 #include "./tox_ui_utils.hpp"
 #include "./tox_dht_cap_histo.hpp"
 #include "./tox_friend_faux_offline_messaging.hpp"
@@ -77,6 +78,7 @@ struct MainScreen final : public Screen {
 
 	ChatGui4 cg;
 	SettingsWindow sw;
+	ObjectStoreUI osui;
 	ToxUIUtils tuiu;
 	ToxDHTCapHisto tdch;
 

src/object_store_ui.cpp

@@ -0,0 +1,104 @@
+#include "./object_store_ui.hpp"
+
+#include <solanaceae/util/utils.hpp>
+#include <solanaceae/object_store/meta_components.hpp>
+
+#include <imgui/imgui.h>
+
+#include <solanaceae/message3/components.hpp>
+
+namespace MM {
+
+template<> void ComponentEditorWidget<ObjectStore::Components::ID>(entt::basic_registry<Object>& registry, Object entity) {
+	auto& c = registry.get<ObjectStore::Components::ID>(entity);
+
+	const auto str = bin2hex(c.v);
+	ImGui::TextUnformatted(str.c_str());
+}
+
+template<> void ComponentEditorWidget<Message::Components::Transfer::FileInfo>(entt::basic_registry<Object>& registry, Object entity) {
+	auto& c = registry.get<Message::Components::Transfer::FileInfo>(entity);
+
+	ImGui::Text("Total size: %lu", c.total_size);
+	if (ImGui::BeginTable("file list", 2, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingFixedFit)) {
+		ImGui::TableSetupColumn("name", ImGuiTableColumnFlags_WidthStretch);
+		ImGui::TableSetupColumn("size", ImGuiTableColumnFlags_WidthFixed);
+		ImGui::TableHeadersRow();
+
+		for (const auto& entry : c.file_list) {
+			ImGui::TableNextColumn();
+			ImGui::TextUnformatted(entry.file_name.c_str());
+
+			ImGui::TableNextColumn();
+			ImGui::Text("%lu", entry.file_size);
+		}
+
+		ImGui::EndTable();
+	}
+}
+
+template<> void ComponentEditorWidget<Message::Components::Transfer::FileInfoLocal>(entt::basic_registry<Object>& registry, Object entity) {
+	auto& c = registry.get<Message::Components::Transfer::FileInfoLocal>(entity);
+
+	if (ImGui::BeginTable("file list", 1, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingFixedFit)) {
+		ImGui::TableSetupColumn("name", ImGuiTableColumnFlags_WidthStretch);
+		//ImGui::TableSetupColumn("size", ImGuiTableColumnFlags_WidthFixed);
+		ImGui::TableHeadersRow();
+
+		for (const auto& entry : c.file_list) {
+			ImGui::TableNextColumn();
+			ImGui::TextUnformatted(entry.c_str());
+		}
+
+		ImGui::EndTable();
+	}
+}
+
+template<> void ComponentEditorWidget<Message::Components::Transfer::BytesReceived>(entt::basic_registry<Object>& registry, Object entity) {
+	auto& c = registry.get<Message::Components::Transfer::BytesReceived>(entity);
+	ImGui::Text("total bytes received: %lu", c.total);
+}
+
+template<> void ComponentEditorWidget<Message::Components::Transfer::BytesSent>(entt::basic_registry<Object>& registry, Object entity) {
+	auto& c = registry.get<Message::Components::Transfer::BytesSent>(entity);
+	ImGui::Text("total bytes sent: %lu", c.total);
+}
+
+} // MM
+
+ObjectStoreUI::ObjectStoreUI(
+	ObjectStore2& os
+) : _os(os) {
+	_ee.show_window = false;
+
+	_ee.registerComponent<ObjectStore::Components::ID>("ID");
+	_ee.registerComponent<ObjectStore::Components::DataCompressionType>("DataCompressionType");
+
+	_ee.registerComponent<Message::Components::Transfer::FileInfo>("Transfer::FileInfo");
+	_ee.registerComponent<Message::Components::Transfer::FileInfoLocal>("Transfer::FileInfoLocal");
+	_ee.registerComponent<Message::Components::Transfer::BytesReceived>("Transfer::BytesReceived");
+	_ee.registerComponent<Message::Components::Transfer::BytesSent>("Transfer::BytesSent");
+}
+
+void ObjectStoreUI::render(void) {
+	{ // main window menubar injection
+		// assumes the window "tomato" was rendered already by cg
+		if (ImGui::Begin("tomato")) {
+			if (ImGui::BeginMenuBar()) {
+				ImGui::Separator();
+				if (ImGui::BeginMenu("ObjectStore")) {
+					if (ImGui::MenuItem("Inspector")) {
+						_ee.show_window = true;
+					}
+					ImGui::EndMenu();
+				}
+				ImGui::EndMenuBar();
+			}
+		}
+		ImGui::End();
+	}
+
+	static Object selected_ent {entt::null};
+	_ee.renderSimpleCombo(_os.registry(), selected_ent);
+}
+

src/object_store_ui.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <solanaceae/object_store/object_store.hpp>
+
+#include "./imgui_entt_entity_editor.hpp"
+
+class ObjectStoreUI {
+	ObjectStore2& _os;
+
+	MM::EntityEditor<Object> _ee;
+
+	public:
+		ObjectStoreUI(
+			ObjectStore2& os
+		);
+
+		void render(void);
+};
+