Improved custom event code and fixed some warnings

This commit is contained in:
Yousef Khadadeh 2026-04-11 16:36:24 +03:00
parent da1a1c26cb
commit b2fe1ab7ba
52 changed files with 193 additions and 240 deletions

View file

@ -5,64 +5,25 @@
namespace CustomEvents { namespace CustomEvents {
std::queue<std::any> eventDataQueue;
bool alreadyInitialized = false; bool alreadyInitialized = false;
void init() { void init() {
if(!alreadyInitialized) { if(!alreadyInitialized) {
PASTE_EVENT = SDL_RegisterEvents(1); PasteEvent::EVENT_NUM = SDL_RegisterEvents(1);
OPEN_INFINIPAINT_FILE_EVENT = SDL_RegisterEvents(1); OpenInfiniPaintFileEvent::EVENT_NUM = SDL_RegisterEvents(1);
AddFileToCanvasEvent::EVENT_NUM = SDL_RegisterEvents(1);
alreadyInitialized = true; alreadyInitialized = true;
} }
} }
void pop_event() {
// Paste event eventDataQueue.pop();
uint32_t PASTE_EVENT;
std::queue<PasteEventData> pasteEventData;
bool emit_paste_event(const PasteEventData& pasteData) {
SDL_Event event;
SDL_zero(event);
event.type = PASTE_EVENT;
if(SDL_PushEvent(&event)) {
pasteEventData.push(pasteData);
return true;
}
return false;
} }
const PasteEventData& get_paste_event_data() { uint32_t PasteEvent::EVENT_NUM;
return pasteEventData.front(); uint32_t OpenInfiniPaintFileEvent::EVENT_NUM;
} uint32_t AddFileToCanvasEvent::EVENT_NUM;
void pop_paste_event_data() {
pasteEventData.pop();
}
// Open InfiniPaint file event
uint32_t OPEN_INFINIPAINT_FILE_EVENT;
std::queue<OpenInfiniPaintFileEventData> openInfiniPaintFileEventData;
bool emit_open_infinipaint_file_event(const OpenInfiniPaintFileEventData& openData) {
SDL_Event event;
SDL_zero(event);
event.type = OPEN_INFINIPAINT_FILE_EVENT;
if(SDL_PushEvent(&event)) {
openInfiniPaintFileEventData.push(openData);
return true;
}
return false;
}
const OpenInfiniPaintFileEventData& get_open_infinipaint_file_event_data() {
return openInfiniPaintFileEventData.front();
}
void pop_open_infinipaint_file_event_data() {
openInfiniPaintFileEventData.pop();
}
} }

View file

@ -2,33 +2,46 @@
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#include <optional> #include <optional>
#include <queue>
#include <SDL3/SDL.h>
#include <SDL3/SDL_events.h>
#include "RichText/TextBox.hpp" #include "RichText/TextBox.hpp"
namespace CustomEvents { namespace CustomEvents {
void init(); void init();
// Paste event extern std::queue<std::any> eventDataQueue;
enum class PasteEventDataType {
TEXT, template <typename T> bool emit_event(const T& data) {
IMAGE SDL_Event event;
}; SDL_zero(event);
struct PasteEventData { event.type = T::EVENT_NUM;
PasteEventDataType type; if(SDL_PushEvent(&event)) {
eventDataQueue.push(data);
return true;
}
return false;
}
template <typename T> const T& get_event() {
return std::any_cast<const T&>(eventDataQueue.front());
}
void pop_event();
struct PasteEvent {
static uint32_t EVENT_NUM;
enum class DataType {
TEXT,
IMAGE
} type;
std::string data; std::string data;
std::optional<RichText::TextData> richText; std::optional<RichText::TextData> richText;
std::optional<Vector2f> mousePos; std::optional<Vector2f> mousePos;
}; };
bool emit_paste_event(const PasteEventData& pasteData); struct OpenInfiniPaintFileEvent {
const PasteEventData& get_paste_event_data(); static uint32_t EVENT_NUM;
void pop_paste_event_data();
extern uint32_t PASTE_EVENT;
// Open InfiniPaint file event
struct OpenInfiniPaintFileEventData {
bool isClient; bool isClient;
std::optional<std::filesystem::path> filePathSource; std::optional<std::filesystem::path> filePathSource;
std::string netSource; std::string netSource;
@ -36,9 +49,15 @@ namespace CustomEvents {
std::string_view fileDataBuffer; std::string_view fileDataBuffer;
}; };
bool emit_open_infinipaint_file_event(const OpenInfiniPaintFileEventData& openData); struct AddFileToCanvasEvent {
const OpenInfiniPaintFileEventData& get_open_infinipaint_file_event_data(); static uint32_t EVENT_NUM;
void pop_open_infinipaint_file_event_data(); enum class Type {
BUFFER,
extern uint32_t OPEN_INFINIPAINT_FILE_EVENT; PATH
} type;
std::string name;
std::string buffer;
std::filesystem::path filePath;
Vector2f pos;
};
} }

View file

@ -58,16 +58,19 @@ void DrawingProgram::on_tab_out() {
controls.middleClickHeld = false; controls.middleClickHeld = false;
} }
void DrawingProgram::input_paste_callback(const CustomEvents::PasteEventData& paste) { void DrawingProgram::input_paste_callback(const CustomEvents::PasteEvent& paste) {
drawTool->input_paste_callback(paste); if(paste.type == CustomEvents::PasteEvent::DataType::IMAGE)
selection.paste_image_process_event(paste);
else
drawTool->input_paste_callback(paste);
} }
void DrawingProgram::input_drop_file_callback(const InputManager::DropCallbackArgs& drop) { void DrawingProgram::input_drop_file_callback(const InputManager::DropCallbackArgs& drop) {
if(std::filesystem::is_regular_file(drop.data)) { if(std::filesystem::is_regular_file(drop.data)) {
#ifdef __EMSCRIPTEN_ #ifdef __EMSCRIPTEN_
add_file_to_canvas_by_path(drop.data, world.main.input.mouse.pos, true); add_file_to_canvas_by_path(drop.data, world.main.input.mouse.pos);
#else #else
add_file_to_canvas_by_path(drop.data, drop.pos, true); add_file_to_canvas_by_path(drop.data, drop.pos);
#endif #endif
} }
} }
@ -422,7 +425,10 @@ void DrawingProgram::popup_menu_action_button(const char* id, const char* text,
.drawType = GUIStuff::SelectableButton::DrawType::TRANSPARENT_ALL, .drawType = GUIStuff::SelectableButton::DrawType::TRANSPARENT_ALL,
.wide = true, .wide = true,
.centered = false, .centered = false,
.onClick = onClick .onClick = [&, onClick] {
onClick();
clear_right_click_popup();
}
}); });
} }
@ -442,7 +448,9 @@ void DrawingProgram::selection_action_menu(Vector2f popupPos) {
}); });
popup_menu_action_button("Paste Image", "Paste Image", [&, popupPos] { popup_menu_action_button("Paste Image", "Paste Image", [&, popupPos] {
selection.deselect_all(); selection.deselect_all();
selection.paste_image(popupPos * world.main.g.final_gui_scale()); world.main.input.call_paste(CustomEvents::PasteEvent::DataType::IMAGE, {
.pastePosition = popupPos * world.main.g.final_gui_scale()
});
}); });
if(selection.is_something_selected()) { if(selection.is_something_selected()) {
popup_menu_action_button("Copy", "Copy", [&] { popup_menu_action_button("Copy", "Copy", [&] {
@ -463,8 +471,8 @@ void DrawingProgram::selection_action_menu(Vector2f popupPos) {
}); });
} }
}, LayoutElement::Callbacks{ }, LayoutElement::Callbacks{
.mouseButton = [&](LayoutElement*, const InputManager::MouseButtonCallbackArgs& button) { .mouseButton = [&](LayoutElement* l, const InputManager::MouseButtonCallbackArgs& button) {
if(button.down && button.button != InputManager::MouseButton::RIGHT) if(button.down && button.button != InputManager::MouseButton::RIGHT && !l->mouseHovering)
clear_right_click_popup(); clear_right_click_popup();
} }
}); });
@ -510,11 +518,6 @@ void DrawingProgram::modify_grid(const NetworkingObjects::NetObjWeakPtr<WorldGri
} }
void DrawingProgram::update() { void DrawingProgram::update() {
if(addFileInNextFrame) {
add_file_to_canvas_by_path_execute(addFileInfo.first, addFileInfo.second);
addFileInNextFrame = false;
}
selection.update(); selection.update();
drawTool->tool_update(); drawTool->tool_update();
@ -652,16 +655,11 @@ void DrawingProgram::update_downloading_dropped_files() {
}); });
} }
void DrawingProgram::add_file_to_canvas_by_path(const std::filesystem::path& filePath, Vector2f dropPos, bool addInSameThread) { void DrawingProgram::input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile) {
if(addInSameThread) add_file_to_canvas_by_path(addFile.filePath, addFile.pos);
add_file_to_canvas_by_path_execute(filePath, dropPos);
else if(!addFileInNextFrame) {
addFileInfo = {filePath, dropPos};
addFileInNextFrame = true;
}
} }
void DrawingProgram::add_file_to_canvas_by_path_execute(const std::filesystem::path& filePath, Vector2f dropPos) { void DrawingProgram::add_file_to_canvas_by_path(const std::filesystem::path& filePath, Vector2f dropPos) {
if(layerMan.is_a_layer_being_edited()) { if(layerMan.is_a_layer_being_edited()) {
NetworkingObjects::NetObjTemporaryPtr<ResourceData> imageTempPtr = world.rMan.add_resource_file(filePath); NetworkingObjects::NetObjTemporaryPtr<ResourceData> imageTempPtr = world.rMan.add_resource_file(filePath);
if(imageTempPtr) { if(imageTempPtr) {

View file

@ -36,7 +36,7 @@ class DrawingProgram {
void read_components_client(cereal::PortableBinaryInputArchive& a); void read_components_client(cereal::PortableBinaryInputArchive& a);
void init_server_callbacks(); void init_server_callbacks();
void init_client_callbacks(); void init_client_callbacks();
void add_file_to_canvas_by_path(const std::filesystem::path& filePath, Vector2f dropPos, bool addInSameThread); void add_file_to_canvas_by_path(const std::filesystem::path& filePath, Vector2f dropPos);
CanvasComponentContainer::ObjInfo* add_file_to_canvas_by_data(const std::string& fileName, std::string_view fileBuffer, Vector2f dropPos); CanvasComponentContainer::ObjInfo* add_file_to_canvas_by_data(const std::string& fileName, std::string_view fileBuffer, Vector2f dropPos);
void get_used_resources(std::unordered_set<NetworkingObjects::NetObjID>& resourceSet); void get_used_resources(std::unordered_set<NetworkingObjects::NetObjID>& resourceSet);
@ -59,7 +59,8 @@ class DrawingProgram {
void send_transforms_for(const std::vector<CanvasComponentContainer::ObjInfo*>& objsToSendTransformsFor); void send_transforms_for(const std::vector<CanvasComponentContainer::ObjInfo*>& objsToSendTransformsFor);
void on_tab_out(); void on_tab_out();
void input_paste_callback(const CustomEvents::PasteEventData& paste); void input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile);
void input_paste_callback(const CustomEvents::PasteEvent& paste);
void input_drop_text_callback(const InputManager::DropCallbackArgs& drop); void input_drop_text_callback(const InputManager::DropCallbackArgs& drop);
void input_drop_file_callback(const InputManager::DropCallbackArgs& drop); void input_drop_file_callback(const InputManager::DropCallbackArgs& drop);
void input_text_key_callback(const InputManager::KeyCallbackArgs& key); void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
@ -80,7 +81,6 @@ class DrawingProgram {
void process_transform_message(const std::vector<std::pair<NetworkingObjects::NetObjID, CoordSpaceHelper>>& transforms); void process_transform_message(const std::vector<std::pair<NetworkingObjects::NetObjID, CoordSpaceHelper>>& transforms);
void drag_drop_update(); void drag_drop_update();
void add_file_to_canvas_by_path_execute(const std::filesystem::path& filePath, Vector2f dropPos);
void check_updateable_components(); void check_updateable_components();
void update_downloading_dropped_files(); void update_downloading_dropped_files();
@ -88,9 +88,6 @@ class DrawingProgram {
void popup_menu_action_button(const char* id, const char* text, const std::function<void()>& onClick); void popup_menu_action_button(const char* id, const char* text, const std::function<void()>& onClick);
void rebuild_cache(); void rebuild_cache();
std::atomic<bool> addFileInNextFrame = false;
std::pair<std::filesystem::path, Vector2f> addFileInfo;
float drag_point_radius(); float drag_point_radius();
void draw_drag_circle(SkCanvas* canvas, const Vector2f& pos, const SkColor4f& c, const DrawData& drawData, float radiusMultiplier = 1.0f); void draw_drag_circle(SkCanvas* canvas, const Vector2f& pos, const SkColor4f& c, const DrawData& drawData, float radiusMultiplier = 1.0f);
SkPaint select_tool_line_paint(const DrawData& drawData); SkPaint select_tool_line_paint(const DrawData& drawData);

View file

@ -5,7 +5,6 @@
#include "../InputManager.hpp" #include "../InputManager.hpp"
#include <Helpers/Parallel.hpp> #include <Helpers/Parallel.hpp>
#include <Helpers/Logger.hpp> #include <Helpers/Logger.hpp>
#include <chrono>
#ifdef USE_SKIA_BACKEND_GRAPHITE #ifdef USE_SKIA_BACKEND_GRAPHITE
#include <include/gpu/graphite/Surface.h> #include <include/gpu/graphite/Surface.h>
@ -423,7 +422,9 @@ void DrawingProgramSelection::input_key_callback_display_selection(const InputMa
case InputManager::KEY_PASTE_IMAGE: { case InputManager::KEY_PASTE_IMAGE: {
if(key.down && !key.repeat) { if(key.down && !key.repeat) {
deselect_all(); deselect_all();
paste_image(drawP.world.main.input.mouse.pos); drawP.world.main.input.call_paste(CustomEvents::PasteEvent::DataType::IMAGE, {
.pastePosition = drawP.world.main.input.mouse.pos
});
drawP.world.main.g.gui.set_to_layout(); drawP.world.main.g.gui.set_to_layout();
} }
break; break;
@ -689,39 +690,19 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
} }
} }
void DrawingProgramSelection::paste_image(Vector2f pasteScreenPos) { void DrawingProgramSelection::paste_image_process_event(const CustomEvents::PasteEvent& paste) {
check_add_stroke_color_change_undo(); check_add_stroke_color_change_undo();
if(drawP.layerMan.is_a_layer_being_edited()) { if(drawP.layerMan.is_a_layer_being_edited()) {
#ifdef __EMSCRIPTEN__ if(!drawP.is_selection_allowing_tool(drawP.drawTool->get_type()))
struct PasteData { drawP.switch_to_tool(DrawingProgramToolType::EDIT);
std::weak_ptr<World> w;
Vector2f screenPos;
};
static PasteData pasteData;
pasteData.screenPos = pasteScreenPos;
pasteData.w = make_weak_ptr(drawP.world.main.world);
emscripten_browser_clipboard::paste_async_image([](std::string_view pasteData, void* callbackData){
PasteData* p = (PasteData*)callbackData;
std::shared_ptr<World> wLock = p->w.lock();
if(wLock)
wLock->drawProg.add_file_to_canvas_by_data("Image from clipboard", pasteData, p->screenPos);
else
Logger::get().log("INFO", "Loading image to canvas that has been destroyed");
}, &pasteData);
#else
if(!drawP.is_selection_allowing_tool(drawP.drawTool->get_type()))
drawP.switch_to_tool(DrawingProgramToolType::EDIT);
std::vector<CanvasComponentContainer::ObjInfo*> compSetInserted; std::vector<CanvasComponentContainer::ObjInfo*> compSetInserted;
drawP.world.main.input.get_clipboard_image_data_SDL([&](std::string_view pasteData) { compSetInserted.emplace_back(drawP.add_file_to_canvas_by_data("Image from clipboard", paste.data, paste.mousePos.value()));
compSetInserted.emplace_back(drawP.add_file_to_canvas_by_data("Image from clipboard", pasteData, pasteScreenPos)); if(compSetInserted.back() != nullptr) {
}); drawP.drawCache.erase_component(compSetInserted.back());
if(!compSetInserted.empty() && compSetInserted.back() != nullptr) { set_to_selection(compSetInserted);
drawP.drawCache.erase_component(compSetInserted.back()); }
set_to_selection(compSetInserted);
}
#endif
} }
} }

View file

@ -22,7 +22,7 @@ class DrawingProgramSelection {
void sort_selection(); void sort_selection();
void deselect_all(); void deselect_all();
void paste_clipboard(Vector2f pasteScreenPos); void paste_clipboard(Vector2f pasteScreenPos);
void paste_image(Vector2f pasteScreenPos); void paste_image_process_event(const CustomEvents::PasteEvent& paste);
std::unordered_set<CanvasComponentContainer::ObjInfo*> get_selection_as_set(); std::unordered_set<CanvasComponentContainer::ObjInfo*> get_selection_as_set();
void push_selection_to_front(); void push_selection_to_front();
void push_selection_to_back(); void push_selection_to_back();

View file

@ -6,9 +6,7 @@
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include "../../CanvasComponents/BrushStrokeCanvasComponent.hpp" #include "../../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp" #include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp"
#include "Helpers/NetworkingObjects/NetObjWeakPtr.hpp"
#include "../../CanvasComponents/CanvasComponentContainer.hpp" #include "../../CanvasComponents/CanvasComponentContainer.hpp"
#include <chrono>
#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp" #include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp"
@ -176,7 +174,6 @@ void BrushTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("brush tool", [&] { gui.new_id("brush tool", [&] {

View file

@ -4,7 +4,6 @@
#include <include/core/SkPath.h> #include <include/core/SkPath.h>
#include <include/core/SkVertices.h> #include <include/core/SkVertices.h>
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <deque>
#include <include/core/SkCanvas.h> #include <include/core/SkCanvas.h>
#include "../../CanvasComponents/CanvasComponentContainer.hpp" #include "../../CanvasComponents/CanvasComponentContainer.hpp"
#include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp> #include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp>

View file

@ -55,7 +55,7 @@ std::unique_ptr<DrawingProgramToolBase> DrawingProgramToolBase::allocate_tool_ty
return nullptr; return nullptr;
} }
void DrawingProgramToolBase::input_paste_callback(const CustomEvents::PasteEventData& paste) {} void DrawingProgramToolBase::input_paste_callback(const CustomEvents::PasteEvent& paste) {}
void DrawingProgramToolBase::input_text_key_callback(const InputManager::KeyCallbackArgs& key) {} void DrawingProgramToolBase::input_text_key_callback(const InputManager::KeyCallbackArgs& key) {}
void DrawingProgramToolBase::input_text_callback(const InputManager::TextCallbackArgs& text) {} void DrawingProgramToolBase::input_text_callback(const InputManager::TextCallbackArgs& text) {}
void DrawingProgramToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {} void DrawingProgramToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {}

View file

@ -36,7 +36,7 @@ class DrawingProgramToolBase {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0; virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;
virtual void switch_tool(DrawingProgramToolType newTool) = 0; virtual void switch_tool(DrawingProgramToolType newTool) = 0;
virtual bool prevent_undo_or_redo() = 0; virtual bool prevent_undo_or_redo() = 0;
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste); virtual void input_paste_callback(const CustomEvents::PasteEvent& paste);
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
virtual void input_text_callback(const InputManager::TextCallbackArgs& text); virtual void input_text_callback(const InputManager::TextCallbackArgs& text);
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_key_callback(const InputManager::KeyCallbackArgs& key);

View file

@ -1,5 +1,4 @@
#include "EditTool.hpp" #include "EditTool.hpp"
#include <chrono>
#include "../DrawingProgram.hpp" #include "../DrawingProgram.hpp"
#include "../../MainProgram.hpp" #include "../../MainProgram.hpp"
#include "../../DrawData.hpp" #include "../../DrawData.hpp"
@ -29,7 +28,6 @@ void EditTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
if(objInfoBeingEdited) if(objInfoBeingEdited)
@ -46,7 +44,7 @@ void EditTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
switch_tool(get_type()); switch_tool(get_type());
} }
void EditTool::input_paste_callback(const CustomEvents::PasteEventData& paste) { void EditTool::input_paste_callback(const CustomEvents::PasteEvent& paste) {
if(objInfoBeingEdited) if(objInfoBeingEdited)
compEditTool->input_paste_callback(paste); compEditTool->input_paste_callback(paste);
} }

View file

@ -26,7 +26,7 @@ class EditTool : public DrawingProgramToolBase {
virtual void switch_tool(DrawingProgramToolType newTool) override; virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override; virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override; virtual bool prevent_undo_or_redo() override;
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste) override; virtual void input_paste_callback(const CustomEvents::PasteEvent& paste) override;
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override; virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override;
virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override; virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override;
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key) override; virtual void input_key_callback(const InputManager::KeyCallbackArgs& key) override;

View file

@ -3,6 +3,7 @@
#include "../../../World.hpp" #include "../../../World.hpp"
#include "../../../MainProgram.hpp" #include "../../../MainProgram.hpp"
#include "../EditTool.hpp" #include "../EditTool.hpp"
#include "../../../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../../GUIStuff/ElementHelpers/LayoutHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/LayoutHelpers.hpp"

View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
#include "../../../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include <Helpers/SCollision.hpp> #include <Helpers/SCollision.hpp>
#include <any> #include <any>

View file

@ -11,7 +11,7 @@ void DrawingProgramEditToolBase::right_click_popup_gui(Vector2f popupPos) {
t.paint_popup(popupPos); t.paint_popup(popupPos);
} }
void DrawingProgramEditToolBase::input_paste_callback(const CustomEvents::PasteEventData& paste) {} void DrawingProgramEditToolBase::input_paste_callback(const CustomEvents::PasteEvent& paste) {}
void DrawingProgramEditToolBase::input_text_key_callback(const InputManager::KeyCallbackArgs& key) {} void DrawingProgramEditToolBase::input_text_key_callback(const InputManager::KeyCallbackArgs& key) {}
void DrawingProgramEditToolBase::input_text_callback(const InputManager::TextCallbackArgs& text) {} void DrawingProgramEditToolBase::input_text_callback(const InputManager::TextCallbackArgs& text) {}
void DrawingProgramEditToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {} void DrawingProgramEditToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {}

View file

@ -14,7 +14,7 @@ class DrawingProgramEditToolBase {
virtual bool edit_update() = 0; virtual bool edit_update() = 0;
virtual void edit_gui() = 0; virtual void edit_gui() = 0;
virtual void right_click_popup_gui(Vector2f popupPos); virtual void right_click_popup_gui(Vector2f popupPos);
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste); virtual void input_paste_callback(const CustomEvents::PasteEvent& paste);
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
virtual void input_text_callback(const InputManager::TextCallbackArgs& text); virtual void input_text_callback(const InputManager::TextCallbackArgs& text);
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_key_callback(const InputManager::KeyCallbackArgs& key);

View file

@ -4,7 +4,6 @@
#include "../../../MainProgram.hpp" #include "../../../MainProgram.hpp"
#include "../../../DrawData.hpp" #include "../../../DrawData.hpp"
#include <cereal/types/vector.hpp> #include <cereal/types/vector.hpp>
#include <memory>
#include "../EditTool.hpp" #include "../EditTool.hpp"
#include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"

View file

@ -8,7 +8,6 @@
#include "../EditTool.hpp" #include "../EditTool.hpp"
#include "DrawingProgramEditToolBase.hpp" #include "DrawingProgramEditToolBase.hpp"
#include "Eigen/Geometry" #include "Eigen/Geometry"
#include <fstream>
#include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../../GUIStuff/ElementHelpers/ButtonHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/ButtonHelpers.hpp"

View file

@ -2,7 +2,6 @@
#include "../../DrawingProgram.hpp" #include "../../DrawingProgram.hpp"
#include "../../../World.hpp" #include "../../../World.hpp"
#include "../../../MainProgram.hpp" #include "../../../MainProgram.hpp"
#include <memory>
#include "../EditTool.hpp" #include "../EditTool.hpp"
#include "../../../GUIStuff/ElementHelpers/NumberSliderHelpers.hpp" #include "../../../GUIStuff/ElementHelpers/NumberSliderHelpers.hpp"

View file

@ -2,7 +2,6 @@
#include "../../DrawingProgram.hpp" #include "../../DrawingProgram.hpp"
#include "../../../MainProgram.hpp" #include "../../../MainProgram.hpp"
#include "../../../DrawData.hpp" #include "../../../DrawData.hpp"
#include "Helpers/ConvertVec.hpp"
#include "Helpers/SCollision.hpp" #include "Helpers/SCollision.hpp"
#include <cereal/types/vector.hpp> #include <cereal/types/vector.hpp>
#include <include/core/SkFontStyle.h> #include <include/core/SkFontStyle.h>
@ -204,7 +203,7 @@ void TextBoxEditTool::edit_gui() {
}); });
} }
void TextBoxEditTool::input_paste_callback(const CustomEvents::PasteEventData& paste) { void TextBoxEditTool::input_paste_callback(const CustomEvents::PasteEvent& paste) {
if(textboxID.has_value() && textboxID.value() == drawP.world.main.input.text.current_textbox_editing_id()) { if(textboxID.has_value() && textboxID.value() == drawP.world.main.input.text.current_textbox_editing_id()) {
auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp()); auto& a = static_cast<TextBoxCanvasComponent&>(comp->obj->get_comp());
if(userInput->input_paste_callback(paste)) { if(userInput->input_paste_callback(paste)) {
@ -289,10 +288,10 @@ void TextBoxEditTool::right_click_popup_gui(Vector2f popupPos) {
text_label_light(gui, "Text menu"); text_label_light(gui, "Text menu");
InputManager& input = drawP.world.main.input; InputManager& input = drawP.world.main.input;
drawP.popup_menu_action_button("Paste", "Paste", [&] { drawP.popup_menu_action_button("Paste", "Paste", [&] {
drawP.world.main.input.call_paste(CustomEvents::PasteEventDataType::TEXT, { .allowRichText = true }); drawP.world.main.input.call_paste(CustomEvents::PasteEvent::DataType::TEXT, { .allowRichText = true });
}); });
drawP.popup_menu_action_button("Paste without formatting", "Paste without formatting", [&] { drawP.popup_menu_action_button("Paste without formatting", "Paste without formatting", [&] {
drawP.world.main.input.call_paste(CustomEvents::PasteEventDataType::TEXT, { .allowRichText = false }); drawP.world.main.input.call_paste(CustomEvents::PasteEvent::DataType::TEXT, { .allowRichText = false });
}); });
if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos) { if(a.cursor->selectionBeginPos != a.cursor->selectionEndPos) {
drawP.popup_menu_action_button("Copy", "Copy", [&] { drawP.popup_menu_action_button("Copy", "Copy", [&] {

View file

@ -17,7 +17,7 @@ class TextBoxEditTool : public DrawingProgramEditToolBase {
virtual void edit_gui() override; virtual void edit_gui() override;
virtual void right_click_popup_gui(Vector2f popupPos) override; virtual void right_click_popup_gui(Vector2f popupPos) override;
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste) override; virtual void input_paste_callback(const CustomEvents::PasteEvent& paste) override;
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override; virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override;
virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override; virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override;
virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button, bool isDraggingPoint) override; virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button, bool isDraggingPoint) override;

View file

@ -24,7 +24,6 @@ void EllipseDrawTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
auto& toolConfig = drawP.world.main.toolConfig; auto& toolConfig = drawP.world.main.toolConfig;
auto& fillStrokeMode = toolConfig.ellipseDraw.fillStrokeMode; auto& fillStrokeMode = toolConfig.ellipseDraw.fillStrokeMode;

View file

@ -20,7 +20,6 @@ void EraserTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("eraser tool", [&] { gui.new_id("eraser tool", [&] {
text_label_centered(gui, "Eraser"); text_label_centered(gui, "Eraser");

View file

@ -2,7 +2,6 @@
#include <include/core/SkCanvas.h> #include <include/core/SkCanvas.h>
#include "../../DrawData.hpp" #include "../../DrawData.hpp"
#include "DrawingProgramToolBase.hpp" #include "DrawingProgramToolBase.hpp"
#include "../DrawingProgramCache.hpp"
class DrawingProgram; class DrawingProgram;

View file

@ -30,7 +30,6 @@ void EyeDropperTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
auto& selectingStrokeColor = drawP.world.main.toolConfig.eyeDropper.selectingStrokeColor; auto& selectingStrokeColor = drawP.world.main.toolConfig.eyeDropper.selectingStrokeColor;
gui.new_id("Color select tool", [&] { gui.new_id("Color select tool", [&] {

View file

@ -2,11 +2,9 @@
#include "../DrawingProgram.hpp" #include "../DrawingProgram.hpp"
#include "../../MainProgram.hpp" #include "../../MainProgram.hpp"
#include "../../DrawData.hpp" #include "../../DrawData.hpp"
#include "Helpers/Networking/NetLibrary.hpp"
#include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp" #include "Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp"
#include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp> #include <Helpers/NetworkingObjects/NetObjWeakPtr.hpp>
#include <Helpers/NetworkingObjects/NetObjGenericSerializedClass.hpp> #include <Helpers/NetworkingObjects/NetObjGenericSerializedClass.hpp>
#include <cstddef>
#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/LayoutHelpers.hpp" #include "../../GUIStuff/ElementHelpers/LayoutHelpers.hpp"

View file

@ -7,7 +7,6 @@
#include "Helpers/SCollision.hpp" #include "Helpers/SCollision.hpp"
#include "../../CoordSpaceHelper.hpp" #include "../../CoordSpaceHelper.hpp"
#include <ranges> #include <ranges>
#include "../../DrawCollision.hpp"
#include <earcut.hpp> #include <earcut.hpp>
#include <include/core/SkPathBuilder.h> #include <include/core/SkPathBuilder.h>
@ -41,7 +40,6 @@ DrawingProgramToolType LassoSelectTool::get_type() {
} }
void LassoSelectTool::gui_toolbox() { void LassoSelectTool::gui_toolbox() {
auto& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("lasso select tool", [&] { gui.new_id("lasso select tool", [&] {
GUIStuff::ElementHelpers::text_label_centered(gui, "Lasso Select"); GUIStuff::ElementHelpers::text_label_centered(gui, "Lasso Select");

View file

@ -6,7 +6,6 @@
#include "../../CanvasComponents/BrushStrokeCanvasComponent.hpp" #include "../../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include "../../CanvasComponents/CanvasComponentContainer.hpp" #include "../../CanvasComponents/CanvasComponentContainer.hpp"
#include "Helpers/MathExtras.hpp" #include "Helpers/MathExtras.hpp"
#include <limits>
#include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp" #include "../../GUIStuff/ElementHelpers/TextLabelHelpers.hpp"
#include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp" #include "../../GUIStuff/ElementHelpers/CheckBoxHelpers.hpp"
@ -22,7 +21,6 @@ DrawingProgramToolType LineDrawTool::get_type() {
void LineDrawTool::gui_toolbox() { void LineDrawTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
auto& toolConfig = drawP.world.main.toolConfig; auto& toolConfig = drawP.world.main.toolConfig;
gui.new_id("rect draw tool", [&] { gui.new_id("rect draw tool", [&] {

View file

@ -17,7 +17,6 @@ DrawingProgramToolType PanCanvasTool::get_type() {
} }
void PanCanvasTool::gui_toolbox() { void PanCanvasTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("Pan canvas tool", [&] { gui.new_id("Pan canvas tool", [&] {
GUIStuff::ElementHelpers::text_label_centered(gui, "Pan tool"); GUIStuff::ElementHelpers::text_label_centered(gui, "Pan tool");

View file

@ -22,7 +22,6 @@ void RectDrawTool::gui_toolbox() {
using namespace GUIStuff; using namespace GUIStuff;
using namespace ElementHelpers; using namespace ElementHelpers;
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
auto& toolConfig = drawP.world.main.toolConfig; auto& toolConfig = drawP.world.main.toolConfig;
auto& fillStrokeMode = toolConfig.rectDraw.fillStrokeMode; auto& fillStrokeMode = toolConfig.rectDraw.fillStrokeMode;

View file

@ -19,7 +19,6 @@ DrawingProgramToolType RectSelectTool::get_type() {
} }
void RectSelectTool::gui_toolbox() { void RectSelectTool::gui_toolbox() {
auto& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("rectangle select tool", [&] { gui.new_id("rectangle select tool", [&] {
GUIStuff::ElementHelpers::text_label_centered(gui, "Rectangle Select"); GUIStuff::ElementHelpers::text_label_centered(gui, "Rectangle Select");

View file

@ -17,9 +17,7 @@
#include <include/encode/SkPngEncoder.h> #include <include/encode/SkPngEncoder.h>
#include <include/encode/SkWebpEncoder.h> #include <include/encode/SkWebpEncoder.h>
#include <include/encode/SkJpegEncoder.h> #include <include/encode/SkJpegEncoder.h>
#include <fstream>
#include <include/gpu/GpuTypes.h> #include <include/gpu/GpuTypes.h>
#include "../../FileHelpers.hpp"
#include <filesystem> #include <filesystem>
#ifdef USE_SKIA_BACKEND_GRAPHITE #ifdef USE_SKIA_BACKEND_GRAPHITE
#include <include/gpu/graphite/Surface.h> #include <include/gpu/graphite/Surface.h>

View file

@ -1,10 +1,8 @@
#include "TextBoxTool.hpp" #include "TextBoxTool.hpp"
#include <chrono>
#include "../DrawingProgram.hpp" #include "../DrawingProgram.hpp"
#include "../../MainProgram.hpp" #include "../../MainProgram.hpp"
#include "../../DrawData.hpp" #include "../../DrawData.hpp"
#include "Helpers/MathExtras.hpp" #include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include <cereal/types/vector.hpp> #include <cereal/types/vector.hpp>
#include <memory> #include <memory>
#include "../../CanvasComponents/TextBoxCanvasComponent.hpp" #include "../../CanvasComponents/TextBoxCanvasComponent.hpp"
@ -22,7 +20,6 @@ DrawingProgramToolType TextBoxTool::get_type() {
} }
void TextBoxTool::gui_toolbox() { void TextBoxTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("textbox tool", [&] { gui.new_id("textbox tool", [&] {
GUIStuff::ElementHelpers::text_label_centered(gui, "Place textbox"); GUIStuff::ElementHelpers::text_label_centered(gui, "Place textbox");

View file

@ -17,7 +17,6 @@ DrawingProgramToolType ZoomCanvasTool::get_type() {
} }
void ZoomCanvasTool::gui_toolbox() { void ZoomCanvasTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
auto& gui = drawP.world.main.g.gui; auto& gui = drawP.world.main.g.gui;
gui.new_id("Zoom canvas tool", [&] { gui.new_id("Zoom canvas tool", [&] {
GUIStuff::ElementHelpers::text_label_centered(gui, "Zoom tool"); GUIStuff::ElementHelpers::text_label_centered(gui, "Zoom tool");

View file

@ -128,7 +128,7 @@ void GUIHolder::draw(SkCanvas* canvas, bool skiaAA) {
gui.draw(canvas, skiaAA); gui.draw(canvas, skiaAA);
} }
void GUIHolder::input_paste_callback(const CustomEvents::PasteEventData& paste) { void GUIHolder::input_paste_callback(const CustomEvents::PasteEvent& paste) {
gui.input_paste_callback(paste); gui.input_paste_callback(paste);
} }

View file

@ -21,7 +21,7 @@ class GUIHolder {
void delete_cache_surface(); void delete_cache_surface();
void draw(SkCanvas* canvas, bool skiaAA); void draw(SkCanvas* canvas, bool skiaAA);
void input_paste_callback(const CustomEvents::PasteEventData& paste); void input_paste_callback(const CustomEvents::PasteEvent& paste);
void input_text_key_callback(const InputManager::KeyCallbackArgs& key); void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
void input_text_callback(const InputManager::TextCallbackArgs& text); void input_text_callback(const InputManager::TextCallbackArgs& text);
void input_key_callback(const InputManager::KeyCallbackArgs& key); void input_key_callback(const InputManager::KeyCallbackArgs& key);

View file

@ -8,7 +8,7 @@ namespace GUIStuff {
void Element::update() {} void Element::update() {}
void Element::deselect() {} void Element::deselect() {}
void Element::input_paste_callback(const CustomEvents::PasteEventData& paste) { } void Element::input_paste_callback(const CustomEvents::PasteEvent& paste) { }
void Element::input_text_key_callback(const InputManager::KeyCallbackArgs& key) { } void Element::input_text_key_callback(const InputManager::KeyCallbackArgs& key) { }
void Element::input_text_callback(const InputManager::TextCallbackArgs& text) { } void Element::input_text_callback(const InputManager::TextCallbackArgs& text) { }
void Element::input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { } void Element::input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) { }

View file

@ -25,7 +25,7 @@ namespace GUIStuff {
virtual void update(); virtual void update();
virtual void deselect(); virtual void deselect();
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste); virtual void input_paste_callback(const CustomEvents::PasteEvent& paste);
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key); virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
virtual void input_text_callback(const InputManager::TextCallbackArgs& text); virtual void input_text_callback(const InputManager::TextCallbackArgs& text);
virtual void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button); virtual void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button);

View file

@ -41,7 +41,7 @@ template <typename T> class TextBox : public Element {
virtual void update() override; virtual void update() override;
virtual void deselect() override; virtual void deselect() override;
virtual void clay_draw(SkCanvas* canvas, UpdateInputData& io, Clay_RenderCommand* command, bool skiaAA) override; virtual void clay_draw(SkCanvas* canvas, UpdateInputData& io, Clay_RenderCommand* command, bool skiaAA) override;
virtual void input_paste_callback(const CustomEvents::PasteEventData& paste) override; virtual void input_paste_callback(const CustomEvents::PasteEvent& paste) override;
virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override; virtual void input_text_key_callback(const InputManager::KeyCallbackArgs& key) override;
virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override; virtual void input_text_callback(const InputManager::TextCallbackArgs& text) override;
virtual void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) override; virtual void input_mouse_button_callback(const InputManager::MouseButtonCallbackArgs& button) override;

View file

@ -92,7 +92,7 @@ template <typename T> bool TextBox<T>::is_selected() const {
return edit.has_value(); return edit.has_value();
} }
template <typename T> void TextBox<T>::input_paste_callback(const CustomEvents::PasteEventData& paste) { template <typename T> void TextBox<T>::input_paste_callback(const CustomEvents::PasteEvent& paste) {
if(is_selected() && edit.value().userInput.input_paste_callback(paste)) if(is_selected() && edit.value().userInput.input_paste_callback(paste))
after_text_input_callback(); after_text_input_callback();
} }

View file

@ -495,7 +495,7 @@ void GUIManager::deselect_all() {
e->elem->deselect(); e->elem->deselect();
} }
void GUIManager::input_paste_callback(const CustomEvents::PasteEventData& paste) { void GUIManager::input_paste_callback(const CustomEvents::PasteEvent& paste) {
for(ElementContainer* e : orderedElements) for(ElementContainer* e : orderedElements)
e->elem->input_paste_callback(paste); e->elem->input_paste_callback(paste);
} }

View file

@ -90,7 +90,7 @@ class GUIManager {
DefaultStringArena strArena; DefaultStringArena strArena;
void input_paste_callback(const CustomEvents::PasteEventData& paste); void input_paste_callback(const CustomEvents::PasteEvent& paste);
void input_text_key_callback(const InputManager::KeyCallbackArgs& key); void input_text_key_callback(const InputManager::KeyCallbackArgs& key);
void input_text_callback(const InputManager::TextCallbackArgs& text); void input_text_callback(const InputManager::TextCallbackArgs& text);
void input_key_callback(const InputManager::KeyCallbackArgs& key); void input_key_callback(const InputManager::KeyCallbackArgs& key);

View file

@ -362,16 +362,6 @@ uint32_t InputManager::make_generic_key_mod(SDL_Keymod m) {
return toRet; return toRet;
} }
void InputManager::backend_open_infinipaint_file_event() {
main.input_open_infinipaint_file_callback(CustomEvents::get_open_infinipaint_file_event_data());
CustomEvents::pop_open_infinipaint_file_event_data();
}
void InputManager::backend_paste_event() {
main.input_paste_callback(CustomEvents::get_paste_event_data());
CustomEvents::pop_paste_event_data();
}
void InputManager::backend_input_text_event(const std::string& str) { void InputManager::backend_input_text_event(const std::string& str) {
main.input_text_callback(TextCallbackArgs{ .str = str }); main.input_text_callback(TextCallbackArgs{ .str = str });
} }
@ -934,7 +924,7 @@ void InputManager::backend_key_down_update(const SDL_KeyboardEvent& e) {
set_key_down(e, f->second, acceptingTextInput); set_key_down(e, f->second, acceptingTextInput);
} }
void InputManager::call_paste(CustomEvents::PasteEventDataType type, const InputManagerCallPasteInfo& info) { void InputManager::call_paste(CustomEvents::PasteEvent::DataType type, const InputManagerCallPasteInfo& info) {
// Workaround for not being able to copy richtext to system clipboard, this should at least work within the application itself // Workaround for not being able to copy richtext to system clipboard, this should at least work within the application itself
#ifdef __EMSCRIPTEN__ #ifdef __EMSCRIPTEN__
if(type == PasteDataType::TEXT) { if(type == PasteDataType::TEXT) {
@ -944,25 +934,49 @@ void InputManager::call_paste(CustomEvents::PasteEventDataType type, const Input
inMan->process_text_paste(pData); inMan->process_text_paste(pData);
}, this); }, this);
} }
else {
struct PasteData {
std::optional<Vector2f> pos;
InputManager* t;
};
static PasteData pasteData;
pasteData.pos = info.pastePosition;
pasteData.t = this;
emscripten_browser_clipboard::paste_async_image([](std::string_view pasteData, void* callbackData){
PasteData* p = (PasteData*)callbackData;
p->t->process_image_paste(pasteData, p->pos);
}, &pasteData);
}
#else #else
switch(type) { switch(type) {
case CustomEvents::PasteEventDataType::TEXT: case CustomEvents::PasteEvent::DataType::TEXT:
process_text_paste(get_clipboard_str_SDL(), info.allowRichText); process_text_paste(get_clipboard_str_SDL(), info.allowRichText);
break; break;
case CustomEvents::PasteEventDataType::IMAGE: case CustomEvents::PasteEvent::DataType::IMAGE:
get_clipboard_image_data_SDL([&](std::string_view pasteData) {
process_image_paste(pasteData, info.pastePosition);
});
break; break;
} }
#endif #endif
} }
void InputManager::process_text_paste(const std::string& pasteStr, bool allowRichText) { void InputManager::process_text_paste(const std::string& pasteStr, bool allowRichText) {
CustomEvents::emit_paste_event({ CustomEvents::emit_event<CustomEvents::PasteEvent>({
.type = CustomEvents::PasteEventDataType::TEXT, .type = CustomEvents::PasteEvent::DataType::TEXT,
.data = pasteStr, .data = pasteStr,
.richText = allowRichText && lastCopiedRichText.has_value() && lastCopiedRichText.value().get_plain_text() == remove_carriage_returns_from_str(pasteStr) ? lastCopiedRichText : std::nullopt .richText = allowRichText && lastCopiedRichText.has_value() && lastCopiedRichText.value().get_plain_text() == remove_carriage_returns_from_str(pasteStr) ? lastCopiedRichText : std::nullopt
}); });
} }
void InputManager::process_image_paste(std::string_view pasteData, const std::optional<Vector2f>& pastePos) {
CustomEvents::emit_event<CustomEvents::PasteEvent>({
.type = CustomEvents::PasteEvent::DataType::IMAGE,
.data = std::string(pasteData),
.mousePos = pastePos
});
}
bool InputManager::ctrl_or_meta_held() { bool InputManager::ctrl_or_meta_held() {
return key(KEY_GENERIC_LCTRL).held || key(KEY_GENERIC_LMETA).held; return key(KEY_GENERIC_LCTRL).held || key(KEY_GENERIC_LMETA).held;
} }

View file

@ -4,15 +4,11 @@
#include <SDL3/SDL_properties.h> #include <SDL3/SDL_properties.h>
#include <SDL3/SDL_touch.h> #include <SDL3/SDL_touch.h>
#include <array> #include <array>
#include "RichText/TextStyleModifier.hpp"
#include "RichText/TextBox.hpp" #include "RichText/TextBox.hpp"
#include "TimePoint.hpp"
#include <Helpers/Hashes.hpp> #include <Helpers/Hashes.hpp>
#include <unordered_map> #include <unordered_map>
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
#include <queue>
#include <Helpers/CallbackManager.hpp> #include <Helpers/CallbackManager.hpp>
#include "UndoManager.hpp"
#include <SDL3/SDL.h> #include <SDL3/SDL.h>
#include <SDL3/SDL_events.h> #include <SDL3/SDL_events.h>
@ -260,8 +256,6 @@ struct InputManager {
void touch_finger_do_mouse_up(const SDL_TouchFingerEvent& f); void touch_finger_do_mouse_up(const SDL_TouchFingerEvent& f);
void touch_finger_do_mouse_motion(const SDL_TouchFingerEvent& f); void touch_finger_do_mouse_motion(const SDL_TouchFingerEvent& f);
void backend_open_infinipaint_file_event();
void backend_paste_event();
void backend_input_text_event(const std::string& str); void backend_input_text_event(const std::string& str);
void backend_drop_file_event(const SDL_DropEvent& e); void backend_drop_file_event(const SDL_DropEvent& e);
void backend_drop_text_event(const SDL_DropEvent& e); void backend_drop_text_event(const SDL_DropEvent& e);
@ -288,8 +282,9 @@ struct InputManager {
std::string get_clipboard_str_SDL(); std::string get_clipboard_str_SDL();
void get_clipboard_image_data_SDL(const std::function<void(std::string_view data)>& callback); void get_clipboard_image_data_SDL(const std::function<void(std::string_view data)>& callback);
void call_paste(CustomEvents::PasteEventDataType type, const InputManagerCallPasteInfo& info = {}); void call_paste(CustomEvents::PasteEvent::DataType type, const InputManagerCallPasteInfo& info = {});
void process_text_paste(const std::string& pasteStr, bool allowRichText); void process_text_paste(const std::string& pasteStr, bool allowRichText);
void process_image_paste(std::string_view pasteData, const std::optional<Vector2f>& pastePos);
std::optional<RichText::TextData> lastCopiedRichText; std::optional<RichText::TextData> lastCopiedRichText;

View file

@ -267,7 +267,7 @@ sk_sp<SkSurface> MainProgram::create_native_surface(Vector2i resolution, bool is
return nullptr; return nullptr;
} }
void MainProgram::create_new_tab(const CustomEvents::OpenInfiniPaintFileEventData& openFile) { void MainProgram::create_new_tab(const CustomEvents::OpenInfiniPaintFileEvent& openFile) {
std::shared_ptr<World> newWorld; std::shared_ptr<World> newWorld;
try { try {
newWorld = std::make_shared<World>(*this, openFile); newWorld = std::make_shared<World>(*this, openFile);
@ -295,12 +295,18 @@ void MainProgram::post_callback() {
g.post_callback(); g.post_callback();
} }
void MainProgram::input_open_infinipaint_file_callback(const CustomEvents::OpenInfiniPaintFileEventData& openFile) { void MainProgram::input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile) {
if(world)
world->input_add_file_to_canvas_callback(addFile);
post_callback();
}
void MainProgram::input_open_infinipaint_file_callback(const CustomEvents::OpenInfiniPaintFileEvent& openFile) {
create_new_tab(openFile); create_new_tab(openFile);
post_callback(); post_callback();
} }
void MainProgram::input_paste_callback(const CustomEvents::PasteEventData& paste) { void MainProgram::input_paste_callback(const CustomEvents::PasteEvent& paste) {
g.input_paste_callback(paste); g.input_paste_callback(paste);
if(world) if(world)
world->input_paste_callback(paste); world->input_paste_callback(paste);
@ -330,7 +336,7 @@ void MainProgram::input_drop_file_callback(const InputManager::DropCallbackArgs&
if(std::filesystem::is_regular_file(drop.data)) { if(std::filesystem::is_regular_file(drop.data)) {
std::filesystem::path droppedFilePath(drop.data); std::filesystem::path droppedFilePath(drop.data);
if(droppedFilePath.has_extension() && droppedFilePath.extension().string() == std::string("." + World::FILE_EXTENSION)) { if(droppedFilePath.has_extension() && droppedFilePath.extension().string() == std::string("." + World::FILE_EXTENSION)) {
CustomEvents::emit_open_infinipaint_file_event({ CustomEvents::emit_event<CustomEvents::OpenInfiniPaintFileEvent>({
.isClient = false, .isClient = false,
.filePathSource = droppedFilePath .filePathSource = droppedFilePath
}); });

View file

@ -119,8 +119,10 @@ class MainProgram {
GlobalConfig conf; GlobalConfig conf;
std::optional<unsigned> keybindWaiting; std::optional<unsigned> keybindWaiting;
void input_open_infinipaint_file_callback(const CustomEvents::OpenInfiniPaintFileEventData& openFile); void input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile);
void input_paste_callback(const CustomEvents::PasteEventData& paste); void input_open_infinipaint_file_callback(const CustomEvents::OpenInfiniPaintFileEvent& openFile);
void input_paste_callback(const CustomEvents::PasteEvent& paste);
bool input_keybind_callback(const Vector2ui32& newKey); bool input_keybind_callback(const Vector2ui32& newKey);
void input_drop_file_callback(const InputManager::DropCallbackArgs& drop); void input_drop_file_callback(const InputManager::DropCallbackArgs& drop);
void input_drop_text_callback(const InputManager::DropCallbackArgs& drop); void input_drop_text_callback(const InputManager::DropCallbackArgs& drop);
@ -141,7 +143,7 @@ class MainProgram {
void input_window_resize_callback(const InputManager::WindowResizeCallbackArgs& w); void input_window_resize_callback(const InputManager::WindowResizeCallbackArgs& w);
void input_window_scale_callback(const InputManager::WindowScaleCallbackArgs& w); void input_window_scale_callback(const InputManager::WindowScaleCallbackArgs& w);
void create_new_tab(const CustomEvents::OpenInfiniPaintFileEventData& openFile); void create_new_tab(const CustomEvents::OpenInfiniPaintFileEvent& openFile);
void set_tab_to_close(World* world); void set_tab_to_close(World* world);
void switch_to_tab(size_t wIndex); void switch_to_tab(size_t wIndex);

View file

@ -14,8 +14,8 @@ RichTextUserInput::RichTextUserInput(const std::shared_ptr<RichText::TextBox>& i
modMap(initModMap) modMap(initModMap)
{} {}
bool RichTextUserInput::input_paste_callback(const CustomEvents::PasteEventData& paste) { bool RichTextUserInput::input_paste_callback(const CustomEvents::PasteEvent& paste) {
if(paste.type == CustomEvents::PasteEventDataType::TEXT) { if(paste.type == CustomEvents::PasteEvent::DataType::TEXT) {
do_textbox_operation_with_undo([&]() { do_textbox_operation_with_undo([&]() {
if(paste.richText.has_value()) if(paste.richText.has_value())
textBox->process_rich_text_input(*cursor, paste.richText.value()); textBox->process_rich_text_input(*cursor, paste.richText.value());
@ -104,7 +104,7 @@ RichTextUserInput::Changes RichTextUserInput::input_key_callback(InputManager& i
toRet.textEdited = true; toRet.textEdited = true;
break; break;
case InputManager::KEY_TEXT_PASTE: case InputManager::KEY_TEXT_PASTE:
input.call_paste(CustomEvents::PasteEventDataType::TEXT); input.call_paste(CustomEvents::PasteEvent::DataType::TEXT);
break; break;
case InputManager::KEY_TEXT_SELECTALL: case InputManager::KEY_TEXT_SELECTALL:
textBox->process_key_input(*cursor, RichText::TextBox::InputKey::SELECT_ALL, input.ctrl_or_meta_held(), input.key(InputManager::KEY_GENERIC_LSHIFT).held, modMapOpt); textBox->process_key_input(*cursor, RichText::TextBox::InputKey::SELECT_ALL, input.ctrl_or_meta_held(), input.key(InputManager::KEY_GENERIC_LSHIFT).held, modMapOpt);

View file

@ -12,7 +12,7 @@ class RichTextUserInput {
bool cursorChanged = false; bool cursorChanged = false;
}; };
Changes input_key_callback(InputManager& input, const InputManager::KeyCallbackArgs& key); Changes input_key_callback(InputManager& input, const InputManager::KeyCallbackArgs& key);
bool input_paste_callback(const CustomEvents::PasteEventData& paste); bool input_paste_callback(const CustomEvents::PasteEvent& paste);
void add_text_to_textbox(const std::string& inputText); void add_text_to_textbox(const std::string& inputText);
void do_textbox_operation_with_undo(const std::function<void()>& func); void do_textbox_operation_with_undo(const std::function<void()>& func);
void add_textbox_undo(const RichText::TextBox::Cursor& prevCursor, const RichText::TextData& prevRichText); void add_textbox_undo(const RichText::TextBox::Cursor& prevCursor, const RichText::TextData& prevRichText);

View file

@ -619,7 +619,7 @@ void Toolbar::top_toolbar() {
}); });
}; };
menu_popup_text_button("new file local", "New File", [&] { menu_popup_text_button("new file local", "New File", [&] {
CustomEvents::emit_open_infinipaint_file_event({ CustomEvents::emit_event<CustomEvents::OpenInfiniPaintFileEvent>({
.isClient = false .isClient = false
}); });
}); });
@ -630,24 +630,23 @@ void Toolbar::top_toolbar() {
menu_popup_text_button("screenshot", "Screenshot", [&] { main.world->drawProg.switch_to_tool(DrawingProgramToolType::SCREENSHOT); }); menu_popup_text_button("screenshot", "Screenshot", [&] { main.world->drawProg.switch_to_tool(DrawingProgramToolType::SCREENSHOT); });
menu_popup_text_button("add image or file to canvas", "Add Image/File to Canvas", [&] { menu_popup_text_button("add image or file to canvas", "Add Image/File to Canvas", [&] {
#ifdef __EMSCRIPTEN__ #ifdef __EMSCRIPTEN__
static std::weak_ptr<World> worldWeakPtr;
worldWeakPtr = make_weak_ptr(main.world);
emscripten_browser_file::upload("*", [](std::string const& fileName, std::string const& mimeType, std::string_view buffer, void* callbackData) { emscripten_browser_file::upload("*", [](std::string const& fileName, std::string const& mimeType, std::string_view buffer, void* callbackData) {
if(!buffer.empty()) { if(!buffer.empty()) {
auto world = ((std::weak_ptr<World>*)callbackData)->lock(); auto& main = *static_cast<MainProgram*>(callbackData);
if(world) CustomEvents::emit_event<CustomEvents::AddFileToCanvasEvent>({
world->drawProg.add_file_to_canvas_by_data(fileName, buffer, world->main.window.size.cast<float>() / 2.0f); .type = CustomEvents::AddFileToCanvasEvent::Type::BUFFER,
else .name = fileName,
Logger::get().log("INFO", "Loading image to canvas that has been destroyed"); .buffer = std::string(buffer)
});
} }
}, &worldWeakPtr); }, &main);
#else #else
open_file_selector("Open File", {{"Any File", "*"}}, [w = make_weak_ptr(main.world)](const std::filesystem::path& p, const auto& e) { open_file_selector("Open File", {{"Any File", "*"}}, [&](const std::filesystem::path& p, const auto& e) {
auto wLock = w.lock(); CustomEvents::emit_event<CustomEvents::AddFileToCanvasEvent>({
if(wLock) .type = CustomEvents::AddFileToCanvasEvent::Type::PATH,
wLock->drawProg.add_file_to_canvas_by_path(p, wLock->main.window.size.cast<float>() / 2.0f, false); .filePath = p,
else .pos = main.window.size.cast<float>() / 2.0f
Logger::get().log("INFO", "Loading image to canvas that has been destroyed"); });
}); });
#endif #endif
}); });
@ -1492,8 +1491,6 @@ void Toolbar::performance_metrics() {
void Toolbar::player_list() { void Toolbar::player_list() {
auto& gui = main.g.gui; auto& gui = main.g.gui;
auto& io = gui.io;
center_obstructing_window_gui("player client list", CLAY_SIZING_FIT(500), CLAY_SIZING_FIT(0), [&] { center_obstructing_window_gui("player client list", CLAY_SIZING_FIT(500), CLAY_SIZING_FIT(0), [&] {
gui.new_id("client list", [&] { gui.new_id("client list", [&] {
@ -1564,7 +1561,7 @@ void Toolbar::open_world_file(bool isClient, const std::string& netSource, const
}, &uploadData); }, &uploadData);
#else #else
open_file_selector("Open", {{"InfiniPaint Canvas", World::FILE_EXTENSION}, {"Any File", "*"}}, [&, isClient = isClient, netSource = netSource, serverLocalID2 = serverLocalID2](const std::filesystem::path& p, const auto& e) { open_file_selector("Open", {{"InfiniPaint Canvas", World::FILE_EXTENSION}, {"Any File", "*"}}, [&, isClient = isClient, netSource = netSource, serverLocalID2 = serverLocalID2](const std::filesystem::path& p, const auto& e) {
CustomEvents::emit_open_infinipaint_file_event({ CustomEvents::emit_event<CustomEvents::OpenInfiniPaintFileEvent>({
.isClient = isClient, .isClient = isClient,
.filePathSource = p, .filePathSource = p,
.netSource = netSource, .netSource = netSource,
@ -1600,7 +1597,6 @@ void Toolbar::center_obstructing_window_gui(const char* id, Clay_SizingAxis x, C
void Toolbar::text_button_wide(const char* id, const char* str, const std::function<void()>& onClick) { void Toolbar::text_button_wide(const char* id, const char* str, const std::function<void()>& onClick) {
auto& gui = main.g.gui; auto& gui = main.g.gui;
auto& io = gui.io;
text_button(gui, id, str, { text_button(gui, id, str, {
.wide = true, .wide = true,
@ -1610,7 +1606,6 @@ void Toolbar::text_button_wide(const char* id, const char* str, const std::funct
void Toolbar::options_menu() { void Toolbar::options_menu() {
auto& gui = main.g.gui; auto& gui = main.g.gui;
auto& io = gui.io;
switch(optionsMenuType) { switch(optionsMenuType) {
case HOST_MENU: { case HOST_MENU: {
@ -1641,7 +1636,7 @@ void Toolbar::options_menu() {
else if(serverToConnectTo.substr(0, NetLibrary::GLOBALID_LEN) == NetLibrary::get_global_id()) else if(serverToConnectTo.substr(0, NetLibrary::GLOBALID_LEN) == NetLibrary::get_global_id())
Logger::get().log("USERINFO", "Connect issue: Can't connect to your own address"); Logger::get().log("USERINFO", "Connect issue: Can't connect to your own address");
else { else {
CustomEvents::emit_open_infinipaint_file_event({ CustomEvents::emit_event<CustomEvents::OpenInfiniPaintFileEvent>({
.isClient = true, .isClient = true,
.netSource = serverToConnectTo .netSource = serverToConnectTo
}); });

View file

@ -38,7 +38,7 @@
#include <EmscriptenHelpers/emscripten_browser_file.h> #include <EmscriptenHelpers/emscripten_browser_file.h>
#endif #endif
World::World(MainProgram& initMain, const CustomEvents::OpenInfiniPaintFileEventData& worldInfo): World::World(MainProgram& initMain, const CustomEvents::OpenInfiniPaintFileEvent& worldInfo):
netObjMan(!worldInfo.isClient), netObjMan(!worldInfo.isClient),
main(initMain), main(initMain),
undo(*this), undo(*this),
@ -250,7 +250,12 @@ void World::on_tab_out() {
rMan.clear_display_cache(); rMan.clear_display_cache();
} }
void World::input_paste_callback(const CustomEvents::PasteEventData& paste) { void World::input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile) {
if(!clientStillConnecting)
drawProg.input_add_file_to_canvas_callback(addFile);
}
void World::input_paste_callback(const CustomEvents::PasteEvent& paste) {
if(!clientStillConnecting) if(!clientStillConnecting)
drawProg.input_paste_callback(paste); drawProg.input_paste_callback(paste);
} }

View file

@ -25,7 +25,7 @@ class World {
static constexpr std::string FILE_EXTENSION = "infpnt"; static constexpr std::string FILE_EXTENSION = "infpnt";
static constexpr size_t CHAT_SIZE = 10; static constexpr size_t CHAT_SIZE = 10;
World(MainProgram& initMain, const CustomEvents::OpenInfiniPaintFileEventData& worldInfo); World(MainProgram& initMain, const CustomEvents::OpenInfiniPaintFileEvent& worldInfo);
// NOTE: Keep at the very beginning so that it's destroyed last // NOTE: Keep at the very beginning so that it's destroyed last
NetworkingObjects::NetObjManager netObjMan; NetworkingObjects::NetObjManager netObjMan;
@ -89,7 +89,8 @@ class World {
std::shared_ptr<NetServer> netServer; std::shared_ptr<NetServer> netServer;
std::shared_ptr<NetClient> netClient; std::shared_ptr<NetClient> netClient;
void input_paste_callback(const CustomEvents::PasteEventData& paste); void input_add_file_to_canvas_callback(const CustomEvents::AddFileToCanvasEvent& addFile);
void input_paste_callback(const CustomEvents::PasteEvent& paste);
void input_drop_file_callback(const InputManager::DropCallbackArgs& drop); void input_drop_file_callback(const InputManager::DropCallbackArgs& drop);
void input_drop_text_callback(const InputManager::DropCallbackArgs& drop); void input_drop_text_callback(const InputManager::DropCallbackArgs& drop);
void input_text_key_callback(const InputManager::KeyCallbackArgs& key); void input_text_key_callback(const InputManager::KeyCallbackArgs& key);

View file

@ -794,10 +794,18 @@ SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {
case SDL_EVENT_SCREEN_KEYBOARD_HIDDEN: case SDL_EVENT_SCREEN_KEYBOARD_HIDDEN:
break; break;
default: { default: {
if(event->type == CustomEvents::PASTE_EVENT) if(event->type == CustomEvents::PasteEvent::EVENT_NUM) {
mS.m->input.backend_paste_event(); mS.m->input_paste_callback(CustomEvents::get_event<CustomEvents::PasteEvent>());
else if(event->type == CustomEvents::OPEN_INFINIPAINT_FILE_EVENT) CustomEvents::pop_event();
mS.m->input.backend_open_infinipaint_file_event(); }
else if(event->type == CustomEvents::OpenInfiniPaintFileEvent::EVENT_NUM) {
mS.m->input_open_infinipaint_file_callback(CustomEvents::get_event<CustomEvents::OpenInfiniPaintFileEvent>());
CustomEvents::pop_event();
}
else if(event->type == CustomEvents::AddFileToCanvasEvent::EVENT_NUM) {
mS.m->input_add_file_to_canvas_callback(CustomEvents::get_event<CustomEvents::AddFileToCanvasEvent>());
CustomEvents::pop_event();
}
break; break;
} }
} }