Merge branch 'master' into dev

src/slic3r/GUI/Gizmos/GLGizmoBase.cpp

@@ -262,12 +262,6 @@ void GLGizmoBase::render_grabbers_for_picking(const BoundingBoxf3& box) const
     }
 }
 
-
-void GLGizmoBase::set_tooltip(const std::string& tooltip) const
-{
-    m_parent.set_tooltip(tooltip);
-}
-
 std::string GLGizmoBase::format(float value, unsigned int decimals) const
 {
     return Slic3r::string_printf("%.*f", decimals, value);

src/slic3r/GUI/Gizmos/GLGizmoBase.hpp

@@ -100,6 +100,7 @@ protected:
     mutable std::vector<Grabber> m_grabbers;
     ImGuiWrapper* m_imgui;
     bool m_first_input_window_render;
+    mutable std::string m_tooltip;
 
 public:
     GLGizmoBase(GLCanvas3D& parent,
@@ -145,10 +146,12 @@ public:
 
     void update(const UpdateData& data);
 
-    void render() const { on_render(); }
+    void render() const { m_tooltip.clear(); on_render(); }
     void render_for_picking() const { on_render_for_picking(); }
     void render_input_window(float x, float y, float bottom_limit);
 
+    virtual std::string get_tooltip() const { return ""; }
+
 protected:
     virtual bool on_init() = 0;
     virtual void on_load(cereal::BinaryInputArchive& ar) {}
@@ -174,7 +177,6 @@ protected:
     void render_grabbers(float size) const;
     void render_grabbers_for_picking(const BoundingBoxf3& box) const;
 
-    void set_tooltip(const std::string& tooltip) const;
     std::string format(float value, unsigned int decimals) const;
 };
 

src/slic3r/GUI/Gizmos/GLGizmoCut.cpp

@@ -30,6 +30,11 @@ GLGizmoCut::GLGizmoCut(GLCanvas3D& parent, const std::string& icon_filename, uns
     , m_rotate_lower(false)
 {}
 
+std::string GLGizmoCut::get_tooltip() const
+{
+    return (m_hover_id == 0 || m_grabbers[0].dragging) ? "Z: " + format(m_cut_z, 2) : "";
+}
+
 bool GLGizmoCut::on_init()
 {
     m_grabbers.emplace_back();
@@ -79,10 +84,6 @@ void GLGizmoCut::on_update(const UpdateData& data)
 
 void GLGizmoCut::on_render() const
 {
-    if (m_grabbers[0].dragging) {
-        set_tooltip("Z: " + format(m_cut_z, 2));
-    }
-
     const Selection& selection = m_parent.get_selection();
 
     update_max_z(selection);

src/slic3r/GUI/Gizmos/GLGizmoCut.hpp

@@ -28,6 +28,8 @@ public:
     double get_cut_z() const { return m_cut_z; }
     void set_cut_z(double cut_z) const;
 
+    std::string get_tooltip() const override;
+
 protected:
     virtual bool on_init();
     virtual void on_load(cereal::BinaryInputArchive& ar) { ar(m_cut_z, m_keep_upper, m_keep_lower, m_rotate_lower); }

src/slic3r/GUI/Gizmos/GLGizmoMove.cpp

@@ -31,6 +31,22 @@ GLGizmoMove3D::~GLGizmoMove3D()
         ::gluDeleteQuadric(m_quadric);
 }
 
+std::string GLGizmoMove3D::get_tooltip() const
+{
+    const Selection& selection = m_parent.get_selection();
+    bool show_position = selection.is_single_full_instance();
+    const Vec3d& position = selection.get_bounding_box().center();
+
+    if (m_hover_id == 0 || m_grabbers[0].dragging)
+        return "X: " + format(show_position ? position(0) : m_displacement(0), 2);
+    else if (m_hover_id == 1 || m_grabbers[1].dragging)
+        return "Y: " + format(show_position ? position(1) : m_displacement(1), 2);
+    else if (m_hover_id == 2 || m_grabbers[2].dragging)
+        return "Z: " + format(show_position ? position(2) : m_displacement(2), 2);
+    else
+        return "";
+}
+
 bool GLGizmoMove3D::on_init()
 {
     for (int i = 0; i < 3; ++i)
@@ -85,22 +101,6 @@ void GLGizmoMove3D::on_render() const
 {
     const Selection& selection = m_parent.get_selection();
 
-    bool show_position = selection.is_single_full_instance();
-    const Vec3d& position = selection.get_bounding_box().center();
-
-    if ((show_position && (m_hover_id == 0)) || m_grabbers[0].dragging)
-        set_tooltip("X: " + format(show_position ? position(0) : m_displacement(0), 2));
-    else if (!m_grabbers[0].dragging && (m_hover_id == 0))
-        set_tooltip("X");
-    else if ((show_position && (m_hover_id == 1)) || m_grabbers[1].dragging)
-        set_tooltip("Y: " + format(show_position ? position(1) : m_displacement(1), 2));
-    else if (!m_grabbers[1].dragging && (m_hover_id == 1))
-        set_tooltip("Y");
-    else if ((show_position && (m_hover_id == 2)) || m_grabbers[2].dragging)
-        set_tooltip("Z: " + format(show_position ? position(2) : m_displacement(2), 2));
-    else if (!m_grabbers[2].dragging && (m_hover_id == 2))
-        set_tooltip("Z");
-
     glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
     glsafe(::glEnable(GL_DEPTH_TEST));
 

src/slic3r/GUI/Gizmos/GLGizmoMove.hpp

@@ -30,6 +30,8 @@ public:
 
     const Vec3d& get_displacement() const { return m_displacement; }
 
+    std::string get_tooltip() const override;
+
 protected:
     virtual bool on_init();
     virtual std::string on_get_name() const;

src/slic3r/GUI/Gizmos/GLGizmoRotate.cpp

@@ -67,6 +67,18 @@ void GLGizmoRotate::set_angle(double angle)
     m_angle = angle;
 }
 
+std::string GLGizmoRotate::get_tooltip() const
+{
+    std::string axis;
+    switch (m_axis)
+    {
+    case X: { axis = "X"; break; }
+    case Y: { axis = "Y"; break; }
+    case Z: { axis = "Z"; break; }
+    }
+    return (m_hover_id == 0 || m_grabbers[0].dragging) ? axis + ": " + format((float)Geometry::rad2deg(m_angle), 4) : "";
+}
+
 bool GLGizmoRotate::on_init()
 {
     m_grabbers.push_back(Grabber());
@@ -127,19 +139,7 @@ void GLGizmoRotate::on_render() const
     const Selection& selection = m_parent.get_selection();
     const BoundingBoxf3& box = selection.get_bounding_box();
 
-    std::string axis;
-    switch (m_axis)
-    {
-    case X: { axis = "X"; break; }
-    case Y: { axis = "Y"; break; }
-    case Z: { axis = "Z"; break; }
-    }
-
-    if (!m_dragging && (m_hover_id == 0))
-        set_tooltip(axis);
-    else if (m_dragging)
-        set_tooltip(axis + ": " + format((float)Geometry::rad2deg(m_angle), 4) + "\u00B0");
-    else
+    if (m_hover_id != 0 && !m_grabbers[0].dragging)
     {
         m_center = box.center();
         m_radius = Offset + box.radius();

src/slic3r/GUI/Gizmos/GLGizmoRotate.hpp

@@ -49,6 +49,8 @@ public:
     double get_angle() const { return m_angle; }
     void set_angle(double angle);
 
+    std::string get_tooltip() const override;
+
 protected:
     virtual bool on_init();
     virtual std::string on_get_name() const { return ""; }
@@ -81,6 +83,16 @@ public:
     Vec3d get_rotation() const { return Vec3d(m_gizmos[X].get_angle(), m_gizmos[Y].get_angle(), m_gizmos[Z].get_angle()); }
     void set_rotation(const Vec3d& rotation) { m_gizmos[X].set_angle(rotation(0)); m_gizmos[Y].set_angle(rotation(1)); m_gizmos[Z].set_angle(rotation(2)); }
 
+    std::string get_tooltip() const override
+    {
+        std::string tooltip = m_gizmos[X].get_tooltip();
+        if (tooltip.empty())
+            tooltip = m_gizmos[Y].get_tooltip();
+        if (tooltip.empty())
+            tooltip = m_gizmos[Z].get_tooltip();
+        return tooltip;
+    }
+
 protected:
     virtual bool on_init();
     virtual std::string on_get_name() const;

src/slic3r/GUI/Gizmos/GLGizmoScale.cpp

@@ -20,6 +20,38 @@ GLGizmoScale3D::GLGizmoScale3D(GLCanvas3D& parent, const std::string& icon_filen
 {
 }
 
+std::string GLGizmoScale3D::get_tooltip() const
+{
+    const Selection& selection = m_parent.get_selection();
+
+    bool single_instance = selection.is_single_full_instance();
+    bool single_volume = selection.is_single_modifier() || selection.is_single_volume();
+    bool single_selection = single_instance || single_volume;
+
+    Vec3f scale = 100.0f * Vec3f::Ones();
+    if (single_instance)
+        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_scaling_factor().cast<float>();
+    else if (single_volume)
+        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_volume_scaling_factor().cast<float>();
+
+    if (m_hover_id == 0 || m_hover_id == 1 || m_grabbers[0].dragging || m_grabbers[1].dragging)
+        return "X: " + format(scale(0), 4) + "%";
+    else if (m_hover_id == 2 || m_hover_id == 3 || m_grabbers[2].dragging || m_grabbers[3].dragging)
+        return "Y: " + format(scale(1), 4) + "%";
+    else if (m_hover_id == 4 || m_hover_id == 5 || m_grabbers[4].dragging || m_grabbers[5].dragging)
+        return "Z: " + format(scale(2), 4) + "%";
+    else if (m_hover_id == 6 || m_hover_id == 7 || m_hover_id == 8 || m_hover_id == 9 || 
+        m_grabbers[6].dragging || m_grabbers[7].dragging || m_grabbers[8].dragging || m_grabbers[9].dragging)
+    {
+        std::string tooltip = "X: " + format(scale(0), 4) + "%\n";
+        tooltip += "Y: " + format(scale(1), 4) + "%\n";
+        tooltip += "Z: " + format(scale(2), 4) + "%";
+        return tooltip;
+    }
+    else
+        return "";
+}
+
 bool GLGizmoScale3D::on_init()
 {
     for (int i = 0; i < 10; ++i)
@@ -89,37 +121,6 @@ void GLGizmoScale3D::on_render() const
 
     bool single_instance = selection.is_single_full_instance();
     bool single_volume = selection.is_single_modifier() || selection.is_single_volume();
-    bool single_selection = single_instance || single_volume;
-
-    Vec3f scale = 100.0f * Vec3f::Ones();
-    if (single_instance)
-        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_instance_scaling_factor().cast<float>();
-    else if (single_volume)
-        scale = 100.0f * selection.get_volume(*selection.get_volume_idxs().begin())->get_volume_scaling_factor().cast<float>();
-
-    if ((single_selection && ((m_hover_id == 0) || (m_hover_id == 1))) || m_grabbers[0].dragging || m_grabbers[1].dragging)
-        set_tooltip("X: " + format(scale(0), 4) + "%");
-    else if (!m_grabbers[0].dragging && !m_grabbers[1].dragging && ((m_hover_id == 0) || (m_hover_id == 1)))
-        set_tooltip("X");
-    else if ((single_selection && ((m_hover_id == 2) || (m_hover_id == 3))) || m_grabbers[2].dragging || m_grabbers[3].dragging)
-        set_tooltip("Y: " + format(scale(1), 4) + "%");
-    else if (!m_grabbers[2].dragging && !m_grabbers[3].dragging && ((m_hover_id == 2) || (m_hover_id == 3)))
-        set_tooltip("Y");
-    else if ((single_selection && ((m_hover_id == 4) || (m_hover_id == 5))) || m_grabbers[4].dragging || m_grabbers[5].dragging)
-        set_tooltip("Z: " + format(scale(2), 4) + "%");
-    else if (!m_grabbers[4].dragging && !m_grabbers[5].dragging && ((m_hover_id == 4) || (m_hover_id == 5)))
-        set_tooltip("Z");
-    else if ((single_selection && ((m_hover_id == 6) || (m_hover_id == 7) || (m_hover_id == 8) || (m_hover_id == 9)))
-        || m_grabbers[6].dragging || m_grabbers[7].dragging || m_grabbers[8].dragging || m_grabbers[9].dragging)
-    {
-        std::string tooltip = "X: " + format(scale(0), 4) + "%\n";
-        tooltip += "Y: " + format(scale(1), 4) + "%\n";
-        tooltip += "Z: " + format(scale(2), 4) + "%";
-        set_tooltip(tooltip);
-    }
-    else if (!m_grabbers[6].dragging && !m_grabbers[7].dragging && !m_grabbers[8].dragging && !m_grabbers[9].dragging &&
-        ((m_hover_id == 6) || (m_hover_id == 7) || (m_hover_id == 8) || (m_hover_id == 9)))
-        set_tooltip("X/Y/Z");
 
     glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
     glsafe(::glEnable(GL_DEPTH_TEST));

src/slic3r/GUI/Gizmos/GLGizmoScale.hpp

@@ -42,6 +42,8 @@ public:
 
     const Vec3d& get_offset() const { return m_offset; }
 
+    std::string get_tooltip() const override;
+
 protected:
     virtual bool on_init();
     virtual std::string on_get_name() const;

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -226,7 +226,7 @@ void GLGizmosManager::update_data()
         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(nullptr);
+        set_sla_support_data(selection.is_from_single_instance() ? selection.get_model()->objects[selection.get_object_idx()] : nullptr);
     }
 }
 
@@ -423,6 +423,15 @@ void GLGizmosManager::render_overlay() const
     do_render_overlay();
 }
 
+std::string GLGizmosManager::get_tooltip() const
+{
+    if (!m_tooltip.empty())
+        return m_tooltip;
+
+    const GLGizmoBase* curr = get_current();
+    return (curr != nullptr) ? curr->get_tooltip() : "";
+}
+
 bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt)
 {
     bool processed = false;
@@ -448,6 +457,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
     int selected_object_idx = selection.get_object_idx();
     bool processed = false;
 
+#if !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
     // mouse anywhere
     if (!evt.Dragging() && !evt.Leaving() && !evt.Entering() && (m_mouse_capture.parent != nullptr))
     {
@@ -457,10 +467,81 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
 
         m_mouse_capture.reset();
     }
+#endif // !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
 
     // mouse anywhere
     if (evt.Moving())
         m_tooltip = update_hover_state(mouse_pos);
+#if ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
+    else if (evt.LeftUp())
+    {
+        if (m_mouse_capture.left)
+        {
+            processed = true;
+            m_mouse_capture.left = false;
+        }
+        else if (is_dragging())
+        {
+            switch (m_current) {
+            case Move: m_parent.do_move(L("Gizmo-Move")); break;
+            case Scale: m_parent.do_scale(L("Gizmo-Scale")); break;
+            case Rotate: m_parent.do_rotate(L("Gizmo-Rotate")); break;
+            default: break;
+            }
+
+            stop_dragging();
+            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(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
+            // updates camera target constraints
+            m_parent.refresh_camera_scene_box();
+
+            processed = true;
+        }
+//        else
+//            return false;
+    }
+    else if (evt.MiddleUp())
+    {
+        if (m_mouse_capture.middle)
+        {
+            processed = true;
+            m_mouse_capture.middle = false;
+        }
+        else
+            return false;
+    }
+    else if (evt.RightUp())
+    {
+        if (pending_right_up)
+        {
+            pending_right_up = false;
+            return true;
+        }
+        if (m_mouse_capture.right)
+        {
+            processed = true;
+            m_mouse_capture.right = false;
+        }
+        else
+            return false;
+    }
+#if ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
+    else if (evt.Dragging() && !is_dragging())
+#else
+    else if (evt.Dragging()))
+#endif // ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
+    {
+        if (m_mouse_capture.any())
+            // if the button down was done on this toolbar, prevent from dragging into the scene
+            processed = true;
+//        else
+//            return false;
+    }
+#else
     else if (evt.LeftUp())
         m_mouse_capture.left = false;
     else if (evt.MiddleUp())
@@ -477,6 +558,55 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
     else if (evt.Dragging() && m_mouse_capture.any())
         // if the button down was done on this toolbar, prevent from dragging into the scene
         processed = true;
+#endif // ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
+#if ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
+    else if (evt.Dragging() && is_dragging())
+    {
+        if (!m_parent.get_wxglcanvas()->HasCapture())
+            m_parent.get_wxglcanvas()->CaptureMouse();
+
+        m_parent.set_mouse_as_dragging();
+        update(m_parent.mouse_ray(pos), pos);
+
+        switch (m_current)
+        {
+        case Move:
+        {
+            // Apply new temporary offset
+            selection.translate(get_displacement());
+            wxGetApp().obj_manipul()->set_dirty();
+            break;
+        }
+        case Scale:
+        {
+            // Apply new temporary scale factors
+            TransformationType transformation_type(TransformationType::Local_Absolute_Joint);
+            if (evt.AltDown())
+                transformation_type.set_independent();
+            selection.scale(get_scale(), transformation_type);
+            if (evt.ControlDown())
+                selection.translate(get_scale_offset(), true);
+            wxGetApp().obj_manipul()->set_dirty();
+            break;
+        }
+        case Rotate:
+        {
+            // Apply new temporary rotations
+            TransformationType transformation_type(TransformationType::World_Relative_Joint);
+            if (evt.AltDown())
+                transformation_type.set_independent();
+            selection.rotate(get_rotation(), transformation_type);
+            wxGetApp().obj_manipul()->set_dirty();
+            break;
+        }
+        default:
+            break;
+        }
+
+        m_parent.set_as_dirty();
+        processed = true;
+    }
+#endif // ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
 
     if (get_gizmo_idx_from_mouse(mouse_pos) == Undefined)
     {
@@ -519,6 +649,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             m_parent.set_as_dirty();
             processed = true;
         }
+#if !ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
         else if (evt.Dragging() && is_dragging())
         {
             if (!m_parent.get_wxglcanvas()->HasCapture())
@@ -565,6 +696,8 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             m_parent.set_as_dirty();
             processed = true;
         }
+#endif // !ENABLE_GIZMO_TOOLBAR_DRAGGING_FIX
+#if !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
         else if (evt.LeftUp() && is_dragging())
         {
             switch (m_current) {
@@ -586,6 +719,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
 
             processed = true;
         }
+#endif // !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
         else if (evt.LeftUp() && (m_current == SlaSupports || m_current == Hollow) && !m_parent.is_mouse_dragging())
         {
             // in case SLA gizmo is selected, we just pass the LeftUp event and stop processing - neither
@@ -624,8 +758,10 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
             m_mouse_capture.right = true;
             m_mouse_capture.parent = &m_parent;
         }
+#if !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
         else if (evt.LeftUp())
             processed = true;
+#endif // !ENABLE_MODIFIED_GIZMOBAR_MOUSE_EVENT_HANDLING
     }
 
     return processed;

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -206,7 +206,7 @@ public:
 
     void render_overlay() const;
 
-    const std::string& get_tooltip() const { return m_tooltip; }
+    std::string get_tooltip() const;
 
     bool on_mouse(wxMouseEvent& evt);
     bool on_mouse_wheel(wxMouseEvent& evt);