diff --git a/src/slic3r/GUI/GLSelectionRectangle.cpp b/src/slic3r/GUI/GLSelectionRectangle.cpp
index 39b92ff8f..03ee7e1f6 100644
--- a/src/slic3r/GUI/GLSelectionRectangle.cpp
+++ b/src/slic3r/GUI/GLSelectionRectangle.cpp
@@ -1,116 +1,119 @@
 #include "GLSelectionRectangle.hpp"
 #include "Camera.hpp"
 #include "3DScene.hpp"
+#include "GLCanvas3D.hpp"
 
 #include <GL/glew.h>
 
 namespace Slic3r {
 namespace GUI {
 
-void GLSelectionRectangle::start_dragging(const Vec2d& mouse_position, float width, float height, EState status)
-{
-    if (is_dragging() || status == Off)
-        return;
+    void GLSelectionRectangle::start_dragging(const Vec2d& mouse_position, EState state)
+    {
+        if (is_dragging() || (state == Off))
+            return;
 
-    m_width = width;
-    m_height = height;
-    m_status = status;
-    m_start_corner = mouse_position;
-    m_end_corner = mouse_position;
-}
-
-
-
-void GLSelectionRectangle::dragging(const Vec2d& mouse_position)
-{
-    if (is_dragging())
+        m_state = state;
+        m_start_corner = mouse_position;
         m_end_corner = mouse_position;
-}
-
-
-
-std::vector<unsigned int> GLSelectionRectangle::end_dragging(const Camera& camera, const std::vector<Vec3d>& points)
-{
-    if (!is_dragging())
-        return std::vector<unsigned int>();
-
-    m_status = Off;
-    std::vector<unsigned int> out;
-
-    const std::array<int, 4>& viewport = camera.get_viewport();
-    const Transform3d& modelview_matrix = camera.get_view_matrix();
-    const Transform3d& projection_matrix = camera.get_projection_matrix();
-
-    // bounding box created from the rectangle corners - will take care of order of the corners
-    BoundingBox rectangle(Points{Point(m_start_corner.cast<int>()), Point(m_end_corner.cast<int>())});
-
-    // Iterate over all points and determine whether they're in the rectangle.
-    for (unsigned int i=0; i<points.size(); ++i) {
-        const Vec3d& point = points[i];
-        GLdouble out_x, out_y, out_z;
-        ::gluProject((GLdouble)point(0), (GLdouble)point(1), (GLdouble)point(2), (GLdouble*)modelview_matrix.data(), (GLdouble*)projection_matrix.data(), (GLint*)viewport.data(), &out_x, &out_y, &out_z);
-        out_y = m_height - out_y;
-
-        if (rectangle.contains(Point(out_x, out_y)))
-            out.push_back(i);
     }
 
-    return out;
-}
+    void GLSelectionRectangle::dragging(const Vec2d& mouse_position)
+    {
+        if (!is_dragging())
+            return;
 
-
-
-void GLSelectionRectangle::render() const
-{
-    float render_color[3];
-
-    switch (m_status) {
-        case Off : return;
-        case SlaSelect : render_color[0] = 0.f;
-                         render_color[1] = 1.f;
-                         render_color[2] = 0.f;
-                         break;
-        case SlaDeselect : render_color[0] = 1.f;
-                           render_color[1] = 0.3f;
-                           render_color[2] = 0.3f;
-                           break;
+        m_end_corner = mouse_position;
     }
 
-    glsafe(::glColor3fv(render_color));
-    glsafe(::glLineWidth(1.5f));
+    std::vector<unsigned int> GLSelectionRectangle::stop_dragging(const GLCanvas3D& canvas, const std::vector<Vec3d>& points)
+    {
+        std::vector<unsigned int> out;
 
-    glsafe(::glPushAttrib(GL_TRANSFORM_BIT));   // remember current MatrixMode
+        if (!is_dragging())
+            return out;
 
-    glsafe(::glMatrixMode(GL_MODELVIEW));       // cache modelview matrix and set to identity
-    glsafe(::glPushMatrix());
-    glsafe(::glLoadIdentity());
+        m_state = Off;
 
-    glsafe(::glMatrixMode(GL_PROJECTION));      // cache projection matrix and set to identity
-    glsafe(::glPushMatrix());
-    glsafe(::glLoadIdentity());
+        const Camera& camera = canvas.get_camera();
+        const std::array<int, 4>& viewport = camera.get_viewport();
+        const Transform3d& modelview_matrix = camera.get_view_matrix();
+        const Transform3d& projection_matrix = camera.get_projection_matrix();
 
-    glsafe(::glOrtho(0.f, m_width, m_height, 0.f, -1.f, 1.f)); // set projection matrix so that world coords = window coords
+        // bounding box created from the rectangle corners - will take care of order of the corners
+        BoundingBox rectangle(Points{ Point(m_start_corner.cast<int>()), Point(m_end_corner.cast<int>()) });
 
-    // render the selection  rectangle (window coordinates):
-    glsafe(::glPushAttrib(GL_ENABLE_BIT));
-    glsafe(::glLineStipple(4, 0xAAAA));
-    glsafe(::glEnable(GL_LINE_STIPPLE));
+        // Iterate over all points and determine whether they're in the rectangle.
+        for (unsigned int i = 0; i<points.size(); ++i) {
+            const Vec3d& point = points[i];
+            GLdouble out_x, out_y, out_z;
+            ::gluProject((GLdouble)point(0), (GLdouble)point(1), (GLdouble)point(2), (GLdouble*)modelview_matrix.data(), (GLdouble*)projection_matrix.data(), (GLint*)viewport.data(), &out_x, &out_y, &out_z);
+            out_y = canvas.get_canvas_size().get_height() - out_y;
 
-    ::glBegin(GL_LINE_LOOP);
-    ::glVertex3f((GLfloat)m_start_corner(0), (GLfloat)m_start_corner(1), (GLfloat)0.5f);
-    ::glVertex3f((GLfloat)m_end_corner(0), (GLfloat)m_start_corner(1), (GLfloat)0.5f);
-    ::glVertex3f((GLfloat)m_end_corner(0), (GLfloat)m_end_corner(1), (GLfloat)0.5f);
-    ::glVertex3f((GLfloat)m_start_corner(0), (GLfloat)m_end_corner(1), (GLfloat)0.5f);
-    glsafe(::glEnd());
-    glsafe(::glPopAttrib());
+            if (rectangle.contains(Point(out_x, out_y)))
+                out.push_back(i);
+        }
 
-    glsafe(::glPopMatrix());                // restore former projection matrix
-    glsafe(::glMatrixMode(GL_MODELVIEW));
-    glsafe(::glPopMatrix());                // restore former modelview matrix
-    glsafe(::glPopAttrib());                // restore former MatrixMode
-    
-}
+        return out;
+    }
 
+    void GLSelectionRectangle::stop_dragging()
+    {
+        if (!is_dragging())
+            return;
+
+        m_state = Off;
+    }
+
+    void GLSelectionRectangle::render(const GLCanvas3D& canvas) const
+    {
+        if (!is_dragging())
+            return;
+
+        float zoom = canvas.get_camera().zoom;
+        float inv_zoom = (zoom != 0.0f) ? 1.0f / zoom : 0.0f;
+
+        Size cnv_size = canvas.get_canvas_size();
+        float cnv_half_width = 0.5f * (float)cnv_size.get_width();
+        float cnv_half_height = 0.5f * (float)cnv_size.get_height();
+        if ((cnv_half_width == 0.0f) || (cnv_half_height == 0.0f))
+            return;
+
+        Vec2d start(m_start_corner(0) - cnv_half_width, cnv_half_height - m_start_corner(1));
+        Vec2d end(m_end_corner(0) - cnv_half_width, cnv_half_height - m_end_corner(1));
+
+        float left = (float)std::min(start(0), end(0)) * inv_zoom;
+        float top = (float)std::max(start(1), end(1)) * inv_zoom;
+        float right = (float)std::max(start(0), end(0)) * inv_zoom;
+        float bottom = (float)std::min(start(1), end(1)) * inv_zoom;
+
+        glsafe(::glLineWidth(1.5f));
+        float color[3];
+        color[0] = (m_state == Select) ? 0.3f : 1.0f;
+        color[1] = (m_state == Select) ? 1.0f : 0.3f;
+        color[2] = 0.3f;
+        glsafe(::glColor3fv(color));
+
+        glsafe(::glDisable(GL_DEPTH_TEST));
+
+        glsafe(::glPushMatrix());
+        glsafe(::glLoadIdentity());
+
+        glsafe(::glPushAttrib(GL_ENABLE_BIT));
+        glsafe(::glLineStipple(4, 0xAAAA));
+        glsafe(::glEnable(GL_LINE_STIPPLE));
+
+        ::glBegin(GL_LINE_LOOP);
+        ::glVertex2f((GLfloat)left, (GLfloat)bottom);
+        ::glVertex2f((GLfloat)right, (GLfloat)bottom);
+        ::glVertex2f((GLfloat)right, (GLfloat)top);
+        ::glVertex2f((GLfloat)left, (GLfloat)top);
+        glsafe(::glEnd());
+
+        glsafe(::glPopAttrib());
+
+        glsafe(::glPopMatrix());
+    }
 
 } // namespace GUI
 } // namespace Slic3r
diff --git a/src/slic3r/GUI/GLSelectionRectangle.hpp b/src/slic3r/GUI/GLSelectionRectangle.hpp
index f7d5bbdc7..f26d3eb4b 100644
--- a/src/slic3r/GUI/GLSelectionRectangle.hpp
+++ b/src/slic3r/GUI/GLSelectionRectangle.hpp
@@ -7,38 +7,38 @@ namespace Slic3r {
 namespace GUI {
     
 struct Camera;
+class GLCanvas3D;
 
 class GLSelectionRectangle {
 public:
     enum EState {
             Off,
-            SlaSelect,
-            SlaDeselect
-        };
+            Select,
+            Deselect
+    };
 
-    // Initiates the rectangle. Width and height describe canvas size.
-    void start_dragging(const Vec2d& mouse_position, float width, float height, EState status);
+    // Initiates the rectangle. 
+    void start_dragging(const Vec2d& mouse_position, EState state);
 
     // To be called on mouse move.
     void dragging(const Vec2d& mouse_position);
 
     // Given a vector of points in world coordinates, the function returns indices of those
     // that are in the rectangle. It then disables the rectangle.
-    std::vector<unsigned int> end_dragging(const Camera& camera, const std::vector<Vec3d>& points);
+    std::vector<unsigned int> stop_dragging(const GLCanvas3D& canvas, const std::vector<Vec3d>& points);
 
-    void render() const;
+    // Disables the rectangle.
+    void stop_dragging();
 
-    bool is_dragging() const { return m_status != Off; }
-    EState get_status() const { return m_status; }
+    void render(const GLCanvas3D& canvas) const;
+
+    bool is_dragging() const { return m_state != Off; }
+    EState get_state() const { return m_state; }
     
-    
-
 private:
-    EState m_status = Off;
+    EState m_state = Off;
     Vec2d m_start_corner;
     Vec2d m_end_corner;
-    float m_width;
-    float m_height;
 };
 
     
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
index ebb7df138..5be5e9a89 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoSlaSupports.cpp
@@ -100,7 +100,7 @@ void GLGizmoSlaSupports::on_render(const Selection& selection) const
     if (m_quadric != nullptr && selection.is_from_single_instance())
         render_points(selection, false);
 
-    m_selection_rectangle.render();
+    m_selection_rectangle.render(m_parent);
     render_clipping_plane(selection);
 
     glsafe(::glDisable(GL_BLEND));
@@ -467,9 +467,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         if (action == SLAGizmoEventType::LeftDown && (shift_down || alt_down || control_down)) {
             if (m_hover_id == -1) {
                 if (shift_down || alt_down) {
-                    Size size = m_parent.get_canvas_size();
-                    m_selection_rectangle.start_dragging(mouse_position, size.get_width(), size.get_height(),
-                        shift_down ? GLSelectionRectangle::SlaSelect : GLSelectionRectangle::SlaDeselect);
+                    m_selection_rectangle.start_dragging(mouse_position, shift_down ? GLSelectionRectangle::Select : GLSelectionRectangle::Deselect);
                 }
             }
             else {
@@ -512,7 +510,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
         // left up with selection rectangle - select points inside the rectangle:
         if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp || action == SLAGizmoEventType::AltUp) && m_selection_rectangle.is_dragging()) {
             // Is this a selection or deselection rectangle?
-            GLSelectionRectangle::EState rectangle_status = m_selection_rectangle.get_status();
+            GLSelectionRectangle::EState rectangle_status = m_selection_rectangle.get_state();
 
             // First collect positions of all the points in world coordinates.
             const Transform3d& instance_matrix = m_model_object->instances[m_active_instance]->get_transformation().get_matrix();
@@ -524,7 +522,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
             }
             // Now ask the rectangle which of the points are inside.
             const Camera& camera = m_parent.get_camera();
-            std::vector<unsigned int> selected_idxs = m_selection_rectangle.end_dragging(camera, points);
+            std::vector<unsigned int> selected_idxs = m_selection_rectangle.stop_dragging(m_parent, points);
 
             // we'll recover current look direction (in world coords) and transform it to model coords.
             const Selection& selection = m_parent.get_selection();
@@ -577,7 +575,7 @@ bool GLGizmoSlaSupports::gizmo_event(SLAGizmoEventType action, const Vec2d& mous
                     }
 
                     if (!is_obscured) {
-                        if (rectangle_status == GLSelectionRectangle::SlaDeselect)
+                        if (rectangle_status == GLSelectionRectangle::Deselect)
                             unselect_point(i);
                         else
                             select_point(i);