Allow Unsigned Executable Memory in the macOS Entitlements

The Bambu network plug-in's code protector rewrites one page of its own signed __TEXT after loading. The hardened runtime tolerates that until the page is evicted; the next read of it then kills OrcaSlicer with CODESIGNING Invalid Page. Bambu Studio signs with allow-unsigned-executable-memory for this reason; with it added, the same build survives critical memory pressure that killed it in 30 s without.

scripts/clang_tidy_diff.py

@@ -8,9 +8,6 @@ include) fails wherever the error is. Headers are compiled on their own, and
 fail only on errors in their changed lines. Deleting an #include also fails
 on every use, changed or not, that now lacks the header it provided.
 
-With -- --fix, clang-tidy adds the missing includes, on those lines only, and
-each file it changed is checked again so that only what remains is reported.
-
 The checks come from .clang-tidy at the repository root. The compile database
 must come from a configure with SLIC3R_PCH=OFF, or the precompiled header hides
 missing includes.
@@ -105,10 +102,9 @@ def is_checked(path):
 
 def changed_files(merge_base):
     # Against the working tree, so a local run covers uncommitted edits too.
-    # core.quotePath=false keeps a non-ASCII path unquoted, and the explicit prefixes
-    # override diff.noprefix and diff.mnemonicPrefix, so parse_diff sees its b/ prefix.
+    # core.quotePath=false keeps a non-ASCII path unquoted, so parse_diff sees its b/ prefix.
     diff = subprocess.run(["git", "-c", "core.quotePath=false", "diff", "-U0", "--no-color", "--no-ext-diff",
-                           "--src-prefix=a/", "--dst-prefix=b/", "--diff-filter=AMR", merge_base],
+                           "--diff-filter=AMR", merge_base],
                           check=True, capture_output=True, **UTF8).stdout
     return {path: change for path, change in parse_diff(diff).items() if is_checked(path)}
 
@@ -205,19 +201,13 @@ def errors_alone_at(revision, clang_tidy, build_dir, path):
 
 
 def check_file(clang_tidy, build_dir, merge_base, path, change, extra_args):
-    """Run clang-tidy on one file and return (failed, output, failing diagnostics, fixed)."""
-    fixing = any(arg.startswith("--fix") for arg in extra_args)
-    if fixing:
-        with open(path, "rb") as f:
-            before = f.read()
+    """Run clang-tidy on one file and return (failed, output, failing diagnostics)."""
     # A deleted include can orphan uses on unchanged lines, so such a file is
-    # checked whole and the findings narrowed here. --fix keeps a line filter so
-    # it never rewrites unrelated code, which for such a file means a second,
-    # fixing run limited to the lines the first one found wanting.
-    whole = bool(change.removed_includes)
+    # checked whole and the findings narrowed here. --fix keeps the line filter
+    # so it never rewrites unrelated code.
+    whole = bool(change.removed_includes) and not extra_args
     returncode, output, diagnostics = run_clang_tidy(clang_tidy, build_dir, path,
-                                                     None if whole else change.lines,
-                                                     [] if whole else extra_args)
+                                                     None if whole else change.lines, extra_args)
     real = os.path.realpath(path)
 
     def introduced(d):
@@ -233,25 +223,14 @@ def check_file(clang_tidy, build_dir, merge_base, path, change, extra_args):
         if errors and change.removed_includes:
             with open(path, encoding="utf-8") as f:
                 text = f.read()
-            before_sites = errors_alone_at(merge_base, clang_tidy, build_dir, path)
+            before = errors_alone_at(merge_base, clang_tidy, build_dir, path)
             failing += [d for d in errors if d not in failing
-                        and (error_sites([d], text) - before_sites)]
-        failed = bool(failing)
-    elif whole:
+                        and (error_sites([d], text) - before)]
+        return bool(failing), output, failing
+    if whole:
         failing = [d for d in diagnostics if d.is_compile_error or introduced(d)]
-        failed = bool(failing)
-    else:
-        failing, failed = diagnostics, returncode != 0
-    if not fixing:
-        return failed, output, failing, False
-    if whole and failing:
-        lines = change.lines + [[d.line, d.line] for d in failing if os.path.realpath(d.file) == real]
-        run_clang_tidy(clang_tidy, build_dir, path, lines, extra_args)
-    with open(path, "rb") as f:
-        if f.read() == before:
-            return failed, output, failing, False
-    # Checked again, so what is reported is what the fixes left.
-    return check_file(clang_tidy, build_dir, merge_base, path, change, [])[:3] + (True,)
+        return bool(failing), output, failing
+    return returncode != 0, output, diagnostics
 
 
 def main():
@@ -284,14 +263,11 @@ def main():
     annotate = os.environ.get("GITHUB_ACTIONS") == "true"
     root = os.getcwd() + os.sep
     failed = []
-    fixed = []
     with ThreadPoolExecutor(max_workers=args.jobs) as pool:
         jobs = {path: pool.submit(check_file, args.clang_tidy, args.build_dir, merge_base, path, change, args.extra_args)
                 for path, change in todo}
         for path, job in jobs.items():
-            file_failed, output, diagnostics, file_fixed = job.result()
-            if file_fixed:
-                fixed.append(path)
+            file_failed, output, diagnostics = job.result()
             if not file_failed:
                 continue
             failed.append(path)
@@ -306,13 +282,6 @@ def main():
             if len(diagnostics) > MAX_REPORTED:
                 print(f"... and {len(diagnostics) - MAX_REPORTED} more")
 
-    if fixed:
-        print(f"\nAdded includes to {len(fixed)} file(s):")
-        for path in fixed:
-            print(f"    {path}")
-    if failed and fixed:
-        print(f"\nclang-tidy still fails on {len(failed)} file(s); the findings above are what --fix could not add.")
-        return 1
     if failed:
         print(f"\nclang-tidy failed on {len(failed)} file(s). Add the includes it names, or apply its "
               "suggestions locally with scripts/run_clang_tidy.sh --fix (scripts\\run_clang_tidy.ps1 -Fix on Windows).")

scripts/disable_validation.entitlements

@@ -4,5 +4,10 @@
 <dict>
     <key>com.apple.security.cs.disable-library-validation</key>
     <true/>
+    <!-- The Bambu network plug-in's code protector rewrites one of its own signed code pages
+         after loading. Under the hardened runtime macOS kills the process when that page is
+         paged back in; this lets it run, as Bambu Studio's signature does. -->
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
 </dict>
 </plist>

scripts/run_clang_tidy.sh

@@ -6,9 +6,8 @@
 #   scripts/run_clang_tidy.sh --fix      also add the missing includes it names
 #
 # It configures a separate build directory (build-tidy) without the precompiled
-# header, uses the clang-tidy on your system or installs the pinned one into a
-# virtual environment inside it, and runs scripts/clang_tidy_diff.py the way CI
-# does. Uncommitted changes are checked too.
+# header, installs the pinned clang-tidy into a virtual environment inside it, and
+# runs scripts/clang_tidy_diff.py the way CI does. Uncommitted changes are checked too.
 
 set -euo pipefail
 
@@ -24,8 +23,7 @@ Usage: scripts/run_clang_tidy.sh [options]
                        deps/build/<arch> on macOS)
   -j, --jobs N         parallel clang-tidy runs (default: all cores)
       --fix            apply clang-tidy's fixes (adds the missing includes)
-  -y, --yes            install missing tools without asking; another clang-tidy
-                       version found on the system is then not offered
+  -y, --yes            install missing tools without asking
   -h, --help           show this help
 EOF
 }
@@ -138,38 +136,12 @@ REQUIREMENTS="$ROOT/scripts/clang_tidy_requirements.txt"
 PINNED=$(sed -n 's/^clang-tidy==//p' "$REQUIREMENTS")
 VENV="$BUILD_DIR/clang-tidy-venv"
 
-is_pinned() {
-    [ -x "$1" ] && "$1" --version 2>/dev/null | grep -q "version $PINNED"
-}
-
-CLANG_TIDY="${CLANG_TIDY:-}"
-if [ -n "$CLANG_TIDY" ]; then
+if [ -n "${CLANG_TIDY:-}" ]; then
     # Set by the caller: use it as is.
-    is_pinned "$CLANG_TIDY" || echo "Warning: $CLANG_TIDY is not clang-tidy $PINNED, so results may differ from CI." >&2
+    :
 else
-    # One already on the system comes first: the pinned version outright, another
-    # version if the user accepts the difference. The pinned version is installed
-    # into a virtual environment otherwise.
-    INSTALLED=""
-    for candidate in $(command -v clang-tidy "clang-tidy-${PINNED%%.*}" || true) \
-                     "/usr/lib/llvm-${PINNED%%.*}/bin/clang-tidy" \
-                     "$(brew --prefix llvm 2>/dev/null || true)/bin/clang-tidy"; do
-        if is_pinned "$candidate"; then
-            CLANG_TIDY="$candidate"
-            break
-        fi
-        [ -z "$INSTALLED" ] && [ -x "$candidate" ] && INSTALLED="$candidate"
-    done
-    if [ -z "$CLANG_TIDY" ] && [ -n "$INSTALLED" ] && [ "$YES" = 0 ] && ! is_pinned "$VENV/bin/clang-tidy"; then
-        echo "Found $INSTALLED, which is $("$INSTALLED" --version | sed -n 's/.*version \([0-9.]*\).*/\1/p' | head -n 1), not the $PINNED CI uses, so results may differ slightly."
-        if ask "Use it anyway?"; then
-            CLANG_TIDY="$INSTALLED"
-        fi
-    fi
-fi
-if [ -z "$CLANG_TIDY" ]; then
     CLANG_TIDY="$VENV/bin/clang-tidy"
-    if ! is_pinned "$CLANG_TIDY"; then
+    if [ ! -x "$CLANG_TIDY" ] || ! "$CLANG_TIDY" --version | grep -q "version $PINNED"; then
         if ask "clang-tidy $PINNED (the version CI uses) is not installed. Install it into $VENV?"; then
             mkdir -p "$BUILD_DIR"
             if ! python3 -m venv "$VENV"; then
@@ -186,6 +158,9 @@ if [ -z "$CLANG_TIDY" ]; then
         fi
     fi
 fi
+if ! "$CLANG_TIDY" --version | grep -q "version $PINNED"; then
+    echo "Warning: $CLANG_TIDY is not clang-tidy $PINNED, so results may differ from CI." >&2
+fi
 
 # --- Dependencies -------------------------------------------------------------
 
@@ -242,12 +217,7 @@ cmake --build "$BUILD_DIR" --target git_commit_hash_header >/dev/null
 
 if [ -z "$BASE" ]; then
     REMOTE=$(git remote -v | awk '/github\.com[:\/]OrcaSlicer\/OrcaSlicer(\.git)? \(fetch\)/ { print $1; exit }')
-    if [ -z "$REMOTE" ]; then
-        # Against a fork's main that already has the commits, nothing is checked.
-        echo "Warning: no remote points at github.com/OrcaSlicer/OrcaSlicer, so this compares against origin/main." >&2
-        echo "If origin is your fork, add the upstream remote (git remote add upstream https://github.com/OrcaSlicer/OrcaSlicer.git) or pass --base." >&2
-        REMOTE=origin
-    fi
+    REMOTE="${REMOTE:-origin}"
     if [ "$FETCH" = 1 ]; then
         git fetch --quiet "$REMOTE" main
     fi

scripts/tests/test_clang_tidy_diff.py

@@ -155,8 +155,6 @@ class TestSubprocessCalls(unittest.TestCase):
         diff = "+++ b/src/libslic3r/Über.cpp\n@@ -1,0 +2 @@\n+// 打印\n"
         files, call, _ = self.run_patched(clang_tidy_diff.changed_files, "base", stdout=diff)
         self.assertIn("core.quotePath=false", call.args[0])
-        # Whatever diff.noprefix or diff.mnemonicPrefix a user has set.
-        self.assertIn("--dst-prefix=b/", call.args[0])
         self.assertEqual(call.kwargs["encoding"], "utf-8")
         self.assertEqual(files["src/libslic3r/Über.cpp"].lines, [[2, 2]])
 
@@ -169,60 +167,5 @@ class TestSubprocessCalls(unittest.TestCase):
         self.assertEqual(call.kwargs["encoding"], "utf-8")
 
 
-class TestCheckFileFix(unittest.TestCase):
-    """check_file with -- --fix: what clang-tidy is run on, and what is reported afterwards."""
-
-    def setUp(self):
-        self.dir = tempfile.TemporaryDirectory()
-        self.addCleanup(self.dir.cleanup)
-        self.path = os.path.join(self.dir.name, "Color.cpp")
-        with open(self.path, "w") as f:
-            f.write("int x;\n")
-
-    def finding(self, line, include=""):
-        return clang_tidy_diff.Diagnostic(self.path, line, 1, "error",
-                                          'no header providing "x" is directly included [misc-include-cleaner]', include)
-
-    def check(self, change, results, fix_writes=None):
-        """Run check_file with run_clang_tidy answering from `results` in turn; the --fix run
-        rewrites the file with `fix_writes` when given. Returns (result, calls)."""
-        calls = []
-
-        def run(clang_tidy, build_dir, path, lines, extra_args):
-            calls.append((lines, extra_args))
-            if "--fix" in extra_args and fix_writes is not None:
-                with open(path, "w") as f:
-                    f.write(fix_writes)
-            return results[len(calls) - 1]
-
-        with mock.patch.object(clang_tidy_diff, "run_clang_tidy", side_effect=run):
-            result = clang_tidy_diff.check_file("clang-tidy", "build", "base", self.path, change, ["--fix"])
-        return result, calls
-
-    def test_a_deleted_include_is_fixed_on_the_lines_it_orphaned_only(self):
-        change = clang_tidy_diff.FileChange(lines=[[4, 4]], removed_includes={"libslic3r/Point.hpp"})
-        orphaned = self.finding(50, "<libslic3r/Point.hpp>")
-        unrelated = self.finding(60, "<vector>")
-        (failed, _, failing, fixed), calls = self.check(
-            change, [(1, "", [orphaned, unrelated]), (1, "", [orphaned]), (0, "", [])], fix_writes="#include <libslic3r/Point.hpp>\n")
-        self.assertEqual(calls, [(None, []), ([[4, 4], [50, 50]], ["--fix"]), (None, [])])
-        self.assertEqual((failed, failing, fixed), (False, [], True))
-
-    def test_a_file_the_fix_did_not_change_keeps_its_findings(self):
-        change = clang_tidy_diff.FileChange(lines=[[4, 4]])
-        error = clang_tidy_diff.Diagnostic(self.path, 4, 1, "error", "unknown type name 'Foo' [clang-diagnostic-error]")
-        (failed, _, failing, fixed), calls = self.check(change, [(1, "", [error])])
-        self.assertEqual(calls, [([[4, 4]], ["--fix"])])
-        self.assertEqual((failed, failing, fixed), (True, [error], False))
-
-    def test_a_changed_file_is_checked_again_and_reports_what_is_left(self):
-        change = clang_tidy_diff.FileChange(lines=[[4, 4]])
-        error = clang_tidy_diff.Diagnostic(self.path, 4, 1, "error", "unknown type name 'Foo' [clang-diagnostic-error]")
-        (failed, _, failing, fixed), calls = self.check(
-            change, [(1, "", [self.finding(4, "<vector>"), error]), (1, "", [error])], fix_writes="#include <vector>\n")
-        self.assertEqual(calls, [([[4, 4]], ["--fix"]), ([[4, 4]], [])])
-        self.assertEqual((failed, failing, fixed), (True, [error], True))
-
-
 if __name__ == "__main__":
     unittest.main()

src/dev-utils/platform/osx/entitlements.plist

@@ -5,5 +5,10 @@
   <!-- for dynamic loading of libraries without signature validation. Used for 3dconnection drivers.-->
   <key>com.apple.security.cs.disable-library-validation</key>  
   <true/>
+  <!-- The Bambu network plug-in's code protector rewrites one of its own signed code pages
+       after loading. Under the hardened runtime macOS kills the process when that page is
+       paged back in; this lets it run, as Bambu Studio's signature does. -->
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+  <true/>
 </dict>
 </plist>

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -751,50 +751,6 @@ template<typename T>
     }
 }
 
-namespace {
-// Writes G-code to a file in blocks and records in lines_ends the file offset after every '\n'
-class GCodeFileWriter
-{
-public:
-    GCodeFileWriter(FilePtr& out, const std::string& out_path, std::vector<size_t>& lines_ends, const char* error_message)
-        : m_out(out), m_out_path(out_path), m_lines_ends(lines_ends), m_error_message(error_message)
-    {}
-    ~GCodeFileWriter() { assert(m_buffer.empty() || std::uncaught_exceptions() > 0); }
-
-    void append(std::string_view text)
-    {
-        const size_t text_pos = m_file_pos + m_buffer.size();
-        for (size_t i = text.find('\n'); i != std::string_view::npos; i = text.find('\n', i + 1))
-            m_lines_ends.emplace_back(text_pos + i + 1);
-        m_buffer += text;
-        if (m_buffer.size() >= GCodeProcessor::Output_Block_Size)
-            flush();
-    }
-
-    void flush()
-    {
-        if (m_buffer.empty())
-            return;
-        fwrite(m_buffer.data(), 1, m_buffer.size(), m_out.f);
-        if (ferror(m_out.f)) {
-            m_out.close();
-            boost::nowide::remove(m_out_path.c_str());
-            throw Slic3r::RuntimeError(m_error_message);
-        }
-        m_file_pos += m_buffer.size();
-        m_buffer.clear();
-    }
-
-private:
-    FilePtr&             m_out;
-    const std::string&   m_out_path;
-    std::vector<size_t>& m_lines_ends;
-    const char*          m_error_message;
-    std::string          m_buffer;
-    size_t               m_file_pos{0};
-};
-} // namespace
-
 // Helper class to modify and export gcode to file
 class ExportLines
 {
@@ -809,6 +765,16 @@ public:
     enum class EWriteType { BySize, ByTime };
 
 private:
+    static void update_lines_ends_and_out_file_pos(const std::string& out_string, std::vector<size_t>& lines_ends, size_t* out_file_pos)
+    {
+        for (size_t i = 0; i < out_string.size(); ++i) {
+            if (out_string[i] == '\n')
+                lines_ends.emplace_back((out_file_pos != nullptr) ? *out_file_pos + i + 1 : i + 1);
+        }
+        if (out_file_pos != nullptr)
+            *out_file_pos += out_string.size();
+    }
+
     struct LineData
     {
         std::string                                                                        line;
@@ -848,14 +814,12 @@ private:
     EWriteType m_write_type{EWriteType::BySize};
     // Time machines containing g1 times cache
     const std::array<GCodeProcessor::TimeMachine, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)>& m_machines;
-    // Output file writer
-    GCodeFileWriter& m_writer;
     // Current time
     std::array<float, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> m_times{0.0f, 0.0f};
-    // Current size of the cache in bytes
+    // Current size in bytes
     size_t m_size{0};
 
-    // gcode lines cache, used only when writing by time
+    // gcode lines cache
     std::deque<LineData> m_lines;
     size_t               m_added_lines_counter{0};
     // map of gcode line ids from original to final
@@ -863,16 +827,16 @@ private:
     std::vector<std::pair<size_t, size_t>> m_gcode_lines_map;
 
     size_t m_times_cache_id{0};
+    size_t m_out_file_pos{0};
 
 public:
-    ExportLines(EWriteType type, const std::array<GCodeProcessor::TimeMachine, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)>& machines, GCodeFileWriter& writer)
+    ExportLines(EWriteType type, const std::array<GCodeProcessor::TimeMachine, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)>& machines)
 #ifndef NDEBUG
         : m_statistics(*this)
         , m_write_type(type)
-        , m_machines(machines)
-        , m_writer(writer){}
+        , m_machines(machines){}
 #else
-        : m_write_type(type), m_machines(machines), m_writer(writer)
+        : m_write_type(type), m_machines(machines)
     {}
 #endif // NDEBUG
 
@@ -926,14 +890,11 @@ public:
         if (line.empty())
             return;
 
-        if (m_write_type == EWriteType::ByTime) {
-            m_lines.push_back({line, m_times});
+        m_lines.push_back({line, m_times});
 #ifndef NDEBUG
-            m_statistics.add_line(line.length());
+        m_statistics.add_line(line.length());
 #endif // NDEBUG
-            m_size += line.length();
-        } else
-            m_writer.append(line);
+        m_size += line.length();
         ++m_added_lines_counter;
         if (!ignore_from_move) {
             assert(!m_gcode_lines_map.empty());
@@ -999,35 +960,65 @@ public:
         }
     }
 
-    // when writing by time, pass the cached lines older than m_times[Normal] - backtrace_time to the writer
-    void write(float backtrace_time)
+    // write to file:
+    // m_write_type == EWriteType::ByTime - all lines older than m_time - backtrace_time
+    // m_write_type == EWriteType::BySize - all lines if current size is greater than 65535 bytes
+    void write(FilePtr& out, float backtrace_time, GCodeProcessorResult& result, const std::string& out_path)
     {
-        if (m_write_type != EWriteType::ByTime)
+        if (m_lines.empty())
             return;
 
-        while (!m_lines.empty() && m_lines.front().times[Normal] < m_times[Normal] - backtrace_time) {
-            const LineData& data = m_lines.front();
-            m_writer.append(data.line);
-            m_size -= data.line.length();
-            m_lines.pop_front();
+        // collect lines to write into a single string
+        std::string out_string;
+        if (!m_lines.empty()) {
+            if (m_write_type == EWriteType::ByTime) {
+                while (m_lines.front().times[Normal] < m_times[Normal] - backtrace_time) {
+                    const LineData& data = m_lines.front();
+                    out_string += data.line;
+                    m_size -= data.line.length();
+                    m_lines.pop_front();
 #ifndef NDEBUG
-            m_statistics.remove_line();
+                    m_statistics.remove_line();
 #endif // NDEBUG
+                }
+            } else {
+                if (m_size > 65535) {
+                    while (!m_lines.empty()) {
+                        out_string += m_lines.front().line;
+                        m_lines.pop_front();
+                    }
+                    m_size = 0;
+#ifndef NDEBUG
+                    m_statistics.remove_all_lines();
+#endif // NDEBUG
+                }
+            }
+        }
+
+        {
+            write_to_file(out, out_string, result, out_path);
+            update_lines_ends_and_out_file_pos(out_string, result.lines_ends, &m_out_file_pos);
         }
     }
 
-    // flush the current content of the cache and the writer to file
-    void flush()
+    // flush the current content of the cache to file
+    void flush(FilePtr& out, GCodeProcessorResult& result, const std::string& out_path)
     {
+        // collect lines to flush into a single string
+        std::string out_string;
         while (!m_lines.empty()) {
-            m_writer.append(m_lines.front().line);
+            out_string += m_lines.front().line;
             m_lines.pop_front();
         }
         m_size = 0;
 #ifndef NDEBUG
         m_statistics.remove_all_lines();
 #endif // NDEBUG
-        m_writer.flush();
+
+        {
+            write_to_file(out, out_string, result, out_path);
+            update_lines_ends_and_out_file_pos(out_string, result.lines_ends, &m_out_file_pos);
+        }
     }
 
     void synchronize_moves(GCodeProcessorResult& result) const
@@ -1060,7 +1051,20 @@ public:
 
     size_t get_size() const { return m_size; }
 
-    void reserve(size_t lines_count) { m_gcode_lines_map.reserve(lines_count); }
+private:
+    void write_to_file(FilePtr& out, const std::string& out_string, GCodeProcessorResult& result, const std::string& out_path)
+    {
+        if (!out_string.empty()) {
+            if (true) {
+                fwrite((const void*) out_string.c_str(), 1, out_string.length(), out.f);
+                if (ferror(out.f)) {
+                    out.close();
+                    boost::nowide::remove(out_path.c_str());
+                    throw Slic3r::RuntimeError("GCode processor post process export failed.\nIs the disk full?");
+                }
+            }
+        }
+    }
 };
 
 void GCodeProcessor::run_post_process()
@@ -1156,13 +1160,8 @@ void GCodeProcessor::run_post_process()
         last_exported_stop[i] = time_in_minutes(m_time_processor.machines[i].time);
     }
 
-    m_result.lines_ends.clear();
-    // m_result.lines_ends.emplace_back(std::vector<size_t>());
-    GCodeFileWriter writer(out, out_path, m_result.lines_ends, "GCode processor post process export failed.\nIs the disk full?");
     ExportLines export_line(m_result.backtrace_enabled ? ExportLines::EWriteType::ByTime : ExportLines::EWriteType::BySize,
-        m_time_processor.machines, writer);
-    // The line map holds an entry for each line of the file, and the first pass counted them
-    export_line.reserve(m_line_id);
+        m_time_processor.machines);
 
     // replace placeholder lines with the proper final value
     // gcode_line is in/out parameter, to reduce expensive memory allocation
@@ -1536,6 +1535,9 @@ void GCodeProcessor::run_post_process()
         }
     };
 
+    m_result.lines_ends.clear();
+    // m_result.lines_ends.emplace_back(std::vector<size_t>());
+
     // Orca: freshly collect SKIPPABLE ranges each post-process pass. The ranges are stored on the
     // member (rather than a local) so the injection pass can consume them, hence the clear here to
     // avoid stale ranges on re-invocation.
@@ -1800,7 +1802,7 @@ void GCodeProcessor::run_post_process()
 
                     if (!gcode_line.empty())
                         export_line.append_line(gcode_line);
-                    export_line.write(1.1f * max_backtrace_time);
+                    export_line.write(out, 1.1f * max_backtrace_time, m_result, out_path);
                     gcode_line.clear();
                 }
             }
@@ -1842,7 +1844,7 @@ void GCodeProcessor::run_post_process()
         }
     }
 
-    export_line.flush();
+    export_line.flush(out, m_result, out_path);
 
     out.close();
     in.close();
@@ -1990,13 +1992,31 @@ void GCodeProcessor::run_second_pass_injection()
     // The rewrite may shift byte positions (once the injector inserts lines), so rebuild lines_ends from scratch.
     // With an empty map the scanned '\n' offsets reproduce the current lines_ends exactly.
     m_result.lines_ends.clear();
-    GCodeFileWriter writer(out, out_path, m_result.lines_ends, "GCode processor pre-heat injection pass failed.\nIs the disk full?\n");
+    size_t out_file_pos = 0;
+
+    auto write_out = [&out, &out_path, this, &out_file_pos](std::string& str) {
+        if (str.empty())
+            return;
+        fwrite((const void*) str.c_str(), 1, str.length(), out.f);
+        if (ferror(out.f)) {
+            out.close();
+            boost::nowide::remove(out_path.c_str());
+            throw Slic3r::RuntimeError(std::string("GCode processor pre-heat injection pass failed.\nIs the disk full?\n"));
+        }
+        for (size_t i = 0; i < str.size(); ++i) {
+            if (str[i] == '\n')
+                m_result.lines_ends.emplace_back(out_file_pos + i + 1);
+        }
+        out_file_pos += str.size();
+        str.clear();
+    };
 
     // Orca: read/split lines with EOL-preserving semantics (keep the original \r and \n bytes, and
     // synthesize no trailing newline). This is required for the empty-map identity: normalizing every
     // line ending to "\n" would not be byte-identical if the finished file used \r\n or lacked a
     // final newline.
     std::string gcode_line;
+    std::string export_buffer;
     unsigned int line_id = 0;
     auto op_it = inserted_operation_lines.begin();
     std::vector<char> buffer(65536 * 10, 0);
@@ -2038,14 +2058,16 @@ void GCodeProcessor::run_second_pass_injection()
                     }
                     ++op_it;
                 }
-                writer.append(gcode_line);
+                export_buffer += gcode_line;
                 gcode_line.clear();
+                if (export_buffer.length() >= 65536)
+                    write_out(export_buffer);
             }
         }
         if (eof)
             break;
     }
-    writer.flush();
+    write_out(export_buffer);
 
     out.close();
     in.close();

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -491,9 +491,6 @@ class Print;
         static const std::string VFlush_End_Tag;
         static const std::string External_Purge_Tag;
     public:
-        // Size of the blocks the post-processing passes write the G-code in
-        static constexpr size_t Output_Block_Size = 65536;
-
         // Orca: SKIPPABLE region tags, stored as static strings (the FLUSH idiom above) rather than
         // a CustomETags/CustomTags array. Public so the emission sites (WipeTower / change_filament
         // path) can reference them single-sourced.

src/slic3r/GUI/DeviceCore/DevDefs.h

@@ -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>>;

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -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>
@@ -35,25 +34,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 +212,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 +303,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 +326,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 +336,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 +349,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 +914,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 +996,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 +1014,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));
     }
 }
 

src/slic3r/GUI/DeviceCore/DevFilaSystem.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();
 
@@ -434,4 +434,4 @@ struct DevFilamentDryingPreset
     float filament_dev_ams_drying_heat_distortion_temperature = 0.0f;
 };
 
-}// namespace Slic3r
+}// namespace Slic3r

src/slic3r/GUI/DeviceCore/DevNozzleSystem.cpp

@@ -27,7 +27,6 @@
 #include <unordered_map>
 #include <optional>
 #include <cmath>
-#include "slic3r/GUI/GUI_App.hpp"
 
 namespace Slic3r
 {
@@ -175,48 +174,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

src/slic3r/GUI/DeviceManager.cpp

@@ -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>
@@ -1274,24 +1273,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 +5262,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 +5281,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; }
         }
     }
 

src/slic3r/GUI/StatusPanel.hpp

@@ -1,8 +1,6 @@
 #ifndef slic3r_StatusPanel_hpp_
 #define slic3r_StatusPanel_hpp_
 
-#include <vector>
-
 #include "libslic3r/ProjectTask.hpp"
 #include "DeviceManager.hpp"
 #include "MonitorPage.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;

src/slic3r/GUI/Widgets/AMSControl.cpp

@@ -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);

src/slic3r/GUI/Widgets/AMSControl.hpp

@@ -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);

src/slic3r/GUI/Widgets/AMSItem.cpp

@@ -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()

src/slic3r/GUI/Widgets/AMSItem.hpp

@@ -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 };

src/slic3r/GUI/Widgets/MultiNozzleSync.cpp

@@ -866,21 +866,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);
     }
 }

src/slic3r/GUI/Widgets/TempInput.cpp

@@ -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);
 }
 

src/slic3r/Utils/MoonrakerPrinterAgent.cpp

@@ -1057,25 +1057,6 @@ int MoonrakerPrinterAgent::handle_request(const std::string& dev_id, const std::
             }
         }
 
-        // Tool selection is printer-specific G-code. Moonraker forwards the
-        // conventional T<index> command to Klipper, where the printer can
-        // implement logical selection or a physical toolhead attach macro.
-        if (cmd == "select_extruder") {
-            if (!json["print"].contains("extruder_index") || !json["print"]["extruder_index"].is_number_integer()) {
-                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: select_extruder missing integer extruder_index, full json: " << json_str;
-                return BAMBU_NETWORK_ERR_INVALID_RESULT;
-            }
-
-            const int extruder_idx = json["print"]["extruder_index"].get<int>();
-            if (extruder_idx < 0) {
-                BOOST_LOG_TRIVIAL(error) << "MoonrakerPrinterAgent: select_extruder received negative extruder_index: " << extruder_idx;
-                return BAMBU_NETWORK_ERR_INVALID_RESULT;
-            }
-
-            send_gcode_async(dev_id, "T" + std::to_string(extruder_idx));
-            return BAMBU_NETWORK_SUCCESS;
-        }
-
         if (cmd == "home") {
             send_gcode_async(dev_id, "G28");
             return BAMBU_NETWORK_SUCCESS;
@@ -1172,7 +1153,7 @@ bool MoonrakerPrinterAgent::query_printer_status(const std::string& base_url,
                                                  nlohmann::json&    status,
                                                  std::string&       error) const
 {
-    std::string url = join_url(base_url, "/printer/objects/query?print_stats&virtual_sdcard&toolhead&extruder&heater_bed&fan");
+    std::string url = join_url(base_url, "/printer/objects/query?print_stats&virtual_sdcard&extruder&heater_bed&fan");
 
     std::string response_body;
     bool        success = false;
@@ -1585,12 +1566,11 @@ void MoonrakerPrinterAgent::run_status_stream(std::string dev_id, std::string ba
                 }
 
                 for (const auto& name : this->available_objects) {
-                    const bool is_main_extruder = name == "extruder";
-                    const bool is_additional_extruder =
-                        name.rfind("extruder", 0) == 0 && name.size() > 8 &&
-                        std::all_of(name.begin() + 8, name.end(), [](unsigned char c) { return std::isdigit(c) != 0; });
-                    if (is_main_extruder || is_additional_extruder) {
+                    if (name == "extruder" || name.rfind("extruder", 0) == 0) {
                         subscribe_objects.insert(name);
+                        if (name == "extruder") {
+                            break;
+                        }
                     }
                 }
             } else {
@@ -1886,81 +1866,6 @@ nlohmann::json MoonrakerPrinterAgent::build_print_payload_locked() const
         }
     }
 
-    // MachineObject::parse_new_info() only parses device.extruder when the four
-    // legacy new-protocol fields are present. Moonraker has no equivalents, so
-    // empty values act as compatibility markers without enabling any features.
-    std::map<int, const nlohmann::json*> extruder_status;
-    for (const auto& item : status_cache.items()) {
-        int extruder_id = -1;
-        if (item.key() == "extruder") {
-            extruder_id = 0;
-        } else if (item.key().rfind("extruder", 0) == 0 && item.key().size() > 8 &&
-                   std::all_of(item.key().begin() + 8, item.key().end(), [](unsigned char c) { return std::isdigit(c) != 0; })) {
-            try {
-                extruder_id = std::stoi(item.key().substr(8));
-            } catch (...) {
-                extruder_id = -1;
-            }
-        }
-        if (extruder_id >= 0 && item.value().is_object()) {
-            extruder_status.emplace(extruder_id, &item.value());
-        }
-    }
-
-    if (!extruder_status.empty()) {
-        auto& device_extruder = payload["print"]["device"]["extruder"];
-
-        int current_extruder_id = 0;
-        if (status_cache.contains("toolhead") && status_cache["toolhead"].is_object() &&
-            status_cache["toolhead"].contains("extruder") && status_cache["toolhead"]["extruder"].is_string()) {
-            const std::string active_extruder = status_cache["toolhead"]["extruder"].get<std::string>();
-            if (active_extruder != "extruder" && active_extruder.rfind("extruder", 0) == 0 && active_extruder.size() > 8 &&
-                std::all_of(active_extruder.begin() + 8, active_extruder.end(), [](unsigned char c) { return std::isdigit(c) != 0; })) {
-                try {
-                    const int parsed_id = std::stoi(active_extruder.substr(8));
-                    if (parsed_id >= 0 && parsed_id < 16 && extruder_status.count(parsed_id) != 0) {
-                        current_extruder_id = parsed_id;
-                    }
-                } catch (...) {
-                    // Keep the main extruder as the fallback for malformed status data.
-                }
-            }
-        }
-
-        const int extruder_count = std::min<int>(static_cast<int>(extruder_status.size()), 0xF);
-        device_extruder["state"] = extruder_count | (current_extruder_id << 4);
-        device_extruder["info"] = nlohmann::json::array();
-
-        auto encoded_temperature = [](const nlohmann::json& status, const char* key) {
-            if (!status.contains(key) || !status[key].is_number()) {
-                return 0;
-            }
-            const double temperature = status[key].get<double>();
-            return std::clamp(static_cast<int>(temperature + 0.5), 0, 65535);
-        };
-
-        for (const auto& [extruder_id, status] : extruder_status) {
-            const int current_temperature = encoded_temperature(*status, "temperature");
-            const int target_temperature  = encoded_temperature(*status, "target");
-            device_extruder["info"].push_back({
-                {"id", extruder_id},
-                {"filam_bak", nlohmann::json::array()},
-                {"info", 1 << 3}, // The configured Moonraker extruder has a toolhead.
-                {"temp", current_temperature | (target_temperature << 16)},
-                {"spre", 0},
-                {"snow", 0},
-                {"star", 0},
-                {"stat", 0},
-                {"hnow", 0},
-            });
-        }
-
-        payload["print"]["cfg"]  = "";
-        payload["print"]["fun"]  = "";
-        payload["print"]["aux"]  = "";
-        payload["print"]["stat"] = "";
-    }
-
     if (status_cache.contains("heater_bed") && status_cache["heater_bed"].is_object()) {
         const auto& bed = status_cache["heater_bed"];
         if (bed.contains("temperature") && bed["temperature"].is_number()) {

tests/fff_print/test_gcodeprocessor.cpp

@@ -1,20 +1,15 @@
 #include <catch2/catch_all.hpp>
 
-#include <catch2/catch_message.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/generators/catch_generators.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 #include "libslic3r/libslic3r.h"
-#include "libslic3r/Config.hpp"
 #include "libslic3r/GCode/GCodeProcessor.hpp"
-#include "libslic3r/Model.hpp"
 #include "libslic3r/Utils.hpp"
 
-#include "test_helpers.hpp"
 #include "test_utils.hpp"
 
-#include <algorithm>
 #include <cstddef>
 #include <fstream>
 #include "libslic3r/PrintConfig.hpp"
@@ -182,42 +177,3 @@ TEST_CASE("A seam takes the actual speed of the move it follows", "[GCodeProcess
         }
     REQUIRE(seams > 0);
 }
-
-TEST_CASE("Line ends of the exported G-code mark every newline in the file", "[GCodeProcessor]")
-{
-    struct Case
-    {
-        const char* name;
-        bool        preheat_backtrace;
-        bool        pre_heating;
-    };
-    const auto test_case = GENERATE(values<Case>({
-        { "written by size", false, false },
-        { "written by time for the preheat backtrace", true, false },
-        { "rewritten by the pre-heating pass", false, true },
-    }));
-    INFO(test_case.name);
-    DynamicPrintConfig config = Test::multifilament_config(2, {
-        { "single_extruder_multi_material", 0 },
-        { "ooze_prevention",                test_case.preheat_backtrace },
-        { "preheat_time",                   30 },
-        { "enable_pre_heating",             test_case.pre_heating },
-    });
-    Print print;
-    Model model;
-    const std::vector<std::vector<ConfigBase::SetDeserializeItem>> overrides{ { { "extruder", 1 } }, { { "extruder", 2 } } };
-    Test::init_print({ Test::cube(20), Test::cube(20) }, print, model, config, &overrides);
-    GCodeProcessorResult result;
-    const std::string    gcode = Test::gcode(print, &result);
-    REQUIRE((gcode.find("preheat T") != std::string::npos) == test_case.preheat_backtrace);
-    REQUIRE((gcode.find(GCodeProcessor::Machine_Start_GCode_End_Tag) != std::string::npos) == test_case.pre_heating);
-    REQUIRE(gcode.size() > GCodeProcessor::Output_Block_Size);
-
-    std::vector<size_t> newline_ends;
-    for (size_t i = gcode.find('\n'); i != std::string::npos; i = gcode.find('\n', i + 1))
-        newline_ends.push_back(i + 1);
-    REQUIRE(result.lines_ends.size() == newline_ends.size());
-    const auto difference = std::mismatch(result.lines_ends.begin(), result.lines_ends.end(), newline_ends.begin());
-    INFO("first difference at line " << difference.first - result.lines_ends.begin() + 1);
-    CHECK(difference.first == result.lines_ends.end());
-}

tests/fff_print/test_helpers.cpp

@@ -14,7 +14,6 @@
 #include <initializer_list>
 #include "libslic3r/Point.hpp"
 #include <fstream>
-#include <ios>
 #include <iterator>
 #include <set>
 #include <string>
@@ -331,13 +330,13 @@ void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::
 	print.process();
 }
 
-std::string gcode(Print & print, GCodeProcessorResult* result)
+std::string gcode(Print & print)
 {
     ScopedTemporaryFile temp(".gcode");
     print.set_status_silent();
     print.process();
-    print.export_gcode(temp.string(), result, nullptr);
-    std::ifstream t(temp.string(), std::ios::binary);
+    print.export_gcode(temp.string(), nullptr, nullptr);
+    std::ifstream t(temp.string());
 	std::string str((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
 	return str;
 }

tests/fff_print/test_helpers.hpp

@@ -17,9 +17,7 @@
 #include <unordered_map>
 #include <vector>
 
-namespace Slic3r {
-struct GCodeProcessorResult;
-namespace Test {
+namespace Slic3r { namespace Test {
 
 constexpr double MM_PER_MIN = 60.0;
 
@@ -94,8 +92,8 @@ void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::
 void init_and_process_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items);
 void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items);
 
-// Process `print` and return its exported G-code, filling `result` when one is given.
-std::string gcode(Print& print, GCodeProcessorResult* result = nullptr);
+// Process `print` and return its exported G-code.
+std::string gcode(Print& print);
 
 // Build, slice, and return the G-code for `meshes` under the given config.
 std::string slice(std::initializer_list<TestMesh> meshes, const DynamicPrintConfig &config);

tests/slic3rutils/test_dev_mapping.cpp

@@ -3,8 +3,6 @@
 // makes std::byte a competing candidate (otherwise the Windows COM headers pulled in via
 // DeviceManager.hpp error with an ambiguous `byte`). wx/timer.h must precede DeviceManager.hpp,
 // which includes DeviceErrorDialog.hpp (uses wxTimerEvent) before its own wx/timer.h include.
-#include <string>
-#include <utility>
 #ifdef WIN32
     #ifndef WIN32_LEAN_AND_MEAN
         #define WIN32_LEAN_AND_MEAN
@@ -19,7 +17,6 @@
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
 #include "libslic3r/ProjectTask.hpp"
 #include <vector>
-#include <set>
 #include <catch2/catch_message.hpp>
 
 #include <catch2/catch_all.hpp>
@@ -68,111 +65,6 @@ TEST_CASE("AMS tray placeholder state follows the latest status", "[DevFilaSyste
     CHECK_FALSE(tray->is_slot_placeholder);
 }
 
-TEST_CASE("Agent filament slots preserve every extruder and AMS binding", "[DevFilaSystem]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    const json filament = json::parse(R"({
-        "units": [
-            { "id": "0", "extruder": 0, "slots": [
-                { "index": 0, "loaded": true, "material": "PLA", "color": "FF5733FF" },
-                { "index": 1, "loaded": true, "material": "PLA", "color": "33C1FFFF" },
-                { "index": 2, "loaded": true, "material": "PLA", "color": "8D33FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "1", "extruder": 1, "slots": [
-                { "index": 0, "loaded": true, "material": "ASA", "color": "33C1FFFF" },
-                { "index": 1, "loaded": true, "material": "ASA", "color": "8D33FFFF" },
-                { "index": 2, "loaded": true, "material": "ASA", "color": "FF5733FF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "2", "extruder": 2, "slots": [
-                { "index": 0, "loaded": true, "material": "ABS", "color": "8D33FFFF" },
-                { "index": 1, "loaded": true, "material": "ABS", "color": "FF5733FF" },
-                { "index": 2, "loaded": true, "material": "ABS", "color": "33C1FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] },
-            { "id": "3", "extruder": 3, "slots": [
-                { "index": 0, "loaded": true, "material": "PETG", "color": "FF5733FF" },
-                { "index": 1, "loaded": true, "material": "PETG", "color": "33C1FFFF" },
-                { "index": 2, "loaded": true, "material": "PETG", "color": "8D33FFFF" },
-                { "index": 3, "loaded": false, "material": "",    "color": "00000000" }
-            ] }
-        ],
-        "external": [
-            { "extruder": 3, "loaded": true, "material": "PETG", "preset_id": "P3" },
-            { "extruder": 0, "loaded": true, "material": "PLA",  "preset_id": "P0" },
-            { "extruder": 2, "loaded": false, "material": "ABS", "preset_id": "P2" },
-            { "extruder": 1, "loaded": true, "material": "ASA",  "preset_id": "P1" }
-        ]
-    })");
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    REQUIRE(obj.vt_slot.size() == 4);
-    CHECK(obj.vt_slot[0].id == "255");
-    CHECK(obj.vt_slot[1].id == "254");
-    CHECK(obj.vt_slot[2].id == "253");
-    CHECK(obj.vt_slot[3].id == "252");
-    CHECK(obj.vt_slot[0].setting_id == "P0");
-    CHECK(obj.vt_slot[1].setting_id == "P1");
-    CHECK(obj.vt_slot[2].setting_id == "P2");
-    CHECK(obj.vt_slot[3].setting_id == "P3");
-
-    REQUIRE(obj.GetFilaSystem()->GetAmsCount() == 4);
-    for (int extruder = 0; extruder < 4; ++extruder) {
-        const auto& ams = obj.GetFilaSystem()->GetAmsList().at(std::to_string(extruder));
-        CHECK(ams->GetExtruderId() == extruder);
-        CHECK(ams->GetBindedExtruderSet() == std::set<int>{extruder});
-        REQUIRE(ams->GetTrays().size() == 4);
-        CHECK(ams->GetTrays().at("0")->color != ams->GetTrays().at("1")->color);
-        CHECK(ams->GetTrays().at("1")->color != ams->GetTrays().at("2")->color);
-        CHECK_FALSE(ams->GetTrays().at("3")->is_exists);
-    }
-
-    CHECK(obj.contains_tray("253", "0"));
-    CHECK(obj.get_tray("253", "0").setting_id == "P2");
-    CHECK(obj.GetFilaSystem()->GetExtruderIdByAmsId("253") == 2);
-
-    const auto tray_index_map = obj.GetFilaSystem()->GetTrayIndexMap();
-    REQUIRE(tray_index_map.count(252) == 1);
-    CHECK(tray_index_map.at(252).first == 252);
-    CHECK(tray_index_map.at(252).second == 0);
-}
-
-TEST_CASE("Generic AMS tray index map uses cumulative lane counts", "[DevMapping]")
-{
-    MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");
-
-    // A well-formed generic payload pairs "units" with "external". An empty external array resets
-    // vt_slot, clearing the default virtual tray (255) MachineObject's constructor seeds; otherwise
-    // that phantom external tray lands in GetTrayIndexMap and inflates the map size.
-    json filament = { {"units", json::array()}, {"external", json::array()} };
-    for (int ams_id = 0; ams_id < 2; ++ams_id) {
-        json unit = {
-            {"id", std::to_string(ams_id)},
-            {"extruder", ams_id},
-            {"slots", json::array()}
-        };
-        for (int slot_id = 0; slot_id < 5; ++slot_id)
-            unit["slots"].push_back({{"index", slot_id}, {"loaded", false}});
-        filament["units"].push_back(std::move(unit));
-    }
-
-    DevFilaSystemParser::ParseAgentFilament(filament, &obj, obj.GetFilaSystem().get());
-
-    const auto tray_index_map = obj.GetFilaSystem()->GetTrayIndexMap();
-    REQUIRE(tray_index_map.size() == 10);
-    CHECK(tray_index_map.at(0).first == 0);
-    CHECK(tray_index_map.at(0).second == 0);
-    CHECK(tray_index_map.at(4).first == 0);
-    CHECK(tray_index_map.at(4).second == 4);
-    CHECK(tray_index_map.at(5).first == 1);
-    CHECK(tray_index_map.at(5).second == 0);
-    CHECK(tray_index_map.at(9).first == 1);
-    CHECK(tray_index_map.at(9).second == 4);
-}
-
 TEST_CASE("Switch-bound AMS trays map to the left extruder", "[DevMapping]")
 {
     MachineObject obj(nullptr, nullptr, "test", "test_dev", "127.0.0.1");