3DScene mouse variables moved to c++

xs/src/slic3r/GUI/3DScene.cpp

@@ -1915,7 +1915,8 @@ Pointf3 _3DScene::get_camera_target(wxGLCanvas* canvas)
 
 void _3DScene::set_camera_target(wxGLCanvas* canvas, const Pointf3* target)
 {
-    s_canvas_mgr.set_camera_target(canvas, target);
+    if (target != nullptr)
+        s_canvas_mgr.set_camera_target(canvas, *target);
 }
  
 bool _3DScene::is_layers_editing_enabled(wxGLCanvas* canvas)
@@ -1953,6 +1954,27 @@ void _3DScene::enable_shader(wxGLCanvas* canvas, bool enable)
     s_canvas_mgr.enable_shader(canvas, enable);
 }
 
+bool _3DScene::is_mouse_dragging(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.is_mouse_dragging(canvas);
+}
+
+void _3DScene::set_mouse_dragging(wxGLCanvas* canvas, bool dragging)
+{
+    s_canvas_mgr.set_mouse_dragging(canvas, dragging);
+}
+
+Pointf _3DScene::get_mouse_position(wxGLCanvas* canvas)
+{
+    return s_canvas_mgr.get_mouse_position(canvas);
+}
+
+void _3DScene::set_mouse_position(wxGLCanvas* canvas, const Pointf* position)
+{
+    if (position != nullptr)
+        s_canvas_mgr.set_mouse_position(canvas, *position);
+}
+
 void _3DScene::zoom_to_bed(wxGLCanvas* canvas)
 {
     s_canvas_mgr.zoom_to_bed(canvas);
@@ -2028,9 +2050,9 @@ void _3DScene::register_on_viewport_changed_callback(wxGLCanvas* canvas, void* c
     s_canvas_mgr.register_on_viewport_changed_callback(canvas, callback);
 }
 
-void _3DScene::register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback)
+void _3DScene::register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback)
 {
-    s_canvas_mgr.register_on_mark_volumes_for_layer_height(canvas, callback);
+    s_canvas_mgr.register_on_mark_volumes_for_layer_height_callback(canvas, callback);
 }
 
 //void _3DScene::_glew_init()

xs/src/slic3r/GUI/3DScene.hpp

@@ -603,6 +603,12 @@ public:
     static void enable_picking(wxGLCanvas* canvas, bool enable);
     static void enable_shader(wxGLCanvas* canvas, bool enable);
 
+    static bool is_mouse_dragging(wxGLCanvas* canvas);
+    static void set_mouse_dragging(wxGLCanvas* canvas, bool dragging);
+
+    static Pointf get_mouse_position(wxGLCanvas* canvas);
+    static void set_mouse_position(wxGLCanvas* canvas, const Pointf* position);
+
     static void zoom_to_bed(wxGLCanvas* canvas);
     static void zoom_to_volumes(wxGLCanvas* canvas);
     static void select_view(wxGLCanvas* canvas, const std::string& direction);
@@ -622,7 +628,7 @@ public:
     static void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top);
 
     static void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback);
-    static void register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback);
+    static void register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback);
 
 //    static void _glew_init();
 //##################################################################################################################

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -474,6 +474,31 @@ void GLCanvas3D::Shader::stop() const
         m_shader->disable();
 }
 
+GLCanvas3D::Mouse::Mouse()
+    : m_dragging(false)
+{
+}
+
+bool GLCanvas3D::Mouse::is_dragging() const
+{
+    return m_dragging;
+}
+
+void GLCanvas3D::Mouse::set_dragging(bool dragging)
+{
+    m_dragging = dragging;
+}
+
+const Pointf& GLCanvas3D::Mouse::get_position() const
+{
+    return m_position;
+}
+
+void GLCanvas3D::Mouse::set_position(const Pointf& position)
+{
+    m_position = position;
+}
+
 GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context)
     : m_canvas(canvas)
     , m_context(context)
@@ -804,6 +829,26 @@ void GLCanvas3D::enable_shader(bool enable)
     m_shader.set_enabled(enable);
 }
 
+bool GLCanvas3D::is_mouse_dragging() const
+{
+    return m_mouse.is_dragging();
+}
+
+void GLCanvas3D::set_mouse_dragging(bool dragging)
+{
+    m_mouse.set_dragging(dragging);
+}
+
+const Pointf& GLCanvas3D::get_mouse_position() const
+{
+    return m_mouse.get_position();
+}
+
+void GLCanvas3D::set_mouse_position(const Pointf& position)
+{
+    m_mouse.set_position(position);
+}
+
 void GLCanvas3D::zoom_to_bed()
 {
     _zoom_to_bounding_box(bed_bounding_box());
@@ -960,7 +1005,7 @@ void GLCanvas3D::render_objects(bool useVBOs)
     {
         if (is_picking_enabled())
         {
-            m_on_mark_volumes_for_layer_height.call();
+            m_on_mark_volumes_for_layer_height_callback.call();
 
             if (m_config != nullptr)
             {
@@ -1093,10 +1138,10 @@ void GLCanvas3D::register_on_viewport_changed_callback(void* callback)
         m_on_viewport_changed_callback.register_callback(callback);
 }
 
-void GLCanvas3D::register_on_mark_volumes_for_layer_height(void* callback)
+void GLCanvas3D::register_on_mark_volumes_for_layer_height_callback(void* callback)
 {
     if (callback != nullptr)
-        m_on_mark_volumes_for_layer_height.register_callback(callback);
+        m_on_mark_volumes_for_layer_height_callback.register_callback(callback);
 }
 
 void GLCanvas3D::on_size(wxSizeEvent& evt)
@@ -1273,7 +1318,7 @@ float GLCanvas3D::_get_zoom_to_bounding_box_factor(const BoundingBoxf3& bbox) co
 void GLCanvas3D::_deregister_callbacks()
 {
     m_on_viewport_changed_callback.deregister_callback();
-    m_on_mark_volumes_for_layer_height.deregister_callback();
+    m_on_mark_volumes_for_layer_height_callback.deregister_callback();
 }
 
 } // namespace GUI

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -161,6 +161,21 @@ public:
         void stop() const;
     };
 
+    class Mouse
+    {
+        bool m_dragging;
+        Pointf m_position;
+
+    public:
+        Mouse();
+
+        bool is_dragging() const;
+        void set_dragging(bool dragging);
+
+        const Pointf& get_position() const;
+        void set_position(const Pointf& position);
+    };
+
 private:
     wxGLCanvas* m_canvas;
     wxGLContext* m_context;
@@ -170,6 +185,7 @@ private:
     CuttingPlane m_cutting_plane;
     LayersEditing m_layers_editing;
     Shader m_shader;
+    Mouse m_mouse;
 
     GLVolumeCollection* m_volumes;
     DynamicPrintConfig* m_config;
@@ -181,7 +197,7 @@ private:
     bool m_picking_enabled;
 
     PerlCallback m_on_viewport_changed_callback;
-    PerlCallback m_on_mark_volumes_for_layer_height;
+    PerlCallback m_on_mark_volumes_for_layer_height_callback;
 
 public:
     GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context);
@@ -253,6 +269,12 @@ public:
     void enable_picking(bool enable);
     void enable_shader(bool enable);
 
+    bool is_mouse_dragging() const;
+    void set_mouse_dragging(bool dragging);
+
+    const Pointf& get_mouse_position() const;
+    void set_mouse_position(const Pointf& position);
+
     void zoom_to_bed();
     void zoom_to_volumes();
     void select_view(const std::string& direction);
@@ -272,7 +294,7 @@ public:
     void render_texture(unsigned int tex_id, float left, float right, float bottom, float top) const;
 
     void register_on_viewport_changed_callback(void* callback);
-    void register_on_mark_volumes_for_layer_height(void* callback);
+    void register_on_mark_volumes_for_layer_height_callback(void* callback);
 
     void on_size(wxSizeEvent& evt);
     void on_idle(wxIdleEvent& evt);

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -358,14 +358,11 @@ Pointf3 GLCanvas3DManager::get_camera_target(wxGLCanvas* canvas) const
     return (it != m_canvases.end()) ? it->second->get_camera_target() : Pointf3(0.0, 0.0, 0.0);
 }
 
-void GLCanvas3DManager::set_camera_target(wxGLCanvas* canvas, const Pointf3* target)
+void GLCanvas3DManager::set_camera_target(wxGLCanvas* canvas, const Pointf3& target)
 {
-    if (target == nullptr)
-        return;
-
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
-        it->second->set_camera_target(*target);
+        it->second->set_camera_target(target);
 }
 
 bool GLCanvas3DManager::is_layers_editing_enabled(wxGLCanvas* canvas) const
@@ -414,6 +411,32 @@ void GLCanvas3DManager::enable_shader(wxGLCanvas* canvas, bool enable)
         it->second->enable_shader(enable);
 }
 
+bool GLCanvas3DManager::is_mouse_dragging(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->is_mouse_dragging() : false;
+}
+
+void GLCanvas3DManager::set_mouse_dragging(wxGLCanvas* canvas, bool dragging)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_mouse_dragging(dragging);
+}
+
+Pointf GLCanvas3DManager::get_mouse_position(wxGLCanvas* canvas) const
+{
+    CanvasesMap::const_iterator it = _get_canvas(canvas);
+    return (it != m_canvases.end()) ? it->second->get_mouse_position() : Pointf();
+}
+
+void GLCanvas3DManager::set_mouse_position(wxGLCanvas* canvas, const Pointf& position)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_mouse_position(position);
+}
+
 void GLCanvas3DManager::zoom_to_bed(wxGLCanvas* canvas)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -518,11 +541,11 @@ void GLCanvas3DManager::register_on_viewport_changed_callback(wxGLCanvas* canvas
         it->second->register_on_viewport_changed_callback(callback);
 }
 
-void GLCanvas3DManager::register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback)
+void GLCanvas3DManager::register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
     if (it != m_canvases.end())
-        it->second->register_on_mark_volumes_for_layer_height(callback);
+        it->second->register_on_mark_volumes_for_layer_height_callback(callback);
 }
 
 GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::_get_canvas(wxGLCanvas* canvas)

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -100,7 +100,7 @@ public:
     void set_camera_distance(wxGLCanvas* canvas, float distance);
 
     Pointf3 get_camera_target(wxGLCanvas* canvas) const;
-    void set_camera_target(wxGLCanvas* canvas, const Pointf3* target);
+    void set_camera_target(wxGLCanvas* canvas, const Pointf3& target);
 
     bool is_layers_editing_enabled(wxGLCanvas* canvas) const;
     bool is_picking_enabled(wxGLCanvas* canvas) const;
@@ -111,6 +111,12 @@ public:
     void enable_picking(wxGLCanvas* canvas, bool enable);
     void enable_shader(wxGLCanvas* canvas, bool enable);
 
+    bool is_mouse_dragging(wxGLCanvas* canvas) const;
+    void set_mouse_dragging(wxGLCanvas* canvas, bool dragging);
+
+    Pointf get_mouse_position(wxGLCanvas* canvas) const;
+    void set_mouse_position(wxGLCanvas* canvas, const Pointf& position);
+
     void zoom_to_bed(wxGLCanvas* canvas);
     void zoom_to_volumes(wxGLCanvas* canvas);
     void select_view(wxGLCanvas* canvas, const std::string& direction);
@@ -130,7 +136,7 @@ public:
     void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top) const;
 
     void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback);
-    void register_on_mark_volumes_for_layer_height(wxGLCanvas* canvas, void* callback);
+    void register_on_mark_volumes_for_layer_height_callback(wxGLCanvas* canvas, void* callback);
 
 private:
     CanvasesMap::iterator _get_canvas(wxGLCanvas* canvas);

xs/xsp/GUI_3DScene.xsp

@@ -483,6 +483,36 @@ enable_shader(canvas, enable)
     CODE:
         _3DScene::enable_shader((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), enable);
 
+bool
+is_mouse_dragging(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::is_mouse_dragging((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
+void
+set_mouse_dragging(canvas, dragging)
+        SV   *canvas;
+        bool dragging;
+    CODE:
+        _3DScene::set_mouse_dragging((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), dragging);
+
+Clone<Pointf>
+get_mouse_position(canvas)
+        SV *canvas;
+    CODE:
+        RETVAL = _3DScene::get_mouse_position((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
+    OUTPUT:
+        RETVAL
+
+void
+set_mouse_position(canvas, position)
+        SV     *canvas;
+        Pointf *position;
+    CODE:
+        _3DScene::set_mouse_position((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), position);
+
 void
 zoom_to_bed(canvas)
         SV *canvas;
@@ -585,11 +615,11 @@ register_on_viewport_changed_callback(canvas, callback)
         _3DScene::register_on_viewport_changed_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
     
 void
-register_on_mark_volumes_for_layer_height(canvas, callback)
+register_on_mark_volumes_for_layer_height_callback(canvas, callback)
         SV *canvas;
         SV *callback;
     CODE:
-        _3DScene::register_on_mark_volumes_for_layer_height((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);
+        _3DScene::register_on_mark_volumes_for_layer_height_callback((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), (void*)callback);