Clean up GLGizmoManagaer

Clean up GLGizmoBase

src/slic3r/GUI/Gizmos/GLGizmoBase.cpp

@@ -89,9 +89,6 @@ GLGizmoBase::GLGizmoBase(GLCanvas3D& parent, const std::string& icon_filename, u
     , m_first_input_window_render(true)
     , m_dirty(false)
 {
-    m_base_color = DEFAULT_BASE_COLOR;
-    m_drag_color = DEFAULT_DRAG_COLOR;
-    m_highlight_color = DEFAULT_HIGHLIGHT_COLOR;
     m_cone.init_from(its_make_cone(1., 1., 2 * PI / 24));
     m_sphere.init_from(its_make_sphere(1., (2 * M_PI) / 24.));
     m_cylinder.init_from(its_make_cylinder(1., 1., 2 * PI / 24.));
@@ -110,51 +107,6 @@ void GLGizmoBase::set_hover_id(int id)
     on_set_hover_id();    
 }
 
-void GLGizmoBase::set_highlight_color(const std::array<float, 4>& color)
-{
-    m_highlight_color = color;
-}
-
-void GLGizmoBase::enable_grabber(unsigned int id)
-{
-    if (id < m_grabbers.size())
-        m_grabbers[id].enabled = true;
-
-    on_enable_grabber(id);
-}
-
-void GLGizmoBase::disable_grabber(unsigned int id)
-{
-    if (id < m_grabbers.size())
-        m_grabbers[id].enabled = false;
-
-    on_disable_grabber(id);
-}
-
-void GLGizmoBase::start_dragging()
-{
-    m_dragging = true;
-
-    for (int i = 0; i < (int)m_grabbers.size(); ++i)
-    {
-        m_grabbers[i].dragging = (m_hover_id == i);
-    }
-
-    on_start_dragging();
-}
-
-void GLGizmoBase::stop_dragging()
-{
-    m_dragging = false;
-
-    for (int i = 0; i < (int)m_grabbers.size(); ++i)
-    {
-        m_grabbers[i].dragging = false;
-    }
-
-    on_stop_dragging();
-}
-
 bool GLGizmoBase::update_items_state()
 {
     bool res = m_dirty;
@@ -225,13 +177,18 @@ bool GLGizmoBase::use_grabbers(const wxMouseEvent &mouse_event) {
     if (mouse_event.LeftDown()) {
         Selection &selection = m_parent.get_selection();
         if (!selection.is_empty() && m_hover_id != -1) {
+            // TODO: investigate if it is neccessary -> there was no stop dragging
             selection.start_dragging();
 
-            start_dragging();
+            m_dragging = true;
+            for (auto &grabber : m_grabbers) grabber.dragging = false;
+            if (!m_grabbers.empty() && m_hover_id < m_grabbers.size())
+                m_grabbers[m_hover_id].dragging = true;            
+            
+            on_start_dragging();
 
             // Let the plater know that the dragging started
-            m_parent.post_event(
+            m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_STARTED));
-                SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_STARTED));
             m_parent.set_as_dirty();
             return true;
         }
@@ -248,16 +205,22 @@ bool GLGizmoBase::use_grabbers(const wxMouseEvent &mouse_event) {
             m_parent.set_as_dirty();
             return true;
         } else if (mouse_event.LeftUp()) {
-            stop_dragging();
+            for (auto &grabber : m_grabbers) grabber.dragging = false;
+            m_dragging = false;
 
+            on_stop_dragging();
+
+            // There is prediction that after draggign, data are changed
+            // Data are updated twice also by canvas3D::reload_scene.
+            // Should be fixed.
             m_parent.get_gizmos_manager().update_data(); 
+
             wxGetApp().obj_manipul()->set_dirty();
 
             // Let the plater know that the dragging finished, so a delayed
             // refresh of the scene with the background processing data should
             // be performed.
-            m_parent.post_event(
+            m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
-                SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
             // updates camera target constraints
             m_parent.refresh_camera_scene_box();
             return true;

src/slic3r/GUI/Gizmos/GLGizmoBase.hpp

@@ -32,7 +32,6 @@ class ImGuiWrapper;
 class GLCanvas3D;
 enum class CommonGizmosDataID;
 class CommonGizmosDataPool;
-class Selection;
 
 class GLGizmoBase
 {
@@ -89,21 +88,16 @@ public:
 
 protected:
     GLCanvas3D& m_parent;
-
+    int m_group_id; // TODO: remove only for rotate
-    int m_group_id;
     EState m_state;
     int m_shortcut_key;
     std::string m_icon_filename;
     unsigned int m_sprite_id;
     int m_hover_id;
     bool m_dragging;
-    std::array<float, 4> m_base_color;
-    std::array<float, 4> m_drag_color;
-    std::array<float, 4> m_highlight_color;
     mutable std::vector<Grabber> m_grabbers;
     ImGuiWrapper* m_imgui;
     bool m_first_input_window_render;
-    mutable std::string m_tooltip;
     CommonGizmosDataPool* m_c;
     GLModel m_cone;
     GLModel m_cylinder;
@@ -122,9 +116,6 @@ public:
 
     std::string get_name(bool include_shortcut = true) const;
 
-    int get_group_id() const { return m_group_id; }
-    void set_group_id(int id) { m_group_id = id; }
-
     EState get_state() const { return m_state; }
     void set_state(EState state) { m_state = state; on_set_state(); }
 
@@ -146,25 +137,26 @@ public:
     int get_hover_id() const { return m_hover_id; }
     void set_hover_id(int id);
     
-    void set_highlight_color(const std::array<float, 4>& color);
-
-    void enable_grabber(unsigned int id);
-    void disable_grabber(unsigned int id);
-
-    void start_dragging();
-    void stop_dragging();
-
     bool is_dragging() const { return m_dragging; }
 
     // returns True when Gizmo changed its state
     bool update_items_state();
 
-    void render() { m_tooltip.clear(); on_render(); }
+    void render() { on_render(); }
     void render_for_picking() { on_render_for_picking(); }
     void render_input_window(float x, float y, float bottom_limit);
 
+    /// <summary>
+    /// Mouse tooltip text
+    /// </summary>
+    /// <returns>Text to be visible in mouse tooltip</returns>
     virtual std::string get_tooltip() const { return ""; }
 
+    /// <summary>
+    /// Is called when data (Selection) is changed
+    /// </summary>
+    virtual void data_changed(){};
+
     /// <summary>
     /// Implement when want to process mouse events in gizmo
     /// Click, Right click, move, drag, ...
@@ -207,10 +199,12 @@ protected:
     void set_dirty();
 
     /// <summary>
-    /// 
+    /// function which 
+    /// Set up m_dragging and call functions
+    /// on_start_dragging / on_dragging / on_stop_dragging
     /// </summary>
-    /// <param name="mouse_event"></param>
+    /// <param name="mouse_event">Keep information about mouse click</param>
-    /// <returns></returns>
+    /// <returns>same as on_mouse</returns>
     bool use_grabbers(const wxMouseEvent &mouse_event);
 private:
     // Flag for dirty visible state of Gizmo

src/slic3r/GUI/Gizmos/GLGizmoCut.cpp

@@ -58,7 +58,7 @@ std::string GLGizmoCut::on_get_name() const
 void GLGizmoCut::on_set_state()
 {
     // Reset m_cut_z on gizmo activation
-    if (get_state() == On)
+    if (m_state == On)
         m_cut_z = bounding_box().center().z();
 }
 

src/slic3r/GUI/Gizmos/GLGizmoCut.hpp

@@ -8,6 +8,7 @@
 
 namespace Slic3r {
 namespace GUI {
+class Selection;
 
 class GLGizmoCut : public GLGizmoBase
 {

src/slic3r/GUI/Gizmos/GLGizmoFlatten.cpp

@@ -44,6 +44,17 @@ bool GLGizmoFlatten::on_mouse(const wxMouseEvent &mouse_event)
     return false;
 }
 
+void GLGizmoFlatten::data_changed()
+{
+    const Selection &  selection    = m_parent.get_selection();
+    const ModelObject *model_object = nullptr;
+    if (selection.is_single_full_instance() ||
+        selection.is_from_single_object() ) {        
+        model_object = selection.get_model()->objects[selection.get_object_idx()];
+    }    
+    set_flattening_data(model_object);
+}
+
 bool GLGizmoFlatten::on_init()
 {
     m_shortcut_key = WXK_CONTROL_F;

src/slic3r/GUI/Gizmos/GLGizmoFlatten.hpp

@@ -53,6 +53,7 @@ public:
     /// <returns>Return True when use the information otherwise False.</returns>
     bool on_mouse(const wxMouseEvent &mouse_event) override;
 
+    void data_changed() override;
 protected:
     bool on_init() override;
     std::string on_get_name() const override;

src/slic3r/GUI/Gizmos/GLGizmoHollow.cpp

@@ -43,7 +43,7 @@ bool GLGizmoHollow::on_init()
     return true;
 }
 
-void GLGizmoHollow::set_sla_support_data(ModelObject*, const Selection&)
+void GLGizmoHollow::data_changed()
 {
     if (! m_c->selection_info())
         return;

src/slic3r/GUI/Gizmos/GLGizmoHollow.hpp

@@ -19,7 +19,7 @@ class ConfigOptionDef;
 namespace GUI {
 
 enum class SLAGizmoEventType : unsigned char;
-
+class Selection;
 class GLGizmoHollow : public GLGizmoBase
 {
 private:
@@ -29,7 +29,7 @@ private:
 public:
     GLGizmoHollow(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
     virtual ~GLGizmoHollow() = default;
-    void set_sla_support_data(ModelObject* model_object, const Selection& selection);
+    void data_changed() override; 
     bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
     void delete_selected_points();    
     bool is_selection_rectangle_dragging() const {

src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp

@@ -152,10 +152,9 @@ void GLGizmoMmuSegmentation::render_painter_gizmo() const
     glsafe(::glDisable(GL_BLEND));
 }
 
-void GLGizmoMmuSegmentation::set_painter_gizmo_data(const Selection &selection)
+void GLGizmoMmuSegmentation::data_changed()
 {
-    GLGizmoPainterBase::set_painter_gizmo_data(selection);
+    GLGizmoPainterBase::data_changed();
-
     if (m_state != On || wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptFFF || wxGetApp().extruders_edited_cnt() <= 1)
         return;
 

src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.hpp

@@ -87,7 +87,7 @@ public:
 
     void render_painter_gizmo() const override;
 
-    void set_painter_gizmo_data(const Selection& selection) override;
+    void data_changed() override;
 
     void render_triangles(const Selection& selection) const override;
 

src/slic3r/GUI/Gizmos/GLGizmoMove.cpp

@@ -43,6 +43,12 @@ bool GLGizmoMove3D::on_mouse(const wxMouseEvent &mouse_event) {
     return use_grabbers(mouse_event);
 }
 
+void GLGizmoMove3D::data_changed() {
+    const Selection &selection = m_parent.get_selection();
+    bool is_wipe_tower = selection.is_wipe_tower();
+    m_grabbers[2].enabled = !is_wipe_tower;
+}
+
 bool GLGizmoMove3D::on_init()
 {
     for (int i = 0; i < 3; ++i) {

src/slic3r/GUI/Gizmos/GLGizmoMove.hpp

@@ -37,6 +37,7 @@ public:
     /// <returns>Return True when use the information otherwise False.</returns>
     bool on_mouse(const wxMouseEvent &mouse_event) override;
 
+    void data_changed() override;
 protected:
     bool on_init() override;
     std::string on_get_name() const override;

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.cpp

@@ -27,13 +27,13 @@ GLGizmoPainterBase::GLGizmoPainterBase(GLCanvas3D& parent, const std::string& ic
     m_vbo_sphere.finalize_geometry(true);
 }
 
-void GLGizmoPainterBase::set_painter_gizmo_data(const Selection& selection)
+void GLGizmoPainterBase::data_changed()
 {
     if (m_state != On)
         return;
 
     const ModelObject* mo = m_c->selection_info() ? m_c->selection_info()->model_object() : nullptr;
-
+    const Selection &  selection = m_parent.get_selection();
     if (mo && selection.is_from_single_instance()
      && (m_schedule_update || mo->id() != m_old_mo_id || mo->volumes.size() != m_old_volumes_size))
     {

src/slic3r/GUI/Gizmos/GLGizmoPainterBase.hpp

@@ -20,6 +20,7 @@ enum class SLAGizmoEventType : unsigned char;
 class ClippingPlane;
 struct Camera;
 class GLGizmoMmuSegmentation;
+class Selection;
 
 enum class PainterGizmoType {
     FDM_SUPPORTS,
@@ -113,7 +114,7 @@ private:
 public:
     GLGizmoPainterBase(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
     ~GLGizmoPainterBase() override = default;
-    virtual void set_painter_gizmo_data(const Selection& selection);
+    void data_changed() override;
     virtual bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
 
     // Following function renders the triangles and cursor. Having this separated

src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp

@@ -36,23 +36,17 @@ GLGizmoRotate::GLGizmoRotate(GLCanvas3D& parent, GLGizmoRotate::Axis axis)
     , m_snap_coarse_out_radius(0.0f)
     , m_snap_fine_in_radius(0.0f)
     , m_snap_fine_out_radius(0.0f)
+    , m_drag_color(DEFAULT_DRAG_COLOR)
+    , m_highlight_color(DEFAULT_HIGHLIGHT_COLOR)
 {
+    m_group_id = static_cast<int>(axis);
 }
 
-GLGizmoRotate::GLGizmoRotate(const GLGizmoRotate& other)
+void GLGizmoRotate::set_highlight_color(const std::array<float, 4> &color)
-    : GLGizmoBase(other.m_parent, other.m_icon_filename, other.m_sprite_id)
-    , m_axis(other.m_axis)
-    , m_angle(other.m_angle)
-    , m_center(other.m_center)
-    , m_radius(other.m_radius)
-    , m_snap_coarse_in_radius(other.m_snap_coarse_in_radius)
-    , m_snap_coarse_out_radius(other.m_snap_coarse_out_radius)
-    , m_snap_fine_in_radius(other.m_snap_fine_in_radius)
-    , m_snap_fine_out_radius(other.m_snap_fine_out_radius)
 {
+    m_highlight_color = color;
 }
 
-
 void GLGizmoRotate::set_angle(double angle)
 {
     if (std::abs(angle - 2.0 * (double)PI) < EPSILON)
@@ -80,6 +74,21 @@ bool GLGizmoRotate::on_mouse(const wxMouseEvent &mouse_event)
 
 void GLGizmoRotate::dragging(const UpdateData &data) { on_dragging(data); }
 
+void GLGizmoRotate::start_dragging()
+{
+    m_grabbers[0].dragging = true;
+    on_start_dragging();
+}
+
+void GLGizmoRotate::stop_dragging()
+{
+    m_grabbers[0].dragging = false;
+    on_stop_dragging();
+}
+
+void GLGizmoRotate::enable_grabber() { m_grabbers[0].enabled = true; }
+void GLGizmoRotate::disable_grabber() { m_grabbers[0].enabled = false; }
+
 bool GLGizmoRotate::on_init()
 {
     m_grabbers.push_back(Grabber());
@@ -444,11 +453,6 @@ GLGizmoRotate3D::GLGizmoRotate3D(GLCanvas3D& parent, const std::string& icon_fil
     m_gizmos.emplace_back(parent, GLGizmoRotate::X);
     m_gizmos.emplace_back(parent, GLGizmoRotate::Y);
     m_gizmos.emplace_back(parent, GLGizmoRotate::Z);
-
-    for (unsigned int i = 0; i < 3; ++i) {
-        m_gizmos[i].set_group_id(i);
-    }
-
     load_rotoptimize_state();
 }
 
@@ -464,6 +468,25 @@ bool GLGizmoRotate3D::on_mouse(const wxMouseEvent &mouse_event) {
     return use_grabbers(mouse_event);
 }
 
+void GLGizmoRotate3D::data_changed() {
+    const Selection &selection = m_parent.get_selection();
+    bool is_wipe_tower = selection.is_wipe_tower();
+    if (is_wipe_tower) {
+        DynamicPrintConfig& config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
+        float wipe_tower_rotation_angle =
+            dynamic_cast<const ConfigOptionFloat *>(
+                config.option("wipe_tower_rotation_angle"))
+                ->value;
+        set_rotation(Vec3d(0., 0., (M_PI / 180.) * wipe_tower_rotation_angle));
+        m_gizmos[0].disable_grabber();
+        m_gizmos[1].disable_grabber();
+    } else {
+        set_rotation(Vec3d::Zero());
+        m_gizmos[0].enable_grabber();
+        m_gizmos[1].enable_grabber();
+    }
+}
+
 bool GLGizmoRotate3D::on_init()
 {
     for (GLGizmoRotate& g : m_gizmos) 

src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp

@@ -7,7 +7,7 @@
 
 namespace Slic3r {
 namespace GUI {
-
+class Selection;
 class GLGizmoRotate : public GLGizmoBase
 {
     static const float Offset;
@@ -23,9 +23,9 @@ class GLGizmoRotate : public GLGizmoBase
 public:
     enum Axis : unsigned char
     {
-        X,
+        X=0,
-        Y,
+        Y=1,
-        Z
+        Z=2
     };
 
 private:
@@ -40,9 +40,10 @@ private:
     mutable float m_snap_fine_in_radius;
     mutable float m_snap_fine_out_radius;
 
+    std::array<float, 4> m_drag_color;
+    std::array<float, 4> m_highlight_color;
 public:
     GLGizmoRotate(GLCanvas3D& parent, Axis axis);
-    GLGizmoRotate(const GLGizmoRotate& other);
     virtual ~GLGizmoRotate() = default;
 
     double get_angle() const { return m_angle; }
@@ -50,6 +51,14 @@ public:
 
     std::string get_tooltip() const override;
 
+    void start_dragging();
+    void stop_dragging();
+       
+    void enable_grabber();
+    void disable_grabber(); 
+
+    void set_highlight_color(const std::array<float, 4> &color);
+
     /// <summary>
     /// Postpone to Grabber for move
     /// Detect move of object by dragging
@@ -107,6 +116,7 @@ public:
     /// <returns>Return True when use the information otherwise False.</returns>
     bool on_mouse(const wxMouseEvent &mouse_event) override;
 
+    void data_changed() override;
 protected:
     bool on_init() override;
     std::string on_get_name() const override;
@@ -120,16 +130,7 @@ protected:
         for (int i = 0; i < 3; ++i)
             m_gizmos[i].set_hover_id((m_hover_id == i) ? 0 : -1);
     }
-    void on_enable_grabber(unsigned int id) override
+    
-    {
-        if (id < 3)
-            m_gizmos[id].enable_grabber(0);
-    }
-    void on_disable_grabber(unsigned int id) override
-    {
-        if (id < 3)
-            m_gizmos[id].disable_grabber(0);
-    }
     bool on_is_activable() const override;
     void on_start_dragging() override;
     void on_stop_dragging() override;

src/slic3r/GUI/Gizmos/GLGizmoScale.cpp

@@ -18,6 +18,9 @@ GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filen
     , m_scale(Vec3d::Ones())
     , m_offset(Vec3d::Zero())
     , m_snap_step(0.05)
+    , m_base_color(DEFAULT_BASE_COLOR)
+    , m_drag_color(DEFAULT_DRAG_COLOR)
+    , m_highlight_color(DEFAULT_HIGHLIGHT_COLOR)
 {
 }
 
@@ -68,6 +71,30 @@ bool GLGizmoScale3D::on_mouse(const wxMouseEvent &mouse_event)
     return use_grabbers(mouse_event);
 }
 
+void GLGizmoScale3D::data_changed()
+{
+    const Selection &selection        = m_parent.get_selection();
+    bool             enable_scale_xyz = selection.is_single_full_instance() ||
+                            selection.is_single_volume() ||
+                            selection.is_single_modifier();
+    for (unsigned int i = 0; i < 6; ++i)
+        m_grabbers[i].enabled = enable_scale_xyz;
+
+    if (enable_scale_xyz) {
+        // all volumes in the selection belongs to the same instance, any of
+        // them contains the needed data, so we take the first
+        const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+        if (selection.is_single_full_instance()) {
+            set_scale(volume->get_instance_scaling_factor());
+        } else if (selection.is_single_volume() ||
+                   selection.is_single_modifier()) {
+            set_scale(volume->get_volume_scaling_factor());
+        }
+    } else {
+        set_scale(Vec3d::Ones());
+    }
+}
+
 bool GLGizmoScale3D::on_init()
 {
     for (int i = 0; i < 10; ++i)

src/slic3r/GUI/Gizmos/GLGizmoScale.hpp

@@ -33,6 +33,9 @@ class GLGizmoScale3D : public GLGizmoBase
     double m_snap_step;
     StartingData m_starting;
 
+    std::array<float, 4> m_base_color;
+    std::array<float, 4> m_drag_color;
+    std::array<float, 4> m_highlight_color;
 public:
     GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
 
@@ -51,6 +54,7 @@ public:
     /// <returns>Return True when use the information otherwise False.</returns>
     bool on_mouse(const wxMouseEvent &mouse_event) override;
 
+    void data_changed() override;
 protected:
     virtual bool on_init() override;
     virtual std::string on_get_name() const override;

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp

@@ -52,7 +52,7 @@ bool GLGizmoSlaSupports::on_init()
     return true;
 }
 
-void GLGizmoSlaSupports::set_sla_support_data(ModelObject* model_object, const Selection& selection)
+void GLGizmoSlaSupports::data_changed()
 {
     if (! m_c->selection_info())
         return;

src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp

@@ -16,7 +16,7 @@ namespace Slic3r {
 class ConfigOption;
 
 namespace GUI {
-
+class Selection;
 enum class SLAGizmoEventType : unsigned char;
 
 class GLGizmoSlaSupports : public GLGizmoBase
@@ -57,7 +57,7 @@ private:
 public:
     GLGizmoSlaSupports(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
     virtual ~GLGizmoSlaSupports() = default;
-    void set_sla_support_data(ModelObject* model_object, const Selection& selection);
+    void data_changed() override;
     bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
     void delete_selected_points(bool force = false);
     //ClippingPlane get_sla_clipping_plane() const;
@@ -77,7 +77,6 @@ public:
     /// <param name="mouse_event">Keep information about mouse click</param>
     /// <returns>Return True when use the information otherwise False.</returns>
     bool on_mouse(const wxMouseEvent &mouse_event) override;
-
 private:
     bool on_init() override;
     void on_render() override;

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -163,8 +163,8 @@ void GLGizmosManager::refresh_on_off_state()
     if (m_serializing || m_current == Undefined || m_gizmos.empty())
         return;
 
-    if (m_current != Undefined
+    // FS: Why update data after Undefined gizmo activation?
-    && ! m_gizmos[m_current]->is_activable() && activate_gizmo(Undefined))
+    if (!m_gizmos[m_current]->is_activable() && activate_gizmo(Undefined))
         update_data(); 
 }
 
@@ -214,78 +214,14 @@ void GLGizmosManager::set_hover_id(int id)
     m_gizmos[m_current]->set_hover_id(id);
 }
 
-void GLGizmosManager::enable_grabber(EType type, unsigned int id, bool enable)
-{
-    if (!m_enabled || type == Undefined || m_gizmos.empty())
-        return;
-
-    if (enable)
-        m_gizmos[type]->enable_grabber(id);
-    else
-        m_gizmos[type]->disable_grabber(id);
-}
-
-// TODO: divide into gizmo: on init + on selection change
 void GLGizmosManager::update_data()
 {
-    if (!m_enabled)
+    if (!m_enabled) return;
-        return;
+    if (m_current != Undefined) m_gizmos[m_current]->data_changed();
-
-    const Selection& selection = m_parent.get_selection();
-
-    bool is_wipe_tower = selection.is_wipe_tower();
-    enable_grabber(Move, 2, !is_wipe_tower);
-    enable_grabber(Rotate, 0, !is_wipe_tower);
-    enable_grabber(Rotate, 1, !is_wipe_tower);
-
-    bool enable_scale_xyz = selection.is_single_full_instance() || selection.is_single_volume() || selection.is_single_modifier();
-    for (unsigned int i = 0; i < 6; ++i)
-    {
-        enable_grabber(Scale, i, enable_scale_xyz);
-    }
-
     if (m_common_gizmos_data)
         m_common_gizmos_data->update(get_current()
                                    ? get_current()->get_requirements()
                                    : CommonGizmosDataID(0));
-
-    if (selection.is_single_full_instance())
-    {
-        // all volumes in the selection belongs to the same instance, any of them contains the needed data, so we take the first
-        const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
-        set_scale(volume->get_instance_scaling_factor());
-        set_rotation(Vec3d::Zero());
-        ModelObject* model_object = selection.get_model()->objects[selection.get_object_idx()];
-        set_flattening_data(model_object);
-        set_sla_support_data(model_object);
-        set_painter_gizmo_data();
-    }
-    else if (selection.is_single_volume() || selection.is_single_modifier())
-    {
-        const GLVolume* volume = selection.get_volume(*selection.get_volume_idxs().begin());
-        set_scale(volume->get_volume_scaling_factor());
-        set_rotation(Vec3d::Zero());
-        set_flattening_data(nullptr);
-        set_sla_support_data(nullptr);
-        set_painter_gizmo_data();
-    }
-    else if (is_wipe_tower)
-    {
-        DynamicPrintConfig& config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
-        set_scale(Vec3d::Ones());
-        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_painter_gizmo_data();
-    }
-    else
-    {
-        set_scale(Vec3d::Ones());
-        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_painter_gizmo_data();
-    }
 }
 
 bool GLGizmosManager::is_running() const
@@ -325,83 +261,6 @@ bool GLGizmosManager::is_dragging() const
     return m_gizmos[m_current]->is_dragging();
 }
 
-void GLGizmosManager::start_dragging()
-{
-    if (! m_enabled || m_current == Undefined)
-        return;
-    m_gizmos[m_current]->start_dragging();
-}
-
-void GLGizmosManager::stop_dragging()
-{
-    if (! m_enabled || m_current == Undefined)
-        return;
-
-    m_gizmos[m_current]->stop_dragging();
-}
-
-Vec3d GLGizmosManager::get_scale() const
-{
-    if (!m_enabled)
-        return Vec3d::Ones();
-
-    return dynamic_cast<GLGizmoScale3D*>(m_gizmos[Scale].get())->get_scale();
-}
-
-void GLGizmosManager::set_scale(const Vec3d& scale)
-{
-    if (!m_enabled || m_gizmos.empty())
-        return;
-
-    dynamic_cast<GLGizmoScale3D*>(m_gizmos[Scale].get())->set_scale(scale);
-}
-
-Vec3d GLGizmosManager::get_rotation() const
-{
-    if (!m_enabled || m_gizmos.empty())
-        return Vec3d::Zero();
-
-    return dynamic_cast<GLGizmoRotate3D*>(m_gizmos[Rotate].get())->get_rotation();
-}
-
-void GLGizmosManager::set_rotation(const Vec3d& rotation)
-{
-    if (!m_enabled || m_gizmos.empty())
-        return;
-    dynamic_cast<GLGizmoRotate3D*>(m_gizmos[Rotate].get())->set_rotation(rotation);
-}
-
-void GLGizmosManager::set_flattening_data(const ModelObject* model_object)
-{
-    if (!m_enabled || m_gizmos.empty())
-        return;
-
-    dynamic_cast<GLGizmoFlatten*>(m_gizmos[Flatten].get())->set_flattening_data(model_object);
-}
-
-void GLGizmosManager::set_sla_support_data(ModelObject* model_object)
-{
-    if (! m_enabled
-     || m_gizmos.empty()
-     || wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptSLA)
-        return;
-
-    auto* gizmo_hollow = dynamic_cast<GLGizmoHollow*>(m_gizmos[Hollow].get());
-    auto* gizmo_supports = dynamic_cast<GLGizmoSlaSupports*>(m_gizmos[SlaSupports].get());
-    gizmo_hollow->set_sla_support_data(model_object, m_parent.get_selection());
-    gizmo_supports->set_sla_support_data(model_object, m_parent.get_selection());
-}
-
-void GLGizmosManager::set_painter_gizmo_data()
-{
-    if (!m_enabled || m_gizmos.empty())
-        return;
-
-    dynamic_cast<GLGizmoFdmSupports*>(m_gizmos[FdmSupports].get())->set_painter_gizmo_data(m_parent.get_selection());
-    dynamic_cast<GLGizmoSeam*>(m_gizmos[Seam].get())->set_painter_gizmo_data(m_parent.get_selection());
-    dynamic_cast<GLGizmoMmuSegmentation*>(m_gizmos[MmuSegmentation].get())->set_painter_gizmo_data(m_parent.get_selection());
-}
-
 // Returns true if the gizmo used the event to do something, false otherwise.
 bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down)
 {
@@ -1131,11 +990,5 @@ bool GLGizmosManager::is_hiding_instances() const
          && m_common_gizmos_data->instances_hider()->is_valid());
 }
 
-
-int GLGizmosManager::get_shortcut_key(GLGizmosManager::EType type) const
-{
-    return m_gizmos[type]->get_shortcut_key();
-}
-
 } // namespace GUI
 } // namespace Slic3r

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -172,8 +172,11 @@ public:
     bool check_gizmos_closed_except(EType) const;
 
     void set_hover_id(int id);
-    void enable_grabber(EType type, unsigned int id, bool enable);
 
+    /// <summary>
+    /// Distribute information about different data into active gizmo
+    /// Should be called when selection changed
+    /// </summary>
     void update_data();
 
     EType get_current_type() const { return m_current; }
@@ -184,22 +187,7 @@ public:
     bool handle_shortcut(int key);
 
     bool is_dragging() const;
-    void start_dragging();
-    void stop_dragging();
     
-    Vec3d get_scale() const;
-    void set_scale(const Vec3d& scale);
-
-    Vec3d get_rotation() const;
-    void set_rotation(const Vec3d& rotation);
-
-    void set_flattening_data(const ModelObject* model_object);
-
-    void set_sla_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;
     bool wants_reslice_supports_on_undo() const;
 
@@ -224,13 +212,18 @@ public:
     void update_after_undo_redo(const UndoRedo::Snapshot& snapshot);
 
     int get_selectable_icons_cnt() const { return get_selectable_idxs().size(); }
-    int get_shortcut_key(GLGizmosManager::EType) const;
 
     // To end highlight set gizmo = undefined
     void set_highlight(EType gizmo, bool highlight_shown) { m_highlight = std::pair<EType, bool>(gizmo, highlight_shown); }
     bool get_highlight_state() const { return m_highlight.second; }
 
 private:
+    bool gizmo_event(SLAGizmoEventType action,
+                     const Vec2d &     mouse_position = Vec2d::Zero(),
+                     bool              shift_down     = false,
+                     bool              alt_down       = false,
+                     bool              control_down   = false);
+    
     void render_background(float left, float top, float right, float bottom, float border) const;
     
     void do_render_overlay() const;