diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
index 473a48865..b5e2c99c5 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
@@ -20,10 +20,6 @@ GLGizmosManager::GLGizmosManager(GLCanvas3D& parent)
     , m_enabled(false)
     , m_icons_texture_dirty(true)
     , m_current(Undefined)
-    , 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)
 {
@@ -53,19 +49,18 @@ size_t GLGizmosManager::get_gizmo_idx_from_mouse(const Vec2d& mouse_pos) const
         return Undefined;
 
     float cnv_h = (float)m_parent.get_canvas_size().get_height();
-    float height = get_total_overlay_height();
-    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;
+    float height = get_scaled_total_height();
+    float icons_size = m_layout.scaled_icons_size();
+    float border = m_layout.scaled_border();
+    float stride_y = m_layout.scaled_stride_y();
+    float top_y = 0.5f * (cnv_h - height) + border;
 
     // is mouse horizontally in the area?
-    if ((scaled_border <= (float)mouse_pos(0) && ((float)mouse_pos(0) <= scaled_border + scaled_icons_size))) {
+    if ((border <= (float)mouse_pos(0) && ((float)mouse_pos(0) <= border + icons_size))) {
         // which icon is it on?
-        size_t from_top = (size_t)((float)mouse_pos(1) - top_y)/scaled_stride_y;
+        size_t from_top = (size_t)((float)mouse_pos(1) - top_y) / stride_y;
         // is it really on the icon or already past the border?
-        if ((float)mouse_pos(1) <= top_y + from_top*scaled_stride_y + scaled_icons_size) {
+        if ((float)mouse_pos(1) <= top_y + from_top * stride_y + icons_size) {
             std::vector<size_t> selectable = get_selectable_idxs();
             if (from_top < selectable.size())
                 return selectable[from_top];
@@ -110,18 +105,18 @@ bool GLGizmosManager::init()
 
 void GLGizmosManager::set_overlay_icon_size(float size)
 {
-    if (m_overlay_icons_size != size)
+    if (m_layout.icons_size != size)
     {
-        m_overlay_icons_size = size;
+        m_layout.icons_size = size;
         m_icons_texture_dirty = true;
     }
 }
 
 void GLGizmosManager::set_overlay_scale(float scale)
 {
-    if (m_overlay_scale != scale)
+    if (m_layout.scale != scale)
     {
-        m_overlay_scale = scale;
+        m_layout.scale = scale;
         m_icons_texture_dirty = true;
     }
 }
@@ -851,26 +846,27 @@ void GLGizmosManager::do_render_overlay() const
     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();
-    float scaled_border = m_overlay_border * m_overlay_scale * inv_zoom;
+    float height = get_scaled_total_height();
+    float width = get_scaled_total_width();
+    float zoomed_border = m_layout.scaled_border() * inv_zoom;
 
-    float top_x = (-0.5f * cnv_w) * inv_zoom;
-    float top_y = (0.5f * height) * inv_zoom;
+    float zoomed_top_x = (-0.5f * cnv_w) * inv_zoom;
+    float zoomed_top_y = (0.5f * height) * inv_zoom;
 
-    float left = top_x;
-    float top = top_y;
-    float right = left + width * inv_zoom;
-    float bottom = top - height * inv_zoom;
+    float zoomed_left = zoomed_top_x;
+    float zoomed_top = zoomed_top_y;
+    float zoomed_right = zoomed_left + width * inv_zoom;
+    float zoomed_bottom = zoomed_top - height * inv_zoom;
 
-    render_background(left, top, right, bottom, scaled_border);
+    render_background(zoomed_left, zoomed_top, zoomed_right, zoomed_bottom, zoomed_border);
 
-    top_x += scaled_border;
-    top_y -= scaled_border;
-    float scaled_gap_y = m_overlay_gap_y * m_overlay_scale * inv_zoom;
+    zoomed_top_x += zoomed_border;
+    zoomed_top_y -= zoomed_border;
+
+    float icons_size = m_layout.scaled_icons_size();
+    float zoomed_icons_size = icons_size * inv_zoom;
+    float zoomed_stride_y = m_layout.scaled_stride_y() * inv_zoom;
 
-    float scaled_icons_size = m_overlay_icons_size * m_overlay_scale * inv_zoom;
-    float scaled_stride_y = scaled_icons_size + scaled_gap_y;
     unsigned int icons_texture_id = m_icons_texture.get_id();
     int tex_width = m_icons_texture.get_width();
     int tex_height = m_icons_texture.get_height();
@@ -891,53 +887,36 @@ void GLGizmosManager::do_render_overlay() const
         int icon_idx = m_current == idx ? 2 : (m_hover == idx ? 1 : 0);
 #endif // ENABLE_GIZMO_ICONS_NON_ACTIVABLE_STATE
 
-        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 u_icon_size = icons_size * inv_tex_width;
+        float v_icon_size = icons_size * inv_tex_height;
+
         float v_top = sprite_id * v_icon_size;
         float u_left = icon_idx * u_icon_size;
         float v_bottom = v_top + v_icon_size;
         float u_right = u_left + u_icon_size;
 
-        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 } });
+        GLTexture::render_sub_texture(icons_texture_id, zoomed_top_x, zoomed_top_x + zoomed_icons_size, zoomed_top_y - zoomed_icons_size, zoomed_top_y, { { u_left, v_bottom }, { u_right, v_bottom }, { u_right, v_top }, { u_left, v_top } });
         if (idx == m_current) {
             float toolbar_top = cnv_h - m_parent.get_view_toolbar_height();
-            gizmo->render_input_window(width, 0.5f * cnv_h - top_y * zoom, toolbar_top);
+            gizmo->render_input_window(width, 0.5f * cnv_h - zoomed_top_y * zoom, toolbar_top);
         }
-        top_y -= scaled_stride_y;
+        zoomed_top_y -= zoomed_stride_y;
     }
 }
 
-float GLGizmosManager::get_total_overlay_height() const
+float GLGizmosManager::get_scaled_total_height() const
 {
-    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;
-
-    /*for (size_t idx=0; idx<m_gizmos.size(); ++idx)
-    {
-        if ((m_gizmos[idx] == nullptr) || !m_gizmos[idx]->is_selectable())
-            continue;
-
-        height += scaled_stride_y;
-    }*/
-    height += get_selectable_idxs().size() * scaled_stride_y;
-
-    return height - scaled_gap_y;
+    return m_layout.scale * (2.0f * m_layout.border + (float)get_selectable_idxs().size() * m_layout.stride_y() - m_layout.gap_y);
 }
 
-float GLGizmosManager::get_total_overlay_width() const
+float GLGizmosManager::get_scaled_total_width() const
 {
-    return (2.0f * m_overlay_border + m_overlay_icons_size) * m_overlay_scale;
+    return 2.0f * m_layout.scaled_border() + m_layout.scaled_icons_size();
 }
 
 GLGizmoBase* GLGizmosManager::get_current() const
 {
-    if (m_current==Undefined || m_gizmos.empty())
-        return nullptr;
-    else
-        return m_gizmos[m_current].get();
+    return ((m_current == Undefined) || m_gizmos.empty()) ? nullptr : m_gizmos[m_current].get();
 }
 
 bool GLGizmosManager::generate_icons_texture() const
@@ -962,7 +941,7 @@ bool GLGizmosManager::generate_icons_texture() const
     states.push_back(std::make_pair(2, false)); // Disabled
 #endif // ENABLE_GIZMO_ICONS_NON_ACTIVABLE_STATE
 
-    unsigned int sprite_size_px = (unsigned int)(m_overlay_icons_size * m_overlay_scale);
+    unsigned int sprite_size_px = (unsigned int)m_layout.scaled_icons_size();
 //    // force even size
 //    if (sprite_size_px % 2 != 0)
 //        sprite_size_px += 1;
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
index 0defb1348..6120e961a 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
@@ -64,12 +64,28 @@ public:
     };
 
 private:
+    struct Layout
+    {
+        float scale{ 1.0f };
+        float icons_size{ Default_Icons_Size };
+        float border{ 5.0f };
+        float gap_y{ 5.0f };
+
+        float stride_y() const { return icons_size + gap_y;}
+
+        float scaled_icons_size() const { return scale * icons_size; }
+        float scaled_border() const { return scale * border; }
+        float scaled_gap_y() const { return scale * gap_y; }
+        float scaled_stride_y() const { return scale * stride_y(); }
+    };
+
     GLCanvas3D& m_parent;
     bool m_enabled;
     std::vector<std::unique_ptr<GLGizmoBase>> m_gizmos;
     mutable GLTexture m_icons_texture;
     mutable bool m_icons_texture_dirty;
     BackgroundTexture m_background_texture;
+    Layout m_layout;
     EType m_current;
     EType m_hover;
 
@@ -79,11 +95,6 @@ private:
 
     void activate_gizmo(EType type);
 
-    float m_overlay_icons_size;
-    float m_overlay_scale;
-    float m_overlay_border;
-    float m_overlay_gap_y;
-
     struct MouseCapture
     {
         bool left;
@@ -202,8 +213,8 @@ private:
     void render_background(float left, float top, float right, float bottom, float border) const;
     void do_render_overlay() const;
 
-    float get_total_overlay_height() const;
-    float get_total_overlay_width() const;
+    float get_scaled_total_height() const;
+    float get_scaled_total_width() const;
 
     GLGizmoBase* get_current() const;