Declare json in OrcaSlicer.cpp on Every Platform

OrcaSlicer.cpp had its "using namespace nlohmann;" and the json include inside the Linux-only include block, so on Windows and macOS it took json from AppConfig.hpp's global directive, which is gone. The include and a "using json = nlohmann::json;" now sit outside the block.
Stop Leaking json Through Headers and Drop Includes Kept Only for the Name
2026-10-07 07:41:06 +00:00 · 2026-10-07 02:45:49 +08:00 · 2026-10-07 01:39:17 +08:00 · 2026-10-06 11:41:25 -03:00 · 2026-10-06 11:36:47 -03:00 · 2026-10-06 10:34:28 -03:00
106 changed files with 881 additions and 2186 deletions
@@ -23,7 +23,6 @@
 #include <map>
 #include <vector>
 #include "libslic3r/PrintBase.hpp"
-#include "slic3r/Utils/json_diff.hpp"
 #include <boost/date_time/posix_time/posix_time_duration.hpp>
 #include <cerrno>
 #include <utility>
@@ -78,12 +77,10 @@
 #include <condition_variable>
 #include <mutex>
 #include <boost/thread.hpp>
-//add json logic
-#include "nlohmann/json.hpp"
-
-using namespace nlohmann;
 #endif

+#include "nlohmann/json.hpp"
+
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/nowide/args.hpp>
@@ -157,6 +154,7 @@ using namespace nlohmann;
 #include <stdio.h>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 #ifdef __WXGTK__
 #if __has_include(<X11/Xlib.h>)
@@ -3524,7 +3522,7 @@ int CLI::run(int argc, char **argv)
            ConfigOptionStrings *curr_variant_opt = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant");
            if (!curr_variant_opt) {
                curr_variant_opt = m_print_config.option<ConfigOptionStrings>("filament_extruder_variant", true);
-                std::vector<string>& filament_variants = curr_variant_opt->values;
+                std::vector<std::string>& filament_variants = curr_variant_opt->values;
                filament_variants.resize(filament_count, get_extruder_variant_string(etDirectDrive, nvtStandard));
            }
            const ConfigOptionStrings *new_variant_opt = dynamic_cast<const ConfigOptionStrings*>(config.option("filament_extruder_variant", true));
@@ -6554,7 +6552,7 @@ int CLI::run(int argc, char **argv)
                                                std::vector<int> result_filaments;
                                                //result_filaments.reserve(conflict_filaments.size());
                                                std::set_intersection(conflict_filament_vector.begin(), conflict_filament_vector.end(), unprintable_filament_vec[index].begin(),
-                                                    unprintable_filament_vec[index].end(), insert_iterator<vector<int>>(result_filaments, result_filaments.begin()));
+                                                    unprintable_filament_vec[index].end(), std::insert_iterator<std::vector<int>>(result_filaments, result_filaments.begin()));
                                                conflict_filament_vector = result_filaments;
                                            }
                                        }
@@ -15,8 +15,6 @@
 #include "libslic3r/Semver.hpp"
 #include "calib.hpp"

-using namespace nlohmann;
-
 #define ENV_DEV_HOST		"0"
 #define ENV_QAT_HOST		"1"
 #define ENV_PRE_HOST		"2"
@@ -352,6 +352,16 @@ 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;
@@ -759,6 +759,59 @@ 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
@@ -2546,44 +2599,90 @@ 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();

-            // Get top ExPolygons from current infill contour.
-            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, infill_contour_bbox);
-            } else
-                upper_slices_clipped = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*upper_slices, infill_contour_bbox);
+            // 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);

-            top_expolygons = diff_ex(infill_contour, upper_slices_clipped);
+            // Get top ExPolygons from the given contour. uncovered reports whether the upper layer leaves any of the
+            // 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, infill_contour_bbox);
-                    const ExPolygons current_slices_bridges = offset_ex(diff_ex(top_expolygons, lower_slices_clipped), bridge_offset);
+                    const Polygons   lower_slices_clipped   = ClipperUtils::clip_clipper_polygons_with_subject_bbox(*lower_slices, contour_bbox);
+                    const ExPolygons current_slices_bridges = offset_ex(diff_ex(top, lower_slices_clipped), bridge_offset);

                    // Remove bridges from top surface polygons.
-                    top_expolygons = diff_ex(top_expolygons, current_slices_bridges);
+                    top = diff_ex(top, 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_expolygons = offset2_ex(top_expolygons, -top_surface_min_width, top_surface_min_width + float(perimeter_width * 0.85));
+                top = offset2_ex(top, -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).
-                top_expolygons = intersection_ex(top_expolygons, infill_contour);
+                return intersection_ex(top, 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
@@ -2612,11 +2711,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 we call Arachne again with parameters
-                // like when the single perimeter feature is disabled.
-                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     = no_single_perimeter_tool_paths.getToolPaths();
-                infill_contour = union_ex(no_single_perimeter_tool_paths.getInnerContour());
+                // There is no top surface ExPolygon, so use the walls generated like when the single perimeter
+                // feature is disabled.
+                generate_full_perimeters();
+                perimeters     = std::move(full_perimeters);
+                infill_contour = union_ex(full_inner_contour);
            }
        }
        //PS
@@ -87,6 +87,7 @@
 #include "libslic3r/GCode/Thumbnails.hpp"

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 using boost::property_tree::ptree;

@@ -87,6 +87,8 @@
 // This breaks compatibility with the upstream Slic3r if the --datadir is used to switch between the two versions.
 //#define SLIC3R_PROFILE_USE_PRESETS_SUBDIR

+using json = nlohmann::json;
+
 namespace Slic3r {

 // Project-level options imported from a loaded 3MF into project_config. s_project_options_published
@@ -1580,7 +1580,7 @@ bool GLVolumeCollection::check_outside_state(const BuildVolume &build_volume, Mo
                    {
                        std::vector<int> result_filaments;
                        //result_filaments.reserve(conflict_filaments.size());
-                        std::set_intersection (conflict_filament_vector.begin(), conflict_filament_vector.end(), unprintable_filament_vec[index].begin(), unprintable_filament_vec[index].end(), insert_iterator<vector<int>>(result_filaments, result_filaments.begin()));
+                        std::set_intersection (conflict_filament_vector.begin(), conflict_filament_vector.end(), unprintable_filament_vec[index].begin(), unprintable_filament_vec[index].end(), std::insert_iterator<std::vector<int>>(result_filaments, result_filaments.begin()));
                        conflict_filament_vector = result_filaments;
                    }
                }
@@ -69,6 +69,7 @@
 #include <wx/dcmemory.h>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 namespace Slic3r { namespace GUI {

@@ -11,7 +11,7 @@
 #include "slic3r/GUI/Widgets/Button.hpp"
 #include "slic3r/GUI/Widgets/ComboBox.hpp"
 #include <string>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <wx/notebook.h>
 #include <wx/scrolwin.h>
 #include <wx/sizer.h>
@@ -246,7 +246,7 @@ public:
    void                                            create_folder(wxString name = wxEmptyString);
    std::string                                     replaceSpace(std::string s, std::string ts, std::string ns);
    void                                            on_import_file(wxCommandEvent &event);
-    void                                            Reload(wxString aux_path, std::map<std::string, std::vector<json>> paths);
+    void                                            Reload(wxString aux_path, std::map<std::string, std::vector<nlohmann::json>> paths);

    void update_all_panel();
    void update_all_cover();
@@ -26,7 +26,7 @@
 #include <memory>
 #include "slic3r/GUI/BBLStatusBarBind.hpp"
 #include "slic3r/GUI/Jobs/BindJob.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include "slic3r/GUI/Jobs/Worker.hpp"
 #include <utility>
@@ -54,6 +54,8 @@

 #include "DeviceCore/DevManager.h"

+using json = nlohmann::json;
+
 namespace Slic3r {
 namespace GUI {

@@ -25,7 +25,7 @@
 #include "slic3r/GUI/Widgets/RadioBox.hpp"
 #include <cstdio>
 #include <map>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <cstdlib>
 #include "slic3r/GUI/GUI_Utils.hpp"
 #include "slic3r/GUI/Widgets/Label.hpp"
@@ -91,6 +91,8 @@
 #define SELECT_ALL_OPTION_COLOUR wxColour("#009688")
 #define DEFAULT_PROMPT_TEXT_COLOUR wxColour("#ACACAC")

+using json = nlohmann::json;
+
 namespace Slic3r {
 namespace GUI {

@@ -1,10 +1,12 @@
 #include "DevAxis.h"
 #include "DevUtil.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/DeviceCore/DevDefs.h"

+using json = nlohmann::json;
+
 namespace Slic3r
 {

@@ -2,7 +2,6 @@
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <string>
-#include "slic3r/Utils/json_diff.hpp"

 namespace Slic3r {

@@ -22,7 +21,7 @@ public:
    bool IsArchCoreXY() const;

 public:
-    void ParseAxis(const json &print_json);
+    void ParseAxis(const nlohmann::json &print_json);

    int Ctrl_GoHome();
    int Ctrl_Axis(std::string axis, double unit = 1.0f, double input_val = 1.0f, int speed = 3000); // xyz e
@@ -1,11 +1,13 @@
 #include "DevAxis.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include <string>
 #include <cstdlib>
 #include <cstdio>

+using json = nlohmann::json;
+
 namespace Slic3r
 {

@@ -1,7 +1,9 @@
 #include "DevBed.h"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"

+using json = nlohmann::json;
+
 namespace Slic3r {

 void DevBed::ParseV1_0(const json &print_json, DevBed *system)
@@ -1,6 +1,5 @@
 #pragma once
 #include <nlohmann/json.hpp>
-#include "slic3r/Utils/json_diff.hpp"

 namespace Slic3r {

@@ -16,8 +15,8 @@ public:

 public:

-    static void ParseV1_0(const json &print_json, DevBed *system);
-    static void ParseV2_0(const json &print_json, DevBed *system);
+    static void ParseV1_0(const nlohmann::json &print_json, DevBed *system);
+    static void ParseV2_0(const nlohmann::json &print_json, DevBed *system);

 private:

@@ -1,6 +1,6 @@
 #include <algorithm>
 #include <boost/log/trivial.hpp>
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"
@@ -22,6 +22,8 @@
 #include "DevFilaSystem.h"
 #include "DevConfig.h"

+using json = nlohmann::json;
+
 namespace Slic3r {

 static float string_to_float(const std::string &str_value)
@@ -2,7 +2,6 @@
 #include <nlohmann/json.hpp>
 #include <optional>
 #include <vector>
-#include "slic3r/Utils/json_diff.hpp"


 #include "DevDefs.h"
@@ -86,11 +85,11 @@ public:
    std::vector<FlowRatioCalibResult>   GetFlowRatioResult() const {return m_flow_ratio_results; }

 protected:
-    void ExtrusionCalibSetParse(const json &jj);
-    void ExtrusionCalibSelectParse(const json &jj);
-    void ExtrusionCalibGetTableParse(const json &jj);
-    void ExtrusionCalibGetResultParse(const json &jj);
-    void FlowrateGetResultParse(const json &jj);
+    void ExtrusionCalibSetParse(const nlohmann::json &jj);
+    void ExtrusionCalibSelectParse(const nlohmann::json &jj);
+    void ExtrusionCalibGetTableParse(const nlohmann::json &jj);
+    void ExtrusionCalibGetResultParse(const nlohmann::json &jj);
+    void FlowrateGetResultParse(const nlohmann::json &jj);

 private:
    MachineObject* m_owner{nullptr};
@@ -119,11 +118,11 @@ private:
    bool                        m_calib_finished{false};

 public:
-    static void ParseCalibVersion(const json& j, DevCalib* system);
+    static void ParseCalibVersion(const nlohmann::json& j, DevCalib* system);

    static void ParseSupportNewAutoCalib(int flag, DevCalib* system);

-    static void ParseV1_0(const json& print_json, DevCalib* system, bool key_field_only);
+    static void ParseV1_0(const nlohmann::json& print_json, DevCalib* system, bool key_field_only);
 };

 } // namespace Slic3r
@@ -3,9 +3,11 @@
 #include "DevConfig.h"
 #include "DevUtil.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"

+using json = nlohmann::json;
+
 namespace Slic3r {

 bool DevChamber::HasChamber() const { return m_owner->GetConfig()->HasChamber(); }
@@ -1,7 +1,6 @@
 #pragma once
 #include <memory>
 #include <nlohmann/json.hpp>
-#include "slic3r/Utils/json_diff.hpp"

 namespace Slic3r {

@@ -25,10 +24,10 @@ public: // getter

 public:
    // setter
-    void ParseChamber(const json &print_json);
+    void ParseChamber(const nlohmann::json &print_json);

-    void ParseChamberV1_0(const json& print_json);
-    void ParseChamberV2_0(const json& print_json);
+    void ParseChamberV1_0(const nlohmann::json& print_json);
+    void ParseChamberV2_0(const nlohmann::json& print_json);

    // control
    int CtrlSetChamberTemp(int temp);
@@ -1,8 +1,10 @@
 #include "DevChamber.h"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include <string>

+using json = nlohmann::json;
+
 namespace Slic3r {

 int DevChamber::CtrlSetChamberTemp(int temp) 
@@ -2,7 +2,6 @@

 #include "DevConfig.h"
 #include "DevUtil.h"
-#include "json_diff.hpp"

 using namespace nlohmann;

@@ -1,7 +1,7 @@
 #pragma once
 #include "libslic3r/CommonDefs.hpp"

-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <wx/string.h>

 #include <limits>
@@ -47,11 +47,11 @@ public:

 public:
    /*Setters*/
-    void ParseConfig(const json& print_json);
+    void ParseConfig(const nlohmann::json& print_json);

-    void ParseChamberConfig(const json& print_json); // chamber
-    void ParsePrintOptionsConfig(const json& print_json); // print options
-    void ParseCalibrationConfig(const json& print_json); //cali
+    void ParseChamberConfig(const nlohmann::json& print_json); // chamber
+    void ParsePrintOptionsConfig(const nlohmann::json& print_json); // print options
+    void ParseCalibrationConfig(const nlohmann::json& print_json); //cali

 private:
    [[maybe_unused]] MachineObject* m_obj;
@@ -1,6 +1,6 @@
 #include "DevConfigUtil.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"

 #include <string>
@@ -4,7 +4,6 @@
 #include "DevCtrl.h"

 // TODO: remove this include
-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"

 using namespace nlohmann;
@@ -1,6 +1,6 @@
 #pragma once

-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <string>
 #include <ctime>
 #include <wx/string.h>
@@ -15,7 +15,7 @@ class DevCtrlInfo
 {
 public:
    DevCtrlInfo() {};
-    DevCtrlInfo(MachineObject* obj, int sequence_id, const json& req_json, int interval_max = 3, int interval_min = 0);
+    DevCtrlInfo(MachineObject* obj, int sequence_id, const nlohmann::json& req_json, int interval_max = 3, int interval_min = 0);

 public:
    bool CheckCanUpdateData(const nlohmann::json& jj);
@@ -32,7 +32,7 @@ private:

    time_t m_request_time = 0;
    int    m_request_seq = 0;
-    json   m_request_json = json();
+    nlohmann::json   m_request_json = nlohmann::json();

    // check
    int m_request_interval_max = 3;
@@ -163,8 +163,8 @@ public:
    ~devPrinterUtil() = delete;

 public:
-    static bool IsVirtualSlot(int ams_id);
-    static bool IsVirtualSlot(const std::string& ams_id);
+    static bool IsVirtualSlot(int ams_id) { return (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID);}
+    static bool IsVirtualSlot(const std::string& ams_id) { return (ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR); }
 };

 namespace GUI
@@ -200,4 +200,4 @@ template<> struct std::hash<NozzleDef>
 };

 // key(extruder_id) -> { key1(nozzle type info), val1( number of the nozzle type)}
-using ExtruderNozzleInfos = std::unordered_map<int, std::unordered_map<NozzleDef, int>>;
+using ExtruderNozzleInfos = std::unordered_map<int, std::unordered_map<NozzleDef, int>>;
@@ -3,7 +3,7 @@
 #include <optional>
 #include "libslic3r/CommonDefs.hpp"

-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <wx/string.h>

 #include "DevDefs.h"
@@ -15,7 +15,6 @@
 #include "DevFilaSystem.h" // complete type for GetFilaSystem()->GetTrayIndexMap() in GetBackupAmsSlotInGroup

 // TODO: remove this include
-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/I18N.hpp"

@@ -5,7 +5,7 @@
 #include <unordered_map>
 #include "libslic3r/CommonDefs.hpp"

-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <vector>
 #include <wx/string.h>

@@ -6,7 +6,6 @@
 #include <string>
 #include <vector>
 #include <wx/app.h>
-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"
 using namespace nlohmann;

@@ -2,7 +2,6 @@
 #include <functional>
 #include <cstdint>
 #include <nlohmann/json.hpp>
-#include "slic3r/Utils/json_diff.hpp"

 #include <map>
 #include <vector>
@@ -13,7 +12,7 @@ namespace Slic3r {
 class MachineObject;

 enum AirDuctType { AIR_FAN_TYPE, AIR_DOOR_TYPE };
-typedef std::function<void(const json &)> CommandCallBack;
+typedef std::function<void(const nlohmann::json &)> CommandCallBack;

 enum AIR_FUN : int {
    FAN_HEAT_BREAK_0_IDX      = 0,
@@ -123,14 +122,14 @@ public:
     AirDuctData GetAirDuctData() { return m_air_duct_data; };

     void converse_to_duct(bool is_suppt_part_fun, bool is_suppt_aux_fun, bool is_suppt_cham_fun); // Convert the data to duct type to make the newand old protocols consistent
-     int  command_handle_response(const json &response);
+     int  command_handle_response(const nlohmann::json &response);
     int  command_control_fan(int fan_type, int val);                              // Old protocol
     int  command_control_fan_new(int fan_id, int val); // New protocol
     int  command_control_air_duct(int mode_id, int submode, const CommandCallBack& cb);

-     void ParseV1_0(const json &print_json);
-     void ParseV2_0(const json &print_json);
-     void ParseV3_0(const json &print_json);
+     void ParseV1_0(const nlohmann::json &print_json);
+     void ParseV2_0(const nlohmann::json &print_json);
+     void ParseV3_0(const nlohmann::json &print_json);

 public:
     bool     GetSupportAirduct() { return is_support_airduct; };
@@ -1,11 +1,13 @@
 #include "DevFilaAmsSetting.h"
 #include "DevFilaSystem.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include <string>
 #include "slic3r/GUI/DeviceCore/DevCtrl.h"

+using json = nlohmann::json;
+
 namespace Slic3r {
    int DevAmsSystemFirmwareSwitch::CrtlSwitchFirmware(int firmware_idx)
    {
@@ -14,7 +14,6 @@
 #include "slic3r/GUI/DeviceCore/DevDefs.h"

 #include "DevFilaBlackList.h"
-#include "json_diff.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "DevFilaSystem.h"
@@ -5,7 +5,7 @@
 #include <string>
 #include <vector>
 #include <wx/string.h>
-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>

 namespace Slic3r
 {
@@ -67,7 +67,7 @@ public:
    static CheckResult check_filaments_in_blacklist(const CheckFilamentInfo& info);

 public:
-    static json filaments_blacklist;
+    static nlohmann::json filaments_blacklist;
 };// class DevFilaBlacklist

 }// namespace Slic3r
@@ -8,7 +8,6 @@
 #include <cstdlib>
 #include <chrono>
 #include <nlohmann/json.hpp>
-#include <wx/app.h>
 #include <wx/colour.h>
 #include <string>
 #include <wx/string.h>
@@ -19,7 +18,6 @@
 #include <set>
 #include <utility>
 #include "DevFilaSystem.h"
-#include "json_diff.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include "DevNozzleSystem.h" // DevNozzle / DevNozzleSystem for GetNozzleFlowStringByAmsId

@@ -35,25 +33,6 @@
 using namespace nlohmann;

 namespace Slic3r {
-
-bool devPrinterUtil::IsVirtualSlot(int ams_id)
-{
-    if (wxTheApp == nullptr || GUI::wxGetApp().preset_bundle == nullptr || GUI::wxGetApp().preset_bundle->is_bbl_vendor())
-        return ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID;
-
-    const int extruder_count = GUI::wxGetApp().preset_bundle->get_printer_extruder_count();
-    return ams_id >= VIRTUAL_TRAY_MAIN_ID - extruder_count + 1 && ams_id <= VIRTUAL_TRAY_MAIN_ID;
-}
-
-bool devPrinterUtil::IsVirtualSlot(const std::string& ams_id)
-{
-    try {
-        return IsVirtualSlot(std::stoi(ams_id));
-    } catch (...) {
-        return false;
-    }
-}
-
 static int _hex_digit_to_int(const char c) { return (c >= '0' && c <= '9') ? c - '0' : (c >= 'A' && c <= 'F') ? c - 'A' + 10 : (c >= 'a' && c <= 'f') ? c - 'a' + 10 : -1; }

 wxColour DevAmsTray::decode_color(const std::string &color)
@@ -232,7 +211,7 @@ int DevAms::GetSlotCount() const
        return 1;
    }

-    return static_cast<int>(m_trays.size());
+    return 1;
 }

 DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
@@ -323,21 +302,13 @@ int DevFilaSystem::GetExtruderIdByAmsId(const std::string& ams_id) const
    {
        return it->second->GetExtruderId();
    }
-
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (!is_bbl_vendor && GetOwner()) {
-        for (const auto& tray : GetOwner()->vt_slot) {
-            if (tray.id == ams_id)
-                return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
-        }
-    }
-
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_MAIN_ID_STR)
+    else if (stoi(ams_id) == VIRTUAL_TRAY_MAIN_ID)
+    {
        return MAIN_EXTRUDER_ID;
-    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_DEPUTY_ID_STR)
+    }
+    else if (stoi(ams_id) == VIRTUAL_TRAY_DEPUTY_ID)
+    {
        return DEPUTY_EXTRUDER_ID;
-    if (!is_bbl_vendor && devPrinterUtil::IsVirtualSlot(ams_id)) {
-        return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
    }

    assert(false && __FUNCTION__);
@@ -354,22 +325,9 @@ std::string DevFilaSystem::GetNozzleFlowStringByAmsId(const std::string& ams_id)
 std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
 {
    std::map<int, DevAmsSlotId> tray_id_map;
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor) {
-        tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
-        tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
-    } else if (GetOwner()) {
-        for (const auto& tray : GetOwner()->vt_slot) {
-            try {
-                const int tray_id = std::stoi(tray.id);
-                tray_id_map[tray_id] = DevAmsSlotId{tray_id, 0};
-            } catch (...) {
-                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " invalid virtual tray id: " << tray.id;
-            }
-        }
-    }
+    tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
+    tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};

-    int generic_tray_index = 0;
    for (auto& [ams_id, ams_item] : GetAmsList()) {
        for (auto &[slot_id, slot_item] : ams_item->GetTrays()) {
            if (ams_item && slot_item) {
@@ -377,11 +335,9 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                    int ams_id_int  = stoi(ams_id);
                    int slot_id_int = stoi(slot_id);
                    int tray_index  = -1;
-                    if (!is_bbl_vendor) {
-                        tray_index = generic_tray_index + slot_id_int;
-                    } else if (ams_item->GetAmsType() == DevAms::N3S) {
+                    if (ams_item->GetAmsType() == DevAms::N3S) {
                        tray_index = ams_id_int;
-                    } else if (ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
+                    } else if(ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
                        tray_index = 24 + slot_id_int;
                    } else {
                        tray_index = (ams_id_int * 4 + slot_id_int);
@@ -392,8 +348,6 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                }
            }
        }
-        if (!is_bbl_vendor)
-            generic_tray_index += static_cast<int>(ams_item->GetTrays().size());
    }

    return  tray_id_map;
@@ -959,8 +913,6 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            }

            ams->m_exist               = true;
-            ams->m_binded_extruder_set = {ext_id};
-            ams->m_binded_switcher_pos.reset();
            ams->m_current_temperature = u.value("temperature", (float) INVALID_AMS_TEMPERATURE);
            ams->m_humidity_percent    = u.value("humidity_percent", -1);
            ams->m_left_dry_time       = u.value("dry_time_min", 0);
@@ -1043,22 +995,16 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
    }

    // --- external / direct spools -> obj->vt_slot ---
-    // Keep one virtual slot per extruder. The legacy two-extruder mapping uses
-    // 255 for extruder 0 and 254 for extruder 1; continue that sequence for
-    // additional extruders (253, 252, ...).
+    // extruder 0 -> main virtual slot, extruder >0 -> deputy.
    if (obj && data.contains("external") && data["external"].is_array())
    {
-        std::map<int, DevAmsTray> external_slots;
        obj->vt_slot.clear();
        for (const auto& e : data["external"])
        {
            if (!e.is_object())
                continue;
            const int  ext   = e.value("extruder", MAIN_EXTRUDER_ID);
-            if (ext < MAIN_EXTRUDER_ID || ext > VIRTUAL_TRAY_MAIN_ID)
-                continue;
-
-            const int  vt_id = VIRTUAL_TRAY_MAIN_ID - ext;
+            const int  vt_id = (ext == MAIN_EXTRUDER_ID) ? VIRTUAL_TRAY_MAIN_ID : VIRTUAL_TRAY_DEPUTY_ID;
            DevAmsTray tray(std::to_string(vt_id));
            tray.is_exists       = e.value("loaded", false);
            tray.m_fila_type     = e.value("material", std::string());
@@ -1067,11 +1013,8 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            tray.nozzle_temp_min = std::to_string(e.value("nozzle_temp_min", 0));
            tray.nozzle_temp_max = std::to_string(e.value("nozzle_temp_max", 0));
            tray.remain          = e.value("remain_percent", -1);
-            external_slots.insert_or_assign(ext, std::move(tray));
+            obj->vt_slot.push_back(tray);
        }
-
-        for (auto& entry : external_slots)
-            obj->vt_slot.push_back(std::move(entry.second));
    }
 }

@@ -1,6 +1,6 @@
 #pragma once
 #include "libslic3r/CommonDefs.hpp"
-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>

 #include "DevDefs.h"
 #include "DevFilaAmsSetting.h"
@@ -349,7 +349,7 @@ public:
    DevAmsTray* GetAmsTray(const std::string& ams_id, const std::string& tray_id) const;
    void        CollectAmsColors(std::vector<wxColour>& ams_colors) const;

-    // Map a linear tray index -> {ams_id, slot_id}. Includes virtual external-spool trays,
+    // Map a linear tray index -> {ams_id, slot_id}. Includes the two virtual (external-spool) trays,
    // N3S single-slot units, and the A2L/N9 AMS-Lite-mixed layout (trays 24-27).
    std::map<int, DevAmsSlotId> GetTrayIndexMap();

@@ -415,9 +415,9 @@ private:
 class DevFilaSystemParser
 {
 public:
-    static void ParseV1_0(const json& print_json, MachineObject* obj, DevFilaSystem* system, bool key_field_only);
+    static void ParseV1_0(const nlohmann::json& print_json, MachineObject* obj, DevFilaSystem* system, bool key_field_only);

-    static void ParseAgentFilament(const json& data, MachineObject* obj, DevFilaSystem* system);
+    static void ParseAgentFilament(const nlohmann::json& data, MachineObject* obj, DevFilaSystem* system);
 };

 struct DevFilamentDryingPreset
@@ -434,4 +434,4 @@ struct DevFilamentDryingPreset
    float filament_dev_ams_drying_heat_distortion_temperature = 0.0f;
 };

-}// namespace Slic3r
+}// namespace Slic3r
@@ -2,7 +2,6 @@
 #include <string>
 #include "DevFilaSystem.h"

-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"// TODO: remove this include

 using namespace nlohmann;
@@ -1,11 +1,9 @@
 #pragma once
 #include "DevFirmware.h"
-#include "slic3r/Utils/json_diff.hpp"

 #include <nlohmann/json.hpp>
 #include <string>
 #include <wx/string.h>
-#include "slic3r/Utils/json_diff.hpp"

 namespace Slic3r {

@@ -51,10 +49,10 @@ public:
    bool isCuttingModule() const { return product_name.Contains("Cutting Module"); }
    bool isRotary() const { return product_name.Contains("Rotary"); }// Rotary Attachment
    bool isExtinguishSystem() const { return product_name.Contains("Extinguishing System"); }// Auto Fire Extinguishing System
-    bool isWTM() const { return name.find("wtm") != string::npos; } // nozzle
+    bool isWTM() const { return name.find("wtm") != std::string::npos; } // nozzle
    bool isExhaustFan() const { return product_name.Contains("Exhaust Fan"); }
-    bool isHmshub() const { return product_name.find("Filament Buffer") != string::npos; }
-    bool isFilaTrackSwitch() const { return product_name.find("Filament Track") != string::npos; }
+    bool isHmshub() const { return product_name.find("Filament Buffer") != std::string::npos; }
+    bool isFilaTrackSwitch() const { return product_name.find("Filament Track") != std::string::npos; }

 };

@@ -2,10 +2,12 @@
 #include "DevHMS.h"
 #include <string>
 #include <cstdio>
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <exception>
 #include <cassert>

+using json = nlohmann::json;
+
 namespace Slic3r
 {

@@ -1,6 +1,6 @@
 #pragma once

-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <vector>
 #include <string>
 #include <wx/string.h>
@@ -18,7 +18,7 @@ public:
    DevHMS(MachineObject* obj) : m_object(obj) {}

 public:
-    void                           ParseHMSItems(const json& hms_json);
+    void                           ParseHMSItems(const nlohmann::json& hms_json);
    const std::vector<DevHMSItem>& GetHMSItems() const { return m_hms_list; };

 private:
@@ -69,7 +69,7 @@ public:
    bool has_read() const { return m_already_read; };

 protected:
-    friend void DevHMS::ParseHMSItems(const json& hms_json);
+    friend void DevHMS::ParseHMSItems(const nlohmann::json& hms_json);
    bool parse_hms_info(unsigned attr, unsigned code);

 private:
@@ -3,7 +3,6 @@
 #include "DevLamp.h"

 // TODO: remove this include
-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"

 using namespace nlohmann;
@@ -23,7 +23,6 @@
 #include "DevUtil.h"

 // TODO: remove this include
-#include "json_diff.hpp"
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
@@ -3,7 +3,6 @@
 #include <mutex>
 #include "libslic3r/CommonDefs.hpp"

-#include "slic3r/Utils/json_diff.hpp"
 #include <string>
 #include <vector>
 #include <wx/object.h>
@@ -6,7 +6,6 @@
 #include "DevUtil.h"
 #include "DevUtilBackend.h"

-#include "json_diff.hpp"
 #include "libslic3r/MultiNozzleUtils.hpp"

 #include "slic3r/GUI/DeviceManager.hpp"
@@ -1,7 +1,7 @@
 #pragma once
 #include "libslic3r/CommonDefs.hpp"
 #include "libslic3r/MultiNozzleUtils.hpp"
-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>

 #include "DevNozzleSystem.h"
 #include "DevFirmware.h"
@@ -1,7 +1,7 @@
 #include "DevNozzleRack.h"
 #include "DevExtruderSystem.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/MsgDialog.hpp"
 #include "slic3r/GUI/I18N.hpp"
@@ -14,6 +14,8 @@
 #include "slic3r/GUI/DeviceCore/DevNozzleSystem.h"


+using json = nlohmann::json;
+
 namespace Slic3r
 {

@@ -4,7 +4,7 @@
 #include "DevNozzleSystem.h"
 #include "DevUtil.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/I18N.hpp"

@@ -27,7 +27,8 @@
 #include <unordered_map>
 #include <optional>
 #include <cmath>
-#include "slic3r/GUI/GUI_App.hpp"
+
+using json = nlohmann::json;

 namespace Slic3r
 {
@@ -175,48 +176,34 @@ DevFirmwareVersionInfo DevNozzle::GetFirmwareInfo() const
 int DevNozzle::GetLogicExtruderId() const
 {
    int total_ext_count = GetTotalExtruderCount();
-
-    if (GUI::wxGetApp().preset_bundle->is_bbl_vendor()) {
-        if (total_ext_count == 1) {
-            return LOGIC_UNIQUE_EXTRUDER_ID;
-        } else if (total_ext_count == 2) {
-            if (AtLeftExtruder()) {
-                return LOGIC_L_EXTRUDER_ID;
-            } else if (AtRightExtruder()) {
-                return LOGIC_R_EXTRUDER_ID;
-            }
-        }
-
-        assert(0);
+    if (total_ext_count == 1) {
        return LOGIC_UNIQUE_EXTRUDER_ID;
+    } else if (total_ext_count == 2) {
+        if (AtLeftExtruder()) {
+            return LOGIC_L_EXTRUDER_ID;
+        } else if (AtRightExtruder()) {
+            return LOGIC_R_EXTRUDER_ID;
+        }
    }

-    // For some reason, BBL's logical extruder ID is inverted:
-    // physical extruder id = 0 (MAIN_EXTRUDER_ID) vs logical extruder id = 1 (LOGIC_R_EXTRUDER_ID)
-    // Likely because logical id reads from left to right (left = 0, right = 1)
-    // For generic N extruders, this inversion does not apply.
-    if (IsOnRack()) return INVALID_EXTRUDER_ID;
-    return m_nozzle_id;
+    assert(0);
+    return LOGIC_UNIQUE_EXTRUDER_ID;
 }

 int DevNozzle::GetExtruderId() const
 {
-    if (GUI::wxGetApp().preset_bundle->is_bbl_vendor()) {
-        int total_ext_count = GetTotalExtruderCount();
-        if (total_ext_count == 1) {
-            return MAIN_EXTRUDER_ID;
-        } else if (total_ext_count == 2) {
-            if (AtRightExtruder()) {
-                return MAIN_EXTRUDER_ID;
-            } else if (AtLeftExtruder()) {
-                return DEPUTY_EXTRUDER_ID;
-            }
-        }
-    
+    int total_ext_count = GetTotalExtruderCount();
+    if (total_ext_count == 1) {
        return MAIN_EXTRUDER_ID;
+    } else if (total_ext_count == 2) {
+        if (AtRightExtruder()) {
+            return MAIN_EXTRUDER_ID;
+        } else if (AtLeftExtruder()) {
+            return DEPUTY_EXTRUDER_ID;
+        }
    }

-    return m_nozzle_id;
+    return MAIN_EXTRUDER_ID;
 }

 bool DevNozzle::AtLeftExtruder() const
@@ -4,7 +4,7 @@

 #include "libslic3r/CommonDefs.hpp"
 #include "libslic3r/MultiNozzleUtils.hpp"
-#include "slic3r/Utils/json_diff.hpp"
+#include <nlohmann/json.hpp>

 #include "libslic3r/PrintConfig.hpp"
 #include <string>
@@ -195,6 +195,6 @@ namespace Slic3r
   {
   public:
       static void  ParseV1_0(const nlohmann::json& nozzletype_json, const nlohmann::json& diameter_json, DevNozzleSystem* system, std::optional<int> flag_e3d);
-       static void  ParseV2_0(const json& device_json, DevNozzleSystem* system);
+       static void  ParseV2_0(const nlohmann::json& device_json, DevNozzleSystem* system);
   };
 };
@@ -8,9 +8,11 @@
 #include <ctime>
 #include <exception>

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"

+using json = nlohmann::json;
+
 namespace Slic3r
 {

@@ -1,8 +1,10 @@
 #include "DevStorage.h"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include <string>


+using json = nlohmann::json;
+
 namespace Slic3r {

 DevStorage::SdcardState Slic3r::DevStorage::set_sdcard_state(int state)
@@ -1,7 +1,6 @@
 #pragma once
 #include <nlohmann/json.hpp>
 #include <string>
-#include "slic3r/Utils/json_diff.hpp"

 namespace Slic3r {

@@ -27,7 +26,7 @@ public:
    SdcardState get_sdcard_state() const { return  m_sdcard_state; };
    SdcardState set_sdcard_state(int state);

-    static void ParseV1_0(const json &print_json, DevStorage *system);
+    static void ParseV1_0(const nlohmann::json &print_json, DevStorage *system);

    bool is_timelapse_storage_low(const std::string& storage) const;

@@ -1,7 +1,7 @@
 #include "DevUpgrade.h"
 #include "DevUtil.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"

 #include "slic3r/GUI/GUI_App.hpp"
@@ -13,6 +13,8 @@
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include <wx/string.h>

+using json = nlohmann::json;
+
 namespace Slic3r {

 int DevUpgrade::GetUpgradeProgressInt() const
@@ -4,7 +4,6 @@
 #include <nlohmann/json.hpp>
 #include <string>
 #include <wx/string.h>
-#include "slic3r/Utils/json_diff.hpp"

 #include "DevDefs.h"
 #include "DevFirmware.h"
@@ -47,8 +46,8 @@ public:
    int CtrlUpgradeModule(std::string url, std::string module_type, std::string version);

    // parser
-    void ParseUpgrade_V1_0(const json &print_jj);
-    void ParseUpgradeDisplayState(const json &upgrade_state_jj);
+    void ParseUpgrade_V1_0(const nlohmann::json &print_jj);
+    void ParseUpgradeDisplayState(const nlohmann::json &upgrade_state_jj);

 protected:
    DevUpgrade(MachineObject *owner) : m_owner(owner) {}
@@ -90,7 +89,7 @@ public:
 public:
    int CtrlGetVersion(bool with_retry = true);

-    void ParseGetVersion(const json &print_jj);
+    void ParseGetVersion(const nlohmann::json &print_jj);

 private:
    MachineObject *m_owner;
@@ -1,10 +1,12 @@
 #include "DevUpgrade.h"

-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/DeviceManager.hpp"
 #include <string>
 #include "slic3r/GUI/DeviceCore/DevFirmware.h"

+using json = nlohmann::json;
+
 namespace Slic3r {

 int DevUpgrade::CtrlUpgradeConfirm()
@@ -1,5 +1,5 @@
 #include "PrinterNetworkTypes.hpp"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "DeviceManager.hpp"
 #include "HMS.hpp"
 #include "I18N.hpp"
@@ -65,7 +65,6 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-#include <wx/app.h>
 #include <wx/colour.h>
 #include <tuple>
 #include <wx/dir.h>
@@ -106,6 +105,8 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/Jobs/SendJob.hpp"

+using json = nlohmann::json;
+
 class wxWindow;

 namespace fs = boost::filesystem;
@@ -1274,24 +1275,19 @@ int MachineObject::get_bed_temperature_limit()

 bool MachineObject::is_filament_installed()
 {
-    // if (m_extder_system->GetTotalExtderCount() > 0) {
-    //     // right//or single
-    //     auto ext = m_extder_system->m_extders[MAIN_EXTRUDER_ID];
-    //     if (ext.m_ext_has_filament) {
-    //         return true;
-    //     }
-    // }
-    // /*left*/
-    // if (m_extder_system->GetTotalExtderCount() > 1) {
-    //     auto ext = m_extder_system->m_extders[DEPUTY_EXTRUDER_ID];
-    //     if (ext.m_ext_has_filament) {
-    //         return true;
-    //     }
-    // }
-
-    for (auto& ext : m_extder_system->m_extders) {
-        if (ext.m_ext_has_filament)
+    if (m_extder_system->GetTotalExtderCount() > 0) {
+        // right//or single
+        auto ext = m_extder_system->m_extders[MAIN_EXTRUDER_ID];
+        if (ext.m_ext_has_filament) {
            return true;
+        }
+    }
+    /*left*/
+    if (m_extder_system->GetTotalExtderCount() > 1) {
+        auto ext = m_extder_system->m_extders[DEPUTY_EXTRUDER_ID];
+        if (ext.m_ext_has_filament) {
+            return true;
+        }
    }
    return false;
 }
@@ -5268,17 +5264,16 @@ DevAmsTray MachineObject::parse_vt_tray(json vtray)

 bool MachineObject::contains_tray(const std::string &ams_id, const std::string &tray_id) const
 {
-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor && ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR)
-        return m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {

-    if (!is_bbl_vendor || ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR) {
+        return m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    } else {
        for (const auto& tray : vt_slot) {
-            if (tray.id == ams_id) return true;
+            if (tray.id == ams_id) { return true; }
        }
    }

-    return !is_bbl_vendor && m_fila_system->GetAmsTray(ams_id, tray_id) != nullptr;
+    return false;
 }

 DevAmsTray MachineObject::get_tray(const std::string &ams_id, const std::string &tray_id) const
@@ -5288,19 +5283,13 @@ DevAmsTray MachineObject::get_tray(const std::string &ams_id, const std::string
        return DevAmsTray(tray_id);
    }

-    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
-    if (is_bbl_vendor && ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
+    if (ams_id != VIRTUAL_AMS_MAIN_ID_STR && ams_id != VIRTUAL_AMS_DEPUTY_ID_STR) {
        auto tray = m_fila_system->GetAmsTray(ams_id, tray_id);
-        if (tray) return *tray;
+        if (tray) { return *tray;};
    }
-    else if (!is_bbl_vendor || ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR) {
+    else {
        for (const auto &tray : vt_slot) {
-            if (tray.id == ams_id) return tray;
-        }
-
-        if (!is_bbl_vendor) {
-            auto tray = m_fila_system->GetAmsTray(ams_id, tray_id);
-            if (tray) return *tray;
+            if (tray.id == ams_id) { return tray; }
        }
    }

@@ -63,7 +63,6 @@
 #define END_SEQ_ID              30000
 #define SUBSCRIBE_RETRY_COUNT   5

-using namespace nlohmann;
 namespace Slic3r {

 namespace GUI
@@ -467,7 +466,7 @@ public:
    std::string get_print_error_str() const { return MachineObject::get_error_code_str(this->print_error); }

    std::unordered_set<GUI::DeviceErrorDialog*> m_command_error_code_dlgs;
-    void  add_command_error_code_dlg(int command_err, json action_json=json{});
+    void  add_command_error_code_dlg(int command_err, nlohmann::json action_json=nlohmann::json{});

    int     curr_layer = 0;
    int     total_layers = 0;
@@ -759,9 +758,9 @@ public:
    int command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter);
    int command_get_access_code();
    int command_start_camera();
-    int command_ack_proceed(json& proceed);
+    int command_ack_proceed(nlohmann::json& proceed);
    int command_purification_disable();
-    int command_dont_remind_next_time(json& mqtt_guard_json);
+    int command_dont_remind_next_time(nlohmann::json& mqtt_guard_json);

    /* command upgrade */
    int command_upgrade_confirm();
@@ -887,7 +886,7 @@ public:
    static bool is_in_printing_status(std::string status);

    void set_print_state(std::string status);
-    void update_print_progress(const json& value);
+    void update_print_progress(const nlohmann::json& value);

    bool is_connected();
    bool is_connecting();
@@ -903,7 +902,7 @@ public:

    /* Msg for display MsgFn */
    typedef std::function<void(std::string topic, std::string payload)> MsgFn;
-    int publish_json(const json& json_item, int qos = 0, int flag = 0) ;
+    int publish_json(const nlohmann::json& json_item, int qos = 0, int flag = 0) ;
    int publish_json(const std::string& json_str, int qos = 0, int flag = 0) = delete;
    int cloud_publish_json(std::string json_str, int qos = 0, int flag = 0);
    int local_publish_json(std::string json_str, int qos = 0, int flag = 0);
@@ -947,16 +946,16 @@ public:
     * or scenarios where users want to bypass the AMS.
     */
    std::vector<DevAmsTray> vt_slot;
-    DevAmsTray parse_vt_tray(json vtray);
+    DevAmsTray parse_vt_tray(nlohmann::json vtray);

    /*get ams slot info*/
    bool    contains_tray(const std::string &ams_id, const std::string &tray_id) const;
    DevAmsTray get_tray(const std::string &ams_id, const std::string &tray_id) const;/*use contains_tray() check first*/

    /*for parse new info*/
-    bool check_enable_np(const json& print) const;
-    void parse_new_info(json print);
-    void parse_new_info2(const json& info);
+    bool check_enable_np(const nlohmann::json& print) const;
+    void parse_new_info(nlohmann::json print);
+    void parse_new_info2(const nlohmann::json& info);
    int  get_flag_bits(std::string str, int start, int count = 1) const;
    uint32_t get_flag_bits_no_border(std::string str, int start_idx, int count = 1) const;
    int get_flag_bits(int num, int start, int count = 1, int base = 10) const;
@@ -67,7 +67,7 @@ public:

    void on_script_message(const nlohmann::json& payload) override;
    void OnRequestPresets();
-    void OnExportData(const wxString& path, const wxString& name, json data);
+    void OnExportData(const wxString& path, const wxString& name, nlohmann::json data);

 protected:
    bool m_seq_top_layer_only_changed{false};
@@ -2816,7 +2816,7 @@ void GCodeViewer::render_all_plates_stats(const std::vector<const GCodeProcessor
        }
        return ret;
    };
-    auto calculate_offsets = [max_width, window_padding](const std::vector<std::pair<std::string, std::vector<::string>>>& title_columns, float extra_size = 0.0f) {
+    auto calculate_offsets = [max_width, window_padding](const std::vector<std::pair<std::string, std::vector<std::string>>>& title_columns, float extra_size = 0.0f) {
        const ImGuiStyle& style = ImGui::GetStyle();
        std::vector<float> offsets;
        offsets.push_back(max_width(title_columns[0].second, title_columns[0].first, extra_size) + 3.0f * style.ItemSpacing.x + style.WindowPadding.x);
@@ -2963,7 +2963,7 @@ void GCodeViewer::render_all_plates_stats(const std::vector<const GCodeProcessor
        }
        ::sprintf(buff, "%.2f", longest_str);

-        std::vector<std::pair<std::string, std::vector<::string>>> title_columns;
+        std::vector<std::pair<std::string, std::vector<std::string>>> title_columns;
        if (displayed_columns & ColumnData::Model) {
            title_columns.push_back({ _u8L("Filament"), {""} });
            title_columns.push_back({ _u8L("Model"), {buff} });
@@ -3184,7 +3184,7 @@ void GCodeViewer::render_legend_color_arr_recommen(float window_padding)
    float ams_item_height = 0;
    float filament_group_item_align_width = 0;
    {
-        float three_words_width    = imgui.calc_text_size("ABC"sv).x;
+        float three_words_width    = imgui.calc_text_size(std::string_view("ABC")).x;
        const int line_capacity = 4;

        for (const auto& extruder_filaments : {m_left_extruder_filament,m_right_extruder_filament })
@@ -3195,8 +3195,8 @@ void GCodeViewer::render_legend_color_arr_recommen(float window_padding)
                for (int j = idx; j < extruder_filaments.size() && j < idx + line_capacity; ++j) {
                    auto text_info = imgui.calculate_filament_group_text_size(get_filament_display_type(extruder_filaments[j]));
                    auto text_size = std::get<0>(text_info);
-                    filament_group_item_align_width = max(filament_group_item_align_width, text_size.x);
-                    text_line_height = max(text_line_height, text_size.y);
+                    filament_group_item_align_width = std::max(filament_group_item_align_width, text_size.x);
+                    text_line_height = std::max(text_line_height, text_size.y);
                }
                container_height += (three_words_width * 1.3f + text_line_height );
            }
@@ -3589,7 +3589,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
        return ret;
    };

-    auto calculate_offsets = [max_width, this](const std::vector<std::pair<std::string, std::vector<::string>>>& title_columns, float extra_size = 0.0f) {
+    auto calculate_offsets = [max_width, this](const std::vector<std::pair<std::string, std::vector<std::string>>>& title_columns, float extra_size = 0.0f) {
            const ImGuiStyle& style = ImGui::GetStyle();
            std::vector<float> offsets;
            // ORCA increase spacing for more readable format. Using direct number requires much less code change in here. GetTextLineHeight for additional spacing for icon_size
@@ -4014,7 +4014,7 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
        total_filaments.push_back(buffer);


-        std::vector<std::pair<std::string, std::vector<::string>>> title_columns;
+        std::vector<std::pair<std::string, std::vector<std::string>>> title_columns;
        if (displayed_columns & ColumnData::Model) {
            title_columns.push_back({ _u8L("Filament"), {""} });
            title_columns.push_back({ _u8L("Model"), total_filaments });
@@ -7970,9 +7970,16 @@ 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());
@@ -311,6 +311,7 @@ typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS2)(

 using namespace std::literals;
 namespace pt = boost::property_tree;
+using json = nlohmann::json;

 struct StaticBambuLib
 {
@@ -3651,7 +3651,7 @@ void GLGizmoCut3D::perform_cut(const Selection& selection)
                        // model_name     failing reason
                        std::vector<std::pair<std::string, std::string>> failed_models;
                        auto                                             plater = wxGetApp().plater();
-                        auto fix_and_update_progress = [keep_painting](ModelObject *model_object, const int vol_idx, const string &model_name, ProgressDialog &progress_dlg,
+                        auto fix_and_update_progress = [keep_painting](ModelObject *model_object, const int vol_idx, const std::string &model_name, ProgressDialog &progress_dlg,
                                                                      std::vector<std::string> &succes_models, std::vector<std::pair<std::string, std::string>> &failed_models) {
                            wxString msg = _L("Repairing model object");
                            msg += ": " + from_u8(model_name) + "\n";
@@ -6,7 +6,7 @@
 #include "DeviceCore/DevManager.h"
 #include "DeviceCore/DevUtil.h"
 #include "Http.hpp"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "libslic3r/AppConfig.hpp"

 #include <boost/filesystem/operations.hpp>
@@ -26,6 +26,7 @@
 #include <ctime>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 static const char* HMS_PATH = "hms";
 static const char* HMS_LOCAL_IMG_PATH = "hms/local_image";
@@ -1405,7 +1405,7 @@ void IMSlider::render_input_custom_gcode(std::string custom_gcode)
 }

 void IMSlider::do_go_to_layer(size_t layer_number) {
-    layer_number = clamp((int)layer_number, m_min_value, m_max_value);
+    layer_number = std::clamp((int)layer_number, m_min_value, m_max_value);
    GetSelection() == ssLower ? SetLowerValue(layer_number) : SetHigherValue(layer_number);
 }

@@ -19,7 +19,7 @@
 #include <boost/log/trivial.hpp>
 #include <functional>
 #include <cstddef>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <wx/string.h>
 #include "slic3r/GUI/PartPlate.hpp"
 #include "libslic3r/PrintConfig.hpp"
@@ -39,6 +39,7 @@
 #include <boost/filesystem.hpp>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 namespace Slic3r {
 namespace GUI {
@@ -1,5 +1,5 @@
 #include "SendJob.hpp"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "bambu_networking.hpp"
 #include "libslic3r/LifecycleEvents.hpp"
 #include "slic3r/GUI/I18N.hpp"
@@ -23,6 +23,7 @@
 #include <boost/filesystem.hpp>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 namespace Slic3r {
 namespace GUI {
@@ -34,7 +34,7 @@
 #include "slic3r/GUI/Widgets/SideMenuPopup.hpp"
 #include <utility>
 #include "libslic3r/libslic3r.h"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <algorithm>
 #include <wx/dirdlg.h>
 #include <exception>
@@ -155,6 +155,8 @@
 #include <wx/window.h>


+using json = nlohmann::json;
+
 namespace Slic3r {
 namespace GUI {

@@ -45,6 +45,8 @@
 #include "../Utils/MacDarkMode.hpp"
 #endif

+using json = nlohmann::json;
+
 namespace Slic3r {
 namespace GUI {

@@ -13,7 +13,7 @@
 #include "slic3r/GUI/Widgets/WebView.hpp"
 #include <wx/log.h>
 #include <wx/webview.h>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <exception>
 #include <wx/wx.h>
 #include <wx/sizer.h>
@@ -24,6 +24,8 @@
 #include "GUI_App.hpp"
 #include "Plater.hpp"

+using json = nlohmann::json;
+
 namespace Slic3r::GUI { class Plater; }

 namespace Slic3r {
@@ -15,7 +15,7 @@
 #include "slic3r/GUI/StatusPanel.hpp"
 #include "slic3r/GUI/UpgradePanel.hpp"
 #include "slic3r/GUI/Widgets/SideTools.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <wx/app.h>
 #include <wx/bookctrl.h>
 #include <wx/button.h>
@@ -57,6 +57,8 @@
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/Widgets/Button.hpp"

+using json = nlohmann::json;
+
 namespace Slic3r {
 namespace GUI {

@@ -631,8 +631,8 @@ private:
 		// Aditional text after hypertext - currently not used
 		std::string      m_text2;
 		// mark for render operation
-		size_t           pos_start = string::npos;
-		size_t	         pos_end = string::npos;
+		size_t           pos_start = std::string::npos;
+		size_t	         pos_end = std::string::npos;
 		std::string      error_start = "<Error>";
 		std::string      error_end = "</Error>";

@@ -16,7 +16,7 @@
 #include <vector>
 #include <utility>
 #include "slic3r/GUI/GUI.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <wx/app.h>
 #include <wx/event.h>
 #include <wx/filename.h>
@@ -32,6 +32,9 @@
 #include <OrcaCloudServiceAgent.hpp>
 #include <wx/event.h>
 #include <wx/utils.h>
+
+using json = nlohmann::json;
+
 namespace Slic3r { namespace GUI {

 PresetBundleDialog::PresetBundleDialog(
@@ -58,6 +58,8 @@
 //#define PRINTER_FILE_SYSTEM_TEST
 #endif

+using json = nlohmann::json;
+
 std::string last_system_error() {
    return Slic3r::decode_path(std::error_code(
 #ifdef _WIN32
@@ -22,7 +22,6 @@
 #include <boost/enable_shared_from_this.hpp>

 #include "nlohmann/json_fwd.hpp"
-using nlohmann::json;

 #include <functional>
 #include <deque>
@@ -290,17 +289,17 @@ private:
    static void DumpLog(void* context, int level, tchar const *msg);

 private:
-    template<typename T> using Translator = std::function<int(json const &, T &, unsigned char const *)>;
+    template<typename T> using Translator = std::function<int(nlohmann::json const &, T &, unsigned char const *)>;

-    typedef std::function<void(int, json const & resp)> callback_t;
+    typedef std::function<void(int, nlohmann::json const & resp)> callback_t;

-    typedef std::function<int(int, json const &resp, unsigned char const *data)> callback_t2;
+    typedef std::function<int(int, nlohmann::json const &resp, unsigned char const *data)> callback_t2;

    typedef std::function<int(std::string &msg)> callback_t3;

-    template<typename T> boost::uint32_t SendRequest(int type, json const &req, Translator<T> const &translator, Callback<T> const &callback, const std::string &param = "")
+    template<typename T> boost::uint32_t SendRequest(int type, nlohmann::json const &req, Translator<T> const &translator, Callback<T> const &callback, const std::string &param = "")
    {
-        auto c = [translator, callback, this](int result, json const &resp, unsigned char const *data) -> int
+        auto c = [translator, callback, this](int result, nlohmann::json const &resp, unsigned char const *data) -> int
        {
            T t;
            if (result == 0 || result == CONTINUE || result == FILE_EXIST) {
@@ -323,7 +322,7 @@ private:
    template<typename T>
    void InstallNotify(int type, Translator<T> const& translator, Applier<T> const& applier)
    {
-        auto c = [translator, applier, this](int result, json const &resp, unsigned char const *data) -> int
+        auto c = [translator, applier, this](int result, nlohmann::json const &resp, unsigned char const *data) -> int
        {
            T t;
            if (result == 0 || result == CONTINUE) {
@@ -345,7 +344,7 @@ private:
        InstallNotify(type, c);
    }

-    boost::uint32_t SendRequest(int type, json const &req, callback_t2 const &callback, const std::string &param = "");
+    boost::uint32_t SendRequest(int type, nlohmann::json const &req, callback_t2 const &callback, const std::string &param = "");

    void InstallNotify(int type, callback_t2 const &callback);

@@ -6,7 +6,6 @@
 #include <wx/gdicmn.h>
 #include <wx/settings.h>
 #include <cstddef>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
 #include "slic3r/GUI/GUI.hpp"
 #include <exception>
 #include <wx/msgdlg.h>
@@ -30,6 +29,9 @@

 #include <sstream>
 #include <slic3r/GUI/Widgets/WebView.hpp>
+
+using json = nlohmann::json;
+
 //------------------------------------------
 //          PrinterCloundAuthDialog
 //------------------------------------------
@@ -16,7 +16,7 @@
 #include <string>
 #include "slic3r/GUI/GUI.hpp"
 #include "slic3r/GUI/Auxiliary.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <cstddef>
 #include <memory>
 #include <map>
@@ -54,7 +54,8 @@
 #include <slic3r/GUI/Widgets/WebView.hpp>
 #include "slic3r/GUI/Jobs/SendJob.hpp"
 #include "slic3r/GUI/Plater.hpp"
-#include "slic3r/Utils/json_diff.hpp"
+
+using json = nlohmann::json;

 class wxWindow;

@@ -30,7 +30,6 @@
 #include <wx/timer.h>

 #include "nlohmann/json.hpp"
-#include "slic3r/Utils/json_diff.hpp"

 #include <atomic>
 #include <map>
@@ -109,7 +108,7 @@ public:
    void OnScriptMessage(wxWebViewEvent& evt);
    void RunScript(std::string content);

-    std::map<std::string, std::vector<json>> Reload(wxString aux_path);
+    std::map<std::string, std::vector<nlohmann::json>> Reload(wxString aux_path);
    std::string formatBytes(unsigned long bytes);
    wxString to_base64(std::string path);
 };
@@ -74,6 +74,8 @@
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include <boost/filesystem.hpp>

+using json = nlohmann::json;
+
 namespace Slic3r::GUI { class Plater; }

 namespace fs = boost::filesystem;
@@ -1816,7 +1818,10 @@ 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);
-    auto diagram_bmp = create_scaled_bitmap(img_str + "_en", this, 198);
+    if (img_str.empty()) { img_str = "input_access_code_x1"; }
+
+    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);


@@ -62,7 +62,7 @@
 #include <cstdio>
 #include <cstddef>
 #include "libslic3r/Config.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <exception>
 #include <cstdlib>
 #include <map>
@@ -133,6 +133,8 @@
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include <boost/filesystem.hpp>

+using json = nlohmann::json;
+
 namespace Slic3r { class PrintBase; }

 namespace fs = boost::filesystem;
@@ -26,7 +26,7 @@
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include "slic3r/GUI/PartPlate.hpp"
 #include "libslic3r/PrintConfig.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/MsgDialog.hpp"
 #include "slic3r/GUI/Widgets/Label.hpp"
 #include "slic3r/GUI/Widgets/TextInput.hpp"
@@ -77,6 +77,7 @@
 #include <wx/dcgraph.h>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 namespace Slic3r {
 namespace GUI {
@@ -1,8 +1,6 @@
 #ifndef slic3r_StatusPanel_hpp_
 #define slic3r_StatusPanel_hpp_

-#include <vector>
-
 #include "libslic3r/ProjectTask.hpp"
 #include "DeviceManager.hpp"
 #include "MonitorPage.hpp"
@@ -25,7 +23,7 @@
 #include <unordered_set>
 #include "slic3r/GUI/wxMediaCtrl3.h"
 #include "slic3r/GUI/Widgets/StaticBox.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <boost/date_time/posix_time/ptime.hpp>
 #include <map>
 #include "libslic3r/calib.hpp"
@@ -68,7 +66,6 @@
 #include "StagedBuild.hpp"

 class StepIndicator;
-class wxChoice;

 #define COMMAND_TIMEOUT         5

@@ -143,35 +140,28 @@ class ExtruderImage : public wxWindow
    ScalableBitmap *m_left_extruder_active_empty;
    ScalableBitmap *m_left_extruder_unactive_filled;
    ScalableBitmap *m_left_extruder_unactive_empty;
-
    ScalableBitmap *m_right_extruder_active_filled;
    ScalableBitmap *m_right_extruder_active_empty;
    ScalableBitmap *m_right_extruder_unactive_filled;
    ScalableBitmap *m_right_extruder_unactive_empty;
-    
+
    ScalableBitmap *m_extruder_single_nozzle_empty_load;
    ScalableBitmap *m_extruder_single_nozzle_empty_unload;
    ScalableBitmap *m_extruder_single_nozzle_filled_load;
    ScalableBitmap *m_extruder_single_nozzle_filled_unload;
-    
+
    ExtruderState m_left_ext_state   = {ExtruderState::EMPTY_LOAD};
    ExtruderState m_right_ext_state  = {ExtruderState::EMPTY_LOAD};
    ExtruderState m_single_ext_state = {ExtruderState::EMPTY_LOAD};
-    std::vector<ExtruderState> m_multi_extruder_states;
-    bool m_generic_nozzle_display{false};

 public:
    void update(int nozzle_num, int nozzle_id);
    void update(ExtruderState single_state);
    void update(ExtruderState right_state, ExtruderState left_state);

-    void update(ExtruderState state, int idx);
-
    void msw_rescale();
    void setExtruderCount(int nozzle_num);
-    void setGenericNozzleDisplay(bool enabled);
    void setExtruderUsed(std::string loc);
-    void setExtruderUsed(int nozzle_idx);
    void paintEvent(wxPaintEvent &evt);

    void     render(wxDC &dc);
@@ -505,8 +495,6 @@ protected:
    std::vector<ExtruderImage *> m_extruderImage;

    SwitchBoard *   m_nozzle_btn_panel;
-    wxChoice*       m_generic_nozzle_selector{nullptr};
-    int             m_generic_nozzle_selector_count{0};

    wxStaticText *  m_text_tasklist_caption;

@@ -519,18 +507,10 @@ protected:
    wxBoxSizer *    m_misc_ctrl_sizer;
    StaticBox*      m_fan_panel;
    StaticLine *    m_line_nozzle;
-    wxWindowID      m_nozzle_temp_control_id{wxID_ANY};
-    wxWindow*       m_temp_nozzle_parent{nullptr};
-    wxBoxSizer*     m_temp_nozzle_sizer{nullptr};
-    size_t          m_temp_nozzle_active_count{0};
-    TempInput*      m_tempCtrl_nozzle{nullptr};
+    TempInput*      m_tempCtrl_nozzle;
    int             m_temp_nozzle_timeout{ 0 };
-    TempInput*      m_tempCtrl_nozzle_deputy{nullptr};
+    TempInput*      m_tempCtrl_nozzle_deputy;
    int             m_temp_nozzle_deputy_timeout{ 0 };
-
-    std::vector<TempInput*> m_tempCtrl_nozzles;
-    std::vector<int> m_temp_nozzle_timeouts;
-
    TempInput *     m_tempCtrl_bed;
    int             m_temp_bed_timeout {0};
    TempInput *     m_tempCtrl_chamber;
@@ -570,7 +550,6 @@ protected:

    /* AMS control box <-> live nozzle-rack panel toggle (rack printers only) */
    SwitchBoard*    m_ams_rack_switch{ nullptr };
-    MultiSwitchButton* m_ams_nozzle_switch{ nullptr };

    AMSControl*     m_ams_control;
    StaticBox*      m_ams_control_box;
@@ -645,9 +624,6 @@ public:

    wxBoxSizer *create_temp_axis_group(wxWindow *parent);
    wxBoxSizer *create_temp_control(wxWindow *parent);
-    TempInput* create_nozzle_temp_control(wxWindow *parent, wxWindowID id);
-    void set_temp_input_colors(TempInput* temp_ctrl);
-    void ensure_nozzle_temp_controls(size_t count);
    wxBoxSizer *create_misc_control(wxWindow *parent);
    wxBoxSizer *create_axis_control(wxWindow *parent);
    wxPanel *create_bed_control(wxWindow *parent);
@@ -678,7 +654,6 @@ private:
    friend class MonitorPanel;
    void wire_controls();
    bool load_thumbnail_from_url(const wxString &url, MachineObject *obj);
-    void sync_nozzle_temp_controls(size_t count);

 protected:
    std::shared_ptr<SliceInfoPopup> m_slice_info_popup;
@@ -714,7 +689,7 @@ protected:
    int          m_last_vcamera   = -1;
    int          m_model_mall_request_count = 0;
    bool         m_is_load_with_temp = false;
-    json         m_rating_result;
+    nlohmann::json m_rating_result;

    wxWebRequest web_request;
    bool bed_temp_input    = false;
@@ -15,7 +15,7 @@
 #include "libslic3r/Utils.hpp"
 #include <string>
 #include "slic3r/GUI/BBLStatusBarPrint.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <cassert>
 #include "libslic3r/PrintConfig.hpp"
 #include <cstdlib>
@@ -85,6 +85,7 @@
 #include "slic3r/Utils/NetworkAgent.hpp"

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 using namespace Slic3r;
 using namespace Slic3r::GUI;
@@ -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_infill#infill-complete-top");
+        optgroup->append_single_option_line("infill_complete_top", "strength_settings_patterns#fill-pattern-tops");
        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");
@@ -20,7 +20,6 @@
 #include <vector>
 #include <map>
 #include <utility>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"

 using namespace nlohmann;

@@ -1,4 +1,4 @@
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "UserManager.hpp"
 #include "BindDialog.hpp"
 #include "GUI_App.hpp"
@@ -10,6 +10,8 @@
 #include <wx/string.h>


+using json = nlohmann::json;
+
 namespace Slic3r {

 UserManager::UserManager(NetworkAgent* agent)
@@ -9,12 +9,9 @@
 #include <chrono>
 #include <boost/thread.hpp>
 #include "nlohmann/json.hpp"
-#include "slic3r/Utils/json_diff.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"


-using namespace nlohmann;
-
 namespace Slic3r {

 class NetworkAgent;
@@ -4,7 +4,7 @@
 #include "slic3r/GUI/GUI.hpp"
 #include <boost/filesystem/path.hpp>
 #include <boost/log/trivial.hpp>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <exception>
 #include <string.h>
 #include "I18N.hpp"
@@ -36,7 +36,7 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/PresetCacheFormat.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include "libslic3r_version.h"

 #include <string>
@@ -78,7 +78,6 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
 #include "slic3r/Utils/PresetUpdater.hpp"
-#include "slic3r/Utils/json_diff.hpp"

 class wxWindow;

@@ -5,7 +5,6 @@
 #include "slic3r/GUI/HttpServer.hpp"
 #include <memory>
 #include <boost/log/trivial.hpp>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
 #include "slic3r/GUI/GUI.hpp"
 #include <exception>
 #include <boost/filesystem/path.hpp>
@@ -24,7 +24,7 @@
 #include <wx/filename.h>
 #include <sstream>
 #include <string>
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include <functional>
 #include <cstddef>
 #include <wx/dialog.h>
@@ -44,6 +44,7 @@
 #include <wx/infobar.h>

 namespace pt = boost::property_tree;
+using json = nlohmann::json;

 namespace Slic3r {
 namespace GUI {
@@ -244,7 +244,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons
    m_sizer_ams_body->Add(m_sizer_ams_area_right, wxALIGN_CENTER, 0);

    m_sizer_body->Add(m_sizer_ams_items, 0, wxALIGN_CENTER, 0);
-    m_sizer_ams_gap = m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(10));
+    m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(10));
    m_sizer_body->Add(m_sizer_ams_body, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_down_road, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_ams_option, 0, wxEXPAND, 0);
@@ -371,7 +371,7 @@ bool AMSControl::IsAmsInRightPanel(std::string ams_id) {
            return false;
        }
    }
-    else if (m_total_ext_count == 1){
+    else{
        for (auto id : m_item_ids[MAIN_EXTRUDER_ID]){
            if (id == ams_id){
                return true;
@@ -379,10 +379,6 @@ bool AMSControl::IsAmsInRightPanel(std::string ams_id) {
        }
        return false;
    }
-    else {
-        // Generic N Nozzles
-    }
-    return false;
 }

 void AMSControl::AmsSelectedSwitch(wxCommandEvent& event) {
@@ -523,7 +519,7 @@ void AMSControl::msw_rescale()
    m_button_ams_setting_press.msw_rescale();
    m_button_ams_setting->SetBitmap(m_button_ams_setting_normal.bmp());

-    if (m_extruder) m_extruder->msw_rescale();
+    m_extruder->msw_rescale();

    if (m_button_extruder_feed) m_button_extruder_feed->Rescale(); // ORCA
    if (m_button_extruder_back) m_button_extruder_back->Rescale(); // ORCA
@@ -607,8 +603,6 @@ void AMSControl::CreateAms()


 void AMSControl::ClearAms() {
-    m_sizer_ams_items->Clear(false);
-
    m_simplebook_ams_right->DeleteAllPages();
    m_simplebook_ams_left->DeleteAllPages();
    m_simplebook_ams_right->DestroyChildren();
@@ -619,7 +613,7 @@ void AMSControl::ClearAms() {
    m_simplebook_ams_left->Refresh();

    for (auto it : m_ams_preview_list) {
-        if (it.second) it.second->Destroy();
+        delete it.second;
    }
    m_ams_preview_list.clear();
    m_ext_image_list.clear();
@@ -630,167 +624,12 @@ void AMSControl::ClearAms() {
    m_ams_item_list.clear();
    m_sizer_prv_right->Clear();
    m_sizer_prv_left->Clear();
-
-    if (m_nozzle_book) {
-        m_nozzle_book->Destroy();
-        m_nozzle_book = nullptr;
-    } else {
-        for (auto &pane : m_nozzle_panes) {
-            if (pane.preview_panel) pane.preview_panel->Destroy();
-            if (pane.ams_book) pane.ams_book->Destroy();
-        }
-    }
-    m_item_ids.assign(std::max(m_total_ext_count, 2), {});
-    m_nozzle_panes.clear();
-    m_active_nozzle_id = 0;
-    m_current_ams.clear();
-    m_current_show_ams_left.clear();
-    m_current_show_ams_right.clear();
+    m_item_ids = { {}, {} };
    pair_id.clear();
 }

-void AMSControl::restore_legacy_ams_layout()
-{
-    m_sizer_ams_items->Clear(false);
-    m_sizer_ams_items->SetOrientation(wxHORIZONTAL);
-    m_sizer_body->GetItem(m_sizer_ams_items)->SetFlag(wxALIGN_CENTER);
-    m_sizer_ams_items->Add(m_panel_prv_left, 0, wxLEFT | wxRIGHT, FromDIP(5));
-    m_sizer_ams_items->Add(m_panel_prv_right, 0, wxLEFT | wxRIGHT, FromDIP(5));
-
-    m_panel_prv_left->Show();
-    m_panel_prv_right->Show();
-    m_simplebook_ams_left->Show();
-    m_simplebook_ams_right->Show();
-    m_panel_down_road->Show();
-    m_sizer_body->Show(m_sizer_ams_body, true);
-    m_sizer_option_mid->Show(m_extruder, true);
-    m_down_road->SetSingleSideLayout(false);
-    m_sizer_ams_gap->SetProportion(1);
-    m_sizer_ams_gap->SetBorder(FromDIP(10));
-    m_down_road->SetNozzleCount(m_total_ext_count);
-}
-
-void AMSControl::CreateAmsMultiNozzle(const std::string &series_name, const std::string &printer_type) {
-    const size_t pane_count = static_cast<size_t>(std::max(m_total_ext_count, 0));
-    m_nozzle_panes.resize(pane_count);
-    m_active_nozzle_id = 0;
-
-    m_sizer_ams_items->Clear(false);
-    m_sizer_ams_items->SetOrientation(wxVERTICAL);
-    m_sizer_body->GetItem(m_sizer_ams_items)->SetFlag(wxALIGN_CENTER);
-    m_sizer_body->Show(m_sizer_ams_body, false);
-    m_sizer_ams_gap->SetProportion(0);
-    m_sizer_ams_gap->SetBorder(0);
-
-    m_panel_prv_left->Hide();
-    m_panel_prv_right->Hide();
-    m_simplebook_ams_left->Hide();
-    m_simplebook_ams_right->Hide();
-    m_panel_down_road->Show();
-    m_sizer_option_mid->Show(m_extruder, true);
-    m_switcher->Hide();
-    m_down_road->SetNozzleCount(1);
-    m_down_road->SetSingleSideLayout(true, AMSPanelPos::LEFT_PANEL);
-    m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_SINGLE);
-    m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-    m_extruder->updateNozzleNum(1, series_name);
-
-    m_nozzle_book = new wxSimplebook(m_amswin, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
-    m_nozzle_book->SetMinSize(wxSize(FromDIP(264), -1));
-    m_nozzle_book->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-    m_sizer_ams_items->Add(m_nozzle_book, 0, wxALIGN_CENTER);
-
-    for (size_t nozzle_id = 0; nozzle_id < pane_count; ++nozzle_id) {
-        auto &pane = m_nozzle_panes[nozzle_id];
-        // A generic page is one H2C side. Keep the left-side geometry as the
-        // canonical single-nozzle presentation; the road and AMS item code
-        // still use the same side-specific paths as the legacy layout.
-        pane.panel_pos = AMSPanelPos::LEFT_PANEL;
-        pane.page = new wxPanel(m_nozzle_book, wxID_ANY);
-        pane.page->SetMinSize(wxSize(FromDIP(264), -1));
-        pane.page->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-        pane.page_sizer = new wxBoxSizer(wxVERTICAL);
-        pane.page->SetSizer(pane.page_sizer);
-
-        pane.preview_panel = new wxScrolledWindow(pane.page, wxID_ANY);
-        pane.preview_panel->SetScrollRate(10, 0);
-        pane.preview_panel->SetSize(AMS_ITEMS_PANEL_SIZE);
-        pane.preview_panel->SetMinSize(AMS_ITEMS_PANEL_SIZE);
-        pane.preview_panel->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-
-        pane.preview_sizer = new wxBoxSizer(wxHORIZONTAL);
-        pane.preview_panel->SetSizer(pane.preview_sizer);
-
-        // Generic lane cards grow to their calculated width for 1-8 lanes. Keep the
-        // book at the legacy minimum, but allow the page to expand to that width.
-        pane.ams_book = new wxSimplebook(pane.page, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
-        pane.ams_book->SetMinSize(wxSize(FromDIP(264), -1));
-        pane.ams_book->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_BLOCK_BK_COLOUR));
-        pane.ams_area = new wxBoxSizer(wxHORIZONTAL);
-        pane.ams_area->Add(pane.ams_book, 0, wxALIGN_CENTER, 0);
-
-        pane.page_sizer->Add(pane.preview_panel, 0, wxALIGN_CENTER | wxTOP, FromDIP(5));
-        pane.page_sizer->Add(pane.ams_area, 0, wxALIGN_CENTER | wxTOP, FromDIP(10));
-
-        m_nozzle_book->AddPage(pane.page, wxEmptyString, nozzle_id == 0);
-    }
-
-    auto add_info = [this, series_name, printer_type, pane_count](AMSinfo info) {
-        if (pane_count == 0) return;
-
-        info.nozzle_id = std::clamp(info.nozzle_id, 0, static_cast<int>(pane_count) - 1);
-        AddAmsPreview(info, info.ams_type);
-        if (info.ams_type == AMSModel::EXT_AMS && info.cans.size() == 1)
-            AddAms({info}, series_name, printer_type, m_nozzle_panes[info.nozzle_id].panel_pos);
-        else
-            AddAms(info);
-    };
-
-    for (const auto &info : m_ams_info)
-        add_info(info);
-
-    for (auto &info : m_ext_info) {
-        const int virtual_tray_id = std::atoi(info.ams_id.c_str());
-        if (virtual_tray_id <= VIRTUAL_TRAY_MAIN_ID &&
-            virtual_tray_id >= VIRTUAL_TRAY_MAIN_ID - static_cast<int>(pane_count) + 1)
-            info.nozzle_id = VIRTUAL_TRAY_MAIN_ID - virtual_tray_id;
-        add_info(info);
-    }
-
-    for (auto &pane : m_nozzle_panes) {
-        if (pane.ams_book && pane.ams_book->GetPageCount() > 0)
-            pane.ams_book->SetSelection(0);
-        if (pane.preview_sizer) pane.preview_sizer->Layout();
-        if (pane.preview_panel) pane.preview_panel->FitInside();
-        if (pane.ams_book) pane.ams_book->Layout();
-        if (pane.page) pane.page->Layout();
-
-        if (!pane.current_ams.empty()) {
-            auto preview = m_ams_preview_list.find(pane.current_ams);
-            if (preview != m_ams_preview_list.end() && preview->second)
-                preview->second->OnSelected();
-        }
-    }
-
-    if (m_nozzle_book && pane_count > 0) {
-        m_nozzle_book->SetSelection(0);
-        m_current_ams = m_nozzle_panes[0].current_ams;
-        if (!m_current_ams.empty())
-            SwitchAms(m_current_ams);
-        else {
-            m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-            m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-        }
-    }
-    m_amswin->Layout();
-    m_amswin->Fit();
-    // Generic N Nozzles
-}
-
 void AMSControl::CreateAmsDoubleNozzle(const std::string &series_name, const std::string &printer_type)
 {
-    restore_legacy_ams_layout();
-
    std::vector<AMSinfo> single_info_left;
    std::vector<AMSinfo> single_info_right;

@@ -912,8 +751,6 @@ void AMSControl::CreateAmsDoubleNozzle(const std::string &series_name, const std

 void AMSControl::CreateAmsSingleNozzle(const std::string &series_name, const std::string &printer_type)
 {
-    restore_legacy_ams_layout();
-
    std::vector<int>m_item_nums{0,0};
    std::vector<AMSinfo> single_info;

@@ -1142,17 +979,6 @@ void AMSControl::UpdateAms(const std::string   &series_name,
                if (m_ams_info[i].routes_to_main_extruder() != ams_info[i].routes_to_main_extruder()) {
                    fresh = true;
                }
-                if (m_ams_info[i].nozzle_id != ams_info[i].nozzle_id) {
-                    fresh = true;
-                }
-            }
-
-            for (int i = 0; i < static_cast<int>(m_ext_info.size()); ++i) {
-                if (m_ext_info[i].ams_id != ext_info[i].ams_id ||
-                    m_ext_info[i].nozzle_id != ext_info[i].nozzle_id ||
-                    m_ext_info[i].ext_type != ext_info[i].ext_type) {
-                    fresh = true;
-                }
            }
        }
        else{
@@ -1167,19 +993,11 @@ void AMSControl::UpdateAms(const std::string   &series_name,
        m_dev_id = dev_id;
        if (fresh){
            ClearAms();
-            // Keep the established Bambu left/right AMS presentation. Generic N-nozzle
-            // tabs are for non-Bambu printers; the current checkout exposes this behavior
-            // through PresetBundle::is_bbl_vendor().
-            const bool is_bbl_behavior = wxGetApp().preset_bundle && wxGetApp().preset_bundle->is_bbl_vendor();
-            if (is_bbl_behavior) {
-                if (m_total_ext_count == 1)
-                    CreateAmsSingleNozzle(series_name, printer_type);
-                else if (m_total_ext_count == 2)
-                    CreateAmsDoubleNozzle(series_name, printer_type);
+            if (m_total_ext_count >= 2){
+                CreateAmsDoubleNozzle(series_name, printer_type);
+            }else{
+                CreateAmsSingleNozzle(series_name, printer_type);
            }
-            else
-                CreateAmsMultiNozzle(series_name, printer_type);
-
            SetSize(wxSize(FromDIP(578), -1));
            SetMinSize(wxSize(FromDIP(578), -1));
            Layout();
@@ -1252,7 +1070,7 @@ void AMSControl::UpdateAms(const std::string   &series_name,
    }

    /*update ams extruder*/
-    if (m_total_ext_count <= 2 && m_extruder->updateNozzleNum(m_total_ext_count, series_name))
+    if (m_extruder->updateNozzleNum(m_total_ext_count, series_name))
    {
        m_amswin->Layout();
    }
@@ -1288,13 +1106,7 @@ void AMSControl::AddAmsPreview(AMSinfo info, AMSModel type)
 {
    AMSPreview *ams_prv = nullptr;

-    if (m_total_ext_count > 2) {
-        const int nozzle_id = std::clamp(info.nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        ams_prv = new AMSPreview(pane.preview_panel, wxID_ANY, info, type);
-        pane.preview_sizer->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
-    }
-    else if (info.routes_to_main_extruder())
+    if (info.routes_to_main_extruder())
    {
        ams_prv = new AMSPreview(m_panel_prv_right, wxID_ANY, info, type);
        m_sizer_prv_right->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
@@ -1317,40 +1129,6 @@ void AMSControl::AddAmsPreview(AMSinfo info, AMSModel type)
 void AMSControl::createAms(wxSimplebook* parent, int& idx, AMSinfo info, AMSPanelPos pos) {
    auto ams_item = new AmsItem(parent, info, info.ams_type, pos);
    parent->InsertPage(idx, ams_item, wxEmptyString, true);
-
-    // Generic AMS cards may be wider than the legacy 264 DIP page. Propagate
-    // that calculated width through the page and simplebook so 5-8 lanes are
-    // laid out fully instead of being clipped by the old minimum width.
-    if (info.ams_type == AMSModel::GENERIC_AMS) {
-        const int required_width = ams_item->GetMinSize().x;
-        if (required_width > 0) {
-            const int page_width = std::max(parent->GetMinSize().x, required_width);
-            parent->SetMinSize(wxSize(page_width, -1));
-            if (auto *page = parent->GetParent()) {
-                page->SetMinSize(wxSize(std::max(page->GetMinSize().x, page_width), -1));
-                if (auto *nozzle_book = page->GetParent())
-                    nozzle_book->SetMinSize(wxSize(std::max(nozzle_book->GetMinSize().x, page_width), -1));
-            }
-        }
-        // Above eight lanes, AmsItem is a fixed-minimum viewport over a wider
-        // lane strip. Expand the viewport through its page's sizers rather
-        // than propagating the strip's virtual width into the card/book.
-        const bool generic_lane_layout = !wxGetApp().preset_bundle || !wxGetApp().preset_bundle->is_bbl_vendor();
-        if (generic_lane_layout && info.cans.size() > 8) {
-            if (auto *page = parent->GetParent()) {
-                auto pane = std::find_if(m_nozzle_panes.begin(), m_nozzle_panes.end(),
-                    [page](const NozzleAmsPane &candidate) { return candidate.page == page; });
-                if (pane != m_nozzle_panes.end()) {
-                    pane->ams_area->GetItem(pane->ams_book)->SetProportion(1);
-                    pane->ams_area->GetItem(pane->ams_book)->SetFlag(wxEXPAND);
-                    pane->page_sizer->GetItem(pane->ams_area)->SetFlag(wxEXPAND | wxTOP);
-                    m_sizer_ams_items->GetItem(m_nozzle_book)->SetFlag(wxEXPAND);
-                    m_sizer_body->GetItem(m_sizer_ams_items)->SetFlag(wxEXPAND);
-                    m_amswin->Layout();
-                }
-            }
-        }
-    }
    ams_item->set_selection(idx);
    idx++;

@@ -1375,10 +1153,7 @@ AMSRoadShowMode AMSControl::findFirstMode(AMSPanelPos pos) {
        if (item->second->get_ams_model() == AMSModel::EXT_AMS && item->second->get_ext_type() == AMSModelOriginType::LITE_EXT) return AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
        return AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
    }
-    else if (item->second->get_can_count() > GENERIC_AMS_SLOT_NUM) {
-        return AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-    }
-    else {
+    else{
        for (auto ids : pair_id){
            if (ids.first == ams_id || ids.second == ams_id){
                return AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
@@ -1425,11 +1200,6 @@ void AMSControl::createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSi
                //book_sizer->Add(ams1, 0, wxALIGN_CENTER_HORIZONTAL, 0);
                book_sizer->Add(ams1, 0, wxLEFT, (book_panel->GetSize().x - ams1->GetSize().x) / 2);
            }
-            else if (pos == AMSPanelPos::SINGLE_PANEL) {
-                book_sizer->AddStretchSpacer(1);
-                book_sizer->Add(ams1, 0, wxALIGN_CENTER_VERTICAL, 0);
-                book_sizer->AddStretchSpacer(1);
-            }
            else{
                auto ext_image = new AMSExtImage(book_panel, pos, m_total_ext_count, false);
                book_sizer->Add(ams1, 0, wxLEFT, FromDIP(30));
@@ -1458,17 +1228,7 @@ void AMSControl::createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSi

 void AMSControl::AddAms(AMSinfo info, AMSPanelPos pos)
 {
-    if (m_total_ext_count > 2) {
-        const int nozzle_id = std::clamp(info.nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        pane.item_ids.push_back(info.ams_id);
-        m_item_ids[nozzle_id].push_back(info.ams_id);
-        if (pane.current_ams.empty()) pane.current_ams = info.ams_id;
-        createAms(pane.ams_book, pane.page_index, info, AMSPanelPos::SINGLE_PANEL);
-        pane.ams_book->Fit();
-        pane.ams_book->Layout();
-    }
-    else if (m_total_ext_count == 2){
+    if (m_total_ext_count > 1){
        if (info.routes_to_main_extruder()){
            createAms(m_simplebook_ams_right, m_right_page_index, info, AMSPanelPos::RIGHT_PANEL);
        }
@@ -1479,9 +1239,6 @@ void AMSControl::AddAms(AMSinfo info, AMSPanelPos pos)
    else if (m_total_ext_count == 1){
        createAms(m_simplebook_ams_left, m_left_page_index, info, AMSPanelPos::LEFT_PANEL);
    }
-    else {
-        // Generic N Nozzles
-    }
    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
    m_simplebook_ams_left->Refresh();
@@ -1512,19 +1269,7 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
     if (single_info.size() <= 0){
        return;
    }
-    if (m_total_ext_count > 2) {
-        const int nozzle_id = std::clamp(single_info.front().nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        for (const auto &info : single_info) {
-            pane.item_ids.push_back(info.ams_id);
-            m_item_ids[nozzle_id].push_back(info.ams_id);
-        }
-        if (pane.current_ams.empty()) pane.current_ams = single_info.front().ams_id;
-        createAmsPanel(pane.ams_book, pane.page_index, single_info, series_name, printer_type, AMSPanelPos::SINGLE_PANEL, m_total_ext_count);
-        pane.ams_book->Fit();
-        pane.ams_book->Layout();
-    }
-    else if (m_total_ext_count == 2) {
+    if (m_total_ext_count == 2) {
        if (single_info[0].routes_to_main_extruder()) {
            createAmsPanel(m_simplebook_ams_right, m_right_page_index, single_info, series_name, printer_type, AMSPanelPos::RIGHT_PANEL, m_total_ext_count);
        }
@@ -1540,9 +1285,6 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
            createAmsPanel(m_simplebook_ams_left, m_left_page_index, single_info, series_name, printer_type, AMSPanelPos::LEFT_PANEL, m_total_ext_count);
        }
    }
-    else {
-        // Generic N Nozzles
-    }

    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
@@ -1580,21 +1322,6 @@ void AMSControl::AddAms(std::vector<AMSinfo> single_info, const std::string &ser
 void AMSControl::AddAmsPreview(std::vector<AMSinfo>single_info, AMSPanelPos pos) {
    if (single_info.size() <= 0) return;

-    if (m_total_ext_count > 2) {
-        const int nozzle_id = std::clamp(single_info.front().nozzle_id, 0, m_total_ext_count - 1);
-        auto &pane = m_nozzle_panes[nozzle_id];
-        for (const auto &info : single_info) {
-            auto *ams_prv = new AMSPreview(pane.preview_panel, wxID_ANY, info, info.ams_type);
-            pane.preview_sizer->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
-            ams_prv->Bind(wxEVT_LEFT_DOWN, [this, ams_prv](wxMouseEvent &e) {
-                SwitchAms(ams_prv->get_ams_id());
-                e.Skip();
-            });
-            m_ams_preview_list[info.ams_id] = ams_prv;
-        }
-        return;
-    }
-
    AMSPreview* ams_prv = nullptr;
    AMSPreview* ams_prv2 = nullptr;
    if (pos == AMSPanelPos::RIGHT_PANEL){
@@ -1633,97 +1360,8 @@ void AMSControl::AddAmsPreview(std::vector<AMSinfo>single_info, AMSPanelPos pos)
    }
 }

-void AMSControl::SelectNozzle(int nozzle_id)
-{
-    if (nozzle_id < 0 || nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-        return;
-
-    if (m_active_nozzle_id == nozzle_id &&
-        (!m_nozzle_book || m_nozzle_book->GetSelection() == nozzle_id))
-        return;
-
-    m_active_nozzle_id = nozzle_id;
-    if (m_nozzle_book && m_nozzle_book->GetSelection() != nozzle_id)
-        m_nozzle_book->SetSelection(nozzle_id);
-    m_current_ams = m_nozzle_panes[nozzle_id].current_ams;
-    if (!m_current_ams.empty()) {
-        SwitchAms(m_current_ams);
-        return;
-    }
-    if (m_down_road) {
-        m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-        m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-    }
-    if (m_extruder)
-        m_extruder->OnAmsLoading(false, 0);
-    post_event(SimpleEvent(EVT_AMS_SWITCH));
-}
-
 void AMSControl::SwitchAms(std::string ams_id)
 {
-    if (m_total_ext_count > 2) {
-        NozzleAmsPane *pane = nullptr;
-        int nozzle_id = -1;
-        for (int index = 0; index < static_cast<int>(m_nozzle_panes.size()); ++index) {
-            auto &candidate = m_nozzle_panes[index];
-            if (std::find(candidate.item_ids.begin(), candidate.item_ids.end(), ams_id) != candidate.item_ids.end()) {
-                pane = &candidate;
-                nozzle_id = index;
-                break;
-            }
-        }
-        if (!pane) return;
-
-        m_active_nozzle_id = nozzle_id;
-        if (m_nozzle_book && m_nozzle_book->GetSelection() != nozzle_id)
-            m_nozzle_book->SetSelection(nozzle_id);
-
-        pane->current_ams = ams_id;
-        m_current_ams = ams_id;
-        m_current_select = ams_id;
-
-        for (const auto &id : pane->item_ids) {
-            auto preview = m_ams_preview_list.find(id);
-            if (preview == m_ams_preview_list.end() || !preview->second) continue;
-            if (id == ams_id) preview->second->OnSelected();
-            else preview->second->UnSelected();
-        }
-
-        auto item = m_ams_item_list.find(ams_id);
-        if (item != m_ams_item_list.end() && item->second) {
-            if (pane->ams_book)
-                pane->ams_book->SetSelection(item->second->get_selection());
-
-            AMSRoadShowMode road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
-            if (item->second->get_can_count() == GENERIC_AMS_SLOT_NUM)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
-            else if (item->second->get_can_count() > GENERIC_AMS_SLOT_NUM)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-            else if (item->second->get_ams_model() == AMSModel::N3S_AMS)
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
-            else if (item->second->get_ams_model() == AMSModel::AMS_LITE ||
-                     (item->second->get_ams_model() == AMSModel::EXT_AMS &&
-                      item->second->get_ext_type() == AMSModelOriginType::LITE_EXT))
-                road_mode = AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
-
-            if (m_down_road) {
-                if (pane->panel_pos == AMSPanelPos::LEFT_PANEL) {
-                    m_down_road->UpdateLeft(1, road_mode);
-                    m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                } else {
-                    m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                    m_down_road->UpdateRight(1, road_mode);
-                }
-                m_down_road->UpdatePassRoad(pane->panel_pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            }
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-
-        post_event(SimpleEvent(EVT_AMS_SWITCH));
-        return;
-    }
-
    if(ams_id == m_current_show_ams_left || ams_id == m_current_show_ams_right){return;}

    bool is_in_right = IsAmsInRightPanel(ams_id);
@@ -1794,17 +1432,13 @@ void AMSControl::SwitchAms(std::string ams_id)
                    else {
                        AMSRoadShowMode mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;

-                        if (item->get_can_count() > GENERIC_AMS_SLOT_NUM)
-                            mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-                        else if (item->get_ams_model() == AMSModel::N3S_AMS)
+                        if (item->get_ams_model() == AMSModel::N3S_AMS)
                            mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;

-                        if (item->get_can_count() <= GENERIC_AMS_SLOT_NUM) {
-                            for (auto it : pair_id) {
-                                if (it.first == ams_id || it.second == ams_id) {
-                                    mode = AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
-                                    break;
-                                }
+                        for (auto it : pair_id) {
+                            if (it.first == ams_id || it.second == ams_id) {
+                                mode = AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
+                                break;
                            }
                        }
                        pos == AMSPanelPos::LEFT_PANEL ? m_down_road->UpdateLeft(m_total_ext_count, mode)
@@ -1866,20 +1500,6 @@ void AMSControl::SetExtruder(bool on_off, int nozzle_id, std::string ams_id, std
    AmsItem *item = nullptr;
    if (m_ams_item_list.find(ams_id) != m_ams_item_list.end()) { item = m_ams_item_list[ams_id]; }

-    if (m_total_ext_count > 2) {
-        if (nozzle_id < 0 || nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-            return;
-
-        if (!m_extruder)
-            return;
-
-        if (on_off && item)
-            m_extruder->OnAmsLoading(true, 0, item->GetTagColr(slot_id));
-        else
-            m_extruder->OnAmsLoading(false, 0);
-        return;
-    }
-
    if (on_off && item) {
        auto col = item->GetTagColr(slot_id);
        m_extruder->OnAmsLoading(true, nozzle_id, col);
@@ -2004,69 +1624,6 @@ void AMSControl::SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadTy
    else{
        return;
    }
-
-    if (m_total_ext_count > 2) {
-        const int nozzle_id = std::clamp(ams->get_nozzle_id(), 0, m_total_ext_count - 1);
-        if (nozzle_id >= static_cast<int>(m_nozzle_panes.size()))
-            return;
-        auto &pane = m_nozzle_panes[nozzle_id];
-        AMSRoadShowMode road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
-        if (ams->get_can_count() == GENERIC_AMS_SLOT_NUM)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
-        else if (ams->get_can_count() > GENERIC_AMS_SLOT_NUM)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_GENERIC;
-        else if (ams->get_ams_model() == AMSModel::N3S_AMS)
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
-        else if (ams->get_ams_model() == AMSModel::AMS_LITE ||
-                 (ams->get_ams_model() == AMSModel::EXT_AMS && ams->get_ext_type() == AMSModelOriginType::LITE_EXT))
-            road_mode = AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
-
-        if (can_index >= 0 && can_index < static_cast<int>(info.cans.size()) && m_down_road)
-            m_down_road->SetPassRoadColour(pane.panel_pos == AMSPanelPos::LEFT_PANEL,
-                                           info.cans[can_index].material_colour);
-        if (m_down_road) {
-            if (pane.panel_pos == AMSPanelPos::LEFT_PANEL) {
-                m_down_road->UpdateLeft(1, road_mode);
-                m_down_road->UpdateRight(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-            } else {
-                m_down_road->UpdateLeft(1, AMSRoadShowMode::AMS_ROAD_MODE_NONE);
-                m_down_road->UpdateRight(1, road_mode);
-            }
-        }
-
-        int road_length = 0;
-
-        if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(false, 0);
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(true, 0, ams->GetTagColr(canid));
-        }
-        else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) {
-            ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
-            if (m_down_road)
-                m_down_road->UpdatePassRoad(pane.panel_pos, road_length, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
-            if (m_extruder)
-                m_extruder->OnAmsLoading(true, 0, ams->GetTagColr(canid));
-        }
-        return;
-    }
-
    if (can_index >= 0 && can_index < info.cans.size())
    {
        m_down_road->SetPassRoadColour(left, info.cans[can_index].material_colour);
@@ -47,20 +47,6 @@ public:
    void on_retry();

 protected:
-    struct NozzleAmsPane
-    {
-        wxPanel*          page{nullptr};
-        wxBoxSizer*       page_sizer{nullptr};
-        wxScrolledWindow* preview_panel{nullptr};
-        wxBoxSizer*       preview_sizer{nullptr};
-        wxSimplebook*     ams_book{nullptr};
-        wxBoxSizer*       ams_area{nullptr};
-        AMSPanelPos        panel_pos{AMSPanelPos::LEFT_PANEL};
-        std::vector<std::string> item_ids;
-        std::string current_ams;
-        int page_index{0};
-    };
-
    std::string  m_current_ams;
    std::string  m_current_slot_left;
    std::string  m_current_slot_right;
@@ -77,9 +63,6 @@ protected:

    std::string                      m_dev_id;
    std::vector<std::vector<std::string>> m_item_ids{ {}, {} };
-    std::vector<NozzleAmsPane>       m_nozzle_panes;
-    wxSimplebook*                    m_nozzle_book{nullptr};
-    int                              m_active_nozzle_id{0};
    std::vector<std::pair<string, string>> pair_id;

    int         m_total_ext_count = 1;
@@ -120,7 +103,6 @@ protected:
    wxSimplebook *m_simplebook_ams_left{nullptr};
    wxSimplebook *m_simplebook_ams_right{ nullptr };
    wxSimplebook *m_simplebook_bottom{nullptr};
-    wxSizerItem  *m_sizer_ams_gap{nullptr};
    wxPanel      *m_panel_down_road{ nullptr };
    int          m_left_page_index = 0;
    int          m_right_page_index = 0;
@@ -174,7 +156,6 @@ public:
    void createAms(wxSimplebook* parent, int& idx, AMSinfo info, AMSPanelPos pos);
    void createAmsPanel(wxSimplebook *parent, int &idx, std::vector<AMSinfo> infos, const std::string &series_name, const std::string &printer_type, AMSPanelPos pos, int total_ext_num);
    AMSRoadShowMode findFirstMode(AMSPanelPos pos);
-    void restore_legacy_ams_layout();

    AMSModel m_ams_model{AMSModel::EXT_AMS};
    AMSModel m_ext_model{AMSModel::EXT_AMS};
@@ -202,7 +183,6 @@ public:

    void UpdatePassRoad(string ams_id, AMSPassRoadType type, AMSPassRoadSTEP step);
    void CreateAms();
-    void CreateAmsMultiNozzle(const std::string& series_name, const std::string& printer_type);
    void CreateAmsDoubleNozzle(const std::string &series_name, const std::string& printer_type);
    void CreateAmsSingleNozzle(const std::string &series_name, const std::string &printer_type);
    void ClearAms();
@@ -230,8 +210,6 @@ public:
    void SetExtruder(bool on_off, int nozzle_id, std::string ams_id, std::string slot_id);
    void SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step);
    void SwitchAms(std::string ams_id);
-    void SelectNozzle(int nozzle_id);
-    int  GetActiveNozzleId() const { return m_active_nozzle_id; }

    void msw_rescale();
    void on_filament_load(wxCommandEvent &event);
@@ -42,7 +42,6 @@
 #include <boost/log/trivial.hpp>
 #include <wx/timer.h>
 #include <wx/sizer.h>
-#include <wx/scrolwin.h>

 #include "CalibUtils.hpp"
 #include "slic3r/GUI/wxExtensions.hpp"
@@ -77,48 +76,6 @@ namespace Slic3r { namespace GUI {
 //#define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), 144)
 #define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), FromDIP(174))
 #define AMS_SINGLE_CAN_SIZE wxSize(FromDIP(78), FromDIP(174))
-
-int generic_ams_layout_width(wxWindow *window, int lane_count)
-{
-    const int base_width = window->FromDIP(264);
-    const int lane_width = window->FromDIP(52);
-    const int lane_gap = window->FromDIP(4);
-    if (lane_count <= 4)
-        return base_width;
-
-    // Lane centers are distributed as width * (index + 1) / (count + 1).
-    // Keep at least one card width plus the requested gap between centers.
-    return std::max(base_width, (lane_count + 1) * (lane_width + lane_gap));
-}
-
-std::vector<int> generic_ams_lane_centers(int lane_count, int width)
-{
-    std::vector<int> centers;
-    if (lane_count <= 0)
-        return centers;
-
-    centers.reserve(lane_count);
-    for (int lane = 0; lane < lane_count; ++lane)
-        centers.push_back(width * (lane + 1) / (lane_count + 1));
-    return centers;
-}
-
-int generic_ams_preview_width(wxWindow *window, int lane_count)
-{
-    const int base_width = window->FromDIP(52);
-    const int lane_width = window->FromDIP(9);
-    const int lane_gap = window->FromDIP(4);
-    if (lane_count <= 0)
-        return base_width;
-
-    return std::max(base_width, lane_count * lane_width + (lane_count + 1) * lane_gap);
-}
-
-bool use_generic_ams_layout(AMSModel model)
-{
-    return model == AMSModel::GENERIC_AMS &&
-           (!wxGetApp().preset_bundle || !wxGetApp().preset_bundle->is_bbl_vendor());
-}
 bool AMSinfo::parse_ams_info(MachineObject *obj, DevAms *ams, bool remain_flag, bool humidity_flag)
 {
    if (!ams) return false;
@@ -213,14 +170,10 @@ void AMSinfo::parse_ext_info(MachineObject* obj, DevAmsTray tray) {
    info.can_id = std::to_string(0);
    this->cans.clear();

-    try {
-        const int virtual_tray_id = std::stoi(tray.id);
-        if (virtual_tray_id >= 0 && virtual_tray_id <= VIRTUAL_TRAY_MAIN_ID)
-            this->nozzle_id = VIRTUAL_TRAY_MAIN_ID - virtual_tray_id;
-    }
-    catch (...) {
+    if (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID))
        this->nozzle_id = 0;
-    }
+    else if (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID))
+        this->nozzle_id = 1;

    if (tray.is_tray_info_ready()) {
        info.ctype = tray.ctype;
@@ -903,11 +856,7 @@ AMSextruder::AMSextruder(wxWindow *parent, wxWindowID id, int nozzle_num, const

 void AMSextruder::TurnOff()
 {
-    if (m_left_extruder) m_left_extruder->TurnOff();
-    if (m_right_extruder) m_right_extruder->TurnOff();
-    for (auto *extruder : m_nozzle_extruders) {
-        if (extruder) extruder->TurnOff();
-    }
+    m_left_extruder->TurnOff();
 }

 void AMSextruder::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, int nozzle_num)
@@ -933,7 +882,7 @@ void AMSextruder::OnAmsLoading(bool load, int nozzle_id, wxColour col /*= AMS_CO
        m_left_extruder->OnAmsLoading(load, col);
        if (load) m_current_colur_deputy = col;
    }
-    else if (m_nozzle_num == 2){
+    else if (m_nozzle_num > 1){
        if (nozzle_id == MAIN_EXTRUDER_ID) {
            m_right_extruder->OnAmsLoading(load, col);
            if (m_current_colur != col){
@@ -947,15 +896,6 @@ void AMSextruder::OnAmsLoading(bool load, int nozzle_id, wxColour col /*= AMS_CO
            }
        }
    }
-    else if (m_nozzle_num > 2) {
-        if (nozzle_id >= 0 && nozzle_id < static_cast<int>(m_nozzle_extruders.size())) {
-            m_nozzle_extruders[nozzle_id]->OnAmsLoading(load, col);
-            if (load) m_current_colur = col;
-        }
-    }
-    else {
-        // Generic N Nozzles
-    }
 }

 /*return true if something is updated*/
@@ -965,26 +905,12 @@ bool AMSextruder::updateNozzleNum(int nozzle_num, const string& series_name)
    m_series_name = series_name;
    m_nozzle_num = nozzle_num;
    this->DestroyChildren();
-    m_left_extruder = nullptr;
-    m_right_extruder = nullptr;
-    m_nozzle_extruders.clear();

-    m_bitmap_sizer = new wxBoxSizer(wxHORIZONTAL);
-    if (m_nozzle_num == 1) {
-        if (MachineObject::is_series_n(m_series_name)) {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
-        } else if (MachineObject::is_series_x(m_series_name) || MachineObject::is_series_p(m_series_name)) {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
-        } else {
-            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
-        }
+    m_right_extruder = new AMSextruderImage(this, wxID_ANY, "right_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);

-        m_left_extruder->setShowState(true);
-        m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
-    }
-    else if (m_nozzle_num == 2)
+    wxBoxSizer* m_bitmap_sizer = new wxBoxSizer(wxHORIZONTAL);
+    if (m_nozzle_num >= 2)
    {
-        m_right_extruder = new AMSextruderImage(this, wxID_ANY, "right_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
        m_left_extruder = new AMSextruderImage(this, wxID_ANY, "left_nozzle", AMS_EXTRUDER_DOUBLE_NOZZLE_BITMAP_SIZE);
        m_left_extruder->setShowState(true);
        m_right_extruder->setShowState(true);
@@ -992,17 +918,25 @@ bool AMSextruder::updateNozzleNum(int nozzle_num, const string& series_name)
        m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(2));
        m_bitmap_sizer->AddSpacer(2);
    }
-    else if (m_nozzle_num > 2) {
-        for (int nozzle_id = 0; nozzle_id < m_nozzle_num; ++nozzle_id) {
-            auto *extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
-            extruder->setShowState(true);
-            m_nozzle_extruders.push_back(extruder);
-            m_bitmap_sizer->Add(extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
-        }
-    }
    else
    {
-        // Generic N Nozzles
+        if (MachineObject::is_series_n(m_series_name))
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_n", AMS_EXTRUDER_SINGLE_NOZZLE_N_SIZE);
+        }
+        else if(MachineObject::is_series_x(m_series_name) || MachineObject::is_series_p(m_series_name))
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
+        }
+        else
+        {
+            m_left_extruder = new AMSextruderImage(this, wxID_ANY, "single_nozzle_xp", AMS_EXTRUDER_SINGLE_NOZZLE_XP_SIZE);
+        }
+
+        m_left_extruder->setShowState(true);
+        m_right_extruder->setShowState(false);
+        m_bitmap_sizer->Add(m_left_extruder, 0, wxALIGN_LEFT | wxALIGN_TOP, 0);
+        m_bitmap_sizer->Add(m_right_extruder, 0, wxLEFT | wxALIGN_TOP, FromDIP(3));
    }

    SetSizer(m_bitmap_sizer);
@@ -1017,9 +951,6 @@ void AMSextruder::msw_rescale()
    //m_amsSextruder->msw_rescale();
    if (m_left_extruder) m_left_extruder->msw_rescale();
    if (m_right_extruder) m_right_extruder->msw_rescale();
-    for (auto *extruder : m_nozzle_extruders) {
-        if (extruder) extruder->msw_rescale();
-    }
    Layout();
    Update();
    Refresh();
@@ -2192,10 +2123,7 @@ AMSRoadUpPart::AMSRoadUpPart(wxWindow* parent, wxWindowID id, AMSinfo info, AMSM
    m_ams_model = model;

    if (m_ams_model == AMSModel::GENERIC_AMS){
-        const int width = use_generic_ams_layout(m_ams_model)
-            ? generic_ams_layout_width(this, static_cast<int>(m_amsinfo.cans.size()))
-            : FromDIP(264);
-        create(parent, id, pos, wxSize(width, FromDIP(34)));
+        create(parent, id, pos, wxSize(FromDIP(264), FromDIP(34)));
    }
    else{
        create(parent, id, pos, wxSize(FromDIP(78), FromDIP(34)));
@@ -2307,38 +2235,6 @@ void AMSRoadUpPart::doRender(wxDC& dc)
    dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
    dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH));

-    if (use_generic_ams_layout(m_ams_model)) {
-        const int lane_count = static_cast<int>(m_amsinfo.cans.size());
-        if (lane_count <= 0)
-            return;
-
-        const auto lane_centers = generic_ams_lane_centers(lane_count, size.x);
-        const int height = FromDIP(21);
-        for (const int lane_center : lane_centers)
-            dc.DrawLine(lane_center, 0, lane_center, height);
-
-        if (lane_centers.size() > 1)
-            dc.DrawLine(lane_centers.front(), height, lane_centers.back(), height);
-        dc.DrawLine(size.x / 2, height, size.x / 2, size.y);
-
-        if (m_load_step != AMSPassRoadSTEP::AMS_ROAD_STEP_NONE &&
-            m_load_slot_index >= 0 && m_load_slot_index < lane_count) {
-            const int lane_center = lane_centers[m_load_slot_index];
-            dc.SetPen(wxPen(_get_diff_clr(this, m_amsinfo.cans[m_load_slot_index].material_colour), 4, wxPENSTYLE_SOLID));
-            dc.DrawLine(lane_center, 0, lane_center, height);
-            dc.DrawLine(std::min(lane_center, size.x / 2), height,
-                        std::max(lane_center, size.x / 2), height);
-            if (m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 ||
-                m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3)
-                dc.DrawLine(size.x / 2, height, size.x / 2, size.y);
-        }
-
-        dc.SetPen(*wxTRANSPARENT_PEN);
-        dc.SetBrush(wxBrush(wxColour(194, 194, 194)));
-        dc.DrawRectangle(size.x / 2 - FromDIP(14), height - FromDIP(5), FromDIP(28), FromDIP(10));
-        return;
-    }
-
    if ((m_ams_model == N3S_AMS || m_ams_model == EXT_AMS) && m_amsinfo.cans.size() != 4){
        dc.DrawLine(((float)size.x / 2), (0), ((float)size.x / 2), (size.y));
        if (m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_load_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3){
@@ -2464,45 +2360,6 @@ void AMSRoadDownPart::UpdateRight(int nozzle_num, AMSRoadShowMode mode)
    Refresh();
 }

-void AMSRoadDownPart::SetNozzleCount(int nozzle_num)
-{
-    const int new_nozzle_num = std::max(1, nozzle_num);
-    if (m_nozzle_num == new_nozzle_num &&
-        (new_nozzle_num <= 2 || static_cast<int>(m_generic_road_states.size()) == new_nozzle_num)) {
-        return;
-    }
-
-    m_nozzle_num = new_nozzle_num;
-    if (m_nozzle_num > 2)
-        m_generic_road_states.resize(m_nozzle_num);
-    else
-        m_generic_road_states.clear();
-    Refresh();
-}
-
-void AMSRoadDownPart::SetSingleSideLayout(bool enabled, AMSPanelPos pos)
-{
-    if (m_single_side_layout == enabled && m_single_side_pos == pos)
-        return;
-
-    m_single_side_layout = enabled;
-    m_single_side_pos = pos;
-    Refresh();
-}
-
-void AMSRoadDownPart::UpdateNozzle(int nozzle_id, AMSRoadShowMode mode)
-{
-    if (nozzle_id < 0) return;
-    if (nozzle_id >= static_cast<int>(m_generic_road_states.size()))
-        m_generic_road_states.resize(nozzle_id + 1);
-
-    auto &state = m_generic_road_states[nozzle_id];
-    if (state.mode == mode && m_nozzle_num > 2) return;
-    state.mode = mode;
-    m_nozzle_num = std::max(m_nozzle_num, nozzle_id + 1);
-    Refresh();
-}
-
 void AMSRoadDownPart::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
 {
    /*m_vams_loading = load;
@@ -2532,17 +2389,6 @@ void AMSRoadDownPart::SetPassRoadColour(bool left, wxColour col)
    Refresh();
 }

-void AMSRoadDownPart::SetPassRoadColour(int nozzle_id, wxColour col)
-{
-    if (nozzle_id < 0) return;
-    if (nozzle_id >= static_cast<int>(m_generic_road_states.size()))
-        m_generic_road_states.resize(nozzle_id + 1);
-
-    if (m_generic_road_states[nozzle_id].road_color == col) return;
-    m_generic_road_states[nozzle_id].road_color = col;
-    Refresh();
-}
-
 void AMSRoadDownPart::SetShowMode(AMSRoadShowMode left_mode, AMSRoadShowMode right_mode)
 {
    if (m_left_rode_mode == left_mode && m_right_rode_mode == right_mode) { return; }
@@ -2587,34 +2433,8 @@ void AMSRoadDownPart::doRender(wxDC& dc)
    /*if (m_road_color.Alpha() == 0) { dc.SetPen(wxPen(*wxWHITE, m_passroad_width, wxPENSTYLE_SOLID)); }
    else { dc.SetPen(wxPen(m_road_color, m_passroad_width, wxPENSTYLE_SOLID)); }*/
    dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
-
-    if (m_nozzle_num > 2) {
-        const int nozzle_count = std::min(m_nozzle_num, static_cast<int>(m_generic_road_states.size()));
-        for (int nozzle_id = 0; nozzle_id < nozzle_count; ++nozzle_id) {
-            const auto &state = m_generic_road_states[nozzle_id];
-            if (state.mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE) continue;
-
-            const int x = size.x * (nozzle_id + 1) / (nozzle_count + 1);
-            dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
-            dc.DrawLine(x, size.y / 2, x, size.y);
-
-            if (state.road_length > 0 &&
-                (state.pass_road_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 ||
-                 state.pass_road_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3)) {
-                dc.SetPen(wxPen(_get_diff_clr(this, state.road_color), 4, wxPENSTYLE_SOLID));
-                dc.DrawLine(x - FromDIP(state.road_length), size.y / 2, x, size.y / 2);
-            }
-        }
-        return;
-    }
-
    auto xpos = left_nozzle_pos.x;
-    if (m_single_side_layout) {
-        dc.DrawLine(size.x / 2, 0, size.x / 2, size.y);
-    }
-    else if (
-        (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE ||
-         m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE)){
+    if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE){
        auto length = 50;
        if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE)
            length = -13;
@@ -2645,9 +2465,6 @@ void AMSRoadDownPart::doRender(wxDC& dc)
        case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
            dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
            break;
-        case AMSRoadShowMode::AMS_ROAD_MODE_GENERIC:
-            // Generic N-lane geometry is intentionally left unimplemented.
-            break;
        default:
            break;
        }
@@ -2675,41 +2492,23 @@ void AMSRoadDownPart::doRender(wxDC& dc)
            dc.DrawLine(left_nozzle_pos.x, (size.y / 2), left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x + FromDIP(145), 0, left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            break;
-        case AMSRoadShowMode::AMS_ROAD_MODE_GENERIC:
-            // Generic N-lane geometry is intentionally left unimplemented.
-            break;
        default:
            break;
        }
    }

-    if (m_single_side_layout) {
-        if (m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 ||
-            m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
-            dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[1]), 4, wxPENSTYLE_SOLID));
-            dc.DrawLine(size.x / 2, 0, size.x / 2, size.y);
-        }
-        return;
-    }
-
    if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
-        if (m_nozzle_num == 1) {
-            if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
-                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
-            }
-            const auto &nozzle_pos = m_single_side_layout && m_single_side_pos == AMSPanelPos::RIGHT_PANEL
-                ? right_nozzle_pos
-                : left_nozzle_pos;
-            dc.DrawLine(nozzle_pos.x, (size.y / 2), nozzle_pos.x, (size.y));
-        }
-        else if (m_nozzle_num == 2) {
+        if (m_nozzle_num == 2) {
            /*dc.DrawLine(FromDIP(left_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(left_nozzle_pos.x), FromDIP(size.y));
            dc.DrawLine(FromDIP(right_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(right_nozzle_pos.x), FromDIP(size.y));*/
            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
            dc.DrawLine((right_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y));
        }
        else {
-            // Generic N Nozzles
+            if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
+                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
+            }
+            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
        }
    }

@@ -2734,16 +2533,10 @@ void AMSRoadDownPart::doRender(wxDC& dc)
                 dc.DrawLine(xpos, size.y / 2, xpos, size.y);*/
                int x   = left_nozzle_pos.x;
                int len = m_right_road_length;
-                if (m_nozzle_num == 1) {
-                    // Keep the single-nozzle path anchored at the left nozzle.
-                }
-                else if (m_nozzle_num == 2) {
+                if (m_nozzle_num == 2) {
                    x   = right_nozzle_pos.x;
                    len = len - 14;
                }
-                else {
-                    // Generic N Nozzles
-                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
@@ -2751,16 +2544,10 @@ void AMSRoadDownPart::doRender(wxDC& dc)
            else{
                int x = left_nozzle_pos.x;
                int len = m_right_road_length;
-                if (m_nozzle_num == 1) {
-                    // Keep the single-nozzle path anchored at the left nozzle.
-                }
-                else if (m_nozzle_num == 2) {
+                if (m_nozzle_num == 2) {
                    x = right_nozzle_pos.x;
                    len = len - 14;
                }
-                else {
-                    // Generic N Nozzles
-                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
@@ -2784,7 +2571,7 @@ void AMSRoadDownPart::doRender(wxDC& dc)
 }

 void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP step) {
-    if (m_nozzle_num == 2){
+    if (m_nozzle_num >= 2){
        if (pos == AMSPanelPos::LEFT_PANEL){
            if (m_left_road_length == len && m_pass_road_left_step == step){ return; }
            m_left_road_length = len;;
@@ -2796,7 +2583,7 @@ void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP s
            m_pass_road_right_step = step;
        }
    }
-    else if (m_nozzle_num == 1){
+    else{
        if (pos == AMSPanelPos::LEFT_PANEL) {
            if (m_left_road_length == len && m_pass_road_left_step == step && m_right_road_length == -1) { return; }
            m_left_road_length = len;
@@ -2810,22 +2597,6 @@ void AMSRoadDownPart::UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP s
            m_pass_road_right_step = step;
        }
    }
-    else {
-        // Generic N Nozzles
-    }
-    Refresh();
-}
-
-void AMSRoadDownPart::UpdatePassRoad(int nozzle_id, int len, AMSPassRoadSTEP step)
-{
-    if (nozzle_id < 0) return;
-    if (nozzle_id >= static_cast<int>(m_generic_road_states.size()))
-        m_generic_road_states.resize(nozzle_id + 1);
-
-    auto &state = m_generic_road_states[nozzle_id];
-    if (state.road_length == len && state.pass_road_step == step) return;
-    state.road_length = len;
-    state.pass_road_step = step;
    Refresh();
 }

@@ -2844,10 +2615,7 @@ AMSPreview::AMSPreview(wxWindow* parent, wxWindowID id, AMSinfo amsinfo, AMSMode
 {
    wxWindow::Create(parent, id, pos);
    if (itemType == AMSModel::GENERIC_AMS || itemType == AMSModel::AMS_LITE || itemType == AMSModel::N3F_AMS) {
-        if (itemType == AMSModel::GENERIC_AMS && use_generic_ams_layout(itemType))
-            create(parent, id, pos, wxSize(generic_ams_preview_width(this, static_cast<int>(amsinfo.cans.size())), AMS_PREV_FOUR_SIZE.y));
-        else
-            create(parent, id, pos, AMS_PREV_FOUR_SIZE);
+        create(parent, id, pos, AMS_PREV_FOUR_SIZE);
    }
    else {
        create(parent, id, pos, AMS_PREV_SINGLE_SIZE);
@@ -2882,13 +2650,7 @@ void AMSPreview::UpdateInfo(AMSinfo amsinfo)
    m_amsinfo = amsinfo;
    m_ams_item_type = amsinfo.ams_type;

-    if (m_ams_item_type == AMSModel::GENERIC_AMS && use_generic_ams_layout(m_ams_item_type)) {
-        const wxSize generic_size(generic_ams_preview_width(this, static_cast<int>(m_amsinfo.cans.size())), AMS_PREV_FOUR_SIZE.y);
-        SetSize(generic_size);
-        SetMinSize(generic_size);
-        SetMaxSize(generic_size);
-    }
-    else if (m_ams_item_type == AMSModel::GENERIC_AMS || m_ams_item_type == AMSModel::AMS_LITE || m_ams_item_type == AMSModel::N3F_AMS) {
+    if (m_ams_item_type == AMSModel::GENERIC_AMS || m_ams_item_type == AMSModel::AMS_LITE || m_ams_item_type == AMSModel::N3F_AMS) {
        SetMinSize(AMS_PREV_FOUR_SIZE);
        SetMaxSize(AMS_PREV_FOUR_SIZE);
    } else {
@@ -2996,41 +2758,8 @@ void AMSPreview::doRender(wxDC &dc)
    dc.DrawRoundedRectangle(0, 0, size.x, size.y, FromDIP(3));

    auto left = 0;
-    // Generic AMS previews use the same normalized lane centers as the card row and connector.
-    if (m_ams_item_type == AMSModel::GENERIC_AMS && use_generic_ams_layout(m_ams_item_type)) {
-        const int lane_count = static_cast<int>(m_amsinfo.cans.size());
-        const auto lane_centers = generic_ams_lane_centers(lane_count, size.x);
-        const int cube_width = FromDIP(9);
-        const int cube_height = FromDIP(14);
-
-        for (int lane = 0; lane < lane_count; ++lane) {
-            const Caninfo &can = m_amsinfo.cans[lane];
-            const int cube_left = lane_centers[lane] - cube_width / 2;
-            const int cube_top = (size.y - cube_height) / 2;
-            wxRect rect(cube_left, cube_top, cube_width, cube_height);
-
-            if (can.material_colour.Alpha() == 0) {
-                if (wxGetApp().dark_mode())
-                    dc.DrawBitmap(m_ts_bitmap_cube_dark.bmp(), cube_left - FromDIP(1), (size.y - m_ts_bitmap_cube_dark.GetBmpHeight()) / 2);
-                else
-                    dc.DrawBitmap(m_ts_bitmap_cube.bmp(), cube_left - FromDIP(1), (size.y - m_ts_bitmap_cube.GetBmpHeight()) / 2);
-            }
-            else if (can.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
-                dc.SetPen(wxPen(wxColor(0, 0, 0)));
-                dc.DrawLine(rect.GetRight() - FromDIP(1), rect.GetTop() + FromDIP(1),
-                            rect.GetLeft() + FromDIP(1), rect.GetBottom() - FromDIP(1));
-            }
-            else {
-                wxColour color = can.material_colour;
-                change_the_opacity(color);
-                dc.SetPen(wxPen(*wxTRANSPARENT_PEN));
-                dc.SetBrush(wxBrush(color));
-                dc.DrawRoundedRectangle(rect, 2);
-            }
-        }
-    }
-    // four slot
-    else if (m_ams_item_type != AMSModel::EXT_AMS && m_ams_item_type != AMSModel::N3S_AMS){
+    //four slot
+    if (m_ams_item_type != AMSModel::EXT_AMS && m_ams_item_type != AMSModel::N3S_AMS){
        left =  FromDIP(8);
        for (std::vector<Caninfo>::iterator iter = m_amsinfo.cans.begin(); iter != m_amsinfo.cans.end(); iter++) {

@@ -3429,19 +3158,10 @@ AmsItem::AmsItem(wxWindow *parent,AMSinfo info,  AMSModel model, AMSPanelPos pos
    m_panel_pos = pos;

    if (m_ams_model == AMSModel::GENERIC_AMS){
-        const int lane_count = static_cast<int>(m_info.cans.size());
-        const int width = use_generic_ams_layout(m_ams_model) && lane_count <= 8
-            ? generic_ams_layout_width(this, lane_count)
-            : FromDIP(264);
-        const wxSize generic_size(width, FromDIP(174));
-        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, generic_size);
-        SetSize(generic_size);
-        SetMinSize(generic_size);
-        // For large lane counts the card is a viewport, not the lane strip. Let
-        // its parent allocate the available width; the scrolled child retains
-        // the wider virtual content size.
-        if (!(use_generic_ams_layout(m_ams_model) && lane_count > 8))
-            SetMaxSize(generic_size);
+        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE);
+        SetSize(AMS_CANS_WINDOW_SIZE);
+        SetMinSize(AMS_CANS_WINDOW_SIZE);
+        SetMaxSize(AMS_CANS_WINDOW_SIZE);
    }
    else{
        wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_SINGLE_CAN_SIZE);
@@ -3467,43 +3187,12 @@ void AmsItem::create(wxWindow *parent)
    if (m_ams_model != AMSModel::AMS_LITE) {
        sizer_can = new wxBoxSizer(wxHORIZONTAL);
        sizer_item = new wxBoxSizer(wxVERTICAL);
-        const bool generic_layout = use_generic_ams_layout(m_ams_model);
-        const int lane_count = static_cast<int>(m_info.cans.size());
-        const int content_width = generic_layout ? generic_ams_layout_width(this, lane_count) : 0;
-        const bool scroll_lanes = generic_layout && lane_count > 8;
-        const auto lane_centers = generic_layout
-            ? generic_ams_lane_centers(lane_count, content_width)
-            : std::vector<int>();
-
-        m_can_parent = this;
-        if (scroll_lanes) {
-            m_can_scroll = new wxScrolledWindow(this, wxID_ANY);
-            m_can_scroll->SetScrollRate(FromDIP(10), 0);
-            m_can_scroll->SetMinSize(wxSize(FromDIP(264), FromDIP(143)));
-            m_can_scroll->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
-            m_can_scroll_sizer = new wxBoxSizer(wxVERTICAL);
-            m_can_scroll->SetSizer(m_can_scroll_sizer);
-            m_can_parent = m_can_scroll;
-        }
-
-        int previous_right = 0;
-        for (int can_index = 0; can_index < lane_count; ++can_index) {
-            if (generic_layout) {
-                const int left = lane_centers[can_index] - FromDIP(26);
-                sizer_can->AddSpacer(std::max(0, left - previous_right));
-                AddCan(m_info.cans[can_index], m_can_count, m_info.cans.size(), sizer_can);
-                previous_right = left + FromDIP(52);
-            }
-            else {
-                AddCan(m_info.cans[can_index], m_can_count, m_info.cans.size(), sizer_can);
-            }
+        auto it = m_info.cans.begin();
+        for (; it != m_info.cans.end(); it++) {
+            AddCan(*it, m_can_count, m_info.cans.size(), sizer_can);
            m_can_count++;
        }
-        if (generic_layout)
-            sizer_can->AddSpacer(std::max(0, content_width - previous_right));
-        if (generic_layout)
-            sizer_can->SetMinSize(wxSize(content_width, -1));
-
+        it = m_info.cans.begin();
        //auto        road_panel = new wxWindow(this, wxID_ANY);
        //auto        road_panel = new wxPanel(this, wxID_ANY);
        //road_panel->SetSize(AMS_CAN_ROAD_SIZE);
@@ -3518,18 +3207,11 @@ void AmsItem::create(wxWindow *parent)
                sizer_item->Add(m_ext_image, 0, wxALIGN_CENTER, 0);
            }
        }
-        m_panel_road = new AMSRoadUpPart(m_can_parent, wxID_ANY, m_info, m_ams_model);
+        m_panel_road = new AMSRoadUpPart(this, wxID_ANY, m_info, m_ams_model);

-        if (scroll_lanes) {
-            m_can_scroll_sizer->Add(sizer_can, 0, wxALIGN_LEFT, 0);
-            m_can_scroll_sizer->Add(m_panel_road, 0, wxALIGN_LEFT, 0);
-            sizer_item->Add(m_can_scroll, 1, wxEXPAND);
-        }
-        else {
-            sizer_item->Add(sizer_can, 0, wxALIGN_CENTER_HORIZONTAL, 0);
-            //sizer_item->Add(m_panel_road, 0, wxALIGN_CENTER_HORIZONTAL, 0);
-            sizer_item->Add(m_panel_road, 1, wxEXPAND);
-        }
+        sizer_item->Add(sizer_can, 0, wxALIGN_CENTER_HORIZONTAL, 0);
+        //sizer_item->Add(m_panel_road, 0, wxALIGN_CENTER_HORIZONTAL, 0);
+        sizer_item->Add(m_panel_road, 1, wxEXPAND);

        SetSizer(sizer_item);
    }
@@ -3553,17 +3235,13 @@ void AmsItem::create(wxWindow *parent)

    Layout();
    Fit();
-    if (m_can_scroll) {
-        m_can_scroll->Layout();
-        m_can_scroll->FitInside();
-    }
    Thaw();
    //Refresh();
 }

 void AmsItem::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* sizer)
 {
-    auto        amscan = new wxWindow(m_can_parent ? m_can_parent : this, wxID_ANY);
+    auto        amscan = new wxWindow(this, wxID_ANY);

    amscan->SetSize(wxSize(FromDIP(52), FromDIP(109)));
    amscan->SetMinSize(wxSize(FromDIP(52), FromDIP(109)));
@@ -3644,8 +3322,7 @@ void AmsItem::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* size
    amscan->Layout();
    amscan->Fit();

-    const int margin = use_generic_ams_layout(m_ams_model) ? 0 : FromDIP(5);
-    sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, margin);
+    sizer->Add(amscan, 0, wxUP | wxLEFT | wxRIGHT, FromDIP(5));

    m_can_lib_list[caninfo.can_id] = m_panel_lib;
    //m_can_road_list[caninfo.can_id] = m_panel_road;
@@ -3770,10 +3447,6 @@ void AmsItem::UpdateInfo(AMSinfo info)
    }

    Layout();
-    if (m_can_scroll) {
-        m_can_scroll->Layout();
-        m_can_scroll->FitInside();
-    }
 }

 void AmsItem::SetDefSelectCan()
@@ -30,7 +30,6 @@
 #include <wx/string.h>
 #include <wx/timer.h>
 #include <wx/sizer.h>
-#include <wx/scrolwin.h>

 #include "slic3r/GUI/DeviceCore/DevFilaSwitch.h" // Orca: DevFilaSwitch::SwitchPos for inlet-aware AMS placement

@@ -97,7 +96,6 @@ enum class AMSRoadShowMode : int {
    AMS_ROAD_MODE_SINGLE,
    AMS_ROAD_MODE_SINGLE_N3S,
    AMS_ROAD_MODE_AMS_LITE,
-    AMS_ROAD_MODE_GENERIC,
    AMS_ROAD_MODE_NONE
 };

@@ -482,7 +480,6 @@ public:
    //AMSextruderImage *m_amsSextruder{nullptr};
    AMSextruderImage* m_left_extruder = nullptr;
    AMSextruderImage* m_right_extruder = nullptr;
-    std::vector<AMSextruderImage*> m_nozzle_extruders;
    AMSextruder(wxWindow *parent, wxWindowID id, int nozzle_num, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
    ~AMSextruder();

@@ -684,16 +681,11 @@ public:
    // void                         Update(AMSRoadDownPartMode nozzle, AMSRoadShowMode left_mode, AMSRoadShowMode right_mode, int left_len, int right_len);
    void UpdateLeft(int nozzle_num, AMSRoadShowMode mode);
    void UpdateRight(int nozzle_num, AMSRoadShowMode mode);
-    void SetNozzleCount(int nozzle_num);
-    void SetSingleSideLayout(bool enabled, AMSPanelPos pos = AMSPanelPos::LEFT_PANEL);
-    void UpdateNozzle(int nozzle_id, AMSRoadShowMode mode);

    void OnVamsLoading(bool load, wxColour col = AMS_CONTROL_GRAY500);
    void SetPassRoadColour(bool left, wxColour col);
-    void SetPassRoadColour(int nozzle_id, wxColour col);
    void SetShowMode(AMSRoadShowMode left_mode, AMSRoadShowMode right_mode);
    void UpdatePassRoad(AMSPanelPos pos, int len, AMSPassRoadSTEP step);
-    void UpdatePassRoad(int nozzle_id, int len, AMSPassRoadSTEP step);

    void paintEvent(wxPaintEvent& evt);
    void render(wxDC& dc);
@@ -706,8 +698,6 @@ private:
    AMSRoadShowMode m_left_rode_mode       = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR};
    AMSRoadShowMode m_right_rode_mode      = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR};
    bool            m_selected             = {false};
-    bool            m_single_side_layout   = {false};
-    AMSPanelPos     m_single_side_pos     = {AMSPanelPos::LEFT_PANEL};

    int             m_left_road_length     = {-1};
    int             m_right_road_length    = {-1};
@@ -715,15 +705,6 @@ private:
    AMSPassRoadSTEP m_pass_road_right_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};

    std::map<int, wxColour> m_road_color;
-
-    struct GenericRoadState
-    {
-        AMSRoadShowMode mode{AMSRoadShowMode::AMS_ROAD_MODE_NONE};
-        int road_length{-1};
-        AMSPassRoadSTEP pass_road_step{AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};
-        wxColour road_color{AMS_CONTROL_GRAY500};
-    };
-    std::vector<GenericRoadState> m_generic_road_states;
 };

 /*************************************************
@@ -883,9 +864,6 @@ private:

    std::map<std::string, AMSLib*>      m_can_lib_list;
    //std::map<std::string, AMSRoad*>     m_can_road_list;
-    wxScrolledWindow* m_can_scroll = { nullptr };
-    wxBoxSizer*       m_can_scroll_sizer = { nullptr };
-    wxWindow*         m_can_parent = { nullptr };
    AMSRoadUpPart* m_panel_road = { nullptr };
    std::map<std::string, AMSrefresh*>  m_can_refresh_list;
    AMSHumidity* m_humidity = { nullptr };
@@ -3,7 +3,7 @@
 #include "../I18N.hpp"
 #include "../GUI_App.hpp"
 #include "../MsgDialog.hpp"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>

 #include <wx/anybutton.h>
 #include <wx/event.h>
@@ -28,6 +28,8 @@
 #include <wx/stattext.h>
 #include <wx/sizer.h>

+using json = nlohmann::json;
+
 namespace Slic3r { namespace GUI {

 wxDEFINE_EVENT(EVT_FAN_SWITCH_ON, wxCommandEvent);
@@ -12,7 +12,7 @@
 #include "Label.hpp"
 #include "ComboBox.hpp"
 #include "StaticBox.hpp"
-#include "json_diff.hpp"
+#include <nlohmann/json.hpp>
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/Utils.hpp"

@@ -55,6 +55,7 @@
 #include <boost/filesystem.hpp>

 namespace fs = boost::filesystem;
+using json = nlohmann::json;

 namespace Slic3r { namespace GUI {

@@ -866,21 +867,14 @@ void MultiNozzleStatusTable::UpdateRackInfo(std::weak_ptr<DevNozzleRack> rack)
        bool has_right = false;
        for (auto& elem : nozzles_in_extruder) {
            auto& nozzle = elem.second;
-
-            int extruder_id{};
-            if (wxGetApp().preset_bundle->is_bbl_vendor()) {
-                extruder_id = nozzle.AtLeftExtruder() ? 0 : 1;
-                if (nozzle.AtRightExtruder())
-                    has_right = true;
-            }
-            else
-                extruder_id = nozzle.GetExtruderId();
+            int extruder_id = nozzle.AtLeftExtruder() ? 0 : 1;
+            if (nozzle.AtRightExtruder())
+                has_right = true;

            NozzleVolumeType volume_type = DevNozzle::ToNozzleVolumeType(nozzle.m_nozzle_flow);

            m_badge->SetExtruderInfo(extruder_id, format_diameter_to_str(nozzle.GetNozzleDiameter()), volume_type);
        }
-        // TODO: Update for N extruders
        m_badge->SetExtruderValid(has_right);
    }
 }
@@ -184,9 +184,6 @@ void TempInput::SetFinish()
    wxCommandEvent event(wxCUSTOMEVT_SET_TEMP_FINISH);
    event.SetInt(temp_type);
    event.SetString(wxString::Format("%d", m_input_type));
-    // N-extruder temp controls all share TEMP_OF_NORMAL_TYPE, so the string payload above can't
-    // tell them apart; carry widget identity so the listener can find which one fired.
-    event.SetEventObject(this);
    wxPostEvent(this->GetParent(), event);
 }

@@ -38,11 +38,12 @@
 #include "Widgets/Label.hpp"
 #include "MainFrame.hpp"
 #include "libslic3r/PresetBundle.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
+#include <nlohmann/json.hpp>
 #include "slic3r/GUI/Jobs/SendJob.hpp"
-#include "slic3r/Utils/json_diff.hpp"
 #include <boost/filesystem.hpp>

+using json = nlohmann::json;
+
 class wxWindow;

 namespace fs = boost::filesystem;
@@ -453,9 +453,16 @@ wxBitmap create_scaled_bitmap(  const std::string& bmp_name_in,
                                const bool menu_bitmap/* = false*/,
                                const bool resize/* = false*/,
                                const bool bitmap2/* = false*/,
-                                const vector<std::string>& array_new_color/* = vector<std::string>*/)//used for semi transparent material)
+                                const std::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);
    }
@@ -494,7 +501,7 @@ wxBitmap create_scaled_bitmap(  const std::string& bmp_name_in,

 wxBitmap create_scaled_bitmap2(const std::string& bmp_name_in, Slic3r::GUI::BitmapCache& cache, wxWindow* win/* = nullptr*/ ,
    const int px_cnt/* = 16*/, const bool grayscale/* = false*/ , const bool resize/* = false*/ ,
-    const vector<std::string>& array_new_color/* = vector<std::string>()*/) // color witch will used instead of orange
+    const std::vector<std::string>& array_new_color/* = vector<std::string>()*/) // color witch will used instead of orange
 {
    unsigned int width = 0;
    // win may be nullptr; see create_scaled_bitmap() above.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Hanif Koh	1a5b372fd2	Declare json in OrcaSlicer.cpp on Every Platform OrcaSlicer.cpp had its "using namespace nlohmann;" and the json include inside the Linux-only include block, so on Windows and macOS it took json from AppConfig.hpp's global directive, which is gone. The include and a "using json = nlohmann::json;" now sit outside the block.	2026-10-07 02:45:49 +08:00
Hanif Koh	d8793f8353	Stop Leaking json Through Headers and Drop Includes Kept Only for the Name AppConfig.hpp, DeviceManager.hpp and UserManager.hpp carried a global "using namespace nlohmann;", json_diff.hpp a global "using json = nlohmann::json;" and PrinterFileSystem.h a global "using nlohmann::json;". Every file that included one of them, directly or not, could write a bare json, and 63 did without declaring it. The last two also made the include checker treat json_diff.hpp and PrinterFileSystem.h as the headers that provide json, so they were included from files that use nothing else from them: 57 of the 59 includers of json_diff.hpp never name json_diff. The five statements are removed. Headers that use the type now spell nlohmann::json, source files declare their own "using json = nlohmann::json;", and the includes that only supplied the name are dropped or replaced by <nlohmann/json.hpp>. Eight files reached json_diff.hpp only through an include that is now gone and with it lost that header's "using namespace std;". The std names they used unqualified are qualified.	2026-10-07 01:39:17 +08:00
Rodrigo Faselli	13d4a0d922	Avoid center plug for internal solid infill (spiral inset) (#15705 ) avoid center plug for internal solid infill	2026-10-06 11:41:25 -03:00
Ian Bassi	c74ac8a6c3	Keep FPS/timings overlay below the toolbar on narrow canvases (#16215 )	2026-10-06 11:36:47 -03:00
Ian Bassi	2d90345d1e	Move fill-pattern-tops wiki under 3D Honeycomb (#16214 )	2026-10-06 10:34:28 -03:00
Ioannis Giannakas	5a8eb3f14e	Fix one wall on top dropping inner walls of narrow Arachne walls (#16174 ) * Fix one wall on top dropping inner walls of narrow Arachne walls * Fix clang tidy errors on the test suite	2026-10-06 14:07:01 +01:00
Kris Austin	e7d6f5e6c0	fix: crash in LAN mode when the printer type is not known yet (#16191 ) * fix: crash in LAN mode when the printer type is not known yet InputIpAddressDialog::set_machine_obj() built the help image name from the printer config with no fallback. If the printer type is empty or unknown, for example before the first push_all arrives on a flaky LAN link, the lookup returns "" and create_scaled_bitmap("_en") throws. The dialog is opened by the "LAN Connection Failed" handlers in MediaPlayCtrl and MediaFilePanel, where nothing catches the exception, so the app crashes. Use input_access_code_x1 when there is no image, and the _cn image for zh_CN, the same as ConnectPrinterDialog::init_bitmap(). Ported from Bambu Studio 52ca2ec5d1. * fix: return an empty bitmap for an empty icon name create_scaled_bitmap() threw when a caller passed an empty name. That happens when a printer config lookup has no entry, for example in AMSSetting::update_ams_img() for a printer type with no AMS image. Log an error and return wxNullBitmap instead. Ported from Bambu Studio 52ca2ec5d1.	2026-10-06 09:55:25 -03:00