class 3D callbacks moved to c++

xs/src/libslic3r/Utils.hpp

@@ -96,6 +96,7 @@ public:
     void call(int i) const;
     void call(int i, int j) const;
     void call(const std::vector<int>& ints) const;
+    void call(double x, double y) const;
 //    void call();
 //    void call(int i);
 //    void call(int i, int j);

xs/src/libslic3r/utils.cpp

@@ -266,6 +266,24 @@ void PerlCallback::call(const std::vector<int>& ints) const
     LEAVE;
 }
 
+//##############################################################################################################
+void PerlCallback::call(double x, double y) const
+{
+    if (!m_callback)
+        return;
+    dSP;
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(SP);
+    XPUSHs(sv_2mortal(newSVnv(x)));
+    XPUSHs(sv_2mortal(newSVnv(y)));
+    PUTBACK;
+    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
+    FREETMPS;
+    LEAVE;
+}
+//##############################################################################################################
+
 #ifdef WIN32
     #ifndef NOMINMAX
     # define NOMINMAX

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

@@ -1832,6 +1832,11 @@ void _3DScene::set_print(wxGLCanvas* canvas, Print* print)
     s_canvas_mgr.set_print(canvas, print);
 }
 
+void _3DScene::set_model(wxGLCanvas* canvas, Model* model)
+{
+    s_canvas_mgr.set_model(canvas, model);
+}
+
 void _3DScene::set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape)
 {
     return s_canvas_mgr.set_bed_shape(canvas, shape);
@@ -1992,11 +1997,6 @@ void _3DScene::register_on_model_update_callback(wxGLCanvas* canvas, void* callb
     s_canvas_mgr.register_on_model_update_callback(canvas, callback);
 }
 
-void _3DScene::register_on_move_callback(wxGLCanvas* canvas, void* callback)
-{
-    s_canvas_mgr.register_on_move_callback(canvas, callback);
-}
-
 void _3DScene::register_on_remove_object_callback(wxGLCanvas* canvas, void* callback)
 {
     s_canvas_mgr.register_on_remove_object_callback(canvas, callback);
@@ -2032,6 +2032,21 @@ void _3DScene::register_on_decrease_objects_callback(wxGLCanvas* canvas, void* c
     s_canvas_mgr.register_on_decrease_objects_callback(canvas, callback);
 }
 
+void _3DScene::register_on_instance_moved_callback(wxGLCanvas* canvas, void* callback)
+{
+    s_canvas_mgr.register_on_instance_moved_callback(canvas, callback);
+}
+
+void _3DScene::register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback)
+{
+    s_canvas_mgr.register_on_wipe_tower_moved_callback(canvas, callback);
+}
+
+void _3DScene::register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback)
+{
+    s_canvas_mgr.register_on_enable_action_buttons_callback(canvas, callback);
+}
+
 //void _3DScene::_glew_init()
 //{ 
 //    glewInit();

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

@@ -565,6 +565,7 @@ public:
 
     static void set_config(wxGLCanvas* canvas, DynamicPrintConfig* config);
     static void set_print(wxGLCanvas* canvas, Print* print);
+    static void set_model(wxGLCanvas* canvas, Model* model);
 
     static void set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape);
     static void set_auto_bed_shape(wxGLCanvas* canvas);
@@ -609,7 +610,6 @@ public:
     static void register_on_right_click_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_select_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_model_update_callback(wxGLCanvas* canvas, void* callback);
-    static void register_on_move_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_remove_object_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_arrange_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_rotate_object_left_callback(wxGLCanvas* canvas, void* callback);
@@ -617,6 +617,9 @@ public:
     static void register_on_scale_object_uniformly_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_increase_objects_callback(wxGLCanvas* canvas, void* callback);
     static void register_on_decrease_objects_callback(wxGLCanvas* canvas, void* callback);
+    static void register_on_instance_moved_callback(wxGLCanvas* canvas, void* callback);
+    static void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback);
+    static void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback);
 
 //    static void _glew_init();
 //##################################################################################################################

xs/src/slic3r/GUI/GLCanvas3D.cpp

@@ -947,6 +947,7 @@ GLCanvas3D::GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context)
     , m_volumes(nullptr)
     , m_config(nullptr)
     , m_print(nullptr)
+    , m_model(nullptr)
     , m_dirty(true)
     , m_initialized(false)
     , m_use_VBOs(false)
@@ -1116,6 +1117,11 @@ void GLCanvas3D::set_print(Print* print)
     m_print = print;
 }
 
+void GLCanvas3D::set_model(Model* model)
+{
+    m_model = model;
+}
+
 void GLCanvas3D::set_bed_shape(const Pointfs& shape)
 {
     m_bed.set_shape(shape);
@@ -1836,12 +1842,6 @@ void GLCanvas3D::register_on_model_update_callback(void* callback)
         m_on_model_update_callback.register_callback(callback);
 }
 
-void GLCanvas3D::register_on_move_callback(void* callback)
-{
-    if (callback != nullptr)
-        m_on_move_callback.register_callback(callback);
-}
-
 void GLCanvas3D::register_on_remove_object_callback(void* callback)
 {
     if (callback != nullptr)
@@ -1884,6 +1884,24 @@ void GLCanvas3D::register_on_decrease_objects_callback(void* callback)
         m_on_decrease_objects_callback.register_callback(callback);
 }
 
+void GLCanvas3D::register_on_instance_moved_callback(void* callback)
+{
+    if (callback != nullptr)
+        m_on_instance_moved_callback.register_callback(callback);
+}
+
+void GLCanvas3D::register_on_wipe_tower_moved_callback(void* callback)
+{
+    if (callback != nullptr)
+        m_on_wipe_tower_moved_callback.register_callback(callback);
+}
+
+void GLCanvas3D::register_on_enable_action_buttons_callback(void* callback)
+{
+    if (callback != nullptr)
+        m_on_enable_action_buttons_callback.register_callback(callback);
+}
+
 void GLCanvas3D::bind_event_handlers()
 {
     if (m_canvas != nullptr)
@@ -2283,7 +2301,7 @@ void GLCanvas3D::on_mouse(wxMouseEvent& evt)
                 }
             }
             
-            m_on_move_callback.call(volume_idxs);
+            _on_move(volume_idxs);
         }
         
         m_mouse.drag.volume_idx = -1;
@@ -2511,7 +2529,6 @@ void GLCanvas3D::_deregister_callbacks()
     m_on_right_click_callback.deregister_callback();
     m_on_select_callback.deregister_callback();
     m_on_model_update_callback.deregister_callback();
-    m_on_move_callback.deregister_callback();
     m_on_remove_object_callback.deregister_callback();
     m_on_arrange_callback.deregister_callback();
     m_on_rotate_object_left_callback.deregister_callback();
@@ -2519,6 +2536,9 @@ void GLCanvas3D::_deregister_callbacks()
     m_on_scale_object_uniformly_callback.deregister_callback();
     m_on_increase_objects_callback.deregister_callback();
     m_on_decrease_objects_callback.deregister_callback();
+    m_on_instance_moved_callback.deregister_callback();
+    m_on_wipe_tower_moved_callback.deregister_callback();
+    m_on_enable_action_buttons_callback.deregister_callback();
 }
 
 void GLCanvas3D::_mark_volumes_for_layer_height() const
@@ -3543,6 +3563,48 @@ void GLCanvas3D::_update_gcode_volumes_visibility(const GCodePreviewData& previe
     }
 }
 
+void GLCanvas3D::_on_move(const std::vector<int>& volume_idxs)
+{
+    if ((m_model == nullptr) || (m_volumes == nullptr))
+        return;
+
+    std::set<std::string> done;  // prevent moving instances twice
+    bool object_moved = false;
+    Pointf3 wipe_tower_origin(0.0, 0.0, 0.0);
+    for (int volume_idx : volume_idxs)
+    {
+        GLVolume* volume = m_volumes->volumes[volume_idx];
+        int obj_idx = volume->object_idx();
+        int instance_idx = volume->instance_idx();
+
+        // prevent moving instances twice
+        char done_id[64];
+        ::sprintf(done_id, "%d_%d", obj_idx, instance_idx);
+        if (done.find(done_id) != done.end())
+            continue;
+
+        done.insert(done_id);
+
+        if (obj_idx < 1000)
+        {
+            // Move a regular object.
+            ModelObject* model_object = m_model->objects[obj_idx];
+            model_object->instances[instance_idx]->offset.translate(volume->origin.x, volume->origin.y);
+            model_object->invalidate_bounding_box();
+            object_moved = true;
+        }
+        else if (obj_idx == 1000)
+            // Move a wipe tower proxy.
+            wipe_tower_origin = volume->origin;
+    }
+
+    if (object_moved)
+        m_on_instance_moved_callback.call();
+
+    if (wipe_tower_origin != Pointf3(0.0, 0.0, 0.0))
+        m_on_wipe_tower_moved_callback.call(wipe_tower_origin.x, wipe_tower_origin.y);
+}
+
 std::vector<float> GLCanvas3D::_parse_colors(const std::vector<std::string>& colors)
 {
     std::vector<float> output(colors.size() * 4, 1.0f);

xs/src/slic3r/GUI/GLCanvas3D.hpp

@@ -330,6 +330,7 @@ private:
     GLVolumeCollection* m_volumes;
     DynamicPrintConfig* m_config;
     Print* m_print;
+    Model* m_model;
 
     bool m_dirty;
     bool m_initialized;
@@ -355,7 +356,6 @@ private:
     PerlCallback m_on_right_click_callback;
     PerlCallback m_on_select_callback;
     PerlCallback m_on_model_update_callback;
-    PerlCallback m_on_move_callback;
     PerlCallback m_on_remove_object_callback;
     PerlCallback m_on_arrange_callback;
     PerlCallback m_on_rotate_object_left_callback;
@@ -363,6 +363,9 @@ private:
     PerlCallback m_on_scale_object_uniformly_callback;
     PerlCallback m_on_increase_objects_callback;
     PerlCallback m_on_decrease_objects_callback;
+    PerlCallback m_on_instance_moved_callback;
+    PerlCallback m_on_wipe_tower_moved_callback;
+    PerlCallback m_on_enable_action_buttons_callback;
 
 public:
     GLCanvas3D(wxGLCanvas* canvas, wxGLContext* context);
@@ -381,6 +384,7 @@ public:
 
     void set_config(DynamicPrintConfig* config);
     void set_print(Print* print);
+    void set_model(Model* model);
 
     // Set the bed shape to a single closed 2D polygon(array of two element arrays),
     // triangulate the bed and store the triangles into m_bed.m_triangles,
@@ -447,7 +451,6 @@ public:
     void register_on_right_click_callback(void* callback);
     void register_on_select_callback(void* callback);
     void register_on_model_update_callback(void* callback);
-    void register_on_move_callback(void* callback);
     void register_on_remove_object_callback(void* callback);
     void register_on_arrange_callback(void* callback);
     void register_on_rotate_object_left_callback(void* callback);
@@ -455,6 +458,9 @@ public:
     void register_on_scale_object_uniformly_callback(void* callback);
     void register_on_increase_objects_callback(void* callback);
     void register_on_decrease_objects_callback(void* callback);
+    void register_on_instance_moved_callback(void* callback);
+    void register_on_wipe_tower_moved_callback(void* callback);
+    void register_on_enable_action_buttons_callback(void* callback);
 
     void bind_event_handlers();
     void unbind_event_handlers();
@@ -528,6 +534,8 @@ private:
     // sets gcode geometry visibility according to user selection
     void _update_gcode_volumes_visibility(const GCodePreviewData& preview_data);
 
+    void _on_move(const std::vector<int>& volume_idxs);
+
     static std::vector<float> _parse_colors(const std::vector<std::string>& colors);
 };
 

xs/src/slic3r/GUI/GLCanvas3DManager.cpp

@@ -268,6 +268,13 @@ void GLCanvas3DManager::set_print(wxGLCanvas* canvas, Print* print)
         it->second->set_print(print);
 }
 
+void GLCanvas3DManager::set_model(wxGLCanvas* canvas, Model* model)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->set_model(model);
+}
+
 void GLCanvas3DManager::set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -543,13 +550,6 @@ void GLCanvas3DManager::register_on_model_update_callback(wxGLCanvas* canvas, vo
         it->second->register_on_model_update_callback(callback);
 }
 
-void GLCanvas3DManager::register_on_move_callback(wxGLCanvas* canvas, void* callback)
-{
-    CanvasesMap::iterator it = _get_canvas(canvas);
-    if (it != m_canvases.end())
-        it->second->register_on_move_callback(callback);
-}
-
 void GLCanvas3DManager::register_on_remove_object_callback(wxGLCanvas* canvas, void* callback)
 {
     CanvasesMap::iterator it = _get_canvas(canvas);
@@ -599,6 +599,27 @@ void GLCanvas3DManager::register_on_decrease_objects_callback(wxGLCanvas* canvas
         it->second->register_on_decrease_objects_callback(callback);
 }
 
+void GLCanvas3DManager::register_on_instance_moved_callback(wxGLCanvas* canvas, void* callback)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->register_on_instance_moved_callback(callback);
+}
+
+void GLCanvas3DManager::register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->register_on_wipe_tower_moved_callback(callback);
+}
+
+void GLCanvas3DManager::register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback)
+{
+    CanvasesMap::iterator it = _get_canvas(canvas);
+    if (it != m_canvases.end())
+        it->second->register_on_enable_action_buttons_callback(callback);
+}
+
 GLCanvas3DManager::CanvasesMap::iterator GLCanvas3DManager::_get_canvas(wxGLCanvas* canvas)
 {
     return (canvas == nullptr) ? m_canvases.end() : m_canvases.find(canvas);

xs/src/slic3r/GUI/GLCanvas3DManager.hpp

@@ -60,6 +60,7 @@ public:
 
     void set_config(wxGLCanvas* canvas, DynamicPrintConfig* config);
     void set_print(wxGLCanvas* canvas, Print* print);
+    void set_model(wxGLCanvas* canvas, Model* model);
 
     void set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape);
     void set_auto_bed_shape(wxGLCanvas* canvas);
@@ -112,7 +113,6 @@ public:
     void register_on_right_click_callback(wxGLCanvas* canvas, void* callback);
     void register_on_select_callback(wxGLCanvas* canvas, void* callback);
     void register_on_model_update_callback(wxGLCanvas* canvas, void* callback);
-    void register_on_move_callback(wxGLCanvas* canvas, void* callback);
     void register_on_remove_object_callback(wxGLCanvas* canvas, void* callback);
     void register_on_arrange_callback(wxGLCanvas* canvas, void* callback);
     void register_on_rotate_object_left_callback(wxGLCanvas* canvas, void* callback);
@@ -120,6 +120,9 @@ public:
     void register_on_scale_object_uniformly_callback(wxGLCanvas* canvas, void* callback);
     void register_on_increase_objects_callback(wxGLCanvas* canvas, void* callback);
     void register_on_decrease_objects_callback(wxGLCanvas* canvas, void* callback);
+    void register_on_instance_moved_callback(wxGLCanvas* canvas, void* callback);
+    void register_on_wipe_tower_moved_callback(wxGLCanvas* canvas, void* callback);
+    void register_on_enable_action_buttons_callback(wxGLCanvas* canvas, void* callback);
 
 private:
     CanvasesMap::iterator _get_canvas(wxGLCanvas* canvas);