Merge branch 'master' into tm_arrange_selection

1 files changed, 105 insertions, 243 deletions

diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
index c7435636d..df53b40aa 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
@@ -12,51 +12,29 @@
 namespace Slic3r {
 namespace GUI {
 
-#if ENABLE_SVG_ICONS
-    const float GLGizmosManager::Default_Icons_Size = 64;
-#endif // ENABLE_SVG_ICONS
+const float GLGizmosManager::Default_Icons_Size = 64;
 
-GLGizmosManager::GLGizmosManager()
-    : m_enabled(false)
-#if ENABLE_SVG_ICONS
+GLGizmosManager::GLGizmosManager(GLCanvas3D& parent)
+    : m_parent(parent)
+    , m_enabled(false)
     , m_icons_texture_dirty(true)
-#endif // ENABLE_SVG_ICONS
     , m_current(Undefined)
-#if ENABLE_SVG_ICONS
     , m_overlay_icons_size(Default_Icons_Size)
     , m_overlay_scale(1.0f)
     , m_overlay_border(5.0f)
     , m_overlay_gap_y(5.0f)
     , m_tooltip("")
+    , m_serializing(false)
 {
 }
-#else
-{
-    set_overlay_scale(1.0);
-}
-#endif // ENABLE_SVG_ICONS
 
 GLGizmosManager::~GLGizmosManager()
 {
     reset();
 }
 
-bool GLGizmosManager::init(GLCanvas3D& parent)
+bool GLGizmosManager::init()
 {
-#if !ENABLE_SVG_ICONS
-    m_icons_texture.metadata.filename = "gizmos.png";
-    m_icons_texture.metadata.icon_size = 64;
-
-    if (!m_icons_texture.metadata.filename.empty())
-    {
-        if (!m_icons_texture.texture.load_from_file(resources_dir() + "/icons/" + m_icons_texture.metadata.filename, false))
-        {
-            reset();
-            return false;
-        }
-    }
-#endif // !ENABLE_SVG_ICONS
-
     m_background_texture.metadata.filename = "toolbar_background.png";
     m_background_texture.metadata.left = 16;
     m_background_texture.metadata.top = 16;
@@ -72,11 +50,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
         }
     }
 
-#if ENABLE_SVG_ICONS
-    GLGizmoBase* gizmo = new GLGizmoMove3D(parent, "move.svg", 0);
-#else
-    GLGizmoBase* gizmo = new GLGizmoMove3D(parent, 0);
-#endif // ENABLE_SVG_ICONS
+    GLGizmoBase* gizmo = new GLGizmoMove3D(m_parent, "move.svg", 0);
     if (gizmo == nullptr)
         return false;
 
@@ -85,11 +59,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
 
     m_gizmos.insert(GizmosMap::value_type(Move, gizmo));
 
-#if ENABLE_SVG_ICONS
-    gizmo = new GLGizmoScale3D(parent, "scale.svg", 1);
-#else
-    gizmo = new GLGizmoScale3D(parent, 1);
-#endif // ENABLE_SVG_ICONS
+    gizmo = new GLGizmoScale3D(m_parent, "scale.svg", 1);
     if (gizmo == nullptr)
         return false;
 
@@ -98,11 +68,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
 
     m_gizmos.insert(GizmosMap::value_type(Scale, gizmo));
 
-#if ENABLE_SVG_ICONS
-    gizmo = new GLGizmoRotate3D(parent, "rotate.svg", 2);
-#else
-    gizmo = new GLGizmoRotate3D(parent, 2);
-#endif // ENABLE_SVG_ICONS
+    gizmo = new GLGizmoRotate3D(m_parent, "rotate.svg", 2);
     if (gizmo == nullptr)
     {
         reset();
@@ -117,11 +83,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
 
     m_gizmos.insert(GizmosMap::value_type(Rotate, gizmo));
 
-#if ENABLE_SVG_ICONS
-    gizmo = new GLGizmoFlatten(parent, "place.svg", 3);
-#else
-    gizmo = new GLGizmoFlatten(parent, 3);
-#endif // ENABLE_SVG_ICONS
+    gizmo = new GLGizmoFlatten(m_parent, "place.svg", 3);
     if (gizmo == nullptr)
         return false;
 
@@ -132,11 +94,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
 
     m_gizmos.insert(GizmosMap::value_type(Flatten, gizmo));
 
-#if ENABLE_SVG_ICONS
-    gizmo = new GLGizmoCut(parent, "cut.svg", 4);
-#else
-    gizmo = new GLGizmoCut(parent, 4);
-#endif // ENABLE_SVG_ICONS
+    gizmo = new GLGizmoCut(m_parent, "cut.svg", 4);
     if (gizmo == nullptr)
         return false;
 
@@ -147,11 +105,7 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
 
     m_gizmos.insert(GizmosMap::value_type(Cut, gizmo));
 
-#if ENABLE_SVG_ICONS
-    gizmo = new GLGizmoSlaSupports(parent, "sla_supports.svg", 5);
-#else
-    gizmo = new GLGizmoSlaSupports(parent, 5);
-#endif // ENABLE_SVG_ICONS
+    gizmo = new GLGizmoSlaSupports(m_parent, "sla_supports.svg", 5);
     if (gizmo == nullptr)
         return false;
 
@@ -165,7 +119,6 @@ bool GLGizmosManager::init(GLCanvas3D& parent)
     return true;
 }
 
-#if ENABLE_SVG_ICONS
 void GLGizmosManager::set_overlay_icon_size(float size)
 {
     if (m_overlay_icons_size != size)
@@ -174,29 +127,25 @@ void GLGizmosManager::set_overlay_icon_size(float size)
         m_icons_texture_dirty = true;
     }
 }
-#endif // ENABLE_SVG_ICONS
 
 void GLGizmosManager::set_overlay_scale(float scale)
 {
-#if ENABLE_SVG_ICONS
     if (m_overlay_scale != scale)
     {
         m_overlay_scale = scale;
         m_icons_texture_dirty = true;
     }
-#else
-    m_overlay_icons_scale = scale;
-    m_overlay_border = 5.0f * scale;
-    m_overlay_gap_y = 5.0f * scale;
-#endif // ENABLE_SVG_ICONS
 }
 
-void GLGizmosManager::refresh_on_off_state(const Selection& selection)
+void GLGizmosManager::refresh_on_off_state()
 {
+    if (m_serializing)
+        return;
+
     GizmosMap::iterator it = m_gizmos.find(m_current);
     if ((it != m_gizmos.end()) && (it->second != nullptr))
     {
-        if (!it->second->is_activable(selection))
+        if (!it->second->is_activable())
         {
             it->second->set_state(GLGizmoBase::Off);
             m_current = Undefined;
@@ -209,6 +158,9 @@ void GLGizmosManager::reset_all_states()
     if (!m_enabled)
         return;
 
+    if (m_serializing)
+        return;
+
     for (GizmosMap::const_iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
         if (it->second != nullptr)
@@ -248,22 +200,22 @@ void GLGizmosManager::enable_grabber(EType type, unsigned int id, bool enable)
     }
 }
 
-void GLGizmosManager::update(const Linef3& mouse_ray, const Selection& selection, const Point* mouse_pos)
+void GLGizmosManager::update(const Linef3& mouse_ray, const Point& mouse_pos)
 {
     if (!m_enabled)
         return;
 
     GLGizmoBase* curr = get_current();
     if (curr != nullptr)
-        curr->update(GLGizmoBase::UpdateData(mouse_ray, mouse_pos), selection);
+        curr->update(GLGizmoBase::UpdateData(mouse_ray, mouse_pos));
 }
 
-void GLGizmosManager::update_data(GLCanvas3D& canvas)
+void GLGizmosManager::update_data()
 {
     if (!m_enabled)
         return;
 
-    const Selection& selection = canvas.get_selection();
+    const Selection& selection = m_parent.get_selection();
 
     bool is_wipe_tower = selection.is_wipe_tower();
     enable_grabber(Move, 2, !is_wipe_tower);
@@ -284,7 +236,7 @@ void GLGizmosManager::update_data(GLCanvas3D& canvas)
         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, selection);
+        set_sla_support_data(model_object);
     }
     else if (selection.is_single_volume() || selection.is_single_modifier())
     {
@@ -292,7 +244,7 @@ void GLGizmosManager::update_data(GLCanvas3D& canvas)
         set_scale(volume->get_volume_scaling_factor());
         set_rotation(Vec3d::Zero());
         set_flattening_data(nullptr);
-        set_sla_support_data(nullptr, selection);
+        set_sla_support_data(nullptr);
     }
     else if (is_wipe_tower)
     {
@@ -300,14 +252,14 @@ void GLGizmosManager::update_data(GLCanvas3D& canvas)
         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, selection);
+        set_sla_support_data(nullptr);
     }
     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(nullptr, selection);
+        set_sla_support_data(nullptr);
     }
 }
 
@@ -320,9 +272,12 @@ bool GLGizmosManager::is_running() const
     return (curr != nullptr) ? (curr->get_state() == GLGizmoBase::On) : false;
 }
 
-bool GLGizmosManager::handle_shortcut(int key, const Selection& selection)
+bool GLGizmosManager::handle_shortcut(int key)
 {
-    if (!m_enabled || selection.is_empty())
+    if (!m_enabled)
+        return false;
+
+    if (m_parent.get_selection().is_empty())
         return false;
 
     EType old_current = m_current;
@@ -334,7 +289,7 @@ bool GLGizmosManager::handle_shortcut(int key, const Selection& selection)
 
         int it_key = it->second->get_shortcut_key();
 
-        if (it->second->is_activable(selection) && ((it_key == key - 64) || (it_key == key - 96)))
+        if (it->second->is_activable() && ((it_key == key - 64) || (it_key == key - 96)))
         {
             if ((it->second->get_state() == GLGizmoBase::On))
             {
@@ -370,14 +325,14 @@ bool GLGizmosManager::is_dragging() const
     return (curr != nullptr) ? curr->is_dragging() : false;
 }
 
-void GLGizmosManager::start_dragging(const Selection& selection)
+void GLGizmosManager::start_dragging()
 {
     if (!m_enabled)
         return;
 
     GLGizmoBase* curr = get_current();
     if (curr != nullptr)
-        curr->start_dragging(selection);
+        curr->start_dragging();
 }
 
 void GLGizmosManager::stop_dragging()
@@ -465,14 +420,14 @@ void GLGizmosManager::set_flattening_data(const ModelObject* model_object)
         reinterpret_cast<GLGizmoFlatten*>(it->second)->set_flattening_data(model_object);
 }
 
-void GLGizmosManager::set_sla_support_data(ModelObject* model_object, const Selection& selection)
+void GLGizmosManager::set_sla_support_data(ModelObject* model_object)
 {
     if (!m_enabled)
         return;
 
     GizmosMap::const_iterator it = m_gizmos.find(SlaSupports);
     if (it != m_gizmos.end())
-        reinterpret_cast<GLGizmoSlaSupports*>(it->second)->set_sla_support_data(model_object, selection);
+        reinterpret_cast<GLGizmoSlaSupports*>(it->second)->set_sla_support_data(model_object, m_parent.get_selection());
 }
 
 // Returns true if the gizmo used the event to do something, false otherwise.
@@ -501,40 +456,38 @@ ClippingPlane GLGizmosManager::get_sla_clipping_plane() const
 }
 
 
-void GLGizmosManager::render_current_gizmo(const Selection& selection) const
+void GLGizmosManager::render_current_gizmo() const
 {
     if (!m_enabled)
         return;
 
     GLGizmoBase* curr = get_current();
     if (curr != nullptr)
-        curr->render(selection);
+        curr->render();
 }
 
-void GLGizmosManager::render_current_gizmo_for_picking_pass(const Selection& selection) const
+void GLGizmosManager::render_current_gizmo_for_picking_pass() const
 {
     if (!m_enabled)
         return;
 
     GLGizmoBase* curr = get_current();
     if (curr != nullptr)
-        curr->render_for_picking(selection);
+        curr->render_for_picking();
 }
 
-void GLGizmosManager::render_overlay(const GLCanvas3D& canvas, const Selection& selection) const
+void GLGizmosManager::render_overlay() const
 {
     if (!m_enabled)
         return;
 
-#if ENABLE_SVG_ICONS
     if (m_icons_texture_dirty)
         generate_icons_texture();
-#endif // ENABLE_SVG_ICONS
 
-    do_render_overlay(canvas, selection);
+    do_render_overlay();
 }
 
-bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt, GLCanvas3D& canvas)
+bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt)
 {
     bool processed = false;
 
@@ -547,14 +500,12 @@ bool GLGizmosManager::on_mouse_wheel(wxMouseEvent& evt, GLCanvas3D& canvas)
     return processed;
 }
 
-
-
-bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
+bool GLGizmosManager::on_mouse(wxMouseEvent& evt)
 {
     Point pos(evt.GetX(), evt.GetY());
     Vec2d mouse_pos((double)evt.GetX(), (double)evt.GetY());
 
-    Selection& selection = canvas.get_selection();
+    Selection& selection = m_parent.get_selection();
     int selected_object_idx = selection.get_object_idx();
     bool processed = false;
 
@@ -570,7 +521,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
 
     // mouse anywhere
     if (evt.Moving())
-        m_tooltip = update_hover_state(canvas, mouse_pos);
+        m_tooltip = update_hover_state(mouse_pos);
     else if (evt.LeftUp())
         m_mouse_capture.left = false;
     else if (evt.MiddleUp())
@@ -581,7 +532,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
         // if the button down was done on this toolbar, prevent from dragging into the scene
         processed = true;
 
-    if (!overlay_contains_mouse(canvas, mouse_pos))
+    if (!overlay_contains_mouse(mouse_pos))
     {
         // mouse is outside the toolbar
         m_tooltip = "";
@@ -593,41 +544,40 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
                 processed = true;
             else if (!selection.is_empty() && grabber_contains_mouse())
             {
-                update_data(canvas);
+                update_data();
                 selection.start_dragging();
-                start_dragging(selection);
+                start_dragging();
 
                 if (m_current == Flatten)
                 {
                     // Rotate the object so the normal points downward:
-                    selection.flattening_rotate(get_flattening_normal());
-                    canvas.do_flatten();
+                    m_parent.do_flatten(get_flattening_normal(), L("Gizmo-Place on Face"));
                     wxGetApp().obj_manipul()->set_dirty();
                 }
 
-                canvas.set_as_dirty();
+                m_parent.set_as_dirty();
                 processed = true;
             }
         }
         else if (evt.RightDown() && (selected_object_idx != -1) && (m_current == SlaSupports) && gizmo_event(SLAGizmoEventType::RightDown))
             // event was taken care of by the SlaSupports gizmo
             processed = true;
-        else if (evt.Dragging() && (canvas.get_move_volume_id() != -1) && (m_current == SlaSupports))
-            // don't allow dragging objects with the Sla gizmo on
+        else if (evt.Dragging() && (m_parent.get_move_volume_id() != -1) && (m_current == SlaSupports))
+                        // don't allow dragging objects with the Sla gizmo on
             processed = true;
         else if (evt.Dragging() && (m_current == SlaSupports) && gizmo_event(SLAGizmoEventType::Dragging, mouse_pos, evt.ShiftDown(), evt.AltDown(), evt.ControlDown()))
         {
             // the gizmo got the event and took some action, no need to do anything more here
-            canvas.set_as_dirty();
+            m_parent.set_as_dirty();
             processed = true;
         }
         else if (evt.Dragging() && is_dragging())
         {
-            if (!canvas.get_wxglcanvas()->HasCapture())
-                canvas.get_wxglcanvas()->CaptureMouse();
+            if (!m_parent.get_wxglcanvas()->HasCapture())
+                m_parent.get_wxglcanvas()->CaptureMouse();
 
-            canvas.set_mouse_as_dragging();
-            update(canvas.mouse_ray(pos), selection, &pos);
+            m_parent.set_mouse_as_dragging();
+            update(m_parent.mouse_ray(pos), pos);
 
             switch (m_current)
             {
@@ -664,7 +614,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
                 break;
             }
 
-            canvas.set_as_dirty();
+            m_parent.set_as_dirty();
             processed = true;
         }
         else if (evt.LeftUp() && is_dragging())
@@ -673,18 +623,18 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
             {
             case Move:
             {
-                canvas.disable_regenerate_volumes();
-                canvas.do_move();
+                m_parent.disable_regenerate_volumes();
+                m_parent.do_move(L("Gizmo-Move"));
                 break;
             }
             case Scale:
             {
-                canvas.do_scale();
+                m_parent.do_scale(L("Gizmo-Scale"));
                 break;
             }
             case Rotate:
             {
-                canvas.do_rotate();
+                m_parent.do_rotate(L("Gizmo-Rotate"));
                 break;
             }
             default:
@@ -692,25 +642,25 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
             }
 
             stop_dragging();
-            update_data(canvas);
+            update_data();
 
             wxGetApp().obj_manipul()->set_dirty();
             // Let the platter know that the dragging finished, so a delayed refresh
             // of the scene with the background processing data should be performed.
-            canvas.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
+            m_parent.post_event(SimpleEvent(EVT_GLCANVAS_MOUSE_DRAGGING_FINISHED));
             // updates camera target constraints
-            canvas.refresh_camera_scene_box();
+            m_parent.refresh_camera_scene_box();
 
             processed = true;
         }
-        else if (evt.LeftUp() && (m_current == SlaSupports) && !canvas.is_mouse_dragging())
+        else if (evt.LeftUp() && (m_current == SlaSupports) && !m_parent.is_mouse_dragging())
         {
             // in case SLA gizmo is selected, we just pass the LeftUp event and stop processing - neither
             // object moving or selecting is suppressed in that case
             gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, evt.ShiftDown(), evt.AltDown(), evt.ControlDown());
             processed = true;
         }
-        else if (evt.LeftUp() && (m_current == Flatten) && ((canvas.get_first_hover_volume_idx() != -1) || grabber_contains_mouse()))
+        else if (evt.LeftUp() && (m_current == Flatten) && ((m_parent.get_first_hover_volume_idx() != -1) || grabber_contains_mouse()))
         {
             // to avoid to loose the selection when user clicks an object while the Flatten gizmo is active
             processed = true;
@@ -722,24 +672,24 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
         if (evt.LeftDown() || evt.LeftDClick())
         {
             m_mouse_capture.left = true;
-            m_mouse_capture.parent = &canvas;
+            m_mouse_capture.parent = &m_parent;
             processed = true;
             if (!selection.is_empty())
             {
-                update_on_off_state(canvas, mouse_pos, selection);
-                update_data(canvas);
-                canvas.set_as_dirty();
+                update_on_off_state(mouse_pos);
+                update_data();
+                m_parent.set_as_dirty();
             }
         }
         else if (evt.MiddleDown())
         {
             m_mouse_capture.middle = true;
-            m_mouse_capture.parent = &canvas;
+            m_mouse_capture.parent = &m_parent;
         }
         else if (evt.RightDown())
         {
             m_mouse_capture.right = true;
-            m_mouse_capture.parent = &canvas;
+            m_mouse_capture.parent = &m_parent;
         }
         else if (evt.LeftUp())
             processed = true;
@@ -748,7 +698,7 @@ bool GLGizmosManager::on_mouse(wxMouseEvent& evt, GLCanvas3D& canvas)
     return processed;
 }
 
-bool GLGizmosManager::on_char(wxKeyEvent& evt, GLCanvas3D& canvas)
+bool GLGizmosManager::on_char(wxKeyEvent& evt)
 {
     // see include/wx/defs.h enum wxKeyCode
     int keyCode = evt.GetKeyCode();
@@ -856,20 +806,20 @@ bool GLGizmosManager::on_char(wxKeyEvent& evt, GLCanvas3D& canvas)
 
     if (!processed && !evt.HasModifiers())
     {
-        if (handle_shortcut(keyCode, canvas.get_selection()))
+        if (handle_shortcut(keyCode))
         {
-            update_data(canvas);
+            update_data();
             processed = true;
         }
     }
 
     if (processed)
-        canvas.set_as_dirty();
+        m_parent.set_as_dirty();
 
     return processed;
 }
 
-bool GLGizmosManager::on_key(wxKeyEvent& evt, GLCanvas3D& canvas)
+bool GLGizmosManager::on_key(wxKeyEvent& evt)
 {
     const int keyCode = evt.GetKeyCode();
     bool processed = false;
@@ -895,23 +845,29 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt, GLCanvas3D& canvas)
         }
 
 //        if (processed)
-//            canvas.set_cursor(GLCanvas3D::Standard);
+//            m_parent.set_cursor(GLCanvas3D::Standard);
     }
     else if (evt.GetEventType() == wxEVT_KEY_DOWN)
     {
         if ((m_current == SlaSupports) && ((keyCode == WXK_SHIFT) || (keyCode == WXK_ALT)) && reinterpret_cast<GLGizmoSlaSupports*>(get_current())->is_in_editing_mode())
         {
-//            canvas.set_cursor(GLCanvas3D::Cross);
+//            m_parent.set_cursor(GLCanvas3D::Cross);
             processed = true;
         }
     }
 
     if (processed)
-        canvas.set_as_dirty();
+        m_parent.set_as_dirty();
 
     return processed;
 }
 
+void GLGizmosManager::update_after_undo_redo()
+{
+    update_data();
+    m_serializing = false;
+}
+
 void GLGizmosManager::reset()
 {
     for (GizmosMap::value_type& gizmo : m_gizmos)
@@ -923,23 +879,19 @@ void GLGizmosManager::reset()
     m_gizmos.clear();
 }
 
-void GLGizmosManager::do_render_overlay(const GLCanvas3D& canvas, const Selection& selection) const
+void GLGizmosManager::do_render_overlay() const
 {
     if (m_gizmos.empty())
         return;
 
-    float cnv_w = (float)canvas.get_canvas_size().get_width();
-    float cnv_h = (float)canvas.get_canvas_size().get_height();
-    float zoom = (float)canvas.get_camera().get_zoom();
+    float cnv_w = (float)m_parent.get_canvas_size().get_width();
+    float cnv_h = (float)m_parent.get_canvas_size().get_height();
+    float zoom = (float)m_parent.get_camera().get_zoom();
     float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
 
     float height = get_total_overlay_height();
     float width = get_total_overlay_width();
-#if ENABLE_SVG_ICONS
     float scaled_border = m_overlay_border * m_overlay_scale * inv_zoom;
-#else
-    float scaled_border = m_overlay_border * inv_zoom;
-#endif // ENABLE_SVG_ICONS
 
     float top_x = (-0.5f * cnv_w) * inv_zoom;
     float top_y = (0.5f * height) * inv_zoom;
@@ -1015,7 +967,6 @@ void GLGizmosManager::do_render_overlay(const GLCanvas3D& canvas, const Selectio
         }
     }
 
-#if ENABLE_SVG_ICONS
     top_x += scaled_border;
     top_y -= scaled_border;
     float scaled_gap_y = m_overlay_gap_y * m_overlay_scale * inv_zoom;
@@ -1027,21 +978,9 @@ void GLGizmosManager::do_render_overlay(const GLCanvas3D& canvas, const Selectio
     unsigned int tex_height = m_icons_texture.get_height();
     float inv_tex_width = (tex_width != 0) ? 1.0f / (float)tex_width : 0.0f;
     float inv_tex_height = (tex_height != 0) ? 1.0f / (float)tex_height : 0.0f;
-#else
-    top_x += m_overlay_border * inv_zoom;
-    top_y -= m_overlay_border * inv_zoom;
-    float scaled_gap_y = m_overlay_gap_y * inv_zoom;
-
-    float scaled_icons_size = (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale * inv_zoom;
-    unsigned int icons_texture_id = m_icons_texture.texture.get_id();
-    unsigned int texture_size = m_icons_texture.texture.get_width();
-    float inv_texture_size = (texture_size != 0) ? 1.0f / (float)texture_size : 0.0f;
-#endif // ENABLE_SVG_ICONS
-
-#if ENABLE_SVG_ICONS
+
     if ((icons_texture_id == 0) || (tex_width <= 0) || (tex_height <= 0))
         return;
-#endif // ENABLE_SVG_ICONS
 
     for (GizmosMap::const_iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
@@ -1051,78 +990,44 @@ void GLGizmosManager::do_render_overlay(const GLCanvas3D& canvas, const Selectio
         unsigned int sprite_id = it->second->get_sprite_id();
         GLGizmoBase::EState state = it->second->get_state();
 
-#if ENABLE_SVG_ICONS
         float u_icon_size = m_overlay_icons_size * m_overlay_scale * inv_tex_width;
         float v_icon_size = m_overlay_icons_size * m_overlay_scale * inv_tex_height;
         float v_top = sprite_id * v_icon_size;
         float u_left = state * u_icon_size;
         float v_bottom = v_top + v_icon_size;
         float u_right = u_left + u_icon_size;
-#else
-        float uv_icon_size = (float)m_icons_texture.metadata.icon_size * inv_texture_size;
-        float v_top = sprite_id * uv_icon_size;
-        float u_left = state * uv_icon_size;
-        float v_bottom = v_top + uv_icon_size;
-        float u_right = u_left + uv_icon_size;
-#endif // ENABLE_SVG_ICONS
 
         GLTexture::render_sub_texture(icons_texture_id, top_x, top_x + scaled_icons_size, top_y - scaled_icons_size, top_y, { { u_left, v_bottom }, { u_right, v_bottom }, { u_right, v_top }, { u_left, v_top } });
         if (it->second->get_state() == GLGizmoBase::On) {
-            float toolbar_top = (float)cnv_h - canvas.get_view_toolbar_height();
-#if ENABLE_SVG_ICONS
-            it->second->render_input_window(width, 0.5f * cnv_h - top_y * zoom, toolbar_top, selection);
-#else
-            it->second->render_input_window(2.0f * m_overlay_border + icon_size * zoom, 0.5f * cnv_h - top_y * zoom, toolbar_top, selection);
-#endif // ENABLE_SVG_ICONS
+            float toolbar_top = (float)cnv_h - m_parent.get_view_toolbar_height();
+            it->second->render_input_window(width, 0.5f * cnv_h - top_y * zoom, toolbar_top);
         }
-#if ENABLE_SVG_ICONS
         top_y -= scaled_stride_y;
-#else
-        top_y -= (scaled_icons_size + scaled_gap_y);
-#endif // ENABLE_SVG_ICONS
     }
 }
 
 float GLGizmosManager::get_total_overlay_height() const
 {
-#if ENABLE_SVG_ICONS
     float scaled_icons_size = m_overlay_icons_size * m_overlay_scale;
     float scaled_border = m_overlay_border * m_overlay_scale;
     float scaled_gap_y = m_overlay_gap_y * m_overlay_scale;
     float scaled_stride_y = scaled_icons_size + scaled_gap_y;
     float height = 2.0f * scaled_border;
-#else
-    float height = 2.0f * m_overlay_border;
-
-    float scaled_icons_size = (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale;
-#endif // ENABLE_SVG_ICONS
 
     for (GizmosMap::const_iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
         if ((it->second == nullptr) || !it->second->is_selectable())
             continue;
 
-#if ENABLE_SVG_ICONS
         height += scaled_stride_y;
-#else
-        height += (scaled_icons_size + m_overlay_gap_y);
-#endif // ENABLE_SVG_ICONS
     }
 
-#if ENABLE_SVG_ICONS
     return height - scaled_gap_y;
-#else
-    return height - m_overlay_gap_y;
-#endif // ENABLE_SVG_ICONS
 }
 
 float GLGizmosManager::get_total_overlay_width() const
 {
-#if ENABLE_SVG_ICONS
     return (2.0f * m_overlay_border + m_overlay_icons_size) * m_overlay_scale;
-#else
-    return (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale + 2.0f * m_overlay_border;
-#endif // ENABLE_SVG_ICONS
 }
 
 GLGizmoBase* GLGizmosManager::get_current() const
@@ -1131,7 +1036,6 @@ GLGizmoBase* GLGizmosManager::get_current() const
     return (it != m_gizmos.end()) ? it->second : nullptr;
 }
 
-#if ENABLE_SVG_ICONS
 bool GLGizmosManager::generate_icons_texture() const
 {
     std::string path = resources_dir() + "/icons/";
@@ -1157,38 +1061,28 @@ bool GLGizmosManager::generate_icons_texture() const
 
     return res;
 }
-#endif // ENABLE_SVG_ICONS
 
-void GLGizmosManager::update_on_off_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection)
+void GLGizmosManager::update_on_off_state(const Vec2d& mouse_pos)
 {
     if (!m_enabled)
         return;
 
-    float cnv_h = (float)canvas.get_canvas_size().get_height();
+    float cnv_h = (float)m_parent.get_canvas_size().get_height();
     float height = get_total_overlay_height();
 
-#if ENABLE_SVG_ICONS
     float scaled_icons_size = m_overlay_icons_size * m_overlay_scale;
     float scaled_border = m_overlay_border * m_overlay_scale;
     float scaled_gap_y = m_overlay_gap_y * m_overlay_scale;
     float scaled_stride_y = scaled_icons_size + scaled_gap_y;
     float top_y = 0.5f * (cnv_h - height) + scaled_border;
-#else
-    float top_y = 0.5f * (cnv_h - height) + m_overlay_border;
-    float scaled_icons_size = (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale;
-#endif // ENABLE_SVG_ICONS
 
     for (GizmosMap::iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
         if ((it->second == nullptr) || !it->second->is_selectable())
             continue;
 
-#if ENABLE_SVG_ICONS
         bool inside = (scaled_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= scaled_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size);
-#else
-        bool inside = (m_overlay_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= m_overlay_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size);
-#endif // ENABLE_SVG_ICONS
-        if (it->second->is_activable(selection) && inside)
+        if (it->second->is_activable() && inside)
         {
             if ((it->second->get_state() == GLGizmoBase::On))
             {
@@ -1204,11 +1098,7 @@ void GLGizmosManager::update_on_off_state(const GLCanvas3D& canvas, const Vec2d&
         else
             it->second->set_state(GLGizmoBase::Off);
 
-#if ENABLE_SVG_ICONS
         top_y += scaled_stride_y;
-#else
-        top_y += (scaled_icons_size + m_overlay_gap_y);
-#endif // ENABLE_SVG_ICONS
     }
 
     GizmosMap::iterator it = m_gizmos.find(m_current);
@@ -1216,90 +1106,62 @@ void GLGizmosManager::update_on_off_state(const GLCanvas3D& canvas, const Vec2d&
         it->second->set_state(GLGizmoBase::On);
 }
 
-std::string GLGizmosManager::update_hover_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos)
+std::string GLGizmosManager::update_hover_state(const Vec2d& mouse_pos)
 {
     std::string name = "";
 
     if (!m_enabled)
         return name;
 
-    const Selection& selection = canvas.get_selection();
-
-    float cnv_h = (float)canvas.get_canvas_size().get_height();
+    float cnv_h = (float)m_parent.get_canvas_size().get_height();
     float height = get_total_overlay_height();
-#if ENABLE_SVG_ICONS
     float scaled_icons_size = m_overlay_icons_size * m_overlay_scale;
     float scaled_border = m_overlay_border * m_overlay_scale;
     float scaled_gap_y = m_overlay_gap_y * m_overlay_scale;
     float scaled_stride_y = scaled_icons_size + scaled_gap_y;
     float top_y = 0.5f * (cnv_h - height) + scaled_border;
-#else
-    float top_y = 0.5f * (cnv_h - height) + m_overlay_border;
-    float scaled_icons_size = (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale;
-#endif // ENABLE_SVG_ICONS
 
     for (GizmosMap::iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
         if ((it->second == nullptr) || !it->second->is_selectable())
             continue;
 
-#if ENABLE_SVG_ICONS
         bool inside = (scaled_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= scaled_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size);
-#else
-        bool inside = (m_overlay_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= m_overlay_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size);
-#endif // ENABLE_SVG_ICONS
         if (inside)
             name = it->second->get_name();
 
-        if (it->second->is_activable(selection) && (it->second->get_state() != GLGizmoBase::On))
+        if (it->second->is_activable() && (it->second->get_state() != GLGizmoBase::On))
             it->second->set_state(inside ? GLGizmoBase::Hover : GLGizmoBase::Off);
 
-#if ENABLE_SVG_ICONS
         top_y += scaled_stride_y;
-#else
-        top_y += (scaled_icons_size + m_overlay_gap_y);
-#endif // ENABLE_SVG_ICONS
     }
 
     return name;
 }
 
-bool GLGizmosManager::overlay_contains_mouse(const GLCanvas3D& canvas, const Vec2d& mouse_pos) const
+bool GLGizmosManager::overlay_contains_mouse(const Vec2d& mouse_pos) const
 {
     if (!m_enabled)
         return false;
 
-    float cnv_h = (float)canvas.get_canvas_size().get_height();
+    float cnv_h = (float)m_parent.get_canvas_size().get_height();
     float height = get_total_overlay_height();
 
-#if ENABLE_SVG_ICONS
     float scaled_icons_size = m_overlay_icons_size * m_overlay_scale;
     float scaled_border = m_overlay_border * m_overlay_scale;
     float scaled_gap_y = m_overlay_gap_y * m_overlay_scale;
     float scaled_stride_y = scaled_icons_size + scaled_gap_y;
     float top_y = 0.5f * (cnv_h - height) + scaled_border;
-#else
-    float top_y = 0.5f * (cnv_h - height) + m_overlay_border;
-    float scaled_icons_size = (float)m_icons_texture.metadata.icon_size * m_overlay_icons_scale;
-#endif // ENABLE_SVG_ICONS
 
     for (GizmosMap::const_iterator it = m_gizmos.begin(); it != m_gizmos.end(); ++it)
     {
         if ((it->second == nullptr) || !it->second->is_selectable())
             continue;
 
-#if ENABLE_SVG_ICONS
         if ((scaled_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= scaled_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size))
-#else
-        if ((m_overlay_border <= (float)mouse_pos(0)) && ((float)mouse_pos(0) <= m_overlay_border + scaled_icons_size) && (top_y <= (float)mouse_pos(1)) && ((float)mouse_pos(1) <= top_y + scaled_icons_size))
-#endif // ENABLE_SVG_ICONS
             return true;
 
-#if ENABLE_SVG_ICONS
         top_y += scaled_stride_y;
-#else
-        top_y += (scaled_icons_size + m_overlay_gap_y);
-#endif // ENABLE_SVG_ICONS
     }
 
     return false;