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

Restructure how tool data is stored

Browse source
This commit is contained in:
Yousef Khadadeh 2025-08-02 20:10:33 +03:00
parent d07eaf4207
commit 90374da228
37 changed files with 790 additions and 801 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/DrawingProgram/BrushTool.cpp
View file

@ -1,12 +1,10 @@
#include "BrushTool.hpp"
#include <Helpers/ConvertVec.hpp>
#include "../TimePoint.hpp"
#include "../DrawComponents/DrawBrushStroke.hpp"
#include "../GUIStuff/GUIManager.hpp"
#include "../SharedTypes.hpp"
#include "../Server/CommandList.hpp"
#include "DrawingProgram.hpp"
#include "../MainProgram.hpp"
#include "DrawingProgramToolBase.hpp"
#include <chrono>
#define VEL_SMOOTH_MIN 0.6
@ -14,8 +12,11 @@
#define MINIMUM_DISTANCE_TO_NEXT_POINT 0.002f
BrushTool::BrushTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType BrushTool::get_type() {
return DrawingProgramToolType::BRUSH;
}
void BrushTool::reset_tool() {

16
src/DrawingProgram/BrushTool.hpp
View file

@ -1,5 +1,6 @@
#pragma once
#include "../SharedTypes.hpp"
#include "DrawingProgramToolBase.hpp"
#include <Helpers/Hashes.hpp>
#include <include/core/SkPath.h>
#include <include/core/SkVertices.h>
@ -12,14 +13,15 @@ class DrawingProgram;
class DrawBrushStroke;
struct DrawData;
class BrushTool {
class BrushTool : public DrawingProgramToolBase {
public:
BrushTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void reset_tool();
void draw(SkCanvas* canvas, const DrawData& drawData);
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void reset_tool() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
private:
void commit_stroke();
bool extensive_point_checking_back(const Vector2f& newPoint);
@ -42,6 +44,4 @@ class BrushTool {
bool midwayInterpolation = true;
Vector2f prevPointUnaltered = {0, 0};
} controls;
DrawingProgram& drawP;
};

221
src/DrawingProgram/DrawingProgram.cpp
View file

@ -1,7 +1,5 @@
#include "DrawingProgram.hpp"
#include "Helpers/Hashes.hpp"
#include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include "DrawingProgramToolBase.hpp"
#include <include/core/SkPaint.h>
#include <include/core/SkVertices.h>
#include "../DrawCamera.hpp"
@ -11,11 +9,10 @@
#include "../InputManager.hpp"
#include "../SharedTypes.hpp"
#include "../Server/CommandList.hpp"
#include <memory>
#include <optional>
#include <ranges>
#include <Helpers/ConvertVec.hpp>
#include <cereal/types/vector.hpp>
#include <iostream>
#include "../DrawComponents/DrawImage.hpp"
#include <include/core/SkImage.h>
#include <include/core/SkSurface.h>
@ -29,23 +26,16 @@
#include <include/effects/SkDashPathEffect.h>
#include <chrono>
#include "EraserTool.hpp"
DrawingProgram::DrawingProgram(World& initWorld):
world(initWorld),
compCache(*this),
components([&](){ return world.get_new_id(); }),
brushTool(*this),
eraserTool(*this),
rectSelectTool(*this),
lassoSelectTool(*this),
rectDrawTool(*this),
ellipseDrawTool(*this),
textBoxTool(*this),
inkDropperTool(*this),
screenshotTool(*this),
editTool(*this),
imageTool(*this),
selection(*this)
{
drawTool = DrawingProgramToolBase::allocate_tool_type(*this, controls.selectedTool);
components.updateCallback = [&]() {
if(&world == world.main.world.get())
world.main.drawProgCache.refresh = true;
@ -199,16 +189,16 @@ void DrawingProgram::toolbar_gui() {
.border = {.color = convert_vec4<Clay_Color>(t.io->theme->backColor2), .width = CLAY_BORDER_OUTSIDE(t.io->theme->windowBorders1)}
}) {
t.gui.obstructing_window();
if(t.gui.svg_icon_button("Brush Toolbar Button", "data/icons/brush.svg", controls.selectedTool == TOOL_BRUSH)) { controls.selectedTool = TOOL_BRUSH; }
if(t.gui.svg_icon_button("Eraser Toolbar Button", "data/icons/eraser.svg", controls.selectedTool == TOOL_ERASER)) { controls.selectedTool = TOOL_ERASER; }
if(t.gui.svg_icon_button("Text Toolbar Button", "data/icons/text.svg", controls.selectedTool == TOOL_TEXTBOX)) { controls.selectedTool = TOOL_TEXTBOX; }
if(t.gui.svg_icon_button("Ellipse Toolbar Button", "data/icons/circle.svg", controls.selectedTool == TOOL_ELLIPSE)) { controls.selectedTool = TOOL_ELLIPSE; }
if(t.gui.svg_icon_button("Rect Toolbar Button", "data/icons/rectangle.svg", controls.selectedTool == TOOL_RECTANGLE)) { controls.selectedTool = TOOL_RECTANGLE; }
if(t.gui.svg_icon_button("RectSelect Toolbar Button", "data/icons/rectselect.svg", controls.selectedTool == TOOL_RECTSELECT)) { controls.selectedTool = TOOL_RECTSELECT; }
if(t.gui.svg_icon_button("LassoSelect Toolbar Button", "data/icons/close.svg", controls.selectedTool == TOOL_LASSOSELECT)) { controls.selectedTool = TOOL_LASSOSELECT; }
if(t.gui.svg_icon_button("Edit Toolbar Button", "data/icons/cursor.svg", controls.selectedTool == TOOL_EDIT)) { controls.selectedTool = TOOL_EDIT; }
if(t.gui.svg_icon_button("Inkdropper Toolbar Button", "data/icons/eyedropper.svg", controls.selectedTool == TOOL_INKDROPPER)) { controls.selectedTool = TOOL_INKDROPPER; }
if(t.gui.svg_icon_button("Screenshot Toolbar Button", "data/icons/camera.svg", controls.selectedTool == TOOL_SCREENSHOT)) { controls.selectedTool = TOOL_SCREENSHOT; }
if(t.gui.svg_icon_button("Brush Toolbar Button", "data/icons/brush.svg", controls.selectedTool == DrawingProgramToolType::BRUSH)) { controls.selectedTool = DrawingProgramToolType::BRUSH; }
if(t.gui.svg_icon_button("Eraser Toolbar Button", "data/icons/eraser.svg", controls.selectedTool == DrawingProgramToolType::ERASER)) { controls.selectedTool = DrawingProgramToolType::ERASER; }
if(t.gui.svg_icon_button("Text Toolbar Button", "data/icons/text.svg", controls.selectedTool == DrawingProgramToolType::TEXTBOX)) { controls.selectedTool = DrawingProgramToolType::TEXTBOX; }
if(t.gui.svg_icon_button("Ellipse Toolbar Button", "data/icons/circle.svg", controls.selectedTool == DrawingProgramToolType::ELLIPSE)) { controls.selectedTool = DrawingProgramToolType::ELLIPSE; }
if(t.gui.svg_icon_button("Rect Toolbar Button", "data/icons/rectangle.svg", controls.selectedTool == DrawingProgramToolType::RECTANGLE)) { controls.selectedTool = DrawingProgramToolType::RECTANGLE; }
if(t.gui.svg_icon_button("RectSelect Toolbar Button", "data/icons/rectselect.svg", controls.selectedTool == DrawingProgramToolType::RECTSELECT)) { controls.selectedTool = DrawingProgramToolType::RECTSELECT; }
if(t.gui.svg_icon_button("LassoSelect Toolbar Button", "data/icons/close.svg", controls.selectedTool == DrawingProgramToolType::LASSOSELECT)) { controls.selectedTool = DrawingProgramToolType::LASSOSELECT; }
if(t.gui.svg_icon_button("Edit Toolbar Button", "data/icons/cursor.svg", controls.selectedTool == DrawingProgramToolType::EDIT)) { controls.selectedTool = DrawingProgramToolType::EDIT; }
if(t.gui.svg_icon_button("Inkdropper Toolbar Button", "data/icons/eyedropper.svg", controls.selectedTool == DrawingProgramToolType::INKDROPPER)) { controls.selectedTool = DrawingProgramToolType::INKDROPPER; }
if(t.gui.svg_icon_button("Screenshot Toolbar Button", "data/icons/camera.svg", controls.selectedTool == DrawingProgramToolType::SCREENSHOT)) { controls.selectedTool = DrawingProgramToolType::SCREENSHOT; }
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Foreground Color", &controls.foregroundColor, &controls.foregroundColor == t.colorLeft)) {
t.color_selector_left(&controls.foregroundColor == t.colorLeft ? nullptr : &controls.foregroundColor);
@ -223,7 +213,7 @@ void DrawingProgram::toolbar_gui() {
void DrawingProgram::tool_options_gui() {
Toolbar& t = world.main.toolbar;
float minGUIWidth = controls.selectedTool == TOOL_SCREENSHOT ? 300 : 200;
float minGUIWidth = controls.selectedTool == DrawingProgramToolType::SCREENSHOT ? 300 : 200;
CLAY({
.layout = {
.sizing = {.width = CLAY_SIZING_FIT(minGUIWidth), .height = CLAY_SIZING_FIT(0)},
@ -237,54 +227,24 @@ void DrawingProgram::tool_options_gui() {
.border = {.color = convert_vec4<Clay_Color>(t.io->theme->backColor2), .width = CLAY_BORDER_OUTSIDE(t.io->theme->windowBorders1)}
}) {
t.gui.obstructing_window();
switch(controls.selectedTool) {
case TOOL_BRUSH:
brushTool.gui_toolbox();
break;
case TOOL_ERASER:
eraserTool.gui_toolbox();
break;
case TOOL_LASSOSELECT:
lassoSelectTool.gui_toolbox();
break;
case TOOL_RECTSELECT:
rectSelectTool.gui_toolbox();
break;
case TOOL_RECTANGLE:
rectDrawTool.gui_toolbox();
break;
case TOOL_ELLIPSE:
ellipseDrawTool.gui_toolbox();
break;
case TOOL_TEXTBOX:
textBoxTool.gui_toolbox();
break;
case TOOL_INKDROPPER:
inkDropperTool.gui_toolbox();
break;
case TOOL_SCREENSHOT:
screenshotTool.gui_toolbox();
break;
case TOOL_EDIT:
editTool.gui_toolbox();
break;
}
drawTool->gui_toolbox();
}
}
void DrawingProgram::update() {
if(controls.selectedTool == TOOL_BRUSH && world.main.input.pen.isEraser && !temporaryEraser) {
controls.selectedTool = TOOL_ERASER;
if(controls.selectedTool == DrawingProgramToolType::BRUSH && world.main.input.pen.isEraser && !temporaryEraser) {
controls.selectedTool = DrawingProgramToolType::ERASER;
temporaryEraser = true;
}
else if(controls.selectedTool == TOOL_ERASER && !world.main.input.pen.isEraser && temporaryEraser) {
controls.selectedTool = TOOL_BRUSH;
else if(controls.selectedTool == DrawingProgramToolType::ERASER && !world.main.input.pen.isEraser && temporaryEraser) {
controls.selectedTool = DrawingProgramToolType::BRUSH;
temporaryEraser = false;
}
if(controls.selectedTool != controls.previousSelected) {
controls.previousSelected = controls.selectedTool;
reset_tools();
drawTool = DrawingProgramToolBase::allocate_tool_type(*this, controls.selectedTool);
controls.previousSelected = controls.selectedTool;
}
controls.cursorHoveringOverCanvas = !world.main.toolbar.io->hoverObstructed;
@ -317,56 +277,25 @@ void DrawingProgram::update() {
drag_drop_update();
if(world.main.input.key(InputManager::KEY_DRAW_TOOL_BRUSH).pressed)
controls.selectedTool = TOOL_BRUSH;
controls.selectedTool = DrawingProgramToolType::BRUSH;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_ERASER).pressed)
controls.selectedTool = TOOL_ERASER;
controls.selectedTool = DrawingProgramToolType::ERASER;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_RECTSELECT).pressed)
controls.selectedTool = TOOL_RECTSELECT;
controls.selectedTool = DrawingProgramToolType::RECTSELECT;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_RECTANGLE).pressed)
controls.selectedTool = TOOL_RECTANGLE;
controls.selectedTool = DrawingProgramToolType::RECTANGLE;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_ELLIPSE).pressed)
controls.selectedTool = TOOL_ELLIPSE;
controls.selectedTool = DrawingProgramToolType::ELLIPSE;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_TEXTBOX).pressed)
controls.selectedTool = TOOL_TEXTBOX;
controls.selectedTool = DrawingProgramToolType::TEXTBOX;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_INKDROPPER).pressed)
controls.selectedTool = TOOL_INKDROPPER;
controls.selectedTool = DrawingProgramToolType::INKDROPPER;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_SCREENSHOT).pressed)
controls.selectedTool = TOOL_SCREENSHOT;
controls.selectedTool = DrawingProgramToolType::SCREENSHOT;
else if(world.main.input.key(InputManager::KEY_DRAW_TOOL_EDIT).pressed)
controls.selectedTool = TOOL_EDIT;
controls.selectedTool = DrawingProgramToolType::EDIT;
switch(controls.selectedTool) {
case TOOL_BRUSH:
brushTool.tool_update();
break;
case TOOL_ERASER:
eraserTool.tool_update();
break;
case TOOL_LASSOSELECT:
lassoSelectTool.tool_update();
break;
case TOOL_RECTSELECT:
rectSelectTool.tool_update();
break;
case TOOL_RECTANGLE:
rectDrawTool.tool_update();
break;
case TOOL_ELLIPSE:
ellipseDrawTool.tool_update();
break;
case TOOL_TEXTBOX:
textBoxTool.tool_update();
break;
case TOOL_INKDROPPER:
inkDropperTool.tool_update();
break;
case TOOL_SCREENSHOT:
screenshotTool.tool_update();
break;
case TOOL_EDIT:
editTool.tool_update();
break;
};
drawTool->tool_update();
if(controls.leftClickReleased)
controls.leftClickReleased = false;
@ -376,38 +305,18 @@ void DrawingProgram::update() {
selection.update();
if(controls.selectedTool == TOOL_ERASER)
compCache.test_rebuild_dont_include_set_dont_include_nodes(components.client_list(), eraserTool.erasedComponents, eraserTool.erasedBVHNodes);
else if(controls.selectedTool == TOOL_RECTSELECT)
if(controls.selectedTool == DrawingProgramToolType::ERASER) {
EraserTool* eraserTool = static_cast<EraserTool*>(drawTool.get());
compCache.test_rebuild_dont_include_set_dont_include_nodes(components.client_list(), eraserTool->erasedComponents, eraserTool->erasedBVHNodes);
}
else if(controls.selectedTool == DrawingProgramToolType::RECTSELECT)
compCache.test_rebuild_dont_include_set(components.client_list(), selection.get_selected_set());
else
compCache.test_rebuild(components.client_list());
}
bool DrawingProgram::prevent_undo_or_redo() {
switch(controls.selectedTool) {
case TOOL_BRUSH:
return brushTool.prevent_undo_or_redo();
case TOOL_ERASER:
return eraserTool.prevent_undo_or_redo();
case TOOL_LASSOSELECT:
return lassoSelectTool.prevent_undo_or_redo();
case TOOL_RECTSELECT:
return rectSelectTool.prevent_undo_or_redo();
case TOOL_RECTANGLE:
return rectDrawTool.prevent_undo_or_redo();
case TOOL_ELLIPSE:
return ellipseDrawTool.prevent_undo_or_redo();
case TOOL_TEXTBOX:
return textBoxTool.prevent_undo_or_redo();
case TOOL_INKDROPPER:
return inkDropperTool.prevent_undo_or_redo();
case TOOL_SCREENSHOT:
return screenshotTool.prevent_undo_or_redo();
case TOOL_EDIT:
return editTool.prevent_undo_or_redo();
};
return false;
return drawTool->prevent_undo_or_redo();
}
SkPaint DrawingProgram::select_tool_line_paint() {
@ -425,9 +334,11 @@ SkPaint DrawingProgram::select_tool_line_paint() {
}
void DrawingProgram::force_rebuild_cache() {
if(controls.selectedTool == TOOL_ERASER)
compCache.test_rebuild_dont_include_set_dont_include_nodes(components.client_list(), eraserTool.erasedComponents, eraserTool.erasedBVHNodes, true);
else if(controls.selectedTool == TOOL_RECTSELECT)
if(controls.selectedTool == DrawingProgramToolType::ERASER) {
EraserTool* eraserTool = static_cast<EraserTool*>(drawTool.get());
compCache.test_rebuild_dont_include_set_dont_include_nodes(components.client_list(), eraserTool->erasedComponents, eraserTool->erasedBVHNodes, true);
}
else if(controls.selectedTool == DrawingProgramToolType::RECTSELECT)
compCache.test_rebuild_dont_include_set(components.client_list(), selection.get_selected_set(), true);
else
compCache.test_rebuild(components.client_list(), true);
@ -499,14 +410,7 @@ void DrawingProgram::add_file_to_canvas_by_data(const std::string& fileName, std
}
void DrawingProgram::reset_tools() {
lassoSelectTool.reset_tool();
rectSelectTool.reset_tool();
textBoxTool.reset_tool();
brushTool.reset_tool();
rectDrawTool.reset_tool();
ellipseDrawTool.reset_tool();
editTool.reset_tool();
eraserTool.reset_tool();
drawTool->reset_tool();
}
void DrawingProgram::initialize_draw_data(cereal::PortableBinaryInputArchive& a) {
@ -705,38 +609,7 @@ void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
}
}
switch(controls.selectedTool) {
case TOOL_BRUSH:
brushTool.draw(canvas, drawData);
break;
case TOOL_ERASER:
eraserTool.draw(canvas, drawData);
break;
case TOOL_LASSOSELECT:
lassoSelectTool.draw(canvas, drawData);
break;
case TOOL_RECTSELECT:
rectSelectTool.draw(canvas, drawData);
break;
case TOOL_RECTANGLE:
rectDrawTool.draw(canvas, drawData);
break;
case TOOL_ELLIPSE:
ellipseDrawTool.draw(canvas, drawData);
break;
case TOOL_TEXTBOX:
textBoxTool.draw(canvas, drawData);
break;
case TOOL_INKDROPPER:
inkDropperTool.draw(canvas, drawData);
break;
case TOOL_SCREENSHOT:
screenshotTool.draw(canvas, drawData);
break;
case TOOL_EDIT:
editTool.draw(canvas, drawData);
break;
}
drawTool->draw(canvas, drawData);
}
Vector4f* DrawingProgram::get_foreground_color_ptr() {

47
src/DrawingProgram/DrawingProgram.hpp
View file

@ -9,19 +9,9 @@
#include <Helpers/Hashes.hpp>
#include <list>
#include <Helpers/Random.hpp>
#include "BrushTool.hpp"
#include "EraserTool.hpp"
#include "RectSelectTool.hpp"
#include "LassoSelectTool.hpp"
#include "RectDrawTool.hpp"
#include "EllipseDrawTool.hpp"
#include "TextBoxTool.hpp"
#include "InkDropperTool.hpp"
#include "ScreenshotTool.hpp"
#include "EditTool.hpp"
#include "ImageTool.hpp"
#include "DrawingProgramSelection.hpp"
#include "../CollabList.hpp"
#include "DrawingProgramToolBase.hpp"
class World;
@ -87,45 +77,21 @@ class DrawingProgram {
SkPaint select_tool_line_paint();
BrushTool brushTool;
EraserTool eraserTool;
RectSelectTool rectSelectTool;
LassoSelectTool lassoSelectTool;
RectDrawTool rectDrawTool;
EllipseDrawTool ellipseDrawTool;
TextBoxTool textBoxTool;
InkDropperTool inkDropperTool;
ScreenshotTool screenshotTool;
EditTool editTool;
ImageTool imageTool;
std::unique_ptr<DrawingProgramToolBase> drawTool;
DrawingProgramSelection selection;
bool temporaryEraser = false;
enum Tool : int {
TOOL_BRUSH = 0,
TOOL_ERASER,
TOOL_LASSOSELECT,
TOOL_RECTSELECT,
TOOL_RECTANGLE,
TOOL_ELLIPSE,
TOOL_TEXTBOX,
TOOL_INKDROPPER,
TOOL_SCREENSHOT,
TOOL_EDIT
};
struct GlobalControls {
float relativeWidth = 15.0f;
Vector4f foregroundColor{0.9f, 0.9f, 0.9f, 1.0f};
Vector4f backgroundColor{0.0f, 0.0f, 0.0f, 1.0f};
int previousSelected = 0;
DrawingProgramToolType selectedTool = DrawingProgramToolType::BRUSH;
DrawingProgramToolType previousSelected = DrawingProgramToolType::BRUSH;
WorldVec previousMouseWorldPos = {0, 0};
WorldVec currentMouseWorldPos = {0, 0};
int selectedTool = 0;
bool leftClick = false;
bool leftClickHeld = false;
bool leftClickReleased = false;
@ -145,7 +111,10 @@ class DrawingProgram {
friend class TextBoxTool;
friend class ScreenshotTool;
friend class EditTool;
friend class ImageTool;
friend class ImageEditTool;
friend class RectDrawEditTool;
friend class EllipseDrawEditTool;
friend class TextBoxEditTool;
friend class DrawingProgramCache;
friend class DrawingProgramSelection;
friend class LassoSelectTool;

7
src/DrawingProgram/DrawingProgramEditToolBase.cpp Normal file
View file

@ -0,0 +1,7 @@
#include "DrawingProgramEditToolBase.hpp"
DrawingProgramEditToolBase::DrawingProgramEditToolBase(DrawingProgram& initDrawP):
drawP(initDrawP)
{}
DrawingProgramEditToolBase::~DrawingProgramEditToolBase() {}

19
src/DrawingProgram/DrawingProgramEditToolBase.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "../DrawComponents/DrawComponent.hpp"
class DrawingProgram;
class EditTool;
class DrawingProgramEditToolBase {
public:
DrawingProgramEditToolBase(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& a, std::any& prevData) = 0;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& a, std::any& prevData) = 0;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& a) = 0;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& a) = 0;
virtual ~DrawingProgramEditToolBase();
protected:
DrawingProgram& drawP;
};

6
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -325,9 +325,9 @@ void DrawingProgramSelection::update() {
void DrawingProgramSelection::paste_clipboard() {
auto& clipboard = drawP.world.main.clipboard;
drawP.reset_tools();
drawP.controls.selectedTool = DrawingProgram::TOOL_RECTSELECT;
drawP.controls.previousSelected = DrawingProgram::TOOL_RECTSELECT;
drawP.controls.selectedTool = DrawingProgramToolType::RECTSELECT;
uint64_t allPlacement = drawP.components.client_list().size();
std::vector<std::shared_ptr<DrawComponent>> placedComponents;
WorldVec mousePos = drawP.world.get_mouse_world_pos();

44
src/DrawingProgram/DrawingProgramToolBase.cpp Normal file
View file

@ -0,0 +1,44 @@
#include "DrawingProgramToolBase.hpp"
#include "BrushTool.hpp"
#include "EraserTool.hpp"
#include "RectSelectTool.hpp"
#include "LassoSelectTool.hpp"
#include "RectDrawTool.hpp"
#include "EllipseDrawTool.hpp"
#include "TextBoxTool.hpp"
#include "InkDropperTool.hpp"
#include "ScreenshotTool.hpp"
#include "EditTool.hpp"
DrawingProgramToolBase::DrawingProgramToolBase(DrawingProgram& initDrawP):
drawP(initDrawP)
{}
DrawingProgramToolBase::~DrawingProgramToolBase() {}
std::unique_ptr<DrawingProgramToolBase> DrawingProgramToolBase::allocate_tool_type(DrawingProgram& drawP, DrawingProgramToolType t) {
switch(t) {
case DrawingProgramToolType::BRUSH:
return std::make_unique<BrushTool>(drawP);
case DrawingProgramToolType::ERASER:
return std::make_unique<EraserTool>(drawP);
case DrawingProgramToolType::LASSOSELECT:
return std::make_unique<LassoSelectTool>(drawP);
case DrawingProgramToolType::RECTSELECT:
return std::make_unique<RectSelectTool>(drawP);
case DrawingProgramToolType::RECTANGLE:
return std::make_unique<RectDrawTool>(drawP);
case DrawingProgramToolType::ELLIPSE:
return std::make_unique<EllipseDrawTool>(drawP);
case DrawingProgramToolType::TEXTBOX:
return std::make_unique<TextBoxTool>(drawP);
case DrawingProgramToolType::INKDROPPER:
return std::make_unique<InkDropperTool>(drawP);
case DrawingProgramToolType::SCREENSHOT:
return std::make_unique<ScreenshotTool>(drawP);
case DrawingProgramToolType::EDIT:
return std::make_unique<EditTool>(drawP);
}
return nullptr;
}

33
src/DrawingProgram/DrawingProgramToolBase.hpp Normal file
View file

@ -0,0 +1,33 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
class DrawingProgram;
enum class DrawingProgramToolType : int {
BRUSH = 0,
ERASER,
LASSOSELECT,
RECTSELECT,
RECTANGLE,
ELLIPSE,
TEXTBOX,
INKDROPPER,
SCREENSHOT,
EDIT
};
class DrawingProgramToolBase {
public:
DrawingProgramToolBase(DrawingProgram& initDrawP);
virtual DrawingProgramToolType get_type() = 0;
virtual void gui_toolbox() = 0;
virtual void tool_update() = 0;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;
virtual void reset_tool() = 0;
virtual bool prevent_undo_or_redo() = 0;
virtual ~DrawingProgramToolBase();
static std::unique_ptr<DrawingProgramToolBase> allocate_tool_type(DrawingProgram& drawP, DrawingProgramToolType t);
protected:
DrawingProgram& drawP;
};

97
src/DrawingProgram/EditTool.cpp
View file

@ -1,57 +1,38 @@
#include "EditTool.hpp"
#include <chrono>
#include "DrawingProgram.hpp"
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include "Helpers/Serializers.hpp"
#include "../DrawComponents/DrawRectangle.hpp"
#include "../DrawComponents/DrawTextBox.hpp"
#include "../InputManager.hpp"
#include "../SharedTypes.hpp"
#include <cereal/types/vector.hpp>
#include <memory>
#include <ranges>
#include "TextBoxEditTool.hpp"
#include "RectDrawEditTool.hpp"
#include "ImageEditTool.hpp"
#include "EllipseDrawEditTool.hpp"
EditTool::EditTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType EditTool::get_type() {
return DrawingProgramToolType::EDIT;
}
void EditTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
if(controls.isEditing) {
std::shared_ptr<DrawComponent> a = controls.compToEdit.lock();
bool editHappened = false;
if(a) {
switch(a->get_type()) {
case DRAWCOMPONENT_TEXTBOX: {
editHappened = drawP.textBoxTool.edit_gui(std::static_pointer_cast<DrawTextBox>(a));
break;
}
case DRAWCOMPONENT_ELLIPSE: {
editHappened = drawP.ellipseDrawTool.edit_gui(std::static_pointer_cast<DrawEllipse>(a));
break;
}
case DRAWCOMPONENT_RECTANGLE: {
editHappened = drawP.rectDrawTool.edit_gui(std::static_pointer_cast<DrawRectangle>(a));
break;
}
case DRAWCOMPONENT_IMAGE: {
editHappened = drawP.imageTool.edit_gui(std::static_pointer_cast<DrawImage>(a));
break;
}
default: {
break;
}
bool editHappened = controls.compEditTool->edit_gui(a);
if(editHappened) {
a->commit_update(drawP);
a->client_send_update(drawP);
}
}
if(editHappened) {
a->commit_update(drawP);
a->client_send_update(drawP);
}
}
else {
t.gui.push_id("edit tool");
@ -67,22 +48,7 @@ void EditTool::add_point_handle(const HandleData& handle) {
void EditTool::reset_tool() {
auto a = controls.compToEdit.lock();
if(a && a->collabListInfo.lock()) {
switch(a->get_type()) {
case DRAWCOMPONENT_TEXTBOX:
drawP.textBoxTool.commit_edit_updates(std::static_pointer_cast<DrawTextBox>(a), controls.prevData);
break;
case DRAWCOMPONENT_ELLIPSE:
drawP.ellipseDrawTool.commit_edit_updates(std::static_pointer_cast<DrawEllipse>(a), controls.prevData);
break;
case DRAWCOMPONENT_RECTANGLE:
drawP.rectDrawTool.commit_edit_updates(std::static_pointer_cast<DrawRectangle>(a), controls.prevData);
break;
case DRAWCOMPONENT_IMAGE:
drawP.imageTool.commit_edit_updates(std::static_pointer_cast<DrawImage>(a), controls.prevData);
break;
default:
break;
}
controls.compEditTool->commit_edit_updates(a, controls.prevData);
a->commit_update(drawP);
a->client_send_update(drawP);
}
@ -96,19 +62,19 @@ void EditTool::edit_start(const std::shared_ptr<DrawComponent>& comp) {
controls.isEditing = true;
switch(comp->get_type()) {
case DRAWCOMPONENT_TEXTBOX: {
drawP.textBoxTool.edit_start(std::static_pointer_cast<DrawTextBox>(comp), controls.prevData);
controls.compEditTool = std::make_unique<TextBoxEditTool>(drawP);
break;
}
case DRAWCOMPONENT_ELLIPSE: {
drawP.ellipseDrawTool.edit_start(std::static_pointer_cast<DrawEllipse>(comp), controls.prevData);
controls.compEditTool = std::make_unique<EllipseDrawEditTool>(drawP);
break;
}
case DRAWCOMPONENT_RECTANGLE: {
drawP.rectDrawTool.edit_start(std::static_pointer_cast<DrawRectangle>(comp), controls.prevData);
controls.compEditTool = std::make_unique<RectDrawEditTool>(drawP);
break;
}
case DRAWCOMPONENT_IMAGE: {
drawP.imageTool.edit_start(std::static_pointer_cast<DrawImage>(comp), controls.prevData);
controls.compEditTool = std::make_unique<ImageEditTool>(drawP);
break;
}
default: {
@ -118,6 +84,7 @@ void EditTool::edit_start(const std::shared_ptr<DrawComponent>& comp) {
}
if(controls.isEditing) {
controls.compToEdit = comp;
controls.compEditTool->edit_start(*this, comp, controls.prevData);
comp->lastUpdateTime = std::chrono::steady_clock::now();
}
}
@ -188,29 +155,7 @@ void EditTool::tool_update() {
a->lastUpdateTime = std::chrono::steady_clock::now();
bool shouldNotReset;
switch(a->get_type()) {
case DRAWCOMPONENT_TEXTBOX: {
shouldNotReset = drawP.textBoxTool.edit_update(std::static_pointer_cast<DrawTextBox>(a));
break;
}
case DRAWCOMPONENT_ELLIPSE: {
shouldNotReset = drawP.ellipseDrawTool.edit_update(std::static_pointer_cast<DrawEllipse>(a));
break;
}
case DRAWCOMPONENT_RECTANGLE: {
shouldNotReset = drawP.rectDrawTool.edit_update(std::static_pointer_cast<DrawRectangle>(a));
break;
}
case DRAWCOMPONENT_IMAGE: {
shouldNotReset = drawP.imageTool.edit_update(std::static_pointer_cast<DrawImage>(a));
break;
}
default: {
shouldNotReset = false;
break;
}
}
bool shouldNotReset = controls.compEditTool->edit_update(a);
if(!shouldNotReset || clickedAway)
reset_tool();
}

22
src/DrawingProgram/EditTool.hpp
View file

@ -1,13 +1,13 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "../DrawComponents/DrawEllipse.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
#include "DrawingProgramEditToolBase.hpp"
class DrawingProgram;
class EditTool {
class EditTool : public DrawingProgramToolBase {
public:
struct HandleData {
Vector2f* p;
@ -16,22 +16,22 @@ class EditTool {
};
EditTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void reset_tool();
void draw(SkCanvas* canvas, const DrawData& drawData);
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void reset_tool() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
void add_point_handle(const HandleData& handle);
void edit_start(const std::shared_ptr<DrawComponent>& comp);
bool prevent_undo_or_redo();
struct EditControls {
std::unique_ptr<DrawingProgramEditToolBase> compEditTool;
std::vector<HandleData> pointHandles;
std::weak_ptr<DrawComponent> compToEdit;
bool isEditing = false;
HandleData* pointDragging = nullptr;
std::any prevData;
} controls;
private:
DrawingProgram& drawP;
};

82
src/DrawingProgram/EllipseDrawEditTool.cpp Normal file
View file

@ -0,0 +1,82 @@
#include "EllipseDrawEditTool.hpp"
#include "DrawingProgram.hpp"
#include "../World.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include <cereal/types/vector.hpp>
#include <memory>
#include "EditTool.hpp"
EllipseDrawEditTool::EllipseDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool EllipseDrawEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
auto a = std::static_pointer_cast<DrawEllipse>(comp);
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool ellipse");
t.gui.text_label_centered("Edit Ellipse");
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor);
}
t.gui.text_label("Fill Color");
});
}
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor);
}
t.gui.text_label("Outline Color");
});
}
t.gui.pop_id();
bool editHappened = a->d != oldData;
oldData = a->d;
return editHappened;
}
void EllipseDrawEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
auto a = std::static_pointer_cast<DrawEllipse>(comp);
prevData = a->d;
editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
void EllipseDrawEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
auto a = std::static_pointer_cast<DrawEllipse>(comp);
DrawEllipse::Data pData = std::any_cast<DrawEllipse::Data>(prevData);
DrawEllipse::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
bool EllipseDrawEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) {
return true;
}

20
src/DrawingProgram/EllipseDrawEditTool.hpp Normal file
View file

@ -0,0 +1,20 @@
#pragma once
#include "DrawingProgramEditToolBase.hpp"
#include "../DrawComponents/DrawEllipse.hpp"
#include <any>
#include <Helpers/SCollision.hpp>
class DrawingProgram;
class EllipseDrawEditTool : public DrawingProgramEditToolBase {
public:
EllipseDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override;
private:
void commit();
DrawEllipse::Data oldData;
};

72
src/DrawingProgram/EllipseDrawTool.cpp
View file

@ -4,6 +4,7 @@
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "Helpers/SCollision.hpp"
#include "Helpers/Serializers.hpp"
#include "../InputManager.hpp"
@ -11,8 +12,11 @@
#include <cereal/types/vector.hpp>
EllipseDrawTool::EllipseDrawTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType EllipseDrawTool::get_type() {
return DrawingProgramToolType::ELLIPSE;
}
void EllipseDrawTool::gui_toolbox() {
@ -27,75 +31,11 @@ void EllipseDrawTool::gui_toolbox() {
t.gui.pop_id();
}
bool EllipseDrawTool::edit_gui(const std::shared_ptr<DrawEllipse>& a) {
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool ellipse");
t.gui.text_label_centered("Edit Ellipse");
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor);
}
t.gui.text_label("Fill Color");
});
}
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor);
}
t.gui.text_label("Outline Color");
});
}
t.gui.pop_id();
bool editHappened = a->d != controls.oldData;
controls.oldData = a->d;
return editHappened;
}
void EllipseDrawTool::edit_start(const std::shared_ptr<DrawEllipse>& a, std::any& prevData) {
prevData = a->d;
drawP.editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
drawP.editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
void EllipseDrawTool::commit_edit_updates(const std::shared_ptr<DrawEllipse>& a, std::any& prevData) {
DrawEllipse::Data pData = std::any_cast<DrawEllipse::Data>(prevData);
DrawEllipse::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
void EllipseDrawTool::reset_tool() {
commit();
controls.drawStage = 0;
}
bool EllipseDrawTool::edit_update(const std::shared_ptr<DrawEllipse>& a) {
return true;
}
void EllipseDrawTool::tool_update() {
switch(controls.drawStage) {
case 0: {

25
src/DrawingProgram/EllipseDrawTool.hpp
View file

@ -1,36 +1,27 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "../DrawComponents/DrawEllipse.hpp"
#include <any>
#include <Helpers/SCollision.hpp>
class DrawingProgram;
class EllipseDrawTool {
class EllipseDrawTool : public DrawingProgramToolBase {
public:
EllipseDrawTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void reset_tool();
void draw(SkCanvas* canvas, const DrawData& drawData);
void edit_start(const std::shared_ptr<DrawEllipse>& a, std::any& prevData);
void commit_edit_updates(const std::shared_ptr<DrawEllipse>& a, std::any& prevData);
bool edit_update(const std::shared_ptr<DrawEllipse>& a);
bool edit_gui(const std::shared_ptr<DrawEllipse>& a);
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void reset_tool() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
private:
void commit();
struct EllipseDrawControls {
DrawEllipse::Data oldData;
Vector2f startAt;
int fillStrokeMode = 1;
int drawStage = 0;
std::shared_ptr<DrawEllipse> intermediateItem;
} controls;
DrawingProgram& drawP;
};

7
src/DrawingProgram/EraserTool.cpp
View file

@ -4,8 +4,11 @@
#include "../DrawData.hpp"
EraserTool::EraserTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType EraserTool::get_type() {
return DrawingProgramToolType::ERASER;
}
void EraserTool::gui_toolbox() {

18
src/DrawingProgram/EraserTool.hpp
View file

@ -2,22 +2,20 @@
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "../DrawComponents/DrawComponent.hpp"
#include "DrawingProgramToolBase.hpp"
class DrawingProgram;
class EraserTool {
class EraserTool : public DrawingProgramToolBase {
public:
EraserTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void reset_tool();
void draw(SkCanvas* canvas, const DrawData& drawData);
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void reset_tool() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
std::unordered_set<CollabListType::ObjectInfoPtr> erasedComponents;
std::unordered_set<std::shared_ptr<DrawingProgramCacheBVHNode>> erasedBVHNodes;
private:
DrawingProgram& drawP;
};

17
src/DrawingProgram/ImageTool.cpp → src/DrawingProgram/ImageEditTool.cpp
View file

@ -1,29 +1,32 @@
#include "ImageTool.hpp"
#include "ImageEditTool.hpp"
#include "DrawingProgram.hpp"
#include "../DrawComponents/DrawImage.hpp"
#include "../World.hpp"
#include "../Toolbar.hpp"
#include "../MainProgram.hpp"
#include "../ResourceManager.hpp"
#include "DrawingProgramEditToolBase.hpp"
#include <fstream>
#ifdef __EMSCRIPTEN__
#include <EmscriptenHelpers/emscripten_browser_file.h>
#endif
ImageTool::ImageTool(DrawingProgram& initDrawP):
drawP(initDrawP)
ImageEditTool::ImageEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
void ImageTool::edit_start(const std::shared_ptr<DrawImage>& a, std::any& prevData) {
void ImageEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
}
void ImageTool::commit_edit_updates(const std::shared_ptr<DrawImage>& a, std::any& prevData) {
void ImageEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
}
bool ImageTool::edit_update(const std::shared_ptr<DrawImage>& a) {
bool ImageEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) {
return true;
}
bool ImageTool::edit_gui(const std::shared_ptr<DrawImage>& a) {
bool ImageEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
std::shared_ptr<DrawImage> a = std::static_pointer_cast<DrawImage>(comp);
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool image");
t.gui.text_label_centered("File Properties");

14
src/DrawingProgram/ImageEditTool.hpp Normal file
View file

@ -0,0 +1,14 @@
#pragma once
#include "DrawingProgramEditToolBase.hpp"
#include <any>
class DrawingProgram;
class ImageEditTool : public DrawingProgramEditToolBase {
public:
ImageEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override;
};

23
src/DrawingProgram/ImageTool.hpp
View file

@ -1,23 +0,0 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "../DrawComponents/DrawRectangle.hpp"
#include "../DrawComponents/DrawImage.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class ImageTool {
public:
ImageTool(DrawingProgram& initDrawP);
void edit_start(const std::shared_ptr<DrawImage>& a, std::any& prevData);
void commit_edit_updates(const std::shared_ptr<DrawImage>& a, std::any& prevData);
bool edit_update(const std::shared_ptr<DrawImage>& a);
bool edit_gui(const std::shared_ptr<DrawImage>& a);
private:
struct ImageControls {
} controls;
DrawingProgram& drawP;
};

10
src/DrawingProgram/InkDropperTool.cpp
View file

@ -3,6 +3,7 @@
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include <include/core/SkAlphaType.h>
#include <include/core/SkCanvas.h>
#include <include/core/SkColor.h>
@ -21,10 +22,14 @@
#include <Helpers/Logger.hpp>
InkDropperTool::InkDropperTool(DrawingProgram& initDrawP):
drawP(initDrawP)
DrawingProgramToolBase(initDrawP)
{
}
DrawingProgramToolType InkDropperTool::get_type() {
return DrawingProgramToolType::INKDROPPER;
}
void InkDropperTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("Color select tool");
@ -79,3 +84,6 @@ bool InkDropperTool::prevent_undo_or_redo() {
void InkDropperTool::draw(SkCanvas* canvas, const DrawData& drawData) {
}
void InkDropperTool::reset_tool() {
}

19
src/DrawingProgram/InkDropperTool.hpp
View file

@ -1,18 +1,15 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include <Helpers/SCollision.hpp>
#include "DrawingProgramToolBase.hpp"
class DrawingProgram;
class InkDropperTool {
class InkDropperTool : public DrawingProgramToolBase {
public:
InkDropperTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void draw(SkCanvas* canvas, const DrawData& drawData);
bool prevent_undo_or_redo();
private:
DrawingProgram& drawP;
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
virtual void reset_tool() override;
};

8
src/DrawingProgram/LassoSelectTool.cpp
View file

@ -2,6 +2,7 @@
#include "DrawingProgram.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include "../CoordSpaceHelper.hpp"
@ -29,8 +30,11 @@ struct nth<1, Vector2f> {
} // namespace mapbox
LassoSelectTool::LassoSelectTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType LassoSelectTool::get_type() {
return DrawingProgramToolType::LASSOSELECT;
}
void LassoSelectTool::gui_toolbox() {

16
src/DrawingProgram/LassoSelectTool.hpp
View file

@ -4,18 +4,20 @@
#include <Helpers/SCollision.hpp>
#include "../CoordSpaceHelper.hpp"
#include "../DrawComponents/DrawComponent.hpp"
#include "DrawingProgramToolBase.hpp"
class DrawingProgram;
class LassoSelectTool {
class LassoSelectTool : public DrawingProgramToolBase {
public:
LassoSelectTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void draw(SkCanvas* canvas, const DrawData& drawData);
void reset_tool();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void reset_tool() override;
virtual bool prevent_undo_or_redo() override;
bool prevent_undo_or_redo();
private:
struct LassoSelectControls {
int selectionMode = 0;
@ -24,6 +26,4 @@ class LassoSelectTool {
std::vector<Vector2f> lassoPoints;
} controls;
DrawingProgram& drawP;
};

79
src/DrawingProgram/RectDrawEditTool.cpp Normal file
View file

@ -0,0 +1,79 @@
#include "RectDrawEditTool.hpp"
#include "DrawingProgram.hpp"
#include "../World.hpp"
#include "../MainProgram.hpp"
#include <memory>
#include "EditTool.hpp"
RectDrawEditTool::RectDrawEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool RectDrawEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(comp);
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool rectangle");
t.gui.text_label_centered("Edit Rectangle");
t.gui.slider_scalar_field("relradiuswidth", "Corner Radius", &a->d.cornerRadius, 0.0f, 40.0f);
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor);
}
t.gui.text_label("Fill Color");
});
}
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor);
}
t.gui.text_label("Outline Color");
});
}
t.gui.pop_id();
bool editHappened = a->d != oldData;
oldData = a->d;
return editHappened;
}
void RectDrawEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(comp);
prevData = a->d;
editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
void RectDrawEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
std::shared_ptr<DrawRectangle> a = std::static_pointer_cast<DrawRectangle>(comp);
DrawRectangle::Data pData = std::any_cast<DrawRectangle::Data>(prevData);
DrawRectangle::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
bool RectDrawEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) {
return true;
}

18
src/DrawingProgram/RectDrawEditTool.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "DrawingProgramEditToolBase.hpp"
#include "../DrawComponents/DrawRectangle.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class RectDrawEditTool : public DrawingProgramEditToolBase {
public:
RectDrawEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& comp) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& comp) override;
private:
DrawRectangle::Data oldData;
};

76
src/DrawingProgram/RectDrawTool.cpp
View file

@ -1,17 +1,18 @@
#include "RectDrawTool.hpp"
#include "DrawingProgram.hpp"
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "Helpers/SCollision.hpp"
#include "Helpers/Serializers.hpp"
#include "../SharedTypes.hpp"
#include "DrawingProgramToolBase.hpp"
#include <cereal/types/vector.hpp>
RectDrawTool::RectDrawTool(DrawingProgram& initDrawP):
drawP(initDrawP)
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType RectDrawTool::get_type() {
return DrawingProgramToolType::RECTANGLE;
}
void RectDrawTool::gui_toolbox() {
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("rect draw tool");
@ -25,76 +26,11 @@ void RectDrawTool::gui_toolbox() {
t.gui.pop_id();
}
bool RectDrawTool::edit_gui(const std::shared_ptr<DrawRectangle>& a) {
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool rectangle");
t.gui.text_label_centered("Edit Rectangle");
t.gui.slider_scalar_field("relradiuswidth", "Corner Radius", &a->d.cornerRadius, 0.0f, 40.0f);
if(t.gui.radio_button_field("fillonly", "Fill only", a->d.fillStrokeMode == 0)) a->d.fillStrokeMode = 0;
if(t.gui.radio_button_field("outlineonly", "Outline only", a->d.fillStrokeMode == 1)) a->d.fillStrokeMode = 1;
if(t.gui.radio_button_field("filloutline", "Fill and Outline", a->d.fillStrokeMode == 2)) a->d.fillStrokeMode = 2;
if(a->d.fillStrokeMode == 0 || a->d.fillStrokeMode == 2) {
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Fill Color", &a->d.fillColor, &a->d.fillColor == t.colorRight))
t.color_selector_right(&a->d.fillColor == t.colorRight ? nullptr : &a->d.fillColor);
}
t.gui.text_label("Fill Color");
});
}
if(a->d.fillStrokeMode == 1 || a->d.fillStrokeMode == 2) {
t.gui.slider_scalar_field("relstrokewidth", "Outline Size", &a->d.strokeWidth, 3.0f, 40.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Outline Color", &a->d.strokeColor, &a->d.strokeColor == t.colorRight))
t.color_selector_right(&a->d.strokeColor == t.colorRight ? nullptr : &a->d.strokeColor);
}
t.gui.text_label("Outline Color");
});
}
t.gui.pop_id();
bool editHappened = a->d != controls.oldData;
controls.oldData = a->d;
return editHappened;
}
void RectDrawTool::reset_tool() {
commit_rectangle();
controls.drawStage = 0;
}
void RectDrawTool::edit_start(const std::shared_ptr<DrawRectangle>& a, std::any& prevData) {
prevData = a->d;
drawP.editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
drawP.editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
void RectDrawTool::commit_edit_updates(const std::shared_ptr<DrawRectangle>& a, std::any& prevData) {
DrawRectangle::Data pData = std::any_cast<DrawRectangle::Data>(prevData);
DrawRectangle::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
bool RectDrawTool::edit_update(const std::shared_ptr<DrawRectangle>& a) {
return true;
}
void RectDrawTool::tool_update() {
switch(controls.drawStage) {
case 0: {

25
src/DrawingProgram/RectDrawTool.hpp
View file

@ -1,37 +1,28 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "../DrawComponents/DrawRectangle.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class RectDrawTool {
class RectDrawTool : public DrawingProgramToolBase {
public:
RectDrawTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void reset_tool();
void draw(SkCanvas* canvas, const DrawData& drawData);
void edit_start(const std::shared_ptr<DrawRectangle>& a, std::any& prevData);
void commit_edit_updates(const std::shared_ptr<DrawRectangle>& a, std::any& prevData);
bool edit_update(const std::shared_ptr<DrawRectangle>& a);
bool edit_gui(const std::shared_ptr<DrawRectangle>& a);
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void reset_tool() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual bool prevent_undo_or_redo() override;
private:
void commit_rectangle();
struct RectDrawControls {
DrawRectangle::Data oldData;
Vector2f startAt;
float relativeRadiusWidth = 10.0f;
int fillStrokeMode = 1;
int drawStage = 0;
std::shared_ptr<DrawRectangle> intermediateItem;
} controls;
DrawingProgram& drawP;
};

7
src/DrawingProgram/RectSelectTool.cpp
View file

@ -2,15 +2,20 @@
#include "DrawingProgram.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include "../CoordSpaceHelper.hpp"
RectSelectTool::RectSelectTool(DrawingProgram& initDrawP):
drawP(initDrawP)
DrawingProgramToolBase(initDrawP)
{
}
DrawingProgramToolType RectSelectTool::get_type() {
return DrawingProgramToolType::RECTSELECT;
}
void RectSelectTool::gui_toolbox() {
drawP.world.main.toolbar.gui.text_label_centered("Rectangle Select");
}

21
src/DrawingProgram/RectSelectTool.hpp
View file

@ -1,31 +1,26 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include <Helpers/SCollision.hpp>
#include "../CoordSpaceHelper.hpp"
#include "../DrawComponents/DrawComponent.hpp"
class DrawingProgram;
class RectSelectTool {
class RectSelectTool : public DrawingProgramToolBase {
public:
RectSelectTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void draw(SkCanvas* canvas, const DrawData& drawData);
void reset_tool();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void reset_tool() override;
virtual bool prevent_undo_or_redo() override;
bool prevent_undo_or_redo();
private:
struct RectSelectControls {
int selectionMode = 0;
CoordSpaceHelper coords;
Vector2f selectStartAt;
std::array<Vector2f, 4> newT;
} controls;
DrawingProgram& drawP;
};

17
src/DrawingProgram/ScreenshotTool.cpp
View file

@ -3,6 +3,7 @@
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include "Helpers/SCollision.hpp"
#include <include/core/SkAlphaType.h>
#include <include/core/SkColorType.h>
@ -37,8 +38,11 @@
#define AA_LEVEL 4
ScreenshotTool::ScreenshotTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType ScreenshotTool::get_type() {
return DrawingProgramToolType::SCREENSHOT;
}
void ScreenshotTool::gui_toolbox() {
@ -74,10 +78,11 @@ void ScreenshotTool::gui_toolbox() {
setExtensionFilter = {"WebP", "webp"};
t.open_file_selector("Export", {setExtensionFilter}, [setExtensionFilter, w = make_weak_ptr(drawP.world.main.world)](const std::filesystem::path& p, const auto& e) {
auto world = w.lock();
if(world) {
world->drawProg.screenshotTool.controls.screenshotSavePath = force_extension_on_path(p, setExtensionFilter.extensions);
world->drawProg.screenshotTool.controls.setToTakeScreenshot = true;
}
// NOTE: CHANGE THIS
//if(world) {
// world->drawProg.screenshotTool.controls.screenshotSavePath = force_extension_on_path(p, setExtensionFilter.extensions);
// world->drawProg.screenshotTool.controls.setToTakeScreenshot = true;
//}
}, "screenshot", true);
#endif
}

18
src/DrawingProgram/ScreenshotTool.hpp
View file

@ -1,6 +1,5 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "DrawingProgramToolBase.hpp"
#include <Helpers/SCollision.hpp>
#include <filesystem>
#include "../InputManager.hpp"
@ -8,14 +7,15 @@
class DrawingProgram;
class ScreenshotTool {
class ScreenshotTool : public DrawingProgramToolBase {
public:
ScreenshotTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void draw(SkCanvas* canvas, const DrawData& drawData);
void reset_tool();
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void reset_tool() override;
virtual bool prevent_undo_or_redo() override;
private:
void commit_rect();
void take_screenshot(const std::filesystem::path& filePath);
@ -52,6 +52,4 @@ class ScreenshotTool {
std::atomic<bool> setToTakeScreenshot = false;
std::filesystem::path screenshotSavePath;
} controls;
DrawingProgram& drawP;
};

210
src/DrawingProgram/TextBoxEditTool.cpp Normal file
View file

@ -0,0 +1,210 @@
#include "TextBoxEditTool.hpp"
#include "DrawingProgram.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "Helpers/SCollision.hpp"
#include "../CollabTextBox/CollabTextBox.hpp"
#include <cereal/types/vector.hpp>
#include <memory>
#include "EditTool.hpp"
TextBoxEditTool::TextBoxEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool TextBoxEditTool::edit_gui(const std::shared_ptr<DrawComponent>& comp) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp);
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool text");
t.gui.text_label_centered("Edit Text");
t.gui.slider_scalar_field("Text Relative Size", "Text Size", &a->d.textSize, 5.0f, 100.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Text Color", &a->d.textColor, &a->d.textColor == t.colorRight))
t.color_selector_right(&a->d.textColor == t.colorRight ? nullptr : &a->d.textColor);
}
t.gui.text_label("Text Color");
});
t.gui.pop_id();
bool editHappened = a->d != oldData;
oldData = a->d;
return editHappened;
}
void TextBoxEditTool::commit_edit_updates(const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp);
a->d.editing = false;
DrawTextBox::Data pData = std::any_cast<DrawTextBox::Data>(prevData);
DrawTextBox::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->set_textbox_string(pData.currentText);
a->d.editing = false;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->set_textbox_string(cData.currentText);
a->d.editing = false;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
void TextBoxEditTool::edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& comp, std::any& prevData) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp);
auto& cur = a->d.cursor;
auto& textbox = a->textBox;
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = cur.selectionEndPos = textbox.getPosition(p);
prevData = a->d;
a->d.editing = true;
a->client_send_update(drawP);
editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
bool TextBoxEditTool::edit_update(const std::shared_ptr<DrawComponent>& comp) {
std::shared_ptr<DrawTextBox> a = std::static_pointer_cast<DrawTextBox>(comp);
SCollision::ColliderCollection<float> mousePointCollection;
mousePointCollection.circle.emplace_back(drawP.world.main.input.mouse.pos, 1.0f);
mousePointCollection.recalculate_bounds();
a->textBox.setWidth(std::abs(a->d.p2.x() - a->d.p1.x()));
InputManager& input = drawP.world.main.input;
auto& textbox = a->textBox;
auto& cur = a->d.cursor;
bool moved = false;
bool movedHeld = false;
bool collidesWithBox = false;
if(a->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection)) {
//drawP.world.main.input.cursorIcon = InputManager::SystemCursorType::TEXT;
collidesWithBox = true;
}
if(drawP.controls.leftClick) {
if(collidesWithBox) {
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = textbox.getPosition(p);
moved = true;
}
}
else if(drawP.controls.leftClickHeld) {
if(collidesWithBox) {
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = textbox.getPosition(p);
}
movedHeld = true;
}
if(input.key(InputManager::KEY_TEXT_LEFT).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kLeft, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_RIGHT).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kRight, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_UP).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kUp, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_DOWN).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kDown, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_HOME).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kHome, cur.selectionBeginPos);
moved = moved || input.key(InputManager::KEY_TEXT_DOWN).repeat || input.key(InputManager::KEY_TEXT_UP).repeat || input.key(InputManager::KEY_TEXT_RIGHT).repeat || input.key(InputManager::KEY_TEXT_LEFT).repeat || input.key(InputManager::KEY_TEXT_HOME).repeat;
if(moved && !input.key(InputManager::KEY_TEXT_SHIFT).held && !movedHeld)
cur.selectionEndPos = cur.selectionBeginPos;
if(moved || movedHeld)
update_textbox_network(a);
if(input.key(InputManager::KEY_TEXT_BACKSPACE).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
else
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.pos, textbox.move(CollabTextBox::Movement::kLeft, cur.pos));
}, a);
}
if(input.key(InputManager::KEY_TEXT_DELETE).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
else
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.pos, textbox.move(CollabTextBox::Movement::kRight, cur.pos));
}, a);
}
if(input.get_clipboard_paste_happened()) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
std::string clipboard = input.get_clipboard_str();
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.insert(cur.pos, clipboard);
}, a);
}
if(input.key(InputManager::KEY_TEXT_ENTER).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
cur.pos = textbox.insert(cur.pos, "\n");
cur.pos.fParagraphIndex++;
cur.pos.fTextByteIndex = 0;
cur.selectionBeginPos = cur.selectionEndPos = cur.pos;
}, a);
}
if(input.key(InputManager::KEY_TEXT_COPY).repeat) {
std::string clipboardData = textbox.copy(cur.selectionBeginPos, cur.selectionEndPos);
input.set_clipboard_str(clipboardData);
}
if(input.key(InputManager::KEY_TEXT_CUT).repeat) {
edit_text([&]() {
std::string clipboardData = textbox.copy(cur.selectionBeginPos, cur.selectionEndPos);
input.set_clipboard_str(clipboardData);
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
}, a);
}
if(input.key(InputManager::KEY_TEXT_SELECTALL).repeat) {
cur.selectionEndPos.fParagraphIndex = textbox.lineCount() == 0 ? 0 : textbox.lineCount() - 1;
cur.selectionEndPos.fTextByteIndex = textbox.line(cur.selectionEndPos.fParagraphIndex).size();
cur.pos = cur.selectionEndPos;
cur.selectionBeginPos.fTextByteIndex = 0;
cur.selectionBeginPos.fParagraphIndex = 0;
update_textbox_network(a);
}
if(!input.text.newInput.empty()) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.insert(cur.pos, input.text.newInput);
}, a);
}
input.text.set_accepting_input();
return true;
}
// Passing a function in, just in case we have to do something before editing the text
void TextBoxEditTool::edit_text(std::function<void()> toRun, const std::shared_ptr<DrawTextBox>& textBox) {
toRun();
textBox->update_contained_string(drawP);
update_textbox_network(textBox);
}
void TextBoxEditTool::update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox) {
textBox->client_send_update(drawP);
textBox->commit_update(drawP);
}

22
src/DrawingProgram/TextBoxEditTool.hpp Normal file
View file

@ -0,0 +1,22 @@
#pragma once
#include "../DrawComponents/DrawTextBox.hpp"
#include "DrawingProgramEditToolBase.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class TextBoxEditTool : public DrawingProgramEditToolBase {
public:
TextBoxEditTool(DrawingProgram& initDrawP);
virtual void edit_start(EditTool& editTool, const std::shared_ptr<DrawComponent>& a, std::any& prevData) override;
virtual void commit_edit_updates(const std::shared_ptr<DrawComponent>& a, std::any& prevData) override;
virtual bool edit_update(const std::shared_ptr<DrawComponent>& a) override;
virtual bool edit_gui(const std::shared_ptr<DrawComponent>& a) override;
private:
void edit_text(std::function<void()> toRun, const std::shared_ptr<DrawTextBox>& textBox);
void update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox);
DrawTextBox::Data oldData;
};

212
src/DrawingProgram/TextBoxTool.cpp
View file

@ -1,21 +1,20 @@
#include "TextBoxTool.hpp"
#include <chrono>
#include "DrawingProgram.hpp"
#include "../Server/CommandList.hpp"
#include "../MainProgram.hpp"
#include "../DrawData.hpp"
#include "Helpers/MathExtras.hpp"
#include "Helpers/SCollision.hpp"
#include "Helpers/Serializers.hpp"
#include "../CollabTextBox/CollabTextBox.hpp"
#include "../SharedTypes.hpp"
#include <cereal/types/vector.hpp>
#include <memory>
#include <ranges>
TextBoxTool::TextBoxTool(DrawingProgram& initDrawP):
drawP(initDrawP)
{
DrawingProgramToolBase(initDrawP)
{}
DrawingProgramToolType TextBoxTool::get_type() {
return DrawingProgramToolType::TEXTBOX;
}
void TextBoxTool::gui_toolbox() {
@ -31,188 +30,6 @@ void TextBoxTool::reset_tool() {
controls.drawStage = 0;
}
bool TextBoxTool::edit_gui(const std::shared_ptr<DrawTextBox>& a) {
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool text");
t.gui.text_label_centered("Edit Text");
t.gui.slider_scalar_field("Text Relative Size", "Text Size", &a->d.textSize, 5.0f, 100.0f);
t.gui.left_to_right_line_layout([&]() {
CLAY({.layout = {.sizing = {.width = CLAY_SIZING_FIXED(40), .height = CLAY_SIZING_FIXED(40)}}}) {
if(t.gui.color_button("Text Color", &a->d.textColor, &a->d.textColor == t.colorRight))
t.color_selector_right(&a->d.textColor == t.colorRight ? nullptr : &a->d.textColor);
}
t.gui.text_label("Text Color");
});
t.gui.pop_id();
bool editHappened = a->d != controls.oldData;
controls.oldData = a->d;
return editHappened;
}
void TextBoxTool::commit_edit_updates(const std::shared_ptr<DrawTextBox>& a, std::any& prevData) {
a->d.editing = false;
DrawTextBox::Data pData = std::any_cast<DrawTextBox::Data>(prevData);
DrawTextBox::Data cData = a->d;
drawP.world.undo.push(UndoManager::UndoRedoPair{
[&, a, pData]() {
a->d = pData;
a->set_textbox_string(pData.currentText);
a->d.editing = false;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
},
[&, a, cData]() {
a->d = cData;
a->set_textbox_string(cData.currentText);
a->d.editing = false;
a->client_send_update(drawP);
a->commit_update(drawP);
drawP.reset_tools();
return true;
}
});
}
void TextBoxTool::edit_start(const std::shared_ptr<DrawTextBox>& a, std::any& prevData) {
auto& cur = a->d.cursor;
auto& textbox = a->textBox;
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = cur.selectionEndPos = textbox.getPosition(p);
prevData = a->d;
a->d.editing = true;
a->client_send_update(drawP);
drawP.editTool.add_point_handle({&a->d.p1, nullptr, &a->d.p2});
drawP.editTool.add_point_handle({&a->d.p2, &a->d.p1, nullptr});
}
bool TextBoxTool::edit_update(const std::shared_ptr<DrawTextBox>& a) {
SCollision::ColliderCollection<float> mousePointCollection;
mousePointCollection.circle.emplace_back(drawP.world.main.input.mouse.pos, 1.0f);
mousePointCollection.recalculate_bounds();
a->textBox.setWidth(std::abs(a->d.p2.x() - a->d.p1.x()));
InputManager& input = drawP.world.main.input;
auto& textbox = a->textBox;
auto& cur = a->d.cursor;
bool moved = false;
bool movedHeld = false;
bool collidesWithBox = false;
if(a->collides_with_cam_coords(drawP.world.drawData.cam.c, mousePointCollection)) {
//drawP.world.main.input.cursorIcon = InputManager::SystemCursorType::TEXT;
collidesWithBox = true;
}
if(drawP.controls.leftClick) {
if(collidesWithBox) {
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = textbox.getPosition(p);
moved = true;
}
}
else if(drawP.controls.leftClickHeld) {
if(collidesWithBox) {
Vector2f textSelectPos = a->get_mouse_pos(drawP);
SkIPoint p = convert_vec2<SkIPoint>(textSelectPos.cast<int32_t>());
cur.pos = cur.selectionBeginPos = textbox.getPosition(p);
}
movedHeld = true;
}
if(input.key(InputManager::KEY_DRAW_UNSELECT).repeat)
reset_tool();
if(input.key(InputManager::KEY_TEXT_LEFT).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kLeft, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_RIGHT).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kRight, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_UP).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kUp, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_DOWN).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kDown, cur.selectionBeginPos);
if(input.key(InputManager::KEY_TEXT_HOME).repeat)
cur.pos = cur.selectionBeginPos = textbox.move(CollabTextBox::Movement::kHome, cur.selectionBeginPos);
moved = moved || input.key(InputManager::KEY_TEXT_DOWN).repeat || input.key(InputManager::KEY_TEXT_UP).repeat || input.key(InputManager::KEY_TEXT_RIGHT).repeat || input.key(InputManager::KEY_TEXT_LEFT).repeat || input.key(InputManager::KEY_TEXT_HOME).repeat;
if(moved && !input.key(InputManager::KEY_TEXT_SHIFT).held && !movedHeld)
cur.selectionEndPos = cur.selectionBeginPos;
if(moved || movedHeld)
update_textbox_network(a);
if(input.key(InputManager::KEY_TEXT_BACKSPACE).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
else
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.pos, textbox.move(CollabTextBox::Movement::kLeft, cur.pos));
}, a);
}
if(input.key(InputManager::KEY_TEXT_DELETE).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
else
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.pos, textbox.move(CollabTextBox::Movement::kRight, cur.pos));
}, a);
}
if(input.get_clipboard_paste_happened()) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
std::string clipboard = input.get_clipboard_str();
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.insert(cur.pos, clipboard);
}, a);
}
if(input.key(InputManager::KEY_TEXT_ENTER).repeat) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
cur.pos = textbox.insert(cur.pos, "\n");
cur.pos.fParagraphIndex++;
cur.pos.fTextByteIndex = 0;
cur.selectionBeginPos = cur.selectionEndPos = cur.pos;
}, a);
}
if(input.key(InputManager::KEY_TEXT_COPY).repeat) {
std::string clipboardData = textbox.copy(cur.selectionBeginPos, cur.selectionEndPos);
input.set_clipboard_str(clipboardData);
}
if(input.key(InputManager::KEY_TEXT_CUT).repeat) {
edit_text([&]() {
std::string clipboardData = textbox.copy(cur.selectionBeginPos, cur.selectionEndPos);
input.set_clipboard_str(clipboardData);
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
}, a);
}
if(input.key(InputManager::KEY_TEXT_SELECTALL).repeat) {
cur.selectionEndPos.fParagraphIndex = textbox.lineCount() == 0 ? 0 : textbox.lineCount() - 1;
cur.selectionEndPos.fTextByteIndex = textbox.line(cur.selectionEndPos.fParagraphIndex).size();
cur.pos = cur.selectionEndPos;
cur.selectionBeginPos.fTextByteIndex = 0;
cur.selectionBeginPos.fParagraphIndex = 0;
update_textbox_network(a);
}
if(!input.text.newInput.empty()) {
edit_text([&]() {
if(cur.selectionBeginPos != cur.selectionEndPos)
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.remove(cur.selectionBeginPos, cur.selectionEndPos);
cur.selectionEndPos = cur.selectionBeginPos = cur.pos = textbox.insert(cur.pos, input.text.newInput);
}, a);
}
input.text.set_accepting_input();
return true;
}
void TextBoxTool::tool_update() {
switch(controls.drawStage) {
case 0: {
@ -248,9 +65,10 @@ void TextBoxTool::tool_update() {
auto i = controls.intermediateItem;
commit();
drawP.reset_tools();
drawP.controls.selectedTool = DrawingProgram::TOOL_EDIT;
drawP.controls.previousSelected = DrawingProgram::TOOL_EDIT;
drawP.editTool.edit_start(i);
// NOTE: CHANGE THIS
//drawP.controls.selectedTool = DrawingProgram::TOOL_EDIT;
//drawP.controls.previousSelected = DrawingProgram::TOOL_EDIT;
//drawP.editTool.edit_start(i);
}
else {
controls.intermediateItem->client_send_update(drawP);
@ -265,18 +83,6 @@ bool TextBoxTool::prevent_undo_or_redo() {
return controls.intermediateItem != nullptr;
}
// Passing a function in, just in case we have to do something before editing the text
void TextBoxTool::edit_text(std::function<void()> toRun, const std::shared_ptr<DrawTextBox>& textBox) {
toRun();
textBox->update_contained_string(drawP);
update_textbox_network(textBox);
}
void TextBoxTool::update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox) {
textBox->client_send_update(drawP);
textBox->commit_update(drawP);
}
void TextBoxTool::commit() {
if(controls.intermediateItem && controls.intermediateItem->collabListInfo.lock()) {
controls.intermediateItem->client_send_update(drawP);

25
src/DrawingProgram/TextBoxTool.hpp
View file

@ -1,26 +1,20 @@
#pragma once
#include <include/core/SkCanvas.h>
#include "../DrawData.hpp"
#include "../DrawComponents/DrawTextBox.hpp"
#include "DrawingProgramToolBase.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class TextBoxTool {
class TextBoxTool : public DrawingProgramToolBase {
public:
TextBoxTool(DrawingProgram& initDrawP);
void gui_toolbox();
void tool_update();
void draw(SkCanvas* canvas, const DrawData& drawData);
void reset_tool();
void edit_start(const std::shared_ptr<DrawTextBox>& a, std::any& prevData);
void commit_edit_updates(const std::shared_ptr<DrawTextBox>& a, std::any& prevData);
bool edit_update(const std::shared_ptr<DrawTextBox>& a);
bool edit_gui(const std::shared_ptr<DrawTextBox>& a);
bool prevent_undo_or_redo();
virtual DrawingProgramToolType get_type() override;
virtual void gui_toolbox() override;
virtual void tool_update() override;
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void reset_tool() override;
virtual bool prevent_undo_or_redo() override;
private:
void edit_text(std::function<void()> toRun, const std::shared_ptr<DrawTextBox>& textBox);
void update_textbox_network(const std::shared_ptr<DrawTextBox>& textBox);
@ -32,8 +26,5 @@ class TextBoxTool {
Vector2f endAt;
int drawStage = 0;
std::shared_ptr<DrawTextBox> intermediateItem;
DrawTextBox::Data oldData;
} controls;
DrawingProgram& drawP;
};