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

Changed net object ordered list implementation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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