fix: clang-tidy

(cherry picked from commit c6d3e755ec)

src/libslic3r/Fill/FillSpiralInset.cpp

@@ -352,16 +352,6 @@ void FillSpiralInset::_fill_surface_single(const FillParams& params,
     assert(params.use_arachne);
     assert(this->print_config != nullptr && this->print_object_config != nullptr);
 
-    // Internal solid infill must not add Arachne's standalone thin walls: one of those walls can
-    // become the extra centre point after the spiral has finished. Top and bottom surfaces keep
-    // Arachne, including the centre plug handled by generate_spiral_insets().
-    if (params.extrusion_role == erSolidInfill) {
-        Polylines polylines;
-        this->_fill_surface_single(params, thickness_layers, direction, expolygon, polylines);
-        append(thick_polylines_out, to_thick_polylines(std::move(polylines), scaled<coord_t>(this->spacing)));
-        return;
-    }
-
     // Only a solid surface is worth the variable width walls; a sparse one falls back to plain loops.
     if (params.density <= 0.9999f || params.dont_adjust) {
         Polylines polylines;

src/libslic3r/Geometry/Voronoi.cpp

@@ -16,7 +16,6 @@
 
 namespace Slic3r::Geometry {
 
-using VD                          = VoronoiDiagram;
 using PolygonsSegmentIndexConstIt = std::vector<Arachne::PolygonsSegmentIndex>::const_iterator;
 using LinesIt                     = Lines::iterator;
 using ColoredLinesConstIt         = ColoredLines::const_iterator;

src/libslic3r/Geometry/VoronoiUtils.cpp

@@ -20,7 +20,6 @@
 
 namespace Slic3r::Geometry {
 
-using VD                          = VoronoiDiagram;
 using PolygonsSegmentIndexConstIt = std::vector<Arachne::PolygonsSegmentIndex>::const_iterator;
 using LinesIt                     = Lines::iterator;
 using ColoredLinesIt              = ColoredLines::iterator;

src/libslic3r/Geometry/VoronoiUtils.hpp

@@ -10,6 +10,8 @@
 #include "libslic3r/Point.hpp"
 #include "libslic3r/libslic3r.h"
 
+using VD = Slic3r::Geometry::VoronoiDiagram;
+
 namespace Slic3r::Geometry {
 
 // Represent trapezoid Voronoi cell around segment.
@@ -17,8 +19,8 @@ template<typename PT> struct SegmentCellRange
 {
     const PT             source_segment_start_point; // The start point of the source segment of this cell.
     const PT             source_segment_end_point;   // The end point of the source segment of this cell.
-    const VoronoiDiagram::edge_type *edge_begin = nullptr;       // The edge of the Voronoi diagram where the loop around the cell starts.
+    const VD::edge_type *edge_begin = nullptr;       // The edge of the Voronoi diagram where the loop around the cell starts.
-    const VoronoiDiagram::edge_type *edge_end   = nullptr;       // The edge of the Voronoi diagram where the loop around the cell ends.
+    const VD::edge_type *edge_end   = nullptr;       // The edge of the Voronoi diagram where the loop around the cell ends.
 
     SegmentCellRange() = delete;
     explicit SegmentCellRange(const PT &source_segment_start_point, const PT &source_segment_end_point)
@@ -32,8 +34,8 @@ template<typename PT> struct SegmentCellRange
 template<typename PT> struct PointCellRange
 {
     const PT             source_point;  // The source point of this cell.
-    const VoronoiDiagram::edge_type *edge_begin = nullptr; // The edge of the Voronoi diagram where the loop around the cell starts.
+    const VD::edge_type *edge_begin = nullptr; // The edge of the Voronoi diagram where the loop around the cell starts.
-    const VoronoiDiagram::edge_type *edge_end   = nullptr; // The edge of the Voronoi diagram where the loop around the cell ends.
+    const VD::edge_type *edge_end   = nullptr; // The edge of the Voronoi diagram where the loop around the cell ends.
 
     PointCellRange() = delete;
     explicit PointCellRange(const PT &source_point) : source_point(source_point) {}
@@ -44,20 +46,20 @@ template<typename PT> struct PointCellRange
 class VoronoiUtils
 {
 public:
-    static Vec2i64 to_point(const VoronoiDiagram::vertex_type *vertex);
+    static Vec2i64 to_point(const VD::vertex_type *vertex);
 
-    static Vec2i64 to_point(const VoronoiDiagram::vertex_type &vertex);
+    static Vec2i64 to_point(const VD::vertex_type &vertex);
 
-    static bool is_finite(const VoronoiDiagram::vertex_type &vertex);
+    static bool is_finite(const VD::vertex_type &vertex);
 
-    static VoronoiDiagram::vertex_type make_rotated_vertex(VoronoiDiagram::vertex_type &vertex, double angle);
+    static VD::vertex_type make_rotated_vertex(VD::vertex_type &vertex, double angle);
 
     template<typename SegmentIterator>
     static typename boost::polygon::enable_if<
         typename boost::polygon::gtl_if<typename boost::polygon::is_segment_concept<
             typename boost::polygon::geometry_concept<typename std::iterator_traits<SegmentIterator>::value_type>::type>::type>::type,
         typename std::iterator_traits<SegmentIterator>::reference>::type
-    get_source_segment(const VoronoiDiagram::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
+    get_source_segment(const VD::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
 
     template<typename SegmentIterator>
     static typename boost::polygon::enable_if<
@@ -71,7 +73,7 @@ public:
         typename boost::polygon::gtl_if<typename boost::polygon::is_segment_concept<
             typename boost::polygon::geometry_concept<typename std::iterator_traits<SegmentIterator>::value_type>::type>::type>::type,
         Arachne::PolygonsPointIndex>::type
-    get_source_point_index(const VoronoiDiagram::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
+    get_source_point_index(const VD::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
 
     /**
      * Discretize a parabola based on (approximate) step size.
@@ -111,7 +113,7 @@ public:
             typename boost::polygon::geometry_concept<typename std::iterator_traits<SegmentIterator>::value_type>::type>::type>::type,
         Geometry::SegmentCellRange<
             typename boost::polygon::segment_point_type<typename std::iterator_traits<SegmentIterator>::value_type>::type>>::type
-    compute_segment_cell_range(const VoronoiDiagram::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
+    compute_segment_cell_range(const VD::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
 
     /**
      * Compute the range of line segments that surround a cell of the skeletal
@@ -138,19 +140,19 @@ public:
             typename boost::polygon::geometry_concept<typename std::iterator_traits<SegmentIterator>::value_type>::type>::type>::type,
         Geometry::PointCellRange<
             typename boost::polygon::segment_point_type<typename std::iterator_traits<SegmentIterator>::value_type>::type>>::type
-    compute_point_cell_range(const VoronoiDiagram::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
+    compute_point_cell_range(const VD::cell_type &cell, SegmentIterator segment_begin, SegmentIterator segment_end);
 
     template<typename T> static bool is_in_range(double value)
     {
         return double(std::numeric_limits<T>::lowest()) <= value && value <= double(std::numeric_limits<T>::max());
     }
 
-    template<typename T> static bool is_in_range(const VoronoiDiagram::vertex_type &vertex)
+    template<typename T> static bool is_in_range(const VD::vertex_type &vertex)
     {
         return VoronoiUtils::is_finite(vertex) && is_in_range<T>(vertex.x()) && is_in_range<T>(vertex.y());
     }
 
-    template<typename T> static bool is_in_range(const VoronoiDiagram::edge_type &edge)
+    template<typename T> static bool is_in_range(const VD::edge_type &edge)
     {
         if (edge.vertex0() == nullptr || edge.vertex1() == nullptr)
             return false;

src/libslic3r/MultiMaterialSegmentation.cpp

@@ -63,7 +63,6 @@ namespace Slic3r { enum class EnforcerBlockerType : int8_t; }
 
 namespace Slic3r {
 using boost::polygon::voronoi_diagram;
-using VD = Geometry::VoronoiDiagram;
 
 static inline Point mk_point(const Voronoi::VD::vertex_type *point) { return {coord_t(point->x()), coord_t(point->y())}; }
 

src/libslic3r/PerimeterGenerator.cpp

@@ -759,59 +759,6 @@ static void clip_inner_walls_over_top(std::vector<Arachne::VariableWidthLines> &
     }
 }
 
-// ORCA: only_one_wall_top - widest bead of the given walls.
-static coord_t widest_bead(const std::vector<Arachne::VariableWidthLines> &walls)
-{
-    coord_t widest = 0;
-    for (const Arachne::VariableWidthLines &group : walls)
-        for (const Arachne::ExtrusionLine &el : group)
-            for (const Arachne::ExtrusionJunction &j : el.junctions)
-                widest = std::max(widest, j.w);
-    return widest;
-}
-
-// ORCA: only_one_wall_top - length of the walls running further than tolerance from the reference walls, outside the
-// excluded area.
-static double length_off_reference(const std::vector<Arachne::VariableWidthLines> &walls, const Arachne::VariableWidthLines &reference,
-                                   const ExPolygons &excluded, coord_t tolerance)
-{
-    auto append_centerlines = [](const Arachne::VariableWidthLines &lines, Polylines &out) {
-        for (const Arachne::ExtrusionLine &el : lines) {
-            if (el.junctions.size() < 2)
-                continue;
-            Polyline &centerline = out.emplace_back();
-            centerline.points.reserve(el.junctions.size());
-            for (const Arachne::ExtrusionJunction &j : el.junctions)
-                centerline.points.emplace_back(j.p);
-        }
-    };
-    Polylines wall_centerlines;
-    Polylines reference_centerlines;
-    for (const Arachne::VariableWidthLines &group : walls)
-        append_centerlines(group, wall_centerlines);
-    append_centerlines(reference, reference_centerlines);
-
-    Polylines off_reference = diff_pl(wall_centerlines, offset(reference_centerlines, float(tolerance)));
-    if (! excluded.empty())
-        off_reference = diff_pl(off_reference, excluded);
-    return total_length(off_reference);
-}
-
-// ORCA: only_one_wall_top - area covered by the given walls at their local widths.
-static Polygons walls_footprint(const Arachne::VariableWidthLines &walls)
-{
-    Polygons footprint;
-    for (const Arachne::ExtrusionLine &el : walls)
-        for (size_t i = 1; i < el.junctions.size(); ++ i) {
-            const Arachne::ExtrusionJunction &a     = el.junctions[i - 1];
-            const Arachne::ExtrusionJunction &b     = el.junctions[i];
-            const coord_t                     width = std::max(a.w, b.w);
-            if (width > 0)
-                append(footprint, offset(Polyline(a.p, b.p), float(width) / 2.f));
-        }
-    return union_(footprint);
-}
-
 void PerimeterGenerator::split_top_surfaces(const ExPolygons &orig_polygons, ExPolygons &top_fills,
                                             ExPolygons &non_top_polygons, ExPolygons &fill_clip) const {
     // other perimeters
@@ -2599,90 +2546,44 @@ void PerimeterGenerator::process_arachne()
         if (inner_loop_number >= 0) {
             assert(upper_slices != nullptr);
 
+            // Infill contour bounding box.
+            BoundingBox infill_contour_bbox = get_extents(infill_contour);
+            infill_contour_bbox.offset(SCALED_EPSILON);
+            
             coord_t perimeter_width = this->perimeter_flow.scaled_width();
 
-            // Filter out areas that are too thin and expand top surface polygons a bit to hide the wall line.
+            // Get top ExPolygons from current infill contour.
-            // ORCA: skip if the top surface area is smaller than "min_width_top_surface"
+            Polygons upper_slices_clipped;
-            const float top_surface_min_width = std::max<float>(float(ext_perimeter_spacing) / 4.f + scaled<float>(0.00001), float(scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width)))) / 4.f);
+            if (object_config->interface_shells) {
+                auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
+                upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, infill_contour_bbox);
+            } else
+                upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, infill_contour_bbox);
 
-            // Get top ExPolygons from the given contour. uncovered reports whether the upper layer leaves any of the
+            top_expolygons = diff_ex(infill_contour, upper_slices_clipped);
-            // contour uncovered, before bridges and too thin areas are filtered out.
-            auto get_top_expolygons = [&](const ExPolygons &contour, bool &uncovered) {
-                // Contour bounding box.
-                BoundingBox contour_bbox = get_extents(contour);
-                contour_bbox.offset(SCALED_EPSILON);
-
-                Polygons upper_slices_clipped;
-                if (object_config->interface_shells) {
-                    auto upper_slicer_same_region = to_expolygons(this->upper_slices_same_region->surfaces);
-                    upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(upper_slicer_same_region, contour_bbox);
-                } else
-                    upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, contour_bbox);
-
-                ExPolygons top = diff_ex(contour, upper_slices_clipped);
-                uncovered      = !top.empty();
-                if (top.empty())
-                    return top;
 
+            if (!top_expolygons.empty()) {
                 if (lower_slices != nullptr) {
                     const float      bridge_offset          = float(std::max<coord_t>(ext_perimeter_spacing, perimeter_width));
-                    const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, contour_bbox);
+                    const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, infill_contour_bbox);
-                    const ExPolygons current_slices_bridges = offset_ex(diff_ex(top, lower_slices_clipped), bridge_offset);
+                    const ExPolygons current_slices_bridges = offset_ex(diff_ex(top_expolygons, lower_slices_clipped), bridge_offset);
 
                     // Remove bridges from top surface polygons.
-                    top = diff_ex(top, current_slices_bridges);
+                    top_expolygons = diff_ex(top_expolygons, current_slices_bridges);
                 }
 
+                // Filter out areas that are too thin and expand top surface polygons a bit to hide the wall line.
+                // ORCA: skip if the top surface area is smaller than "min_width_top_surface"
+                const float top_surface_min_width = std::max<float>(float(ext_perimeter_spacing) / 4.f + scaled<float>(0.00001), float(scale_(config->min_width_top_surface.get_abs_value(unscale_(perimeter_width)))) / 4.f);
                 // Shrink the polygon to remove the small areas, then expand it back out plus a maragin to hide the wall line a little.
                 // ORCA: Expand the polygon with half the perimeter width in addition to the contracted amount,
                 // not the full perimeter width as PS does, to enable thin lettering to print on the top surface without nozzle collisions
                 // due to thin lines being generated
-                top = offset2_ex(top, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
+                top_expolygons = offset2_ex(top_expolygons, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
 
                 // Get final top ExPolygons (bridges were excluded above, so they stay walled).
-                return intersection_ex(top, contour);
+                top_expolygons = intersection_ex(top_expolygons, infill_contour);
-            };
 
-            // Walls with the full count, as generated when the single perimeter feature is disabled. Generated on first use.
-            std::vector<Arachne::VariableWidthLines> full_perimeters;
-            Polygons                                 full_inner_contour;
-            bool                                     full_perimeters_generated = false;
-            auto generate_full_perimeters = [&]() {
-                if (full_perimeters_generated)
-                    return;
-                Arachne::WallToolPaths full_tool_paths(last_p, bead_width_0, perimeter_spacing, coord_t(inner_loop_number + 2), wall_0_inset, layer_height, input_params_tmp);
-                full_perimeters           = full_tool_paths.getToolPaths();
-                full_inner_contour        = full_tool_paths.getInnerContour();
-                full_perimeters_generated = true;
-            };
-
-            // ORCA: the single wall pass allows Arachne 2 beads across a wall, so it fills a wall narrower than 3 outer wall
-            // widths by widening both, where the full pass adds a middle bead. Over the top surface that is the intent;
-            // anywhere else it leaves no room for the inner walls. When the single wall pass's outer walls run away from
-            // the full pass's outside the top surface, take the full pass's outer walls and the area inside them instead.
-            // Walls closer than outer_wall_tolerance count as the same wall: a widened bead's centerline moves by half
-            // the width added, and only beads widened by more than twice the tolerance are looked for.
-            const coord_t outer_wall_tolerance = bead_width_0 / 10;
-            if (widest_bead(perimeters) > bead_width_0 + 2 * outer_wall_tolerance) {
-                // The single wall pass's inner contour where it widens no bead: inside nominal width outer walls.
-                const ExPolygons nominal_infill_contour = offset_ex(last, -float(bead_width_0 + wall_0_inset));
-                bool             nominal_uncovered      = false;
-                // Grown by an outer wall width to take in the outer walls bordering the top surface.
-                const ExPolygons top_zone = offset_ex(get_top_expolygons(nominal_infill_contour, nominal_uncovered), float(bead_width_0));
-                if (nominal_uncovered) {
-                    generate_full_perimeters();
-                    if (! full_perimeters.empty() && ! full_perimeters.front().empty() &&
-                        length_off_reference(perimeters, full_perimeters.front(), top_zone, outer_wall_tolerance) > double(perimeter_width)) {
-                        perimeters     = { full_perimeters.front() };
-                        infill_contour = diff_ex(nominal_infill_contour, walls_footprint(full_perimeters.front()), ApplySafetyOffset::Yes);
-                    }
-                }
-            }
-
-            bool uncovered = false;
-            top_expolygons = get_top_expolygons(infill_contour, uncovered);
-
-            if (uncovered) {
                 // ORCA: onion the real region (inside the outer wall) so the remaining walls follow the actual
                 // geometry, then cut away the parts over the top surface. Re-onioning the non-top complement
                 // instead - the fallback when there is no top fill - walls the top/non-top interface and rings
@@ -2711,11 +2612,11 @@ void PerimeterGenerator::process_arachne()
                 perimeters.insert(perimeters.end(), inner_perimeters.begin(), inner_perimeters.end());
                 infill_contour = union_ex(top_expolygons, inner_wall_tool_paths.getInnerContour());
             } else {
-                // There is no top surface ExPolygon, so use the walls generated like when the single perimeter
+                // There is no top surface ExPolygon, so we call Arachne again with parameters
-                // feature is disabled.
+                // like when the single perimeter feature is disabled.
-                generate_full_perimeters();
+                Arachne::WallToolPaths no_single_perimeter_tool_paths(last_p, bead_width_0, perimeter_spacing, coord_t(inner_loop_number + 2), wall_0_inset, layer_height, input_params_tmp);
-                perimeters     = std::move(full_perimeters);
+                perimeters     = no_single_perimeter_tool_paths.getToolPaths();
-                infill_contour = union_ex(full_inner_contour);
+                infill_contour = union_ex(no_single_perimeter_tool_paths.getInnerContour());
             }
         }
         //PS

src/libslic3r/PresetBundle.cpp

@@ -80,8 +80,6 @@
 #include <vector>
 #include <utility>
 
-namespace fs = boost::filesystem;
-
 // Mark string for localization and translate.
 #define L(s) Slic3r::I18N::translate(s)
 

src/libslic3r/ProjectTask.hpp

@@ -11,6 +11,8 @@
 #include <boost/filesystem/path.hpp>
 #include <boost/filesystem.hpp>
 
+namespace fs = boost::filesystem;
+
 namespace Slic3r {
 
 class BBLProject;
@@ -206,7 +208,7 @@ public:
     std::string     task_profile_id;    /* profile id*/
     std::string     task_name;          /* task name, generally filename as task name */
     std::string     task_file;          /* local full file path of 3mf or gcode */
-    boost::filesystem::path task_path;          /* local path of 3mf or gcode */
+    fs::path        task_path;          /* local path of 3mf or gcode */
     std::string     task_gcode_in_3mf;  /* gcode in 3mf */
     std::string     task_create_time;   /* time created by cloud */
     std::string     task_thumbnail_url; /* url of task thumbnail */
@@ -324,7 +326,7 @@ public:
     std::string     project_url_md5;        /* md5 of project url file */
     std::string     project_name;
     std::string     project_3mf_file;
-    boost::filesystem::path project_path;
+    fs::path        project_path;
     std::string     project_content;
     std::string     project_country_code;
 

src/slic3r/GUI/BBLTopbar.cpp

@@ -41,7 +41,6 @@
 #define TOPBAR_TITLE_WIDTH  300
 
 using namespace Slic3r;
-using namespace Slic3r::GUI;
 
 enum CUSTOM_ID
 {

src/slic3r/GUI/BBLTopbar.hpp

@@ -18,6 +18,8 @@ class wxMouseCaptureLostEvent;
 class wxMouseEvent;
 class wxWindow;
 
+using namespace Slic3r::GUI;
+
 class CenteredTitle : public wxControl
 {
 public:

src/slic3r/GUI/BackgroundSlicingProcess.cpp

@@ -218,7 +218,7 @@ std::string BackgroundSlicingProcess::output_filepath_for_project(const boost::f
 void BackgroundSlicingProcess::process_fff()
 {
     assert(m_print == m_fff_print);
-    PresetBundle& preset_bundle   = *GUI::wxGetApp().preset_bundle;
+    PresetBundle& preset_bundle   = *wxGetApp().preset_bundle;
     m_fff_print->is_BBL_printer() = preset_bundle.is_bbl_vendor();
     // BBS: add the logic to process from an existed gcode file
     if (m_print->finished()) {
@@ -727,7 +727,7 @@ StringObjectException BackgroundSlicingProcess::validate(std::vector<StringObjec
     assert(m_print != nullptr);
     assert(m_print == m_fff_print);
 
-    m_fff_print->is_BBL_printer() = GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    m_fff_print->is_BBL_printer() = wxGetApp().preset_bundle->is_bbl_vendor();
     return m_print->validate(warnings, collison_polygons, height_polygons);
 }
 

src/slic3r/GUI/ConfigWizard_private.hpp

@@ -43,6 +43,8 @@
 #include <wx/types.h>
 
 
+namespace fs = boost::filesystem;
+
 namespace Slic3r {
 namespace GUI {
 
@@ -86,7 +88,7 @@ struct Bundle
 	// cache or its profile JSONs, whichever is usable.
 	// Returns false if not loaded. Reason for that is logged as boost::log error.
 	//BBS: set BBL as default
-	bool load(boost::filesystem::path dir, const std::string &vendor_name, bool is_in_resources, bool is_bbl_bundle = false);
+	bool load(fs::path dir, const std::string &vendor_name, bool is_in_resources, bool is_bbl_bundle = false);
 
 	const std::string& vendor_id() const { return vendor_profile->id; }
 };

src/slic3r/GUI/GCodeViewer.cpp

@@ -3622,7 +3622,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             if (extruder_id + 1 != static_cast<unsigned char>(item.extruder))
                 continue;
 
-            if (item.type != CustomGCode::ColorChange)
+            if (item.type != ColorChange)
                 continue;
 
             if (!zs_built) {
@@ -4789,10 +4789,10 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
             ImGui::SameLine();
 
             switch (custom_gcode.type) {
-            case CustomGCode::PausePrint: imgui.text(cgcode_pause_str); break;
+            case PausePrint: imgui.text(cgcode_pause_str); break;
-            case CustomGCode::Template: imgui.text(cgcode_template_str); break;
+            case Template: imgui.text(cgcode_template_str); break;
-            case CustomGCode::ToolChange: imgui.text(cgcode_toolchange_str); break;
+            case ToolChange: imgui.text(cgcode_toolchange_str); break;
-            case CustomGCode::Custom: imgui.text(cgcode_custom_str); break;
+            case Custom: imgui.text(cgcode_custom_str); break;
             default: imgui.text(cgcode_unknown_str); break;
             }
             ImGui::SameLine(max_len);

src/slic3r/GUI/GLCanvas3D.cpp

@@ -184,12 +184,12 @@ static Slic3r::ColorRGBA DEFAULT_BG_LIGHT_COLOR_DARK = { 0.329f, 0.329f, 0.353f,
 static Slic3r::ColorRGBA ERROR_BG_LIGHT_COLOR        = { 0.753f, 0.192f, 0.039f, 1.0f };
 static Slic3r::ColorRGBA ERROR_BG_LIGHT_COLOR_DARK   = { 0.753f, 0.192f, 0.039f, 1.0f };
 
-void Slic3r::GUI::GLCanvas3D::update_render_colors()
+void GLCanvas3D::update_render_colors()
 {
     DEFAULT_BG_LIGHT_COLOR = ImGuiWrapper::from_ImVec4(RenderColor::colors[RenderCol_3D_Background]);
 }
 
-void Slic3r::GUI::GLCanvas3D::load_render_colors()
+void GLCanvas3D::load_render_colors()
 {
     RenderColor::colors[RenderCol_3D_Background] = ImGuiWrapper::to_ImVec4(DEFAULT_BG_LIGHT_COLOR);
 }
@@ -7970,16 +7970,9 @@ void GLCanvas3D::_render_fps_overlay(int fps) const
     const float margin = 10.0f * get_scale();
     const ImVec2 display_size = ImGui::GetIO().DisplaySize;
     ImVec2 pos(display_size.x - margin, margin);
-    // Last frame's size; zero until the overlay has been shown once.
-    const ImGuiWindow* self = ImGui::FindWindowByName("###fps_overlay");
-    const float left = pos.x - (self != nullptr ? self->Size.x : 0.0f);
     // The Preview legend takes the top-right corner.
     if (const ImGuiWindow* legend = ImGui::FindWindowByName("Legend"); m_canvas_type == ECanvasType::CanvasPreview && legend != nullptr && legend->Active)
         pos = ImVec2(legend->Pos.x - margin, legend->Pos.y);
-    // The toolbar row can reach the corner on a narrow canvas; stack the overlay below it then.
-    else if (m_main_toolbar.is_enabled() &&
-             get_main_toolbar_offset() + m_main_toolbar.get_width() + m_separator_toolbar.get_width() + m_gizmos.get_scaled_total_width() + m_assemble_view_toolbar.get_width() > left)
-        pos.y = std::max(m_main_toolbar.get_height(), m_gizmos.get_scaled_total_height()) + margin;
     ImGui::SetNextWindowPos(pos, ImGuiCond_Always, ImVec2(1.0f, 0.0f));
     ImGui::SetNextWindowBgAlpha(0.35f);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * get_scale());

src/slic3r/GUI/GUI_App.cpp

@@ -309,7 +309,6 @@ typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS2)(
     #include <gtk/gtk.h>
 #endif
 
-namespace fs = boost::filesystem;
 using namespace std::literals;
 namespace pt = boost::property_tree;
 

src/slic3r/GUI/GUI_Preview.cpp

@@ -396,7 +396,7 @@ void Preview::sys_color_changed()
     // m_layers_slider->sys_color_changed();
 }
 
-void Preview::on_tick_changed(CustomGCode::Type type)
+void Preview::on_tick_changed(Type type)
 {
     //if (type == Type::PausePrint) {
     //    m_schedule_background_process();

src/slic3r/GUI/IMSlider.cpp

@@ -46,8 +46,6 @@
 
 namespace Slic3r {
 
-using namespace CustomGCode;
-
 namespace GUI {
 
 // equal to 25 mm2

src/slic3r/GUI/IMSlider.hpp

@@ -20,6 +20,7 @@ struct IMGUI_API ImRect;
 
 namespace Slic3r {
 
+using namespace CustomGCode;
 class PrintObject;
 class Layer;
 
@@ -88,8 +89,8 @@ public:
     void SetSliderValues(const std::vector<double> &values);
     void SetSliderAlternateValues(const std::vector<double> &values) { m_alternate_values = values; }
 
-    CustomGCode::Info GetTicksValues() const;
+    Info GetTicksValues() const;
-    void SetTicksValues(const CustomGCode::Info &custom_gcode_per_print_z);
+    void SetTicksValues(const Info &custom_gcode_per_print_z);
     void SetLayersTimes(const std::vector<float> &layers_times, float total_time);
     void SetLayersTimes(const std::vector<double> &layers_times);
 
@@ -97,8 +98,8 @@ public:
     void SetDrawMode(DrawMode mode) { m_draw_mode = mode; }
     //BBS
     void SetExtraStyle(long style) { m_extra_style = style; }
-    void SetManipulationMode(CustomGCode::Mode mode) { m_mode = mode; }
+    void SetManipulationMode(Mode mode) { m_mode = mode; }
-    CustomGCode::Mode GetManipulationMode() const { return m_mode; }
+    Mode GetManipulationMode() const { return m_mode; }
     void SetModeAndOnlyExtruder(const bool is_one_extruder_printed_model, const int only_extruder, bool can_change_color);
     void SetExtruderColors(const std::vector<std::string> &extruder_colors);
 
@@ -116,8 +117,8 @@ public:
     void UseDefaultColors(bool def_colors_on) { m_ticks.set_default_colors(def_colors_on); }
 
     void on_mouse_wheel(wxMouseEvent& evt);
-    void post_ticks_changed_event(CustomGCode::Type type = CustomGCode::Unknown);
+    void post_ticks_changed_event(Type type = Unknown);
-    bool check_ticks_changed_event(CustomGCode::Type type);
+    bool check_ticks_changed_event(Type type);
     bool switch_one_layer_mode();
     void show_go_to_layer(bool show) { m_show_go_to_layer_dialog = show; }
 
@@ -129,9 +130,9 @@ public:
     bool is_need_post_tick_event() { return m_is_need_post_tick_changed_event; }
     void reset_post_tick_event(bool val = false) {
         m_is_need_post_tick_changed_event = val;
-        m_tick_change_event_type = CustomGCode::Type::Unknown;
+        m_tick_change_event_type = Type::Unknown;
     }
-    CustomGCode::Type get_post_tick_event_type() { return m_tick_change_event_type; }
+    Type get_post_tick_event_type() { return m_tick_change_event_type; }
 
     float m_scale = 1.0;
     void set_scale(float scale = 1.0);
@@ -142,7 +143,7 @@ public:
 
 protected:
     void add_custom_gcode(std::string custom_gcode);
-    void add_code_as_tick(CustomGCode::Type type, int selected_extruder = -1);
+    void add_code_as_tick(Type type, int selected_extruder = -1);
     void delete_tick(const TickCode& tick);
     void do_go_to_layer(size_t layer_number); //menu
     void correct_lower_value();
@@ -155,7 +156,7 @@ protected:
     void render_edit_menu(const TickCode& tick); //menu
     void draw_background_and_groove(const ImRect& bg_rect, const ImRect& groove);
     void draw_colored_band(const ImRect& groove, const ImRect& slideable_region);
-    void draw_custom_label_block(const ImVec2 anchor, CustomGCode::Type type);
+    void draw_custom_label_block(const ImVec2 anchor, Type type);
     void draw_ticks(const ImRect& slideable_region);
     void draw_tick_on_mouse_position(const ImRect& slideable_region);
     void show_tooltip(const TickCode& tick); //menu
@@ -216,7 +217,7 @@ private:
     void *m_delete_icon_id;
 
     DrawMode            m_draw_mode = dmRegular;
-    CustomGCode::Mode   m_mode          = CustomGCode::SingleExtruder;
+    Mode                m_mode          = SingleExtruder;
     int                 m_only_extruder = -1;
 
     long                m_style;
@@ -231,7 +232,7 @@ private:
     bool                     m_can_change_color;
     std::string              m_print_obj_idxs;
     bool                     m_is_need_post_tick_changed_event { false };
-    CustomGCode::Type        m_tick_change_event_type;
+    Type                     m_tick_change_event_type;
 
     std::vector<double> m_alternate_values;
 

src/slic3r/GUI/Jobs/PrintJob.hpp

@@ -12,6 +12,8 @@
 #include "Job.hpp"
 #include "slic3r/GUI/DeviceCore/DevStorage.h" 
 
+namespace fs = boost::filesystem;
+
 namespace Slic3r {
 namespace GUI {
 
@@ -24,9 +26,9 @@ class PrintPrepareData
 public:
     bool            is_from_plater = true;
     int             plate_idx;
-    boost::filesystem::path _3mf_path;
+    fs::path        _3mf_path;
-    boost::filesystem::path _3mf_config_path;
+    fs::path        _3mf_config_path;
-    boost::filesystem::path _temp_path;
+    fs::path        _temp_path;
     PrintPrepareData() {
         plate_idx = 0;
     }

src/slic3r/GUI/Plater.cpp

@@ -8111,13 +8111,13 @@ Plater::priv::priv(Plater *q, MainFrame *main_frame)
         preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_TAB, [this](SimpleEvent&) { select_next_view_3D(); });
         preview->get_wxglcanvas()->Bind(EVT_GLCANVAS_COLLAPSE_SIDEBAR, [this](SimpleEvent&) { this->q->collapse_sidebar(!this->q->is_sidebar_collapsed());  });
         preview->get_wxglcanvas()->Bind(EVT_CUSTOMEVT_TICKSCHANGED, [this](wxCommandEvent& event) {
-            CustomGCode::Type tick_event_type = (CustomGCode::Type)event.GetInt();
+            Type tick_event_type = (Type)event.GetInt();
             Model& model = wxGetApp().plater()->model();
             //BBS: replace model custom gcode with current plate custom gcode
             model.plates_custom_gcodes[model.curr_plate_index] = preview->get_canvas3d()->get_gcode_viewer().get_layers_slider()->GetTicksValues();
 
             // BBS set to invalid state only
-            if (tick_event_type == CustomGCode::Type::ToolChange || tick_event_type == CustomGCode::Type::Custom || tick_event_type == CustomGCode::Type::Template || tick_event_type == CustomGCode::Type::PausePrint) {
+            if (tick_event_type == Type::ToolChange || tick_event_type == Type::Custom || tick_event_type == Type::Template || tick_event_type == Type::PausePrint) {
                 PartPlate *plate = this->q->get_partplate_list().get_curr_plate();
                 if (plate) {
                     plate->update_slice_result_valid_state(false);
@@ -20544,7 +20544,7 @@ void Plater::on_filaments_delete(size_t num_filaments, size_t filament_id, int r
 
     // update customize gcode
     for (auto item = p->model.plates_custom_gcodes.begin(); item != p->model.plates_custom_gcodes.end(); ++item) {
-        auto iter = std::remove_if(item->second.gcodes.begin(), item->second.gcodes.end(), [filament_id](const CustomGCode::Item& gcode_item) {
+        auto iter = std::remove_if(item->second.gcodes.begin(), item->second.gcodes.end(), [filament_id](const Item& gcode_item) {
             return (gcode_item.type == CustomGCode::Type::ToolChange && gcode_item.extruder == filament_id + 1);
         });
         if (replace_filament_id == -1)

src/slic3r/GUI/PresetComboBoxes.cpp

@@ -2177,7 +2177,7 @@ void GUI::CalibrateFilamentComboBox::OnSelect(wxCommandEvent &evt)
     wxPostEvent(m_parent, e);
 }
 
-void GUI::PlaterPresetComboBox::sys_color_changed()
+void PlaterPresetComboBox::sys_color_changed()
 {
     PresetComboBox::sys_color_changed();
     if (clr_picker) {

src/slic3r/GUI/PrintHostDialogs.cpp

@@ -1752,8 +1752,8 @@ void ElegooPrintHostSendDialog::init() {
     }
 
     {
-        auto radioBoxA = new RadioBox(this);
+        auto radioBoxA = new ::RadioBox(this);
-        auto radioBoxB = new RadioBox(this);
+        auto radioBoxB = new ::RadioBox(this);
         if (m_BedType == BedType::btPC)
             radioBoxB->SetValue(true);
         else

src/slic3r/GUI/ReleaseNote.cpp

@@ -1816,10 +1816,7 @@ void InputIpAddressDialog::set_machine_obj(MachineObject* obj)
     m_input_printer_name->GetTextCtrl()->SetLabelText(m_obj->get_dev_name());
 
     std::string img_str = DevPrinterConfigUtil::get_printer_connect_help_img(m_obj->printer_type);
-    if (img_str.empty()) { img_str = "input_access_code_x1"; }
+    auto diagram_bmp = create_scaled_bitmap(img_str + "_en", this, 198);
-
-    std::string language = wxGetApp().app_config->get("language");
-    auto diagram_bmp = create_scaled_bitmap(img_str + (language == "zh_CN" ? "_cn" : "_en"), this, 198);
     m_img_help->SetBitmap(diagram_bmp);
 
 

src/slic3r/GUI/Tab.cpp

@@ -2928,7 +2928,7 @@ void TabPrint::build()
         optgroup->append_single_option_line("skin_infill_line_width", "strength_settings_patterns#locked-zag");
         optgroup->append_single_option_line("skeleton_infill_line_width", "strength_settings_patterns#locked-zag");
         optgroup->append_single_option_line("symmetric_infill_y_axis", "strength_settings_infill#symmetric-infill-y-axis");
-        optgroup->append_single_option_line("infill_complete_top", "strength_settings_patterns#fill-pattern-tops");
+        optgroup->append_single_option_line("infill_complete_top", "strength_settings_infill#infill-complete-top");
         optgroup->append_single_option_line("infill_shift_step", "strength_settings_patterns#cross-hatch");
         optgroup->append_single_option_line("lateral_lattice_angle_1", "strength_settings_patterns#lateral-lattice");
         optgroup->append_single_option_line("lateral_lattice_angle_2", "strength_settings_patterns#lateral-lattice");

src/slic3r/GUI/TickCode.cpp

@@ -6,9 +6,6 @@
 #include <set>
 
 namespace Slic3r {
-
-using namespace CustomGCode;
-
 namespace GUI {
 std::string TickCodeInfo::get_color_for_tick(TickCode tick, Type type, const int extruder)
 {

src/slic3r/GUI/TickCode.hpp

@@ -7,6 +7,7 @@
 #include <vector>
 
 namespace Slic3r {
+using namespace CustomGCode;
 namespace GUI {
 
 struct TickCode
@@ -15,7 +16,7 @@ struct TickCode
     bool operator>(const TickCode& other) const { return other.tick < this->tick; }
 
     int         tick = 0;
-    CustomGCode::Type type = CustomGCode::ColorChange;
+    Type        type = ColorChange;
     int         extruder = 0;
     std::string color;
     std::string extra;
@@ -30,22 +31,22 @@ class TickCodeInfo
 
     std::vector<std::string>* m_colors{ nullptr };// reference to IMSlider::m_extruder_colors
 
-    std::string get_color_for_tick(TickCode tick, CustomGCode::Type type, const int extruder);
+    std::string get_color_for_tick(TickCode tick, Type type, const int extruder);
 
 public:
     std::set<TickCode>  ticks{};
-    CustomGCode::Mode   mode = CustomGCode::Undef;
+    Mode                mode = Undef;
 
     bool empty() const { return ticks.empty(); }
     void set_pause_print_msg(const std::string& message) { pause_print_msg = message; }
 
-    bool add_tick(const int tick, CustomGCode::Type type, int extruder, double print_z);
+    bool add_tick(const int tick, Type type, int extruder, double print_z);
     bool edit_tick(std::set<TickCode>::iterator it, double print_z);
-    void switch_code(CustomGCode::Type type_from, CustomGCode::Type type_to);
+    void switch_code(Type type_from, Type type_to);
-    bool switch_code_for_tick(std::set<TickCode>::iterator it, CustomGCode::Type type_to, const int extruder);
+    bool switch_code_for_tick(std::set<TickCode>::iterator it, Type type_to, const int extruder);
-    void erase_all_ticks_with_code(CustomGCode::Type type);
+    void erase_all_ticks_with_code(Type type);
 
-    bool            has_tick_with_code(CustomGCode::Type type);
+    bool            has_tick_with_code(Type type);
     bool            has_tick(int tick);
 
     void suppress_plus(bool suppress) { m_suppress_plus = suppress; }

src/slic3r/GUI/wxExtensions.cpp

@@ -456,13 +456,6 @@ wxBitmap create_scaled_bitmap(  const std::string& bmp_name_in,
                                 const vector<std::string>& array_new_color/* = vector<std::string>*/)//used for semi transparent material)
 {
     static Slic3r::GUI::BitmapCache cache;
-
-    // An empty name means the caller's icon lookup failed
-    if (bmp_name_in.empty() || bmp_name_in == ".png") {
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": empty bitmap name";
-        return wxNullBitmap;
-    }
-
     if (bitmap2) {
         return create_scaled_bitmap2(bmp_name_in, cache, win, px_cnt, grayscale, resize, array_new_color);
     }

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,8 +204,9 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
             dir = -dir;
+        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -215,8 +216,9 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -input_val;
+        value = -1.0 * input_val;
+    }
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -237,10 +239,11 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0)
+    if (rtn == 0) {
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    else
+    } else {
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
+    }
     return rtn;
 }
 
@@ -586,8 +589,15 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
+    if (result != 0) {
+        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
+            << ", try_emmc_print=" << params.try_emmc_print
+            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
+            << ", dev_ip=" << params.dev_ip << ", dev_id=" << params.dev_id;
+    }
+    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -110,6 +110,7 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
+    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -289,8 +289,11 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
+    if (sync_mode != get_filament_sync_mode())
+        return false;
+
     if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,7 +37,7 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override = default;
+    ~CrealityPrintAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -12,6 +12,10 @@
 #include <set>
 #include <string>
 #include <thread>
+#include <chrono>
+#include <condition_variable>
+#include <deque>
+#include <functional>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -20,6 +24,39 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
+class Http;
+
+bool moonraker_is_light_name(const std::string& name);
+
+class MoonrakerWebsocket
+{
+public:
+    enum class ReadResult
+    {
+        message,
+        timeout,
+        closed,
+        error,
+    };
+
+    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
+    ~MoonrakerWebsocket();
+
+    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
+    void tls_handshake(const std::string& host);
+    void handshake(const std::string& host, const std::string& target);
+    void text(bool enabled);
+    void write(const std::string& body);
+    ReadResult read(std::string& payload, std::string& error_message);
+    void close();
+    void expires_after(std::chrono::seconds timeout);
+    void abort();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> m_impl;
+};
+
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -65,12 +102,20 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-
-    // Pull-mode agent (on-demand filament sync)
-    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    CameraStreamMode get_camera_stream_mode() const override;
+    std::string get_camera_url() const override;
 
 protected:
+    struct ConnectionSettings
+    {
+        std::string dev_id;
+        std::string base_url;
+        std::string api_key;
+        bool        use_ssl = false;
+        std::string ca_file;
+    };
+
     struct MoonrakerDeviceInfo
     {
         std::string dev_id;
@@ -82,7 +127,9 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
+        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
+        std::string ca_file;
     } device_info;
 
     // Tray data for AMS payload building
@@ -100,12 +147,25 @@ protected:
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
+    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
+    ConnectionSettings get_connection_settings() const;
+    void configure_http(Http& http, const ConnectionSettings& connection) const;
+    static float parse_nozzle_diameter(const nlohmann::json& response);
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
+    // Detached fetch threads hold a raw `this`; shutdown() waits for this to reach 0.
+    std::atomic<int> filament_fetch_in_flight{0};
+
+    // Idempotent teardown; must be called from the most-derived destructor.
+    void shutdown();
+    std::atomic<bool> shutting_down{false};
+
+    // Serializes the shutting_down check with the in-flight reservation.
+    std::mutex fetch_lifecycle_mutex;
+
     // Helpers
     bool        is_numeric(const std::string& value);
     std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
@@ -118,13 +178,30 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
+    // Send a G-code script via Moonraker (/printer/gcode/script)
+    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
+    bool send_gcode(const std::string& dev_id, const std::string& gcode,
+                    const ConnectionSettings& connection) const;
+    bool post_print_action(const std::string& action) const;
+    bool post_print_action(const std::string& action,
+                           const ConnectionSettings& connection) const;
+
+    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
+
+    virtual void on_status_loop_tick(const std::string& dev_id) {}
+
+    // Queue work that may use agent state. The command worker is joined during
+    // destruction, so queued commands cannot outlive the agent.
+    void enqueue_command(std::function<void()> fn);
+    mutable std::recursive_mutex connect_mutex;
+
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
+    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -133,10 +210,11 @@ private:
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
+    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
     void stop_status_stream();
-    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void run_status_stream(std::string dev_id, ConnectionSettings connection);
-    void handle_ws_message(const std::string& dev_id, const std::string& payload);
+    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
+    void refresh_thumbnail_url(const ConnectionSettings& connection);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
@@ -147,22 +225,28 @@ private:
 
     // File upload
     bool upload_gcode(const std::string& local_path, const std::string& filename,
-                      const std::string& base_url, const std::string& api_key,
+                      const ConnectionSettings& connection,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
-    // JSON-RPC helper
+    // Start a print of a previously uploaded G-code file (path relative to the
-    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+    // Moonraker gcodes root).
-                              const nlohmann::json& request, std::string& response) const;
+    bool start_print_file(const ConnectionSettings& connection,
+                          const std::string& filename, std::string& error_msg) const;
 
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   const std::string& base_url,
+                                   ConnectionSettings connection,
-                                   const std::string& api_key,
                                    uint64_t generation);
 
+    // why: a printer with no /server/webcams/list entry can still name its stream directly;
+    // subclasses (e.g. printers with a fixed webcam path) can override this instead.
+    virtual std::string webcam_stream_override(const std::string& base_url) const { return {}; }
+    void refresh_webcam_info() const;
+    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
+
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -188,15 +272,38 @@ private:
 
     mutable std::recursive_mutex payload_mutex;
     nlohmann::json     status_cache;
+    // note: guarded by payload_mutex; filled by refresh_thumbnail_url(), empty url = looked up, none found
+    std::string        thumbnail_filename;
+    std::string        thumbnail_url;
+    mutable std::string        webcam_stream_url;
+    mutable CameraStreamMode   webcam_stream_mode = CameraStreamMode::none;
+    mutable uint64_t            webcam_info_last_lookup_ms = 0;
+    mutable uint64_t            webcam_info_generation = 0;
+    unsigned            thumbnail_lookup_attempts = 0;
+
+    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 1000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
+    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
+    // stop_status_stream() invokes ws_abort_io to wake a blocked synchronous
+    // ws.read()/ws.write()/handshake in run_status_stream(): ws_stop is only
+    // observed between reads, and Beast's expires_after() does not bound
+    // synchronous operations.
+    std::mutex             ws_abort_mutex;
+    std::function<void()>  ws_abort_io;  // guarded by ws_abort_mutex
+
+    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
+    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
+    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
+    std::atomic<uint64_t> ams_last_fetch_ms{0};
+
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -206,7 +313,13 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-    std::recursive_mutex   connect_mutex;
+
+    void run_command_worker();
+    std::thread cmd_thread;
+    std::deque<std::function<void()>> cmd_queue;
+    std::mutex cmd_mutex;
+    std::condition_variable cmd_cv;
+    bool cmd_stop = false;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,18 +2,23 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
+#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
+#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
 #include "libslic3r/Preset.hpp"
+#include <cstddef>
 #include <map>
+#include <mutex>
 #include <sstream>
+#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -36,6 +41,18 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
+// RAII decrement for the in-flight fetch count; movable so a failed thread start still releases it.
+struct InFlightGuard
+{
+    std::atomic<int>* counter;
+    explicit InFlightGuard(std::atomic<int>& c) noexcept : counter(&c) {}
+    InFlightGuard(InFlightGuard&& other) noexcept : counter(other.counter) { other.counter = nullptr; }
+    InFlightGuard(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(InFlightGuard&&) = delete;
+    ~InFlightGuard() { if (counter) counter->fetch_sub(1, std::memory_order_relaxed); }
+};
+
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -49,51 +66,156 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
 {
-    std::string error;
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
 
-    // 1. Fetch device info and infer series_id
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-    std::string series_id;
+{
-    {
+    if (sync_mode != get_filament_sync_mode())
-        MoonrakerDeviceInfo info;
-        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
-            series_id = infer_series_id(info.model_id, info.dev_name);
-        }
-    }
-    if (series_id.empty()) {
-        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-        series_id = infer_series_id(device_info.model_id, device_info.model_name);
-    }
-
-    // 2. Fetch filament dictionary
-    QidiFilamentDict dict;
-    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
-        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-    }
-
-    // 3. Fetch slot info and build AmsTrayData directly
-    std::vector<AmsTrayData> trays;
-    int                      box_count = 0;
-    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
-        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
         return false;
+
+    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
+    ConnectionSettings connection = get_connection_settings();
+    std::string        model_id;
+    std::string        model_name;
+    {
+        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
+        model_id   = device_info.model_id;
+        model_name = device_info.model_name;
     }
 
-    // 4. Build the AMS payload
+    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    build_ams_payload(box_count, box_count * 4 - 1, trays);
+    {
+        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
+        if (shutting_down.load())
+            return false;
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+    }
+
+    InFlightGuard guard{filament_fetch_in_flight};
+    std::thread([this, guard = std::move(guard), connection = std::move(connection), model_id, model_name]() mutable {
+        std::string error;
+
+        // 1. Fetch device info and infer series_id
+        std::string series_id;
+        {
+            MoonrakerDeviceInfo info;
+            if (fetch_device_info(connection, info, error)) {
+                series_id = infer_series_id(info.model_id, info.dev_name);
+            }
+        }
+        if (series_id.empty()) {
+            // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+            series_id = infer_series_id(model_id, model_name);
+        }
+
+        // 2. Fetch filament dictionary
+        QidiFilamentDict dict;
+        if (!fetch_filament_dict(connection, dict, error)) {
+            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
+        }
+
+        // 3. Fetch slot info and build AmsTrayData directly
+        std::vector<AmsTrayData> trays;
+        int box_count = 0;
+        if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
+            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+            return;
+        }
+
+        // 4. Build the AMS payload
+        build_ams_payload(box_count, box_count * 4 - 1, trays);
+    }).detach();
     return true;
 }
 
-bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-                                       const std::string&        api_key,
+{
+    // enable_box mirrors task_use_ams: engage the multi-color box only when this
+    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
+    // if firmware treats enable_box as "a box exists" rather than "use it this job",
+    // switch this gate to HasAms()/box_count instead.)
+    const int enable = params.task_use_ams ? 1 : 0;
+    if (!send_gcode(device_info.dev_id, "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable))) {
+        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to set enable_box";
+        return false;
+    }
+
+    // When the box isn't used this job, leave the existing value_t<tool> slot
+    // assignments untouched (enable_box=0 is enough to disengage it).
+    if (!enable)
+        return true;
+
+    if (params.ams_mapping.empty()) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
+        return true;
+    }
+
+    // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
+    // physical box slot (-1 = unmapped). Mirror it onto the printer's value_t<tool>
+    // variables: SAVE_VARIABLE VARIABLE=value_t<tool> VALUE='slot<n>'.
+    auto mapping = nlohmann::json::parse(params.ams_mapping, nullptr, /*allow_exceptions*/ false);
+    if (mapping.is_discarded() || !mapping.is_array()) {
+        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: invalid ams_mapping: " << params.ams_mapping;
+        return false;
+    }
+
+    for (size_t tool = 0; tool < mapping.size(); ++tool) {
+        if (!mapping[tool].is_number_integer())
+            continue;
+        const int slot = mapping[tool].get<int>();
+        if (slot < 0)
+            continue; // unmapped filament — skip
+        const std::string gcode = "SAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
+                                  " VALUE=\"'slot" + std::to_string(slot) + "'\"";
+        if (!send_gcode(device_info.dev_id, gcode)) {
+            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to set value_t" << tool;
+            return false;
+        }
+    }
+    return true;
+}
+
+int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
+{
+    if (!apply_box_mapping(params))
+        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
+    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
+}
+
+int QidiPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
+{
+    if (!apply_box_mapping(params))
+        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
+    return MoonrakerPrinterAgent::start_print(std::move(params), update_fn, cancel_fn, wait_fn);
+}
+
+int QidiPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
+{
+    if (!apply_box_mapping(params))
+        return BAMBU_NETWORK_ERR_PRINT_WR_UPLOAD_FTP_FAILED;
+    return MoonrakerPrinterAgent::start_local_print_with_record(std::move(params), update_fn, cancel_fn, wait_fn);
+}
+
+int QidiPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
+{
+    if (!apply_box_mapping(params))
+        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
+    return MoonrakerPrinterAgent::start_sdcard_print(std::move(params), update_fn, cancel_fn);
+}
+
+bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -103,8 +225,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     std::string http_error;
 
     auto http = Http::get(url);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -129,20 +252,10 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         return false;
     }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    nlohmann::json status;
-    if (json.is_discarded()) {
+    nlohmann::json variables;
-        error = "Invalid JSON response";
+    if (!parse_slot_response(response_body, status, variables, error))
         return false;
-    }
-
-    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
-        !json["result"]["status"]["save_variables"].contains("variables")) {
-        error = "Unexpected JSON structure";
-        return false;
-    }
-
-    auto& variables = json["result"]["status"]["save_variables"]["variables"];
-    auto& status    = json["result"]["status"];
 
     box_count = variables.value("box_count", 1);
     if (box_count < 0) {
@@ -217,20 +330,45 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     return true;
 }
 
-bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           const std::string& api_key,
+                                           nlohmann::json&    status,
+                                           nlohmann::json&    variables,
+                                           std::string&       error)
+{
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
+        return false;
+    }
+
+    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
+        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
+        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
+        // why: Qidi firmware may send null here, but json::value() throws for it.
+        error = "Unexpected JSON structure: save_variables.variables must be an object";
+        return false;
+    }
+
+    status    = json["result"]["status"];
+    variables = status["save_variables"]["variables"];
+    return true;
+}
+
+bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,6 +3,8 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
+#include "bambu_networking.hpp"
+#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -14,7 +16,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override = default;
+    ~QidiPrinterAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -22,7 +24,23 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
+    static bool parse_slot_response(const std::string& response_body,
+                                    nlohmann::json&    status,
+                                    nlohmann::json&    variables,
+                                    std::string&       error);
+
+    // Print operations — emit QiDi multi-color box config, then delegate to base.
+    int start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
+    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
+    int start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
+    int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
+
+    FilamentSyncMode get_filament_sync_mode() const override;
+
 private:
+    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
+    // Returns false if any command fails (caller should abort the print).
+    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -30,14 +48,13 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const std::string&        base_url,
+    bool fetch_slot_info(const ConnectionSettings& connection,
-                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SimplyPrint.cpp

@@ -115,7 +115,7 @@ static void set_auth(Http& http, const std::string& access_token) { http.header(
 
 static bool should_open_in_external_browser()
 {
-    const auto& app = GUI::wxGetApp();
+    const auto& app = wxGetApp();
 
     if (app.preset_bundle->use_bbl_device_tab()) {
         // When using bbl device tab, we always need to open external browser

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,11 +2,18 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
+#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
+#include <atomic>
 #include <boost/log/trivial.hpp>
+#include <chrono>
+#include <cstdint>
+#include <mutex>
+#include <sstream>
+#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -20,6 +27,25 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
+constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
+
+int64_t now_ms()
+{
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+// RAII decrement for the in-flight fetch count; movable so a failed thread start still releases it.
+struct InFlightGuard
+{
+    std::atomic<int>* counter;
+    explicit InFlightGuard(std::atomic<int>& c) noexcept : counter(&c) {}
+    InFlightGuard(InFlightGuard&& other) noexcept : counter(other.counter) { other.counter = nullptr; }
+    InFlightGuard(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(InFlightGuard&&) = delete;
+    ~InFlightGuard() { if (counter) counter->fetch_sub(1, std::memory_order_relaxed); }
+};
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -76,6 +102,31 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
+void SnapmakerPrinterAgent::start_camera_monitor()
+{
+    enqueue_command([this] {
+        send_ws_rpc("camera.start_monitor",
+                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
+    });
+    m_camera_last_fire_ms.store(now_ms());
+}
+
+void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
+{
+    (void) dev_id;
+    const int64_t last = m_camera_last_fire_ms.load();
+    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
+        start_camera_monitor();
+    }
+}
+
+int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
+{
+    (void) dev_id;
+    start_camera_monitor();
+    return BAMBU_NETWORK_SUCCESS;
+}
+
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -111,127 +162,155 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
-    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    (void) dev_id;
-
+    if (sync_mode != get_filament_sync_mode())
-    std::string response_body;
-    bool        success = false;
-    std::string http_error;
-
-    auto http = Http::get(url);
-    if (!device_info.api_key.empty()) {
-        http.header("X-Api-Key", device_info.api_key);
-    }
-    http.timeout_connect(5)
-        .timeout_max(10)
-        .on_complete([&](std::string body, unsigned status) {
-            if (status == 200) {
-                response_body = body;
-                success       = true;
-            } else {
-                http_error = "HTTP error: " + std::to_string(status);
-            }
-        })
-        .on_error([&](std::string body, std::string err, unsigned status) {
-            http_error = err;
-            if (status > 0) {
-                http_error += " (HTTP " + std::to_string(status) + ")";
-            }
-        })
-        .perform_sync();
-
-    if (!success) {
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
+
+    std::string base_url;
+    std::string api_key;
+    {
+        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
+        base_url = device_info.base_url;
+        api_key  = device_info.api_key;
     }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    if (json.is_discarded()) {
+    {
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        return false;
+        if (shutting_down.load())
+            return false;
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
     }
 
-    // Navigate to result.status.print_task_config
+    InFlightGuard guard{filament_fetch_in_flight};
-    if (!json.contains("result") || !json["result"].contains("status") ||
+    std::thread([this, guard = std::move(guard), base_url, api_key]() {
-        !json["result"]["status"].contains("print_task_config")) {
+        const std::string url = join_url(base_url, "/printer/objects/query?print_task_config&filament_detect");
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-        return false;
-    }
 
-    auto& ptc = json["result"]["status"]["print_task_config"];
+        std::string response_body;
+        bool success = false;
+        std::string http_error;
 
-    // Read parallel arrays from print_task_config
+        auto http = Http::get(url);
-    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+        if (!api_key.empty()) {
-    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+            http.header("X-Api-Key", api_key);
-    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+        }
-    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+        http.timeout_connect(5)
-    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
+            .timeout_max(10)
-
+            .on_complete([&](std::string body, unsigned status) {
-    const int slot_count = static_cast<int>(filament_exist.size());
+                if (status == 200) {
-    if (slot_count == 0) {
+                    response_body = body;
-        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+                    success       = true;
-        return false;
-    }
-
-    // Read NFC filament_detect data for temperature info (optional)
-    nlohmann::json nfc_info;
-    if (json["result"]["status"].contains("filament_detect") &&
-        json["result"]["status"]["filament_detect"].contains("info")) {
-        nfc_info = json["result"]["status"]["filament_detect"]["info"];
-    }
-
-    static const std::string empty_str;
-    static const std::string default_color = "FFFFFFFF";
-
-    std::vector<AmsTrayData> trays;
-    trays.reserve(slot_count);
-
-    for (int i = 0; i < slot_count; ++i) {
-        AmsTrayData tray;
-        tray.slot_index   = i;
-        tray.has_filament = filament_exist[i];
-
-        if (tray.has_filament) {
-            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
-                                                       safe_at(filament_sub_type, i, empty_str));
-            tray.tray_color    = safe_at(filament_color, i, default_color);
-
-            auto* bundle = GUI::wxGetApp().preset_bundle;
-            // Try to find a matching preset for this filament based on vendor, type and color.
-            // If not found, default to traditional search by type only or generic type mapping.
-            if (bundle) {
-                std::string vendor      = safe_at(filament_vendor, i, empty_str);
-                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
-                                                                                       tray.tray_color);
-
-                if (!filament_id.empty()) {
-                    tray.tray_info_idx = filament_id;
-                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
-                                               << filament_id;
                 } else {
-                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                    http_error = "HTTP error: " + std::to_string(status);
                 }
-            } else {
+            })
-                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
+            .on_error([&](std::string body, std::string err, unsigned status) {
-            }
+                http_error = err;
+                if (status > 0) {
+                    http_error += " (HTTP " + std::to_string(status) + ")";
+                }
+            })
+            .perform_sync();
 
-            // Extract NFC temperature data if available
+        if (!success) {
-            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
-                auto& nfc_slot = nfc_info[i];
+            return;
-                std::string vendor = nfc_slot.value("VENDOR", "NONE");
-                if (vendor != "NONE" && !vendor.empty()) {
-                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
-                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
-                }
-            }
         }
 
-        trays.emplace_back(std::move(tray));
+        auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    }
+        if (json.is_discarded()) {
+            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+            return;
+        }
+
+        // Navigate to result.status.print_task_config
+        if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
+            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
+            return;
+        }
+
+        auto& ptc = json["result"]["status"]["print_task_config"];
+
+        // Read parallel arrays from print_task_config
+        auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+        auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+        auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+        auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+        auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
+
+        const int slot_count = static_cast<int>(filament_exist.size());
+        if (slot_count == 0) {
+            BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+            return;
+        }
+
+        // Read NFC filament_detect data for temperature info (optional)
+        nlohmann::json nfc_info;
+        if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
+            nfc_info = json["result"]["status"]["filament_detect"]["info"];
+        }
+
+        static const std::string empty_str;
+        static const std::string default_color = "FFFFFFFF";
+
+        std::vector<AmsTrayData> trays;
+        trays.reserve(slot_count);
+
+        for (int i = 0; i < slot_count; ++i) {
+            AmsTrayData tray;
+            tray.slot_index   = i;
+            tray.has_filament = filament_exist[i];
+
+            if (tray.has_filament) {
+                tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
+                tray.tray_color = safe_at(filament_color, i, default_color);
+
+                auto* bundle = GUI::wxGetApp().preset_bundle;
+                // Try to find a matching preset for this filament based on vendor, type and color.
+                // If not found, default to traditional search by type only or generic type mapping.
+                if (bundle) {
+                    std::string vendor      = safe_at(filament_vendor, i, empty_str);
+                    std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
+                                                                                           tray.tray_color);
+
+                    if (!filament_id.empty()) {
+                        tray.tray_info_idx = filament_id;
+                        BOOST_LOG_TRIVIAL(warning)
+                            << "Filament sync: Found manufacturer-specific profile for slot " << i << ": " << filament_id;
+                    } else {
+                        tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                    }
+                } else {
+                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
+                }
+
+                // Extract NFC temperature data if available
+                if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+                    auto& nfc_slot     = nfc_info[i];
+                    std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                    if (vendor != "NONE" && !vendor.empty()) {
+                        tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
+                        tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
+                    }
+                }
+            }
+
+            trays.emplace_back(std::move(tray));
+        }
+
+        build_ams_payload(1, slot_count - 1, trays);
+    }).detach();
 
-    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
+FilamentSyncMode SnapmakerPrinterAgent::get_filament_sync_mode() const
+{
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
+
 } // namespace Slic3r

src/slic3r/Utils/SnapmakerPrinterAgent.hpp

@@ -3,6 +3,8 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
+#include <atomic>
+#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -11,16 +13,25 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override = default;
+    ~SnapmakerPrinterAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    FilamentSyncMode get_filament_sync_mode() const override;
+    int command_start_camera(std::string dev_id) override;
+    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
+    std::string get_camera_url() const override { return device_info.base_url + "/server/files/camera/monitor.jpg"; }
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
+
+    void start_camera_monitor();
+    void on_status_loop_tick(const std::string& dev_id) override;
+
+    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

src/slic3r/plugin/host/PluginHostUi.cpp

@@ -565,7 +565,7 @@ void progress_close(int id)
     });
 }
 
-void plater_notification(GUI::NotificationManager::NotificationLevel notification_level, const std::string& text,
+void plater_notification(NotificationManager::NotificationLevel notification_level, const std::string& text,
                          const std::string& hypertext, py::object on_click)
 {
     const std::string plugin_key = PluginAuditManager::instance().current_plugin();
@@ -600,7 +600,7 @@ void plater_notification(GUI::NotificationManager::NotificationLevel notificatio
     }
 
     run_on_ui_blocking([notification_level, text, hypertext, callback = std::move(callback)]() mutable {
-        GUI::wxGetApp().plater()->get_notification_manager()->push_notification(GUI::NotificationType::CustomNotification, notification_level, text,
+        wxGetApp().plater()->get_notification_manager()->push_notification(NotificationType::CustomNotification, notification_level, text,
                                                                            hypertext, std::move(callback));
     });
 }
@@ -713,16 +713,16 @@ void PluginHostUi::RegisterBindings(pybind11::module_& host)
            py::arg("maximum") = 100, py::arg("style") = wxPD_APP_MODAL | wxPD_AUTO_HIDE,
            "Create a native progress dialog and return a ProgressDialog handle.");
 
-    py::enum_<GUI::NotificationManager::NotificationLevel>(ui, "NotificationLevel")
+    py::enum_<NotificationManager::NotificationLevel>(ui, "NotificationLevel")
-        .value("ProgressBarNotificationLevel", GUI::NotificationManager::NotificationLevel::ProgressBarNotificationLevel)
+        .value("ProgressBarNotificationLevel", NotificationManager::NotificationLevel::ProgressBarNotificationLevel)
-        .value("HintNotificationLevel", GUI::NotificationManager::NotificationLevel::HintNotificationLevel)
+        .value("HintNotificationLevel", NotificationManager::NotificationLevel::HintNotificationLevel)
-        .value("RegularNotificationLevel", GUI::NotificationManager::NotificationLevel::RegularNotificationLevel)
+        .value("RegularNotificationLevel", NotificationManager::NotificationLevel::RegularNotificationLevel)
-        .value("PrintInfoNotificationLevel", GUI::NotificationManager::NotificationLevel::PrintInfoNotificationLevel)
+        .value("PrintInfoNotificationLevel", NotificationManager::NotificationLevel::PrintInfoNotificationLevel)
-        .value("PrintInfoShortNotificationLevel", GUI::NotificationManager::NotificationLevel::PrintInfoShortNotificationLevel)
+        .value("PrintInfoShortNotificationLevel", NotificationManager::NotificationLevel::PrintInfoShortNotificationLevel)
-        .value("ImportantNotificationLevel", GUI::NotificationManager::NotificationLevel::ImportantNotificationLevel)
+        .value("ImportantNotificationLevel", NotificationManager::NotificationLevel::ImportantNotificationLevel)
-        .value("WarningNotificationLevel", GUI::NotificationManager::NotificationLevel::WarningNotificationLevel)
+        .value("WarningNotificationLevel", NotificationManager::NotificationLevel::WarningNotificationLevel)
-        .value("SeriousWarningNotificationLevel", GUI::NotificationManager::NotificationLevel::SeriousWarningNotificationLevel)
+        .value("SeriousWarningNotificationLevel", NotificationManager::NotificationLevel::SeriousWarningNotificationLevel)
-        .value("ErrorNotificationLevel", GUI::NotificationManager::NotificationLevel::ErrorNotificationLevel)
+        .value("ErrorNotificationLevel", NotificationManager::NotificationLevel::ErrorNotificationLevel)
         .export_values();
 
     ui.def("push_notification", &plater_notification, py::arg("notification_level"), py::arg("text"),

tests/fff_print/test_perimeters.cpp

@@ -19,10 +19,8 @@
 #include <cstddef>
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/BoundingBox.hpp"
-#include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Point.hpp"
-#include "libslic3r/Polyline.hpp"
 #include <limits>
 #include <string>
 #include <utility>
@@ -277,124 +275,6 @@ TEST_CASE("Only one wall on the first layer needs a bottom shell", "[Perimeters]
 
 namespace {
 
-// The last layer of the tab, whose top surface shares an island with the tube walls rising past it.
-const double tab_top_z = 5.0;
-
-// With the widths below the tube walls are 1.10mm wide once the precise outer wall offset (0.043mm a side) is
-// taken off. That is narrower than 3 outer wall spacings (3 x 0.377 = 1.131mm), so an Arachne pass limited to a
-// single wall fills it by widening its 2 beads, yet wide enough for the full 2 wall pass to add a middle wall
-// (from 1.062mm).
-const double narrow_wall = 1.186;
-
-// A 20x30x10 tube with narrow_wall thick walls, and a 20x8x5 tab against its -Y side.
-Print &tube_with_tab(Print &print, Model &model, const DynamicPrintConfig &config)
-{
-    ModelObject *object = model.add_object();
-    object->name = "tube_with_tab.stl";
-    object->add_volume(make_cube(20., 30., 10.), ModelVolumeType::MODEL_PART, false);
-    // Overlaps the tube wall by 0.5mm so the two parts slice as one island.
-    TriangleMesh tab = make_cube(20., 8.5, 5.);
-    tab.translate(0.f, -8.f, 0.f);
-    object->add_volume(std::move(tab), ModelVolumeType::MODEL_PART, false);
-    TriangleMesh bore = make_cube(20. - 2. * narrow_wall, 30. - 2. * narrow_wall, 12.);
-    bore.translate(float(narrow_wall), float(narrow_wall), -1.f);
-    object->add_volume(std::move(bore), ModelVolumeType::NEGATIVE_VOLUME, false);
-    object->add_instance();
-    object->ensure_on_bed();
-
-    print.auto_assign_extruders(object);
-    print.apply(model, config);
-    print.validate();
-    print.set_status_silent();
-    return print;
-}
-
-// Every width the narrow_wall arithmetic depends on, so none of them rests on a default.
-DynamicPrintConfig narrow_wall_config(bool only_one_wall_top, double top_surface_expansion)
-{
-    DynamicPrintConfig config = base_config("arachne");
-    config.set_deserialize_strict({
-        { "wall_loops",            2 },
-        { "nozzle_diameter",       "0.4" },
-        { "line_width",            0.42 },
-        { "outer_wall_line_width", 0.42 },
-        { "inner_wall_line_width", 0.45 },
-        { "min_bead_width",        "85%" },
-        { "precise_outer_wall",    true },
-        { "wall_sequence",         "inner wall/outer wall" },
-        { "only_one_wall_top",     only_one_wall_top },
-        { "top_surface_expansion", top_surface_expansion },
-    });
-    return config;
-}
-
-// Inner wall length the layer at print_z extrudes within 3mm of its +Y edge: the tube wall facing away from the tab.
-double far_wall_inner_wall_length(const Print &print, double print_z)
-{
-    for (const Layer *layer : print.objects().front()->layers()) {
-        if (std::abs(layer->print_z - print_z) > EPSILON)
-            continue;
-        BoundingBox band = get_extents(layer->lslices);
-        band.min.y()     = band.max.y() - scaled<coord_t>(3.);
-
-        Polylines inner_walls;
-        auto      collect = [&inner_walls](const ExtrusionPaths &paths) {
-            for (const ExtrusionPath &path : paths)
-                if (path.role() == erPerimeter)
-                    inner_walls.emplace_back(path.as_polyline());
-        };
-        for (const LayerRegion *region : layer->regions()) {
-            const ExtrusionEntityCollection walls = region->perimeters.flatten();
-            for (const ExtrusionEntity *entity : walls.entities) {
-                if (const auto *loop = dynamic_cast<const ExtrusionLoop*>(entity))
-                    collect(loop->paths);
-                else if (const auto *multi_path = dynamic_cast<const ExtrusionMultiPath*>(entity))
-                    collect(multi_path->paths);
-                else if (const auto *path = dynamic_cast<const ExtrusionPath*>(entity))
-                    collect({ *path });
-            }
-        }
-        return unscaled<double>(total_length(intersection_pl(inner_walls, band.polygon())));
-    }
-    return 0.;
-}
-
-} // namespace
-
-// only_one_wall_top first lays out an island with a single Arachne wall and generates the inner walls inside it.
-// On a wall narrower than 3 outer wall spacings that single wall pass widens its 2 beads to fill the wall and leaves
-// no room for the middle wall, which is only intended over the top surface. The tube walls away from the tab are not
-// under the tab's top surface, so on the tab's last layer they keep the inner wall they get with the option off.
-TEST_CASE("Only one wall on top surfaces keeps the inner walls of narrow walls away from the top surface", "[Perimeters]")
-{
-    // 0 re-onions the region beside the top surface, 2 clips the inner walls over it.
-    const double top_surface_expansion = GENERATE(0.0, 2.0);
-    CAPTURE(top_surface_expansion);
-
-    struct TabTopLayer {
-        double perimeters;
-        double far_wall_inner_walls;
-    };
-    auto tab_top_layer_for = [top_surface_expansion](bool only_one_wall_top) {
-        Print print;
-        Model model;
-        tube_with_tab(print, model, narrow_wall_config(only_one_wall_top, top_surface_expansion));
-        print.process();
-        REQUIRE_FALSE(print.objects().empty());
-        return TabTopLayer{ perimeter_length_at(print, tab_top_z), far_wall_inner_wall_length(print, tab_top_z) };
-    };
-
-    const TabTopLayer plain    = tab_top_layer_for(false);
-    const TabTopLayer one_wall = tab_top_layer_for(true);
-
-    // The option acts on this layer: the inner walls under the tab's top surface are gone.
-    REQUIRE(plain.far_wall_inner_walls > 10.);
-    CHECK(one_wall.perimeters < plain.perimeters);
-    CHECK_THAT(one_wall.far_wall_inner_walls, Catch::Matchers::WithinAbs(plain.far_wall_inner_walls, 1.0));
-}
-
-namespace {
-
 // The layer that closes the cavity of box_over_cavity(), the first one printed over air.
 const double cavity_ceiling_z = 6.2;
 

tests/slic3rutils/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_capabilities_in_use.cpp
     test_plugin_status.cpp
     test_printer_agent.cpp
+    test_qidi_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp

tests/slic3rutils/test_printer_agent.cpp

@@ -1,18 +1,29 @@
 #include <catch2/catch_all.hpp>
 
+#include <functional>
+#include <slic3r/Utils/BBLPrinterAgent.hpp>
+#include <slic3r/Utils/IPrinterAgent.hpp>
+#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
+#include "catch2/catch_approx.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
+#include <atomic>
+#include <chrono>
+#include <future>
+#include <slic3r/Utils/bambu_networking.hpp>
 #include <string>
+#include <thread>
 #include <pybind11/cast.h>
+#include <utility>
 
 namespace Slic3r { class ICloudServiceAgent; }
 namespace Slic3r { class IPrinterAgent; }
@@ -20,6 +31,259 @@ namespace Slic3r { class IPrinterAgent; }
 using namespace Slic3r;
 namespace py = pybind11;
 
+class MoonrakerParserProbe : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::parse_nozzle_diameter;
+
+    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+};
+
+TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[unit][moonraker]")
+{
+    const auto response = nlohmann::json::parse(R"({
+        "result": {
+            "status": {
+                "configfile": {
+                    "settings": {
+                        "extruder": {
+                            "nozzle_diameter": 0.6
+                        }
+                    }
+                }
+            }
+        }
+    })");
+
+    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(response) == Catch::Approx(0.6f));
+}
+
+TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[unit][moonraker]")
+{
+    const auto raw_config_response = nlohmann::json::parse(R"({
+        "result": {
+            "status": {
+                "configfile": {
+                    "config": {
+                        "extruder": {
+                            "nozzle_diameter": "0.8"
+                        }
+                    }
+                }
+            }
+        }
+    })");
+    const auto missing_response = nlohmann::json::object();
+
+    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response) == Catch::Approx(0.8f));
+    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(missing_response) == 0.0f);
+}
+
+// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
+TEST_CASE("unit: default AMS commands report not supported", "[unit][moonraker]")
+{
+    MoonrakerPrinterAgent agent("");
+
+    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+}
+
+TEST_CASE("unit: Moonraker light name matching", "[unit][moonraker]")
+{
+    CHECK(moonraker_is_light_name("caselight"));
+    CHECK(moonraker_is_light_name("LED_STRIP"));
+    CHECK_FALSE(moonraker_is_light_name("beeper"));
+    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
+    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
+}
+
+// ===========================================================================
+// UNIT - handle_request's not-supported default.
+// The agent is the only thing that knows what it can translate, so an untranslated
+// command has to say so instead of returning success and letting the UI believe the
+// control worked. Guards the inverse too: the pushing namespace is genuinely
+// satisfied by the websocket status stream, and it re-fires from the keepalive timer
+// roughly once a second, so it must stay a success or it would raise a dialog on a
+// timer. Only branches that touch neither the network nor wx are exercised.
+// ===========================================================================
+TEST_CASE("unit: Moonraker reports untranslated commands as not supported", "[unit][moonraker]")
+{
+    MoonrakerPrinterAgent agent("");
+
+    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+
+    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
+    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
+
+    // why: malformed input is a different failure than an untranslated command, and the
+    // default must not swallow it into a misleading not-supported verdict.
+    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
+}
+
+// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override
+// (MoonrakerPrinterAgent's own override is synchronous, but QidiPrinterAgent's override is
+// fire-and-forget: it spawns a detached thread and returns immediately). QidiPrinterAgent is
+// `final`, so this probes the same contract with a controllable double instead.
+TEST_CASE("unit: a fire-and-forget override of fetch_filament_info is not waited on by the caller",
+          "[unit][moonraker]")
+{
+    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
+    {
+    public:
+        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+
+        std::atomic<bool>  invoked{false};
+        std::promise<void> release_gate;
+        std::promise<void> done_promise;
+
+        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
+        {
+            std::thread([this]() {
+                invoked.store(true);
+                // Block here until the test explicitly releases us, proving the caller
+                // (fetch_filament_info) does not wait for this to run.
+                release_gate.get_future().wait();
+                done_promise.set_value();
+            }).detach();
+            return true;
+        }
+    };
+
+    auto agent = std::make_shared<RecordingAgent>(std::string{});
+    auto done_future = agent->done_promise.get_future();
+
+    bool immediate_result = agent->fetch_filament_info("test-dev");
+
+    // fetch_filament_info must return before its background work completes — prove
+    // it by confirming the background call is still blocked on the gate right now.
+    REQUIRE(immediate_result == true);
+    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
+
+    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
+    agent->release_gate.set_value();
+    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
+    REQUIRE(agent->invoked.load() == true);
+}
+
+namespace {
+
+// Globals so a parked proxy fetch thread never dereferences a freed agent.
+std::atomic<int>  g_deferred_fetch_running{0};
+std::atomic<bool> g_deferred_destroy_returned{false};
+
+// Joins on scope exit so a throwing REQUIRE does not std::terminate.
+class ScopedJoiner
+{
+public:
+    explicit ScopedJoiner(std::thread& t) : m_thread(t) {}
+    ~ScopedJoiner() { if (m_thread.joinable()) m_thread.join(); }
+    ScopedJoiner(const ScopedJoiner&) = delete;
+    ScopedJoiner& operator=(const ScopedJoiner&) = delete;
+
+private:
+    std::thread& m_thread;
+};
+
+// A fetch that parks before touching the in-flight counter, so teardown's wait can
+// observe zero first.
+class DeferredFetchAgent : public MoonrakerPrinterAgent
+{
+public:
+    explicit DeferredFetchAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+
+    // Shared so a parked proxy fetch can never outlive the stack that owns it.
+    std::shared_ptr<std::promise<void>> entered{std::make_shared<std::promise<void>>()};
+    std::shared_ptr<std::promise<void>> allow_fetch{std::make_shared<std::promise<void>>()};
+    std::shared_ptr<std::promise<void>> allow_finish{std::make_shared<std::promise<void>>()};
+
+    // Runs the callable on the command worker, which teardown joins.
+    void post(std::function<void()> fn) { enqueue_command(std::move(fn)); }
+
+    bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
+    {
+        // Resumes after ~DeferredFetchAgent destroyed these members; snapshot up front.
+        auto entered_p      = entered;
+        auto allow_fetch_p  = allow_fetch;
+        auto allow_finish_p = allow_finish;
+
+        entered_p->set_value();
+        allow_fetch_p->get_future().wait();
+
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+        std::thread([this, finish = std::move(allow_finish_p)] {
+            struct InFlightGuard
+            {
+                std::atomic<int>& counter;
+                ~InFlightGuard() { counter.fetch_sub(1, std::memory_order_relaxed); }
+            } guard{filament_fetch_in_flight};
+
+            g_deferred_fetch_running.fetch_add(1, std::memory_order_relaxed);
+            finish->get_future().wait();
+            g_deferred_fetch_running.fetch_sub(1, std::memory_order_relaxed);
+        }).detach();
+        return true;
+    }
+};
+
+} // namespace
+
+// REGRESSION - teardown must not return while a fetch it started is in flight.
+// The command worker parks a fetch before it reserves the in-flight slot, forcing
+// the "wait already observed zero" interleaving deterministically.
+TEST_CASE("an agent's destruction waits for a fetch started by its worker during teardown",
+          "[unit][moonraker][Regression]")
+{
+    g_deferred_fetch_running.store(0);
+    g_deferred_destroy_returned.store(false);
+
+    auto agent        = std::make_shared<DeferredFetchAgent>(std::string{});
+    auto entered      = agent->entered;
+    auto allow_fetch  = agent->allow_fetch;
+    auto allow_finish = agent->allow_finish;
+
+    // Park a fetch inside the command worker while the agent is still complete.
+    agent->post([ptr = agent.get()] { ptr->fetch_filament_info("dev", FilamentSyncMode::pull); });
+    REQUIRE(entered->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
+
+    // Destroy on another thread so this one can drive the parked fetch.
+    std::thread destroyer([owned = std::move(agent)]() mutable {
+        owned.reset();
+        g_deferred_destroy_returned.store(true);
+    });
+    ScopedJoiner join_destroyer{destroyer};
+
+    // Let teardown pass its wait; the worker has not reserved yet.
+    std::this_thread::sleep_for(std::chrono::milliseconds(300));
+    allow_fetch->set_value();
+
+    // Get the fetch actually in flight (parked on allow_finish).
+    for (int i = 0; i < 200 && g_deferred_fetch_running.load() == 0; ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    REQUIRE(g_deferred_fetch_running.load() == 1);
+
+    // A correct teardown cannot return while the fetch is parked; give a buggy one time.
+    for (int i = 0; i < 200 && !g_deferred_destroy_returned.load(); ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    if (g_deferred_destroy_returned.load()) {
+        // Bug: teardown returned with a fetch still running. Don't release allow_finish.
+        CHECK(g_deferred_fetch_running.load() == 0);
+        return;
+    }
+
+    // Fixed order: destruction is still blocked on the in-flight fetch.
+    allow_finish->set_value();
+    destroyer.join();
+    CHECK(g_deferred_destroy_returned.load());
+    CHECK(g_deferred_fetch_running.load() == 0);
+}
+
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in

tests/slic3rutils/test_qidi_printer_agent.cpp

@@ -0,0 +1,134 @@
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_string.hpp"
+#include <catch2/catch_all.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <slic3r/Utils/QidiPrinterAgent.hpp>
+
+#include <string>
+
+using namespace Slic3r;
+
+TEST_CASE("Qidi slot response rejects null variables without throwing", "[QidiPrinterAgent]")
+{
+    const std::string response = R"({
+        "result": {
+            "status": {
+                "save_variables": {
+                    "variables": null
+                }
+            }
+        }
+    })";
+    nlohmann::json status;
+    nlohmann::json variables;
+    std::string    error;
+    bool           parsed = true;
+
+    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
+    CHECK_FALSE(parsed);
+    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("variables"));
+    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("object"));
+}
+
+TEST_CASE("Qidi slot response rejects missing and non-object fields without throwing", "[QidiPrinterAgent]")
+{
+    std::string response;
+
+    SECTION("missing result")
+    {
+        response = R"({})";
+    }
+
+    SECTION("non-object result")
+    {
+        response = R"({"result":null})";
+    }
+
+    SECTION("missing status")
+    {
+        response = R"({"result":{}})";
+    }
+
+    SECTION("non-object status")
+    {
+        response = R"({"result":{"status":null}})";
+    }
+
+    SECTION("missing save_variables")
+    {
+        response = R"({"result":{"status":{}}})";
+    }
+
+    SECTION("non-object save_variables")
+    {
+        response = R"({"result":{"status":{"save_variables":null}}})";
+    }
+
+    SECTION("missing variables")
+    {
+        response = R"({"result":{"status":{"save_variables":{}}}})";
+    }
+
+    SECTION("scalar")
+    {
+        response = R"({"result":{"status":{"save_variables":{"variables":42}}}})";
+    }
+
+    SECTION("array")
+    {
+        response = R"({"result":{"status":{"save_variables":{"variables":[]}}}})";
+    }
+
+    nlohmann::json status;
+    nlohmann::json variables;
+    std::string    error;
+    bool           parsed = true;
+
+    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
+    CHECK_FALSE(parsed);
+}
+
+TEST_CASE("Qidi slot response exposes valid status and variables", "[QidiPrinterAgent]")
+{
+    const std::string response = R"({
+        "result": {
+            "status": {
+                "save_variables": {
+                    "variables": {
+                        "box_count": 2,
+                        "color_slot0": 3
+                    }
+                },
+                "box_stepper slot0": {
+                    "runout_button": 0
+                }
+            }
+        }
+    })";
+    nlohmann::json status;
+    nlohmann::json variables;
+    std::string    error;
+    bool           parsed = false;
+
+    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
+    REQUIRE(parsed);
+    CHECK(status.is_object());
+    CHECK(variables.is_object());
+    CHECK(variables.at("box_count") == 2);
+    CHECK(status.contains("box_stepper slot0"));
+}
+
+TEST_CASE("Qidi slot response rejects invalid JSON", "[QidiPrinterAgent]")
+{
+    nlohmann::json status;
+    nlohmann::json variables;
+    std::string    error;
+    bool           parsed = true;
+
+    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response("{not json", status, variables, error));
+    CHECK_FALSE(parsed);
+    CHECK(error == "Invalid JSON response");
+}