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

Switching to hardcoded callback functions. Selection tools are working with callbacks

Browse source
This commit is contained in:
Yousef Khadadeh 2026-03-02 16:36:34 +03:00
parent 109fd96b67
commit eac8610456
17 changed files with 486 additions and 429 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/DrawingProgram/Tools/DrawingProgramToolBase.cpp
View file

@ -54,3 +54,7 @@ std::unique_ptr<DrawingProgramToolBase> DrawingProgramToolBase::allocate_tool_ty
}
return nullptr;
}
void DrawingProgramToolBase::input_key_callback(const InputManager::KeyCallbackArgs& key) {}
void DrawingProgramToolBase::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {}
void DrawingProgramToolBase::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {}

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

@ -2,6 +2,7 @@
#include <include/core/SkCanvas.h>
#include "../../DrawData.hpp"
#include "../../CanvasComponents/CanvasComponentContainer.hpp"
#include "../../InputManager.hpp"
class DrawingProgram;
@ -35,6 +36,9 @@ class DrawingProgramToolBase {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) = 0;
virtual void switch_tool(DrawingProgramToolType newTool) = 0;
virtual bool prevent_undo_or_redo() = 0;
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key);
virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button);
virtual void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion);
virtual ~DrawingProgramToolBase();
static std::unique_ptr<DrawingProgramToolBase> allocate_tool_type(DrawingProgram& drawP, DrawingProgramToolType t);
protected:

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

@ -50,6 +50,68 @@ bool LassoSelectTool::right_click_popup_gui(Vector2f popupPos) {
return drawP.selection_action_menu(popupPos);
}
void LassoSelectTool::input_key_callback(const InputManager::KeyCallbackArgs& key) {
drawP.selection.input_key_callback_display_selection(key);
drawP.selection.input_key_callback_modify_selection(key);
}
void LassoSelectTool::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {
drawP.selection.input_mouse_button_on_canvas_callback_modify_selection(button);
if(!controls.isSelecting && button.button == InputManager::MouseButtonCallbackArgs::Button::LEFT && button.down && !drawP.selection.is_being_transformed()) {
controls = LassoSelectControls();
controls.coords = drawP.world.drawData.cam.c;
controls.lassoPoints.emplace_back(controls.coords.get_mouse_pos(drawP.world));
controls.isSelecting = true;
}
else if(controls.isSelecting && button.button == InputManager::MouseButtonCallbackArgs::Button::LEFT && !button.down) {
if(controls.lassoPoints.size() > 3) {
SCollision::ColliderCollection<float> cC;
std::vector<std::vector<Vector2f>> polygon;
polygon.emplace_back(controls.lassoPoints);
auto& poly = polygon[0];
for(auto& v : poly)
v = drawP.world.drawData.cam.c.to_space(controls.coords.from_space(v));
std::vector<unsigned> indices = mapbox::earcut(polygon);
for(size_t i = 0; i < indices.size(); i += 3) {
cC.triangle.emplace_back(
poly[indices[i]],
poly[indices[i + 1]],
poly[indices[i + 2]]
);
}
cC.recalculate_bounds();
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held)
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held)
drawP.selection.remove_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else {
drawP.selection.deselect_all();
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
}
controls.lassoPoints.clear();
}
else if(!drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held) {
drawP.selection.deselect_all();
}
controls.isSelecting = false;
}
}
void LassoSelectTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
if(controls.isSelecting) {
Vector2f newLassoPoint = controls.coords.to_space(drawP.world.drawData.cam.c.from_space(motion.pos));
float lassoPointDist = vec_distance(controls.lassoPoints.back(), newLassoPoint);
if(lassoPointDist > 4.0f)
controls.lassoPoints.emplace_back(newLassoPoint);
}
drawP.selection.input_mouse_motion_callback_modify_selection(motion);
}
void LassoSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
@ -59,68 +121,14 @@ void LassoSelectTool::switch_tool(DrawingProgramToolType newTool) {
}
void LassoSelectTool::tool_update() {
switch(controls.selectionMode) {
case 0: {
if(drawP.controls.leftClick && !drawP.selection.is_being_transformed()) {
controls = LassoSelectControls();
controls.coords = drawP.world.drawData.cam.c;
controls.lassoPoints.emplace_back(controls.coords.get_mouse_pos(drawP.world));
controls.selectionMode = 1;
}
break;
}
case 1: {
using namespace SCollision;
Vector2f newLassoPoint = controls.coords.get_mouse_pos(drawP.world);
float lassoPointDist = vec_distance(controls.lassoPoints.back(), newLassoPoint);
if(lassoPointDist > 4.0f)
controls.lassoPoints.emplace_back(newLassoPoint);
if(!drawP.controls.leftClickHeld) {
if(controls.lassoPoints.size() > 3) {
SCollision::ColliderCollection<float> cC;
std::vector<std::vector<Vector2f>> polygon;
polygon.emplace_back(controls.lassoPoints);
auto& poly = polygon[0];
std::vector<unsigned> indices = mapbox::earcut(polygon);
for(size_t i = 0; i < indices.size(); i += 3) {
cC.triangle.emplace_back(
poly[indices[i]],
poly[indices[i + 1]],
poly[indices[i + 2]]
);
}
cC.recalculate_bounds();
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held)
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held)
drawP.selection.remove_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else {
drawP.selection.deselect_all();
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
}
}
else if(!drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held && !drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held) {
drawP.selection.deselect_all();
}
controls.selectionMode = 0;
}
break;
}
}
}
bool LassoSelectTool::prevent_undo_or_redo() {
return drawP.selection.is_something_selected() || controls.selectionMode == 1;
return drawP.selection.is_something_selected() || controls.isSelecting;
}
void LassoSelectTool::draw(SkCanvas* canvas, const DrawData& drawData) {
if(controls.selectionMode == 1) {
if(controls.isSelecting) {
canvas->save();
controls.coords.transform_sk_canvas(canvas, drawData);

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

@ -18,13 +18,13 @@ class LassoSelectTool : public DrawingProgramToolBase {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual bool prevent_undo_or_redo() override;
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key) override;
virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) override;
virtual void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) override;
private:
struct LassoSelectControls {
int selectionMode = 0;
bool isSelecting = false;
CoordSpaceHelper coords;
std::vector<Vector2f> lassoPoints;
} controls;
};

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

@ -24,6 +24,50 @@ void RectSelectTool::gui_toolbox() {
t.gui.pop_id();
}
void RectSelectTool::input_key_callback(const InputManager::KeyCallbackArgs& key) {
drawP.selection.input_key_callback_display_selection(key);
drawP.selection.input_key_callback_modify_selection(key);
}
void RectSelectTool::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {
drawP.selection.input_mouse_button_on_canvas_callback_modify_selection(button);
if(!controls.isSelecting && button.button == InputManager::MouseButtonCallbackArgs::Button::LEFT && button.down && !drawP.selection.is_being_transformed()) {
controls = RectSelectControls();
controls.coords = drawP.world.drawData.cam.c;
controls.selectStartAt = controls.selectEndAt = button.pos;
controls.isSelecting = true;
}
else if(controls.isSelecting && button.button == InputManager::MouseButtonCallbackArgs::Button::LEFT && !button.down) {
using namespace SCollision;
controls.selectEndAt = controls.coords.to_space(drawP.world.drawData.cam.c.from_space(button.pos));
Vector2f newP1 = drawP.world.drawData.cam.c.to_space(controls.coords.from_space(cwise_vec_min(controls.selectStartAt, controls.selectEndAt)));
Vector2f newP2 = drawP.world.drawData.cam.c.to_space(controls.coords.from_space(cwise_vec_max(controls.selectStartAt, controls.selectEndAt)));
std::array<Vector2f, 4> newT = triangle_from_rect_points(newP1, newP2);
ColliderCollection<float> cC;
cC.triangle.emplace_back(newT[0], newT[1], newT[2]);
cC.triangle.emplace_back(newT[2], newT[3], newT[0]);
cC.recalculate_bounds();
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held)
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held)
drawP.selection.remove_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else {
drawP.selection.deselect_all();
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
}
controls.isSelecting = false;
}
}
void RectSelectTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
if(controls.isSelecting)
controls.selectEndAt = controls.coords.to_space(drawP.world.drawData.cam.c.from_space(motion.pos));
drawP.selection.input_mouse_motion_callback_modify_selection(motion);
}
void RectSelectTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
@ -37,56 +81,24 @@ void RectSelectTool::switch_tool(DrawingProgramToolType newTool) {
}
void RectSelectTool::tool_update() {
switch(controls.selectionMode) {
case 0: {
if(drawP.controls.leftClick && !drawP.selection.is_being_transformed()) {
controls = RectSelectControls();
controls.coords = drawP.world.drawData.cam.c;
controls.selectStartAt = controls.coords.get_mouse_pos(drawP.world);
controls.selectionMode = 1;
}
break;
}
case 1: {
using namespace SCollision;
Vector2f mPos = controls.coords.get_mouse_pos(drawP.world);
Vector2f newP1 = cwise_vec_min(controls.selectStartAt, mPos);
Vector2f newP2 = cwise_vec_max(controls.selectStartAt, mPos);
controls.newT = triangle_from_rect_points(newP1, newP2);
if(!drawP.controls.leftClickHeld) {
ColliderCollection<float> cC;
cC.triangle.emplace_back(controls.newT[0], controls.newT[1], controls.newT[2]);
cC.triangle.emplace_back(controls.newT[2], controls.newT[3], controls.newT[0]);
cC.recalculate_bounds();
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held)
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LALT).held)
drawP.selection.remove_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
else {
drawP.selection.deselect_all();
drawP.selection.add_from_cam_coord_collider_to_selection(cC, drawP.controls.layerSelector, false);
}
controls.selectionMode = 0;
}
break;
}
}
}
bool RectSelectTool::prevent_undo_or_redo() {
return drawP.selection.is_something_selected() || controls.selectionMode == 1;
return drawP.selection.is_something_selected() || controls.isSelecting;
}
void RectSelectTool::draw(SkCanvas* canvas, const DrawData& drawData) {
if(controls.selectionMode == 1) {
if(controls.isSelecting) {
Vector2f mPos = controls.selectEndAt;
Vector2f newP1 = cwise_vec_min(controls.selectStartAt, mPos);
Vector2f newP2 = cwise_vec_max(controls.selectStartAt, mPos);
std::array<Vector2f, 4> newT = triangle_from_rect_points(newP1, newP2);
canvas->save();
controls.coords.transform_sk_canvas(canvas, drawData);
SkRect r = SkRect::MakeLTRB(controls.newT[0].x(), controls.newT[0].y(), controls.newT[2].x(), controls.newT[2].y());
SkRect r = SkRect::MakeLTRB(newT[0].x(), newT[0].y(), newT[2].x(), newT[2].y());
canvas->drawRect(r, drawP.select_tool_line_paint());
canvas->restore();
canvas->restore();
}

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

@ -16,11 +16,14 @@ class RectSelectTool : public DrawingProgramToolBase {
virtual void draw(SkCanvas* canvas, const DrawData& drawData) override;
virtual void switch_tool(DrawingProgramToolType newTool) override;
virtual bool prevent_undo_or_redo() override;
virtual void input_key_callback(const InputManager::KeyCallbackArgs& key) override;
virtual void input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) override;
virtual void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) override;
private:
struct RectSelectControls {
int selectionMode = 0;
bool isSelecting = false;
CoordSpaceHelper coords;
Vector2f selectStartAt;
std::array<Vector2f, 4> newT;
Vector2f selectEndAt;
} controls;
};