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

Can edit stroke colors through selection

Browse source
This commit is contained in:
Yousef Khadadeh 2026-01-27 16:55:09 +03:00
parent f6c4eeb9f3
commit a73f5e2122
18 changed files with 283 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

131
src/DrawingProgram/DrawingProgramSelection.cpp
View file

@ -27,7 +27,106 @@ DrawingProgramSelection::DrawingProgramSelection(DrawingProgram& initDrawP):
drawP(initDrawP)
{}
void DrawingProgramSelection::selection_gui() {
auto& t = drawP.world.main.toolbar;
t.gui.push_id("general selection gui");
t.gui.text_label("Select from:");
if(t.gui.radio_button_field("layer edited", "Layer being edited", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED;
if(t.gui.radio_button_field("all visible", "All visible layers", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS;
if(is_something_selected()) {
t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Stroke Color Button", &strokeColorChangeData.newColor, &strokeColorChangeData.newColor == t.colorRight)) {
if(strokeColorChangeData.newColor.w() == 0.0f)
strokeColorChangeData.newColor.w() = 1.0f;
t.color_selector_right(&strokeColorChangeData.newColor == t.colorRight ? nullptr : &strokeColorChangeData.newColor);
}
t.gui.text_label("Stroke Color");
});
update_selection_stroke_color();
}
t.gui.pop_id();
}
void DrawingProgramSelection::update_selection_stroke_color() {
if(strokeColorChangeData.oldColor != strokeColorChangeData.newColor) {
for(auto& c : selectedSet) {
if(c->obj->get_comp().get_stroke_color() != std::nullopt) {
strokeColorChangeData.oldColorData.emplace(c->obj.get_net_id(), c->obj->get_comp().get_stroke_color().value());
c->obj->get_comp().change_stroke_color(strokeColorChangeData.newColor);
c->obj->commit_update_dont_invalidate_cache(drawP); // Object isn't in the cache since it's selected
c->obj->send_comp_update(drawP, false);
}
}
strokeColorChangeData.oldColor = strokeColorChangeData.newColor;
}
}
void DrawingProgramSelection::check_add_stroke_color_change_undo() {
if(!strokeColorChangeData.oldColorData.empty()) {
class EditCanvasComponentsStrokeColorWorldUndoAction : public WorldUndoAction {
public:
EditCanvasComponentsStrokeColorWorldUndoAction(std::vector<WorldUndoManager::UndoObjectID> initUndoIDs, std::vector<Vector4f> initOldColors):
undoIDs(std::move(initUndoIDs)),
colors(std::move(initOldColors))
{}
std::string get_name() const override {
return "Edit Stroke Colors";
}
bool undo(WorldUndoManager& undoMan) override {
return undo_redo(undoMan);
}
bool redo(WorldUndoManager& undoMan) override {
return undo_redo(undoMan);
}
bool undo_redo(WorldUndoManager& undoMan) {
std::vector<NetworkingObjects::NetObjID> netIDs;
if(!undoMan.fill_netid_list_from_undoid_list(netIDs, undoIDs))
return false;
undoMan.world.netObjMan.send_multi_update_messsage([&]() {
for(size_t i = 0; i < netIDs.size(); i++) {
auto objPtr = undoMan.world.netObjMan.get_obj_temporary_ref_from_id<CanvasComponentContainer>(netIDs[i]);
if(objPtr) {
Vector4f oldColor = objPtr->get_comp().get_stroke_color().value();
objPtr->get_comp().change_stroke_color(colors[i]);
colors[i] = oldColor;
objPtr->commit_update(undoMan.world.drawProg);
objPtr->send_comp_update(undoMan.world.drawProg, true);
}
}
}, NetworkingObjects::NetObjManager::SendUpdateType::SEND_TO_ALL, nullptr);
return true;
}
~EditCanvasComponentsStrokeColorWorldUndoAction() {}
std::vector<WorldUndoManager::UndoObjectID> undoIDs;
std::vector<Vector4f> colors;
};
std::vector<WorldUndoManager::UndoObjectID> undoIDs;
std::vector<Vector4f> oldColors;
for(auto& [netID, strokeColor] : strokeColorChangeData.oldColorData) {
undoIDs.emplace_back(drawP.world.undo.get_undoid_from_netid(netID));
oldColors.emplace_back(strokeColor);
}
drawP.world.undo.push(std::make_unique<EditCanvasComponentsStrokeColorWorldUndoAction>(std::move(undoIDs), std::move(oldColors)));
strokeColorChangeData.oldColorData.clear();
auto& t = drawP.world.main.toolbar;
if(&strokeColorChangeData.newColor == t.colorRight)
t.colorRight = nullptr; // Just making sure that the color selector doesn't leak
}
}
void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
check_add_stroke_color_change_undo();
std::vector<CanvasComponentContainer::ObjInfo*> selectedComponents;
if(frontObjectOnly) {
CanvasComponentContainer::ObjInfo* a = drawP.drawCache.get_front_object_colliding_with_in_editing_layer(cC);
@ -44,6 +143,8 @@ void DrawingProgramSelection::add_from_cam_coord_collider_to_selection(const SCo
}
void DrawingProgramSelection::remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly) {
check_add_stroke_color_change_undo();
if(frontObjectOnly) {
CanvasComponentContainer::ObjInfo* p = get_front_object_colliding_with_in_editing_layer(cC);
if(p) {
@ -139,11 +240,15 @@ bool DrawingProgramSelection::is_selected(CanvasComponentContainer::ObjInfo* obj
}
void DrawingProgramSelection::reset_all() {
check_add_stroke_color_change_undo();
selectedSet.clear();
reset_transform_data();
strokeColorChangeData = StrokeColorChangeData();
}
void DrawingProgramSelection::reset_transform_data() {
check_add_stroke_color_change_undo();
selectionTransformCoords = CoordSpaceHelperTransform();
transformOpHappening = TransformOperation::NONE;
translateData = TranslationData();
@ -168,6 +273,8 @@ bool DrawingProgramSelection::mouse_collided_with_rotate_handle_point() {
}
void DrawingProgramSelection::commit_transform_selection() {
check_add_stroke_color_change_undo();
if(!is_empty_transform()) {
std::vector<WorldUndoManager::UndoObjectID> undoIDList;
std::vector<std::pair<CoordSpaceHelper, CoordSpaceHelper>> transformDataList;
@ -267,17 +374,22 @@ void DrawingProgramSelection::update() {
scaleData.currentPos = scaleData.startPos = selectionTransformCoords.from_space_world(initialSelectionAABB.max);
scaleData.centerPos = selectionTransformCoords.from_space_world(initialSelectionAABB.center());
transformOpHappening = TransformOperation::SCALE;
check_add_stroke_color_change_undo();
}
else if(mouse_collided_with_rotate_center_handle_point())
else if(mouse_collided_with_rotate_center_handle_point()) {
transformOpHappening = TransformOperation::ROTATE_RELOCATE_CENTER;
check_add_stroke_color_change_undo();
}
else if(mouse_collided_with_rotate_handle_point()) {
rotateData.rotationAngle = 0.0;
transformOpHappening = TransformOperation::ROTATE;
check_add_stroke_color_change_undo();
}
else if(mouse_collided_with_selection_aabb()) {
translateData.startPos = drawP.world.get_mouse_world_pos();
transformOpHappening = TransformOperation::TRANSLATE;
translateData.translateWithKeys = false;
check_add_stroke_color_change_undo();
}
}
else {
@ -297,6 +409,7 @@ void DrawingProgramSelection::update() {
selectionTransformCoords = CoordSpaceHelperTransform(translateData.startPos);
transformOpHappening = TransformOperation::TRANSLATE;
translateData.keyTranslateLastMoveTime = std::chrono::steady_clock::now();
check_add_stroke_color_change_undo();
}
}
break;
@ -410,6 +523,8 @@ void DrawingProgramSelection::update() {
}
void DrawingProgramSelection::deselect_all() {
check_add_stroke_color_change_undo();
if(is_something_selected()) {
commit_transform_selection();
for(auto& obj : selectedSet)
@ -419,18 +534,24 @@ void DrawingProgramSelection::deselect_all() {
}
void DrawingProgramSelection::push_selection_to_front() {
check_add_stroke_color_change_undo();
auto selectedVec = selectedSet;
deselect_all();
drawP.layerMan.push_components_to(selectedVec, false);
}
void DrawingProgramSelection::push_selection_to_back() {
check_add_stroke_color_change_undo();
auto selectedVec = selectedSet;
deselect_all();
drawP.layerMan.push_components_to(selectedVec, true);
}
void DrawingProgramSelection::delete_all() {
check_add_stroke_color_change_undo();
if(is_something_selected()) {
auto selectedSetTemp = selectedSet;
reset_all(); // Clear set before erasing, since calling erase_component_set will run a check to see if each object is selected and erase them one by one, which is slower
@ -439,6 +560,8 @@ void DrawingProgramSelection::delete_all() {
}
void DrawingProgramSelection::erase_component(CanvasComponentContainer::ObjInfo* objToCheck) {
check_add_stroke_color_change_undo();
std::erase(selectedSet, objToCheck);
if(selectedSet.empty())
reset_all();
@ -455,6 +578,8 @@ CanvasComponentContainer::ObjInfo* DrawingProgramSelection::get_front_object_col
}
void DrawingProgramSelection::selection_to_clipboard() {
check_add_stroke_color_change_undo();
auto& clipboard = drawP.world.main.clipboard;
std::unordered_set<NetworkingObjects::NetObjID> resourceSet;
for(auto& c : selectedSet)
@ -468,6 +593,8 @@ void DrawingProgramSelection::selection_to_clipboard() {
}
void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
check_add_stroke_color_change_undo();
if(drawP.layerMan.is_a_layer_being_edited()) {
auto& clipboard = drawP.world.main.clipboard;
@ -511,6 +638,8 @@ void DrawingProgramSelection::paste_clipboard(Vector2f pasteScreenPos) {
}
void DrawingProgramSelection::paste_image(Vector2f pasteScreenPos) {
check_add_stroke_color_change_undo();
if(drawP.layerMan.is_a_layer_being_edited()) {
#ifdef __EMSCRIPTEN__
struct PasteData {

10
src/DrawingProgram/DrawingProgramSelection.hpp
View file

@ -8,6 +8,7 @@ class DrawingProgram;
class DrawingProgramSelection {
public:
DrawingProgramSelection(DrawingProgram& initDrawP);
void selection_gui();
void add_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void remove_from_cam_coord_collider_to_selection(const SCollision::ColliderCollection<float>& cC, DrawingProgramLayerManager::LayerSelector layerSelector, bool frontObjectOnly);
void erase_component(CanvasComponentContainer::ObjInfo* objToCheck);
@ -38,6 +39,15 @@ class DrawingProgramSelection {
void rebuild_cam_space();
Vector2f get_rotation_point_pos_from_angle(double angle);
void update_selection_stroke_color();
void check_add_stroke_color_change_undo();
struct StrokeColorChangeData {
Vector4f newColor = {1.0f, 1.0f, 1.0f, 0.0f};
Vector4f oldColor = {1.0f, 1.0f, 1.0f, 0.0f};
std::unordered_map<NetworkingObjects::NetObjID, Vector4f> oldColorData;
} strokeColorChangeData;
void set_to_selection(const std::vector<CanvasComponentContainer::ObjInfo*>& newSelection);
void add_to_selection(const std::vector<CanvasComponentContainer::ObjInfo*>& newSelection);
void sort_selection();

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

@ -32,7 +32,7 @@ void BrushTool::erase_component(CanvasComponentContainer::ObjInfo* erasedComp) {
}
bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) {
auto& points = brushStroke.d->points;
auto& points = *brushStroke.d.points;
if(points.size() >= 1 && (newPoint - points[points.size() - 1].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT)
return false;
if(points.size() >= 2 && (newPoint - points[points.size() - 2].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT)
@ -43,7 +43,7 @@ bool BrushTool::extensive_point_checking(const BrushStrokeCanvasComponent& brush
}
bool BrushTool::extensive_point_checking_back(const BrushStrokeCanvasComponent& brushStroke, const Vector2f& newPoint) {
auto& points = brushStroke.d->points;
auto& points = *brushStroke.d.points;
if(points.size() >= 2 && (newPoint - points[points.size() - 2].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT)
return false;
if(points.size() >= 3 && (newPoint - points[points.size() - 3].pos).norm() < MINIMUM_DISTANCE_TO_NEXT_POINT)
@ -98,9 +98,9 @@ void BrushTool::tool_update() {
p.pos = drawP.world.main.input.mouse.pos;
p.width = toolConfig.get_relative_width(toolConfig.brush.relativeWidth) * penWidth;
prevPointUnaltered = p.pos;
newBrushStroke.d->points.emplace_back(p);
newBrushStroke.d->color = toolConfig.globalConf.foregroundColor;
newBrushStroke.d->hasRoundCaps = toolConfig.brush.hasRoundCaps;
newBrushStroke.d.points->emplace_back(p);
newBrushStroke.d.color = toolConfig.globalConf.foregroundColor;
newBrushStroke.d.hasRoundCaps = toolConfig.brush.hasRoundCaps;
newBrushStrokeContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newBrushStrokeContainer);
addedTemporaryPoint = false;
@ -109,6 +109,7 @@ void BrushTool::tool_update() {
else {
NetworkingObjects::NetObjOwnerPtr<CanvasComponentContainer>& containerPtr = objInfoBeingEdited->obj;
BrushStrokeCanvasComponent& brushStroke = static_cast<BrushStrokeCanvasComponent&>(containerPtr->get_comp());
auto& brushPoints = *brushStroke.d.points;
BrushStrokeCanvasComponentPoint p;
p.pos = containerPtr->coords.get_mouse_pos(drawP.world);
@ -116,28 +117,28 @@ void BrushTool::tool_update() {
if(!addedTemporaryPoint) {
if(extensive_point_checking(brushStroke, p.pos)) {
brushStroke.d->points.emplace_back(p);
brushPoints.emplace_back(p);
addedTemporaryPoint = true;
}
else
brushStroke.d->points.back().width = std::max(brushStroke.d->points.back().width, p.width);
brushPoints.back().width = std::max(brushPoints.back().width, p.width);
}
if(addedTemporaryPoint) {
const BrushStrokeCanvasComponentPoint& prevP = brushStroke.d->points[brushStroke.d->points.size() - 2];
const BrushStrokeCanvasComponentPoint& prevP = brushPoints[brushPoints.size() - 2];
float distToPrev = (p.pos - prevP.pos).norm();
if(extensive_point_checking_back(brushStroke, p.pos)) {
brushStroke.d->points.back().pos = p.pos;
brushStroke.d->points.back().width = std::max(brushStroke.d->points.back().width, p.width);
brushStroke.d->points[brushStroke.d->points.size() - 2].width = std::max(brushStroke.d->points[brushStroke.d->points.size() - 2].width, p.width);
brushPoints.back().pos = p.pos;
brushPoints.back().width = std::max(brushPoints.back().width, p.width);
brushPoints[brushPoints.size() - 2].width = std::max(brushPoints[brushPoints.size() - 2].width, p.width);
}
if((!drawingMinimumRelativeToSize && distToPrev >= 10.0) || (drawingMinimumRelativeToSize && distToPrev >= toolConfig.get_relative_width(toolConfig.brush.relativeWidth) * BrushStrokeCanvasComponent::DRAW_MINIMUM_LIMIT)) {
brushStroke.d->points.back() = p;
brushPoints.back() = p;
addedTemporaryPoint = false;
if(midwayInterpolation) {
if(brushStroke.d->points.size() != 2) // Don't interpolate the first point
brushStroke.d->points[brushStroke.d->points.size() - 2].pos = (prevPointUnaltered + p.pos) * 0.5;
if(brushPoints.size() != 2) // Don't interpolate the first point
brushPoints[brushPoints.size() - 2].pos = (prevPointUnaltered + p.pos) * 0.5;
prevPointUnaltered = p.pos;
}
}

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

@ -13,6 +13,7 @@
#include "EditTools/RectDrawEditTool.hpp"
#include "EditTools/ImageEditTool.hpp"
#include "EditTools/EllipseDrawEditTool.hpp"
#include "EditTools/BrushEditTool.hpp"
EditTool::EditTool(DrawingProgram& initDrawP):
DrawingProgramToolBase(initDrawP)
@ -124,6 +125,10 @@ void EditTool::edit_start(CanvasComponentContainer::ObjInfo* comp, bool initUndo
compEditTool = std::make_unique<ImageEditTool>(drawP);
break;
}
case CanvasComponentType::BRUSHSTROKE: {
compEditTool = std::make_unique<BrushEditTool>(drawP);
break;
}
default: {
isEditing = false;
break;
@ -138,7 +143,7 @@ void EditTool::edit_start(CanvasComponentContainer::ObjInfo* comp, bool initUndo
}
bool EditTool::is_editable(CanvasComponentContainer::ObjInfo* comp) {
return comp->obj->get_comp().get_type() != CanvasComponentType::BRUSHSTROKE;
return true; // Brush strokes used to not be editable, but now they are so this always returns true
}
void EditTool::tool_update() {

38
src/DrawingProgram/Tools/EditTools/BrushEditTool.cpp Normal file
View file

@ -0,0 +1,38 @@
#include "BrushEditTool.hpp"
#include "../../DrawingProgram.hpp"
#include "../../../World.hpp"
#include "../../../MainProgram.hpp"
#include "../EditTool.hpp"
BrushEditTool::BrushEditTool(DrawingProgram& initDrawP):
DrawingProgramEditToolBase(initDrawP)
{}
bool BrushEditTool::edit_gui(CanvasComponentContainer::ObjInfo* comp) {
auto& a = static_cast<BrushStrokeCanvasComponent&>(comp->obj->get_comp());
Toolbar& t = drawP.world.main.toolbar;
t.gui.push_id("edit tool brush");
t.gui.text_label_centered("Edit Brush Stroke");
t.gui.left_to_right_line_layout([&]() {
if(t.gui.color_button_big("Outline Color", &a.d.color, &a.d.color == t.colorRight))
t.color_selector_right(&a.d.color == t.colorRight ? nullptr : &a.d.color);
t.gui.text_label("Outline Color");
});
t.gui.pop_id();
bool editHappened = a.d.color != oldColor;
oldColor = a.d.color;
return editHappened;
}
void BrushEditTool::edit_start(EditTool& editTool, CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
auto& a = static_cast<BrushStrokeCanvasComponent&>(comp->obj->get_comp());
oldColor = a.d.color;
}
void BrushEditTool::commit_edit_updates(CanvasComponentContainer::ObjInfo* comp, std::any& prevData) {
}
bool BrushEditTool::edit_update(CanvasComponentContainer::ObjInfo* comp) {
return true;
}

18
src/DrawingProgram/Tools/EditTools/BrushEditTool.hpp Normal file
View file

@ -0,0 +1,18 @@
#pragma once
#include "DrawingProgramEditToolBase.hpp"
#include "../../../CanvasComponents/BrushStrokeCanvasComponent.hpp"
#include <Helpers/SCollision.hpp>
#include <any>
class DrawingProgram;
class BrushEditTool : public DrawingProgramEditToolBase {
public:
BrushEditTool(DrawingProgram& initDrawP);
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:
Vector4f oldColor;
};

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

@ -42,11 +42,7 @@ void LassoSelectTool::gui_toolbox() {
auto& t = drawP.world.main.toolbar;
t.gui.push_id("lasso select tool");
t.gui.text_label_centered("Lasso Select");
t.gui.text_label("Select from:");
if(t.gui.radio_button_field("layer edited", "Layer being edited", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED;
if(t.gui.radio_button_field("all visible", "All visible layers", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS;
drawP.selection.selection_gui();
t.gui.pop_id();
}

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

@ -51,11 +51,11 @@ void LineDrawTool::tool_update() {
BrushStrokeCanvasComponentPoint p;
p.pos = drawP.world.main.input.mouse.pos;
p.width = toolConfig.get_relative_width(toolConfig.lineDraw.relativeWidth);
newBrushStroke.d->points.emplace_back(p);
newBrushStroke.d.points->emplace_back(p);
p.pos = ensure_points_have_distance(p.pos, p.pos, 1.0f);
newBrushStroke.d->points.emplace_back(p);
newBrushStroke.d->color = toolConfig.globalConf.foregroundColor;
newBrushStroke.d->hasRoundCaps = toolConfig.lineDraw.hasRoundCaps;
newBrushStroke.d.points->emplace_back(p);
newBrushStroke.d.color = toolConfig.globalConf.foregroundColor;
newBrushStroke.d.hasRoundCaps = toolConfig.lineDraw.hasRoundCaps;
newBrushStrokeContainer->coords = drawP.world.drawData.cam.c;
objInfoBeingEdited = drawP.layerMan.add_component_to_layer_being_edited(newBrushStrokeContainer);
}
@ -66,7 +66,7 @@ void LineDrawTool::tool_update() {
if(drawP.controls.leftClickHeld) {
BrushStrokeCanvasComponent& brushStroke = static_cast<BrushStrokeCanvasComponent&>(containerPtr->get_comp());
Vector2f newPos = containerPtr->coords.get_mouse_pos(drawP.world);
Vector2f oldPos = brushStroke.d->points.front().pos;
Vector2f oldPos = brushStroke.d.points->front().pos;
if(drawP.world.main.input.key(InputManager::KEY_GENERIC_LSHIFT).held) {
Vector2f diff = (newPos - oldPos);
float diffLength = diff.norm();
@ -76,7 +76,7 @@ void LineDrawTool::tool_update() {
angle = (angle * std::numbers::pi) / SNAP_DIVISION_COUNT;
newPos = oldPos + diffLength * Vector2f{cos(angle), sin(angle)};
}
brushStroke.d->points.back().pos = ensure_points_have_distance(oldPos, newPos, 1.0f);
brushStroke.d.points->back().pos = ensure_points_have_distance(oldPos, newPos, 1.0f);
containerPtr->send_comp_update(drawP, false);
containerPtr->commit_update(drawP);
}

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

@ -20,11 +20,7 @@ void RectSelectTool::gui_toolbox() {
auto& t = drawP.world.main.toolbar;
t.gui.push_id("rectangle select tool");
t.gui.text_label_centered("Rectangle Select");
t.gui.text_label("Select from:");
if(t.gui.radio_button_field("layer edited", "Layer being edited", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::LAYER_BEING_EDITED;
if(t.gui.radio_button_field("all visible", "All visible layers", drawP.controls.layerSelector == DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS))
drawP.controls.layerSelector = DrawingProgramLayerManager::LayerSelector::ALL_VISIBLE_LAYERS;
drawP.selection.selection_gui();
t.gui.pop_id();
}