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

Use info from events, and textbox place tool works with events

Browse source
This commit is contained in:
Yousef Khadadeh 2026-03-03 10:18:47 +03:00
parent 3dc2455f13
commit 803eb2c08a
10 changed files with 72 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/CoordSpaceHelper.cpp
View file

@ -151,6 +151,14 @@ Vector2f CoordSpaceHelper::get_mouse_pos(const World& w) const {
return to_space(w.drawData.cam.c.from_space(w.main.input.mouse.pos));
}
Vector2f CoordSpaceHelper::from_cam_space_to_this(const World& w, const Vector2f& coord) const {
return to_space(w.drawData.cam.c.from_space(coord));
}
Vector2f CoordSpaceHelper::from_this_to_cam_space(const World& w, const Vector2f& coord) const {
return w.drawData.cam.c.to_space(from_space(coord));
}
CoordSpaceHelper CoordSpaceHelper::other_coord_space_to_this_space(const CoordSpaceHelper& other) const {
CoordSpaceHelper toRet;
toRet.pos = to_space_world(other.pos);

2
src/CoordSpaceHelper.hpp
View file

@ -103,6 +103,8 @@ class CoordSpaceHelper {
}
Vector2f get_mouse_pos(const World& w) const;
Vector2f from_cam_space_to_this(const World& w, const Vector2f& coord) const;
Vector2f from_this_to_cam_space(const World& w, const Vector2f& coord) const;
//SkMatrix get_sk_matrix_temp(const WorldTransform& tempTransform, const DrawData& drawData) const;
//SkMatrix get_sk_matrix(const DrawData& drawData) const;
void transform_sk_canvas(SkCanvas* canvas, const DrawData& drawData) const;

11
src/DrawingProgram/DrawingProgram.cpp
View file

@ -77,6 +77,11 @@ void DrawingProgram::input_mouse_button_callback(const InputManager::MouseButton
else if(!button.down && button.button != InputManager::MouseButton::RIGHT) {
drawTool->input_mouse_button_on_canvas_callback(button);
}
if(toolToSwitchToAfterUpdate) {
switch_to_tool_ptr(std::move(toolToSwitchToAfterUpdate));
toolToSwitchToAfterUpdate = nullptr;
}
}
void DrawingProgram::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
@ -385,12 +390,6 @@ void DrawingProgram::update() {
selection.update();
drawTool->tool_update();
// Switch tools after the tool update, not before, so that we dont have to call erase_component on the toolToSwitchToAfterUpdate as well (components will not be erased in this time period)
if(toolToSwitchToAfterUpdate) {
switch_to_tool_ptr(std::move(toolToSwitchToAfterUpdate));
toolToSwitchToAfterUpdate = nullptr;
}
if(controls.leftClickReleased)
controls.leftClickReleased = false;

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

@ -47,7 +47,7 @@ void EllipseDrawTool::input_mouse_button_on_canvas_callback(const InputManager::
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::ELLIPSE);
EllipseCanvasComponent& newEllipse = static_cast<EllipseCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos;
startAt = button.pos;
newEllipse.d.strokeColor = toolConfig.globalConf.foregroundColor;
newEllipse.d.fillColor = toolConfig.globalConf.backgroundColor;
newEllipse.d.strokeWidth = width;
@ -67,7 +67,7 @@ void EllipseDrawTool::input_mouse_button_on_canvas_callback(const InputManager::
void EllipseDrawTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
if(objInfoBeingEdited) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
Vector2f newPos = containerPtr->coords.from_cam_space_to_this(drawP.world, motion.pos);
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);

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

@ -71,7 +71,7 @@ void LassoSelectTool::input_mouse_button_on_canvas_callback(const InputManager::
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));
v = controls.coords.from_this_to_cam_space(drawP.world, v);
std::vector<unsigned> indices = mapbox::earcut(polygon);
@ -104,7 +104,7 @@ void LassoSelectTool::input_mouse_button_on_canvas_callback(const InputManager::
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));
Vector2f newLassoPoint = controls.coords.from_cam_space_to_this(drawP.world, motion.pos);
float lassoPointDist = vec_distance(controls.lassoPoints.back(), newLassoPoint);
if(lassoPointDist > 4.0f)
controls.lassoPoints.emplace_back(newLassoPoint);

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

@ -62,7 +62,7 @@ void LineDrawTool::input_mouse_motion_callback(const InputManager::MouseMotionCa
constexpr float SNAP_DIVISION_COUNT = 12.0f;
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
BrushStrokeCanvasComponent& brushStroke = static_cast<BrushStrokeCanvasComponent&>(containerPtr->get_comp());
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
Vector2f newPos = containerPtr->coords.from_cam_space_to_this(drawP.world, motion.pos);
Vector2f oldPos = brushStroke.d.points->front().pos;
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
Vector2f diff = (newPos - oldPos);

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

@ -40,8 +40,7 @@ void RectDrawTool::input_mouse_button_on_canvas_callback(const InputManager::Mou
auto relativeWidthResult = drawP.world.main.toolConfig.get_relative_width_stroke_size(drawP, drawP.world.drawData.cam.c.inverseScale);
auto relativeRadiusWidthResult = drawP.world.main.toolConfig.get_relative_width_from_value(drawP, drawP.world.drawData.cam.c.inverseScale, relativeRadiusWidth);
if(!relativeWidthResult.first.has_value() || !relativeRadiusWidthResult.first.has_value()) {
if(drawP.controls.leftClick)
drawP.world.main.toolConfig.print_relative_width_fail_message(relativeWidthResult.second);
drawP.world.main.toolConfig.print_relative_width_fail_message(relativeWidthResult.second);
return;
}
float width = relativeWidthResult.first.value();
@ -50,7 +49,7 @@ void RectDrawTool::input_mouse_button_on_canvas_callback(const InputManager::Mou
CanvasComponentContainer* newContainer = new CanvasComponentContainer(drawP.world.netObjMan, CanvasComponentType::RECTANGLE);
RectangleCanvasComponent& newRectangle = static_cast<RectangleCanvasComponent&>(newContainer->get_comp());
startAt = drawP.world.main.input.mouse.pos;
startAt = button.pos;
newRectangle.d.strokeColor = toolConfig.globalConf.foregroundColor;
newRectangle.d.fillColor = toolConfig.globalConf.backgroundColor;
newRectangle.d.cornerRadius = radiusWidth;
@ -70,7 +69,7 @@ void RectDrawTool::input_mouse_button_on_canvas_callback(const InputManager::Mou
void RectDrawTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
if(objInfoBeingEdited) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
Vector2f newPos = containerPtr->coords.from_cam_space_to_this(drawP.world, motion.pos);
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);

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

@ -39,9 +39,9 @@ void RectSelectTool::input_mouse_button_on_canvas_callback(const InputManager::M
}
else if(controls.isSelecting && button.button == InputManager::MouseButton::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)));
controls.selectEndAt = controls.coords.from_cam_space_to_this(drawP.world, button.pos);
Vector2f newP1 = controls.coords.from_this_to_cam_space(drawP.world, cwise_vec_min(controls.selectStartAt, controls.selectEndAt));
Vector2f newP2 = controls.coords.from_this_to_cam_space(drawP.world, cwise_vec_max(controls.selectStartAt, controls.selectEndAt));
std::array<Vector2f, 4> newT = triangle_from_rect_points(newP1, newP2);
ColliderCollection<float> cC;
@ -64,7 +64,7 @@ void RectSelectTool::input_mouse_button_on_canvas_callback(const InputManager::M
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));
controls.selectEndAt = controls.coords.from_cam_space_to_this(drawP.world, motion.pos);
drawP.selection.input_mouse_motion_callback_modify_selection(motion);
}

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

@ -26,6 +26,49 @@ void TextBoxTool::gui_toolbox() {
t.gui.pop_id();
}
void TextBoxTool::input_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) {
if(button.button == InputManager::MouseButton::LEFT) {
if(button.down && drawP.layerMan.is_a_layer_being_edited() && !objInfoBeingEdited) {
startAt = button.pos;
endAt = startAt;
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);
}
else if(!button.down && objInfoBeingEdited) {
auto editTool = std::make_unique<EditTool>(drawP);
editTool->edit_start(objInfoBeingEdited, false);
drawP.toolToSwitchToAfterUpdate = std::move(editTool);
}
}
}
void TextBoxTool::input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) {
if(objInfoBeingEdited) {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
TextBoxCanvasComponent& textBox = static_cast<TextBoxCanvasComponent&>(containerPtr->get_comp());
Vector2f newPos = containerPtr->coords.from_cam_space_to_this(drawP.world, motion.pos);
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);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
}
void TextBoxTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
if(objInfoBeingEdited == erasedComp)
objInfoBeingEdited = nullptr;
@ -42,45 +85,6 @@ void TextBoxTool::switch_tool(DrawingProgramToolType newTool) {
}
void TextBoxTool::tool_update() {
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());
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);
}
}
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, false);
drawP.toolToSwitchToAfterUpdate = std::move(editTool);
return;
}
else {
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}
}
}
bool TextBoxTool::prevent_undo_or_redo() {

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

@ -16,6 +16,8 @@ class TextBoxTool : 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_mouse_button_on_canvas_callback(const InputManager::MouseButtonCallbackArgs& button) override;
virtual void input_mouse_motion_callback(const InputManager::MouseMotionCallbackArgs& motion) override;
private:
void commit();