Finished separation of FDM gizmo into base and child

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -0,0 +1,296 @@
+#include "GLGizmoFdmSupports.hpp"
+
+#include "libslic3r/Model.hpp"
+
+//#include "slic3r/GUI/3DScene.hpp"
+#include "slic3r/GUI/GLCanvas3D.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/GUI/ImGuiWrapper.hpp"
+#include "slic3r/GUI/Plater.hpp"
+
+
+#include <GL/glew.h>
+
+
+namespace Slic3r {
+
+namespace GUI {
+
+
+
+void GLGizmoFdmSupports::on_opening()
+{
+
+}
+
+
+
+void GLGizmoFdmSupports::on_shutdown()
+{
+    if (m_setting_angle) {
+        m_setting_angle = false;
+        m_parent.use_slope(false);
+    }
+}
+
+
+
+bool GLGizmoFdmSupports::on_init()
+{
+    m_shortcut_key = WXK_CONTROL_L;
+
+    m_desc["clipping_of_view"] = _L("Clipping of view") + ": ";
+    m_desc["reset_direction"]  = _L("Reset direction");
+    m_desc["cursor_size"]      = _L("Cursor size") + ": ";
+    m_desc["enforce_caption"]  = _L("Left mouse button") + ": ";
+    m_desc["enforce"]          = _L("Enforce supports");
+    m_desc["block_caption"]    = _L("Right mouse button") + " ";
+    m_desc["block"]            = _L("Block supports");
+    m_desc["remove_caption"]   = _L("Shift + Left mouse button") + ": ";
+    m_desc["remove"]           = _L("Remove selection");
+    m_desc["remove_all"]       = _L("Remove all selection");
+
+    return true;
+}
+
+
+
+void GLGizmoFdmSupports::on_render() const
+{
+    const Selection& selection = m_parent.get_selection();
+
+    glsafe(::glEnable(GL_BLEND));
+    glsafe(::glEnable(GL_DEPTH_TEST));
+
+    if (! m_setting_angle)
+        render_triangles(selection);
+
+    m_c->object_clipper()->render_cut();
+    render_cursor_circle();
+
+    glsafe(::glDisable(GL_BLEND));
+}
+
+
+
+void GLGizmoFdmSupports::on_render_input_window(float x, float y, float bottom_limit)
+{
+    if (! m_c->selection_info()->model_object())
+        return;
+
+    const float approx_height = m_imgui->scaled(18.0f);
+    y = std::min(y, bottom_limit - approx_height);
+    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
+
+    if (! m_setting_angle) {
+        m_imgui->begin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
+
+        // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
+        const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x, m_imgui->calc_text_size(m_desc.at("reset_direction")).x) + m_imgui->scaled(1.5f);
+        const float cursor_slider_left = m_imgui->calc_text_size(m_desc.at("cursor_size")).x + m_imgui->scaled(1.f);
+        const float button_width = m_imgui->calc_text_size(m_desc.at("remove_all")).x + m_imgui->scaled(1.f);
+        const float minimal_slider_width = m_imgui->scaled(4.f);
+
+        float caption_max = 0.f;
+        float total_text_max = 0.;
+        for (const std::string& t : {"enforce", "block", "remove"}) {
+            caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc.at(t+"_caption")).x);
+            total_text_max = std::max(total_text_max, caption_max + m_imgui->calc_text_size(m_desc.at(t)).x);
+        }
+        caption_max += m_imgui->scaled(1.f);
+        total_text_max += m_imgui->scaled(1.f);
+
+        float window_width = minimal_slider_width + std::max(cursor_slider_left, clipping_slider_left);
+        window_width = std::max(window_width, total_text_max);
+        window_width = std::max(window_width, button_width);
+
+        auto draw_text_with_caption = [this, &caption_max](const wxString& caption, const wxString& text) {
+            static const ImVec4 ORANGE(1.0f, 0.49f, 0.22f, 1.0f);
+            m_imgui->text_colored(ORANGE, caption);
+            ImGui::SameLine(caption_max);
+            m_imgui->text(text);
+        };
+
+        for (const std::string& t : {"enforce", "block", "remove"})
+            draw_text_with_caption(m_desc.at(t + "_caption"), m_desc.at(t));
+
+        m_imgui->text("");
+
+        if (m_imgui->button("Autoset by angle...")) {
+            m_setting_angle = true;
+        }
+
+        ImGui::SameLine();
+
+        if (m_imgui->button(m_desc.at("remove_all"))) {
+            Plater::TakeSnapshot(wxGetApp().plater(), wxString(_L("Reset selection")));
+            ModelObject* mo = m_c->selection_info()->model_object();
+            int idx = -1;
+            for (ModelVolume* mv : mo->volumes) {
+                if (mv->is_model_part()) {
+                    ++idx;
+                    m_triangle_selectors[idx]->reset();
+                }
+            }
+
+            update_model_object();
+            m_parent.set_as_dirty();
+        }
+
+        const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
+
+        m_imgui->text(m_desc.at("cursor_size"));
+        ImGui::SameLine(clipping_slider_left);
+        ImGui::PushItemWidth(window_width - clipping_slider_left);
+        ImGui::SliderFloat(" ", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f");
+        if (ImGui::IsItemHovered()) {
+            ImGui::BeginTooltip();
+            ImGui::PushTextWrapPos(max_tooltip_width);
+            ImGui::TextUnformatted(_L("Alt + Mouse wheel").ToUTF8().data());
+            ImGui::PopTextWrapPos();
+            ImGui::EndTooltip();
+        }
+
+        ImGui::Separator();
+        if (m_c->object_clipper()->get_position() == 0.f)
+            m_imgui->text(m_desc.at("clipping_of_view"));
+        else {
+            if (m_imgui->button(m_desc.at("reset_direction"))) {
+                wxGetApp().CallAfter([this](){
+                        m_c->object_clipper()->set_position(-1., false);
+                    });
+            }
+        }
+
+        ImGui::SameLine(clipping_slider_left);
+        ImGui::PushItemWidth(window_width - clipping_slider_left);
+        float clp_dist = m_c->object_clipper()->get_position();
+        if (ImGui::SliderFloat("  ", &clp_dist, 0.f, 1.f, "%.2f"))
+        m_c->object_clipper()->set_position(clp_dist, true);
+        if (ImGui::IsItemHovered()) {
+            ImGui::BeginTooltip();
+            ImGui::PushTextWrapPos(max_tooltip_width);
+            ImGui::TextUnformatted(_L("Ctrl + Mouse wheel").ToUTF8().data());
+            ImGui::PopTextWrapPos();
+            ImGui::EndTooltip();
+        }
+
+        m_imgui->end();
+        if (m_setting_angle) {
+            m_parent.show_slope(false);
+            m_parent.set_slope_range({90.f - m_angle_threshold_deg, 90.f - m_angle_threshold_deg});
+            m_parent.use_slope(true);
+            m_parent.set_as_dirty();
+        }
+    }
+    else {
+        std::string name = "Autoset custom supports";
+        m_imgui->begin(wxString(name), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
+        m_imgui->text("Threshold:");
+        ImGui::SameLine();
+        if (m_imgui->slider_float("", &m_angle_threshold_deg, 0.f, 90.f, "%.f"))
+            m_parent.set_slope_range({90.f - m_angle_threshold_deg, 90.f - m_angle_threshold_deg});
+        if (m_imgui->button("Enforce"))
+            select_facets_by_angle(m_angle_threshold_deg, false);
+        ImGui::SameLine();
+        if (m_imgui->button("Block"))
+            select_facets_by_angle(m_angle_threshold_deg, true);
+        ImGui::SameLine();
+        if (m_imgui->button("Cancel"))
+            m_setting_angle = false;
+        m_imgui->end();
+        if (! m_setting_angle) {
+            m_parent.use_slope(false);
+            m_parent.set_as_dirty();
+        }
+    }
+}
+
+
+
+void GLGizmoFdmSupports::select_facets_by_angle(float threshold_deg, bool block)
+{
+    float threshold = (M_PI/180.)*threshold_deg;
+    const Selection& selection = m_parent.get_selection();
+    const ModelObject* mo = m_c->selection_info()->model_object();
+    const ModelInstance* mi = mo->instances[selection.get_instance_idx()];
+
+    int mesh_id = -1;
+    for (const ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+
+        ++mesh_id;
+
+        const Transform3d trafo_matrix = mi->get_matrix(true) * mv->get_matrix(true);
+        Vec3f down  = (trafo_matrix.inverse() * (-Vec3d::UnitZ())).cast<float>().normalized();
+        Vec3f limit = (trafo_matrix.inverse() * Vec3d(std::sin(threshold), 0, -std::cos(threshold))).cast<float>().normalized();
+
+        float dot_limit = limit.dot(down);
+
+        // Now calculate dot product of vert_direction and facets' normals.
+        int idx = -1;
+        for (const stl_facet& facet : mv->mesh().stl.facet_start) {
+            ++idx;
+            if (facet.normal.dot(down) > dot_limit)
+                m_triangle_selectors[mesh_id]->set_facet(idx,
+                                                         block
+                                                         ? EnforcerBlockerType::BLOCKER
+                                                         : EnforcerBlockerType::ENFORCER);
+        }
+    }
+
+    activate_internal_undo_redo_stack(true);
+
+    Plater::TakeSnapshot(wxGetApp().plater(), block ? _L("Block supports by angle")
+                                                    : _L("Add supports by angle"));
+    update_model_object();
+    m_parent.set_as_dirty();
+    m_setting_angle = false;
+}
+
+
+
+void GLGizmoFdmSupports::update_model_object() const
+{
+    bool updated = false;
+    ModelObject* mo = m_c->selection_info()->model_object();
+    int idx = -1;
+    for (ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+        ++idx;
+        updated |= mv->m_supported_facets.set(*m_triangle_selectors[idx].get());
+    }
+
+    if (updated)
+        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
+}
+
+
+
+void GLGizmoFdmSupports::update_from_model_object()
+{
+    wxBusyCursor wait;
+
+    const ModelObject* mo = m_c->selection_info()->model_object();
+    m_triangle_selectors.clear();
+
+    int volume_id = -1;
+    for (const ModelVolume* mv : mo->volumes) {
+        if (! mv->is_model_part())
+            continue;
+
+        ++volume_id;
+
+        // This mesh does not account for the possible Z up SLA offset.
+        const TriangleMesh* mesh = &mv->mesh();
+
+        m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorGUI>(*mesh));
+        m_triangle_selectors.back()->deserialize(mv->m_supported_facets.get_data());
+    }
+}
+
+
+} // namespace GUI
+} // namespace Slic3r

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp

@@ -13,6 +13,29 @@ public:
     GLGizmoFdmSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
         : GLGizmoPainterBase(parent, icon_filename, sprite_id) {}
 
+protected:
+    void on_render_input_window(float x, float y, float bottom_limit) override;
+
+private:
+    bool on_init() override;
+    void on_render() const override;
+    void on_render_for_picking() const override {}
+
+    void update_model_object() const override;
+    void update_from_model_object() override;
+
+    void on_opening() override;
+    void on_shutdown() override;
+
+    void select_facets_by_angle(float threshold, bool block);
+    float m_angle_threshold_deg = 45.f;
+    bool m_setting_angle = false;
+
+
+
+    // This map holds all translated description texts, so they can be easily referenced during layout calculations
+    // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.
+    std::map<std::string, wxString> m_desc;
 };
 
 

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp

@@ -19,39 +19,10 @@ namespace GUI {
 
 GLGizmoPainterBase::GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
     : GLGizmoBase(parent, icon_filename, sprite_id)
-    , m_quadric(nullptr)
 {
     m_clipping_plane.reset(new ClippingPlane());
-    m_quadric = ::gluNewQuadric();
-    if (m_quadric != nullptr)
-        // using GLU_FILL does not work when the instance's transformation
-        // contains mirroring (normals are reverted)
-        ::gluQuadricDrawStyle(m_quadric, GLU_FILL);
 }
 
-GLGizmoPainterBase::~GLGizmoPainterBase()
-{
-    if (m_quadric != nullptr)
-        ::gluDeleteQuadric(m_quadric);
-}
-
-bool GLGizmoPainterBase::on_init()
-{
-    m_shortcut_key = WXK_CONTROL_L;
-
-    m_desc["clipping_of_view"] = _L("Clipping of view") + ": ";
-    m_desc["reset_direction"]  = _L("Reset direction");
-    m_desc["cursor_size"]      = _L("Cursor size") + ": ";
-    m_desc["enforce_caption"]  = _L("Left mouse button") + ": ";
-    m_desc["enforce"]          = _L("Enforce supports");
-    m_desc["block_caption"]    = _L("Right mouse button") + " ";
-    m_desc["block"]            = _L("Block supports");
-    m_desc["remove_caption"]   = _L("Shift + Left mouse button") + ": ";
-    m_desc["remove"]           = _L("Remove selection");
-    m_desc["remove_all"]       = _L("Remove all selection");
-
-    return true;
-}
 
 
 void GLGizmoPainterBase::activate_internal_undo_redo_stack(bool activate)
@@ -68,7 +39,9 @@ void GLGizmoPainterBase::activate_internal_undo_redo_stack(bool activate)
     }
 }
 
-void GLGizmoPainterBase::set_fdm_support_data(ModelObject* model_object, const Selection& selection)
+
+
+void GLGizmoPainterBase::set_painter_gizmo_data(const Selection& selection)
 {
     if (m_state != On)
         return;
@@ -87,26 +60,8 @@ void GLGizmoPainterBase::set_fdm_support_data(ModelObject* model_object, const S
 
 
 
-void GLGizmoPainterBase::on_render() const
-{
-    const Selection& selection = m_parent.get_selection();
-
-    glsafe(::glEnable(GL_BLEND));
-    glsafe(::glEnable(GL_DEPTH_TEST));
-
-    render_triangles(selection);
-
-    m_c->object_clipper()->render_cut();
-    render_cursor_circle();
-
-    glsafe(::glDisable(GL_BLEND));
-}
-
 void GLGizmoPainterBase::render_triangles(const Selection& selection) const
 {
-    if (m_setting_angle)
-        return;
-
     const ModelObject* mo = m_c->selection_info()->model_object();
 
     glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
@@ -145,8 +100,7 @@ void GLGizmoPainterBase::render_triangles(const Selection& selection) const
         glsafe(::glPushMatrix());
         glsafe(::glMultMatrixd(trafo_matrix.data()));
 
-        if (! m_setting_angle)
+        m_triangle_selectors[mesh_id]->render(m_imgui);
-            m_triangle_selectors[mesh_id]->render(m_imgui);
 
         glsafe(::glPopMatrix());
         if (is_left_handed)
@@ -202,46 +156,6 @@ void GLGizmoPainterBase::render_cursor_circle() const
 }
 
 
-void GLGizmoPainterBase::update_model_object() const
-{
-    bool updated = false;
-    ModelObject* mo = m_c->selection_info()->model_object();
-    int idx = -1;
-    for (ModelVolume* mv : mo->volumes) {
-        if (! mv->is_model_part())
-            continue;
-        ++idx;
-        updated |= mv->m_supported_facets.set(*m_triangle_selectors[idx].get());
-    }
-
-    if (updated)
-        m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
-}
-
-
-void GLGizmoPainterBase::update_from_model_object()
-{
-    wxBusyCursor wait;
-
-    const ModelObject* mo = m_c->selection_info()->model_object();
-    m_triangle_selectors.clear();
-
-    int volume_id = -1;
-    for (const ModelVolume* mv : mo->volumes) {
-        if (! mv->is_model_part())
-            continue;
-
-        ++volume_id;
-
-        // This mesh does not account for the possible Z up SLA offset.
-        const TriangleMesh* mesh = &mv->mesh();
-
-        m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorGUI>(*mesh));
-        m_triangle_selectors.back()->deserialize(mv->m_supported_facets.get_data());
-    }
-}
-
-
 
 bool GLGizmoPainterBase::is_mesh_point_clipped(const Vec3d& point) const
 {
@@ -461,179 +375,10 @@ bool GLGizmoPainterBase::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
 
 
 
-void GLGizmoPainterBase::select_facets_by_angle(float threshold_deg, bool block)
-{
-    float threshold = (M_PI/180.)*threshold_deg;
-    const Selection& selection = m_parent.get_selection();
-    const ModelObject* mo = m_c->selection_info()->model_object();
-    const ModelInstance* mi = mo->instances[selection.get_instance_idx()];
-
-    int mesh_id = -1;
-    for (const ModelVolume* mv : mo->volumes) {
-        if (! mv->is_model_part())
-            continue;
-
-        ++mesh_id;
-
-        const Transform3d trafo_matrix = mi->get_matrix(true) * mv->get_matrix(true);
-        Vec3f down  = (trafo_matrix.inverse() * (-Vec3d::UnitZ())).cast<float>().normalized();
-        Vec3f limit = (trafo_matrix.inverse() * Vec3d(std::sin(threshold), 0, -std::cos(threshold))).cast<float>().normalized();
-
-        float dot_limit = limit.dot(down);
-
-        // Now calculate dot product of vert_direction and facets' normals.
-        int idx = -1;
-        for (const stl_facet& facet : mv->mesh().stl.facet_start) {
-            ++idx;
-            if (facet.normal.dot(down) > dot_limit)
-                m_triangle_selectors[mesh_id]->set_facet(idx,
-                                                         block
-                                                         ? EnforcerBlockerType::BLOCKER
-                                                         : EnforcerBlockerType::ENFORCER);
-        }
-    }
-
-    activate_internal_undo_redo_stack(true);
-
-    Plater::TakeSnapshot(wxGetApp().plater(), block ? _L("Block supports by angle")
-                                                    : _L("Add supports by angle"));
-    update_model_object();
-    m_parent.set_as_dirty();
-    m_setting_angle = false;
-}
 
 
-void GLGizmoPainterBase::on_render_input_window(float x, float y, float bottom_limit)
-{
-    if (! m_c->selection_info()->model_object())
-        return;
 
-    const float approx_height = m_imgui->scaled(18.0f);
-    y = std::min(y, bottom_limit - approx_height);
-    m_imgui->set_next_window_pos(x, y, ImGuiCond_Always);
 
-    if (! m_setting_angle) {
-        m_imgui->begin(on_get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
-
-        // First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
-        const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x, m_imgui->calc_text_size(m_desc.at("reset_direction")).x) + m_imgui->scaled(1.5f);
-        const float cursor_slider_left = m_imgui->calc_text_size(m_desc.at("cursor_size")).x + m_imgui->scaled(1.f);
-        const float button_width = m_imgui->calc_text_size(m_desc.at("remove_all")).x + m_imgui->scaled(1.f);
-        const float minimal_slider_width = m_imgui->scaled(4.f);
-
-        float caption_max = 0.f;
-        float total_text_max = 0.;
-        for (const std::string& t : {"enforce", "block", "remove"}) {
-            caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc.at(t+"_caption")).x);
-            total_text_max = std::max(total_text_max, caption_max + m_imgui->calc_text_size(m_desc.at(t)).x);
-        }
-        caption_max += m_imgui->scaled(1.f);
-        total_text_max += m_imgui->scaled(1.f);
-
-        float window_width = minimal_slider_width + std::max(cursor_slider_left, clipping_slider_left);
-        window_width = std::max(window_width, total_text_max);
-        window_width = std::max(window_width, button_width);
-
-        auto draw_text_with_caption = [this, &caption_max](const wxString& caption, const wxString& text) {
-            static const ImVec4 ORANGE(1.0f, 0.49f, 0.22f, 1.0f);
-            m_imgui->text_colored(ORANGE, caption);
-            ImGui::SameLine(caption_max);
-            m_imgui->text(text);
-        };
-
-        for (const std::string& t : {"enforce", "block", "remove"})
-            draw_text_with_caption(m_desc.at(t + "_caption"), m_desc.at(t));
-
-        m_imgui->text("");
-
-        if (m_imgui->button("Autoset by angle...")) {
-            m_setting_angle = true;
-        }
-
-        ImGui::SameLine();
-
-        if (m_imgui->button(m_desc.at("remove_all"))) {
-            Plater::TakeSnapshot(wxGetApp().plater(), wxString(_L("Reset selection")));
-            ModelObject* mo = m_c->selection_info()->model_object();
-            int idx = -1;
-            for (ModelVolume* mv : mo->volumes) {
-                if (mv->is_model_part()) {
-                    ++idx;
-                    m_triangle_selectors[idx]->reset();
-                }
-            }
-            update_model_object();
-            m_parent.set_as_dirty();
-        }
-
-        const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
-
-        m_imgui->text(m_desc.at("cursor_size"));
-        ImGui::SameLine(clipping_slider_left);
-        ImGui::PushItemWidth(window_width - clipping_slider_left);
-        ImGui::SliderFloat(" ", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f");
-        if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            ImGui::PushTextWrapPos(max_tooltip_width);
-            ImGui::TextUnformatted(_L("Alt + Mouse wheel").ToUTF8().data());
-            ImGui::PopTextWrapPos();
-            ImGui::EndTooltip();
-        }
-
-        ImGui::Separator();
-        if (m_c->object_clipper()->get_position() == 0.f)
-            m_imgui->text(m_desc.at("clipping_of_view"));
-        else {
-            if (m_imgui->button(m_desc.at("reset_direction"))) {
-                wxGetApp().CallAfter([this](){
-                        m_c->object_clipper()->set_position(-1., false);
-                    });
-            }
-        }
-
-        ImGui::SameLine(clipping_slider_left);
-        ImGui::PushItemWidth(window_width - clipping_slider_left);
-        float clp_dist = m_c->object_clipper()->get_position();
-        if (ImGui::SliderFloat("  ", &clp_dist, 0.f, 1.f, "%.2f"))
-        m_c->object_clipper()->set_position(clp_dist, true);
-        if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            ImGui::PushTextWrapPos(max_tooltip_width);
-            ImGui::TextUnformatted(_L("Ctrl + Mouse wheel").ToUTF8().data());
-            ImGui::PopTextWrapPos();
-            ImGui::EndTooltip();
-        }
-
-        m_imgui->end();
-        if (m_setting_angle) {
-            m_parent.show_slope(false);
-            m_parent.set_slope_range({90.f - m_angle_threshold_deg, 90.f - m_angle_threshold_deg});
-            m_parent.use_slope(true);
-            m_parent.set_as_dirty();
-        }
-    }
-    else {
-        std::string name = "Autoset custom supports";
-        m_imgui->begin(wxString(name), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse);
-        m_imgui->text("Threshold:");
-        ImGui::SameLine();
-        if (m_imgui->slider_float("", &m_angle_threshold_deg, 0.f, 90.f, "%.f"))
-            m_parent.set_slope_range({90.f - m_angle_threshold_deg, 90.f - m_angle_threshold_deg});
-        if (m_imgui->button("Enforce"))
-            select_facets_by_angle(m_angle_threshold_deg, false);
-        ImGui::SameLine();
-        if (m_imgui->button("Block"))
-            select_facets_by_angle(m_angle_threshold_deg, true);
-        ImGui::SameLine();
-        if (m_imgui->button("Cancel"))
-            m_setting_angle = false;
-        m_imgui->end();
-        if (! m_setting_angle) {
-            m_parent.use_slope(false);
-            m_parent.set_as_dirty();
-        }
-    }
-}
 
 bool GLGizmoPainterBase::on_is_activable() const
 {
@@ -680,6 +425,7 @@ void GLGizmoPainterBase::on_set_state()
         return;
 
     if (m_state == On && m_old_state != On) { // the gizmo was just turned on
+        on_opening();
         if (! m_parent.get_gizmos_manager().is_serializing()) {
             wxGetApp().CallAfter([this]() {
                 activate_internal_undo_redo_stack(true);
@@ -688,10 +434,7 @@ void GLGizmoPainterBase::on_set_state()
     }
     if (m_state == Off && m_old_state != Off) { // the gizmo was just turned Off
         // we are actually shutting down
-        if (m_setting_angle) {
+        on_shutdown();
-            m_setting_angle = false;
-            m_parent.use_slope(false);
-        }
         activate_internal_undo_redo_stack(false);
         m_old_mo_id = -1;
         //m_iva.release_geometry();
@@ -702,37 +445,18 @@ void GLGizmoPainterBase::on_set_state()
 
 
 
-void GLGizmoPainterBase::on_start_dragging()
-{
-
-}
-
-
-void GLGizmoPainterBase::on_stop_dragging()
-{
-
-}
-
-
-
 void GLGizmoPainterBase::on_load(cereal::BinaryInputArchive&)
 {
     // We should update the gizmo from current ModelObject, but it is not
     // possible at this point. That would require having updated selection and
     // common gizmos data, which is not done at this point. Instead, save
-    // a flag to do the update in set_fdm_support_data, which will be called
+    // a flag to do the update in set_painter_gizmo_data, which will be called
     // soon after.
     m_schedule_update = true;
 }
 
 
 
-void GLGizmoPainterBase::on_save(cereal::BinaryOutputArchive&) const
-{
-
-}
-
-
 void TriangleSelectorGUI::render(ImGuiWrapper* imgui)
 {
     int enf_cnt = 0;

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp

@@ -46,14 +46,27 @@ private:
 };
 
 
-
+// Following class is a base class for a gizmo with ability to paint on mesh
+// using circular blush (such as FDM supports gizmo and seam painting gizmo).
+// The purpose is not to duplicate code related to mesh painting.
 class GLGizmoPainterBase : public GLGizmoBase
 {
 private:
     ObjectID m_old_mo_id;
     size_t m_old_volumes_size = 0;
 
-    GLUquadricObj* m_quadric;
+public:
+    GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
+    ~GLGizmoPainterBase() override {}
+    void set_painter_gizmo_data(const Selection& selection);
+    bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
+
+protected:
+    void render_triangles(const Selection& selection) const;
+    void render_cursor_circle() const;
+    virtual void update_model_object() const = 0;
+    virtual void update_from_model_object() = 0;
+    void activate_internal_undo_redo_stack(bool activate);
 
     float m_cursor_radius = 2.f;
     static constexpr float CursorRadiusMin  = 0.4f; // cannot be zero
@@ -63,41 +76,17 @@ private:
     // For each model-part volume, store status and division of the triangles.
     std::vector<std::unique_ptr<TriangleSelectorGUI>> m_triangle_selectors;
 
-public:
-    GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
-    ~GLGizmoPainterBase() override;
-    void set_fdm_support_data(ModelObject* model_object, const Selection& selection);
-    bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
-
 
 private:
-    bool on_init() override;
-    void on_render() const override;
-    void on_render_for_picking() const override {}
-
-    void render_triangles(const Selection& selection) const;
-    void render_cursor_circle() const;
-
-    void update_model_object() const;
-    void update_from_model_object();
-    void activate_internal_undo_redo_stack(bool activate);
-
-    void select_facets_by_angle(float threshold, bool block);
-    float m_angle_threshold_deg = 45.f;
-
     bool is_mesh_point_clipped(const Vec3d& point) const;
 
     float m_clipping_plane_distance = 0.f;
     std::unique_ptr<ClippingPlane> m_clipping_plane;
-    bool m_setting_angle = false;
+
     bool m_internal_stack_active = false;
     bool m_schedule_update = false;
     Vec2d m_last_mouse_position = Vec2d::Zero();
 
-    // This map holds all translated description texts, so they can be easily referenced during layout calculations
-    // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.
-    std::map<std::string, wxString> m_desc;
-
     enum class Button {
         None,
         Left,
@@ -109,14 +98,17 @@ private:
 
 protected:
     void on_set_state() override;
-    void on_start_dragging() override;
+    void on_start_dragging() override {}
-    void on_stop_dragging() override;
+    void on_stop_dragging() override {}
-    void on_render_input_window(float x, float y, float bottom_limit) override;
+
+    virtual void on_opening() = 0;
+    virtual void on_shutdown() = 0;
+
     std::string on_get_name() const override;
     bool on_is_activable() const override;
     bool on_is_selectable() const override;
     void on_load(cereal::BinaryInputArchive& ar) override;
-    void on_save(cereal::BinaryOutputArchive& ar) const override;
+    void on_save(cereal::BinaryOutputArchive& ar) const override {}
     CommonGizmosDataID on_get_requirements() const override;
 };
 

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -221,7 +221,7 @@ void GLGizmosManager::update_data()
         ModelObject* model_object = selection.get_model()->objects[selection.get_object_idx()];
         set_flattening_data(model_object);
         set_sla_support_data(model_object);
-        set_fdm_support_data(model_object);
+        set_painter_gizmo_data();
     }
     else if (selection.is_single_volume() || selection.is_single_modifier())
     {
@@ -230,7 +230,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d::Zero());
         set_flattening_data(nullptr);
         set_sla_support_data(nullptr);
-        set_fdm_support_data(nullptr);
+        set_painter_gizmo_data();
     }
     else if (is_wipe_tower)
     {
@@ -239,7 +239,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d(0., 0., (M_PI/180.) * dynamic_cast<const ConfigOptionFloat*>(config.option("wipe_tower_rotation_angle"))->value));
         set_flattening_data(nullptr);
         set_sla_support_data(nullptr);
-        set_fdm_support_data(nullptr);
+        set_painter_gizmo_data();
     }
     else
     {
@@ -247,7 +247,7 @@ void GLGizmosManager::update_data()
         set_rotation(Vec3d::Zero());
         set_flattening_data(selection.is_from_single_object() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr);
         set_sla_support_data(selection.is_from_single_instance() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr);
-        set_fdm_support_data(selection.is_from_single_instance() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr);
+        set_painter_gizmo_data();
     }
 }
 
@@ -382,12 +382,12 @@ void GLGizmosManager::set_sla_support_data(ModelObject* model_object)
     gizmo_supports->set_sla_support_data(model_object, m_parent.get_selection());
 }
 
-void GLGizmosManager::set_fdm_support_data(ModelObject* model_object)
+void GLGizmosManager::set_painter_gizmo_data()
 {
     if (!m_enabled || m_gizmos.empty())
         return;
 
-    dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_fdm_support_data(model_object, m_parent.get_selection());
+    dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_painter_gizmo_data(m_parent.get_selection());
 }
 
 // Returns true if the gizmo used the event to do something, false otherwise.

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -203,7 +203,7 @@ public:
 
     void set_sla_support_data(ModelObject* model_object);
 
-    void set_fdm_support_data(ModelObject* model_object);
+    void set_painter_gizmo_data();
 
     bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position = Vec2d::Zero(), bool shift_down = false, bool alt_down = false, bool control_down = false);
     ClippingPlane get_clipping_plane() const;