Merge branch 'main' into plugin-ui-1

src/slic3r/GUI/3DScene.cpp

@@ -20,6 +20,8 @@
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/GCode/WipeTower.hpp"
+#include "libslic3r/GCode/WipeTowerEstimate.hpp"
 #include "libslic3r/Tesselate.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
@@ -919,6 +921,21 @@ int GLVolumeCollection::load_wipe_tower_preview(
     GUI::PartPlateList& ppl = GUI::wxGetApp().plater()->get_partplate_list();
     std::vector<int> plate_extruders = ppl.get_plate(plate_idx)->get_extruders(true);
     TriangleMesh wipe_tower_shell = make_cube(width, depth, height);
+    // The brim is part of the printed footprint: draw it and fold it into the shell so the
+    // outside-bed shader and the drag clamp react to the true first-layer extent.
+    const bool   show_brim   = brim_width > 0.f;
+    const float  brim_height = 0.2f; // one first layer, visual only
+    TriangleMesh brim_slab;
+    if (show_brim) {
+        // The brim follows the real first-layer outline: a Type2 cone-wall tower's base bulges
+        // past the body box. The wall type and angle are print settings, the planner a printer one.
+        const DynamicPrintConfig &print_cfg   = GUI::wxGetApp().preset_bundle->prints.get_edited_preset().config;
+        const DynamicPrintConfig &printer_cfg = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
+        const Polygon  outline      = estimate_wipe_tower_first_layer_outline(print_cfg, resolve_wipe_tower_type(printer_cfg), width, depth, height);
+        const Polygons brim_outline = offset(outline, scaled(brim_width));
+        brim_slab                   = WipeTower::its_make_rib_brim(brim_outline.empty() ? outline : brim_outline.front(), brim_height);
+        wipe_tower_shell.merge(brim_slab);
+    }
     for (int extruder_id : plate_extruders) {
         if (extruder_id <= extruder_colors.size())
             colors.push_back(extruder_colors[extruder_id - 1]);
@@ -929,14 +946,19 @@ int GLVolumeCollection::load_wipe_tower_preview(
     // Orca: make it transparent
     for(auto& color : colors)
         color.a(0.66f);
+    const size_t slab_count = colors.size(); // per-filament body slabs; the brim part comes after
+    if (show_brim && !colors.empty())
+        colors.push_back(colors.front());
     volumes.emplace_back(new GLWipeTowerVolume(colors));
     GLWipeTowerVolume& v = *dynamic_cast<GLWipeTowerVolume*>(volumes.back());
     v.model_per_colors.resize(colors.size());
-    for (int i = 0; i < colors.size(); i++) {
-        TriangleMesh color_part = make_cube(width, depth / colors.size(), height);
-        color_part.translate({ 0.f, depth * i / colors.size(), 0. });
+    for (size_t i = 0; i < slab_count; i++) {
+        TriangleMesh color_part = make_cube(width, depth / slab_count, height);
+        color_part.translate({ 0.f, depth * i / slab_count, 0. });
         v.model_per_colors[i].init_from(color_part);
     }
+    if (show_brim && !colors.empty())
+        v.model_per_colors[slab_count].init_from(brim_slab);
     v.model.init_from(wipe_tower_shell);
     v.mesh_raycaster = std::make_unique<GUI::MeshRaycaster>(std::make_shared<const TriangleMesh>(wipe_tower_shell));
     v.set_convex_hull(wipe_tower_shell);

src/slic3r/GUI/AMSDryControl.cpp

@@ -1511,6 +1511,10 @@ void AMSDryCtrWin::update_filament_guide_info(DevAms* dev_ams)
                       m_temperature_input->GetValue().ToLong(&input_temp);
     bool can_start = true;
 
+    // "GFA00" is Bambu's PLA id; GetFilamentDryingPreset is keyed by our OF ids.
+    auto* agent = wxGetApp().getAgent();
+    const std::string pla_filament_id = agent ? agent->to_orca_filament_id("GFA00") : std::string("GFA00");
+
     int slot_count = 0, empty_count = 0;
     for (auto& tray_pair : dev_ams->GetTrays()) {
         if (!tray_pair.second) {
@@ -1526,13 +1530,15 @@ void AMSDryCtrWin::update_filament_guide_info(DevAms* dev_ams)
         wxString filament_type = tray_pair.second->get_display_filament_type();
         DevFilamentDryingPreset preset;
         if (filament_type.IsEmpty()) {
-            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset("GFA00");
+            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(pla_filament_id);
+            if (!fallback_preset) continue;                 // no PLA preset (e.g. the id map is missing): skip, don't throw
             preset = fallback_preset.value();
             filament_type = "?";
         } else if (preset_opt.has_value()) {
             preset = preset_opt.value();
         } else {
-            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset("GFA00");
+            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(pla_filament_id);
+            if (!fallback_preset) continue;
             preset = fallback_preset.value();
         }
         std::string icon_path = "dev_ams_dry_ctr_enable";
@@ -1594,39 +1600,21 @@ int AMSDryCtrWin::update_filament_list(DevAms* dev_ams, MachineObject* obj)
         }
         stream << std::fixed << std::setprecision(1) << obj->GetExtderSystem()->GetNozzleDiameter(extruder_id);
         std::string nozzle_diameter_str = stream.str();
-        std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(
-            DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str);
 
-        for (auto filament_it = filaments.begin(); filament_it != filaments.end(); ++filament_it) {
-            Preset& preset = *filament_it;
-            // Filter by system preset: root preset and (system preset or user preset is supported)
-            if (filaments.get_preset_base(*filament_it) != &preset || (!filament_it->is_system && !obj->is_support_user_preset)) {
+        for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
+                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+            if (!filament_id_set.insert(filament_it->filament_id).second)
+                continue;
+            const std::string filament_alias = filaments.get_preset_alias(*filament_it, true);
+            if (filament_alias.empty())
+                continue;
+            auto opt_info = preset_bundle->get_filament_by_filament_id(filament_it->filament_id);
+            if (!opt_info.has_value())
                 continue;
-            }
 
-            ConfigOption *       printer_opt  = filament_it->config.option("compatible_printers");
-            ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt);
-            if (!printer_strs) continue;
-
-            for (auto printer_str : printer_strs->values) {
-                if (printer_names.find(printer_str) != printer_names.end()) {
-                    if (filament_id_set.find(filament_it->filament_id) != filament_id_set.end()) {
-                        continue;
-                    }
-
-                    filament_id_set.insert(filament_it->filament_id);
-                    auto filament_alias = filaments.get_preset_alias(*filament_it, true);
-                    if (!filament_alias.empty()) {
-                        auto opt_info = preset_bundle->get_filament_by_filament_id(filament_it->filament_id);
-                        if (opt_info.has_value()) {
-                            auto real_info = opt_info.value();
-                            real_info.filament_name = filament_alias;
-                            m_tray_ids.push_back(std::move(real_info));
-                            m_trays_combo->Append(wxString::FromUTF8(filament_alias));
-                        }
-                    }
-                }
-            }
+            opt_info->filament_name = filament_alias;
+            m_tray_ids.push_back(std::move(*opt_info));
+            m_trays_combo->Append(wxString::FromUTF8(filament_alias));
         }
 
         if (m_tray_ids.empty()) {
@@ -1701,9 +1689,10 @@ int AMSDryCtrWin::update_filament_list(DevAms* dev_ams, MachineObject* obj)
 
     // Select recommended drying temperature and default filament
     float min_dry_temp = std::numeric_limits<float>::max();
-    std::string default_filament_id = "GFA00";
+    auto* agent = wxGetApp().getAgent();
+    std::string default_filament_id = agent ? agent->to_orca_filament_id("GFA00") : std::string("GFA00");   // compared against m_tray_ids[i].filament_id (our OF ids) below
     bool has_ready = false;
-    const auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset("GFA00");
+    const auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(default_filament_id);
     for (const auto& tray_pair : dev_ams->GetTrays()) {
         if (!tray_pair.second || !tray_pair.second->is_tray_info_ready()) continue;
         has_ready = true;

src/slic3r/GUI/AMSDryControl.hpp

@@ -97,12 +97,6 @@ private:
     wxSimplebook* m_main_simplebook{nullptr};
     wxPanel* m_original_page{nullptr};
 
-    wxWindow* m_amswin{nullptr};
-    wxBoxSizer* m_sizer_ams_items{nullptr};
-    wxScrolledWindow* m_panel_prv_left {nullptr};
-    wxScrolledWindow* m_panel_prv_right{nullptr};
-    wxBoxSizer* m_sizer_prv_left{nullptr};
-    wxBoxSizer* m_sizer_prv_right{nullptr};
 
     // left panel related members
     ScalableBitmap m_humidity_image;

src/slic3r/GUI/AMSMaterialsSetting.cpp

@@ -681,6 +681,19 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
     }
 
 
+    // Orca: log the tray payload this dialog hands the printer, so the filament_id resolved from the
+    // dropdown selection can be checked against the tray_info_idx the AMS actually receives. A
+    // BBL-tagged (RFID) tray is read-only here, so nothing is published for it.
+    BOOST_LOG_TRIVIAL(info) << "ams_materials_setting: " << (m_is_third ? "sending" : "NOT sending (BBL RFID tray, read-only)")
+                            << ", ams_id = " << ams_id << ", slot_id = " << slot_id
+                            << ", selected = " << m_comboBox_filament->GetValue().ToStdString()
+                            << ", tray_info_idx (filament_id) = " << ams_filament_id
+                            << ", setting_id = " << ams_setting_id
+                            << ", tray_type = " << m_filament_type
+                            << ", tray_color = " << col_buf
+                            << ", nozzle_temp_min = " << nozzle_temp_min_int
+                            << ", nozzle_temp_max = " << nozzle_temp_max_int;
+
     // set filament
     if (m_is_third) {
         obj->command_ams_filament_settings(ams_id, slot_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
@@ -802,7 +815,10 @@ void AMSMaterialsSetting::set_color(wxColour color)
     fila_color.m_colors.insert(color);
     fila_color.EndSet(m_clr_picker->ctype);
     auto clr_query = GUI::wxGetApp().get_filament_color_code_query();
-    m_clr_name->SetLabelText(clr_query->GetFilaColorName(ams_filament_id, fila_color));
+    // ams_filament_id is our OF id; GetFilaColorName looks up filaments_color_codes.json,
+    // downloaded from Bambu and keyed by the printer's own ids, so translate for this lookup only.
+    auto* agent = GUI::wxGetApp().getAgent();
+    m_clr_name->SetLabelText(clr_query->GetFilaColorName(agent ? agent->from_orca_filament_id(ams_filament_id) : ams_filament_id, fila_color));
 }
 
 void AMSMaterialsSetting::set_empty_color(wxColour color)
@@ -823,7 +839,10 @@ void AMSMaterialsSetting::set_colors(std::vector<wxColour> colors)
         for (const auto& clr : colors) { fila_color.m_colors.insert(clr); }
         fila_color.EndSet(m_clr_picker->ctype);
         auto clr_query = GUI::wxGetApp().get_filament_color_code_query();
-        m_clr_name->SetLabelText(clr_query->GetFilaColorName(ams_filament_id, fila_color));
+        // ams_filament_id is our OF id; GetFilaColorName looks up filaments_color_codes.json,
+        // downloaded from Bambu and keyed by the printer's own ids, so translate for this lookup only.
+        auto* agent = GUI::wxGetApp().getAgent();
+        m_clr_name->SetLabelText(clr_query->GetFilaColorName(agent ? agent->from_orca_filament_id(ams_filament_id) : ams_filament_id, fila_color));
     }
 }
 
@@ -932,7 +951,6 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
     m_input_k_val->GetTextCtrl()->SetValue(k);
     m_input_n_val->GetTextCtrl()->SetValue(n);
 
-    int idx = 0;
     wxArrayString filament_items;
     wxString bambu_filament_name;
     wxString hint_filament_name; // the hint type to be selected
@@ -940,6 +958,9 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
     std::unordered_map<wxString, wxString> query_filament_types;  //
 
     std::set<std::string> filament_id_set;
+    // The alias keyed map has to start empty: it is a member, so a stale alias left by an earlier
+    // popup (a different printer, a different nozzle) would resolve to that printer's filament_id.
+    map_filament_items.clear();
     PresetBundle *        preset_bundle = wxGetApp().preset_bundle;
     std::ostringstream    stream;
     // Defensive: this dialog is opened only from StatusPanel (BBL-only) today, so the fallback fires
@@ -952,83 +973,48 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
     }
     stream << std::fixed << std::setprecision(1) << machine_diameter;
     std::string nozzle_diameter_str = stream.str();
-    std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str);
 
     if (preset_bundle) {
         BOOST_LOG_TRIVIAL(trace) << "system_preset_bundle filament number=" << preset_bundle->filaments.size();
-        for (auto filament_it = preset_bundle->filaments.begin(); filament_it != preset_bundle->filaments.end(); filament_it++) {
-            //filter by system preset
-            Preset& preset = *filament_it;
-            /*The situation where the user preset is not displayed is as follows:
-                1. Not a root preset
-                2. Not system preset and the printer firmware does not support user preset */
-            if (preset_bundle->filaments.get_preset_base(*filament_it) != &preset || (!filament_it->is_system && !obj->is_support_user_preset)) {
+        for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
+                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+            if (!filament_id_set.insert(filament_it->filament_id).second)
+                continue;
+            const std::string alias = preset_bundle->filaments.get_preset_alias(*filament_it, true);
+            if (alias.empty())
                 continue;
-            }
 
-            ConfigOption *       printer_opt  = filament_it->config.option("compatible_printers");
-            ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt);
-            for (auto printer_str : printer_strs->values) {
-                if (printer_names.find(printer_str) != printer_names.end()) {
-                    if (filament_id_set.find(filament_it->filament_id) != filament_id_set.end()) {
-                        continue;
-                    } else {
-                        filament_id_set.insert(filament_it->filament_id);
-                        // name matched
-                        if (filament_it->is_system) {
-                            filament_items.push_back(filament_it->alias);
-                            _collect_filament_info(filament_it->alias, preset, query_filament_vendors, query_filament_types);
+            filament_items.push_back(alias);
+            _collect_filament_info(alias, *filament_it, query_filament_vendors, query_filament_types);
 
-                            FilamentInfos filament_infos;
-                            filament_infos.filament_id             = filament_it->filament_id;
-                            filament_infos.setting_id              = filament_it->setting_id;
-                            map_filament_items[filament_it->alias] = filament_infos;
-                        } else {
-                            char   target = '@';
-                            size_t pos    = filament_it->name.find(target);
-                            if (pos != std::string::npos) {
-                                std::string user_preset_alias    = filament_it->name.substr(0, pos - 1);
-                                wxString    wx_user_preset_alias = wxString(user_preset_alias.c_str(), wxConvUTF8);
-                                user_preset_alias                = wx_user_preset_alias.ToStdString();
+            FilamentInfos filament_infos;
+            filament_infos.filament_id = filament_it->filament_id;
+            filament_infos.setting_id  = filament_it->setting_id;
+            map_filament_items[alias]  = filament_infos;
 
-                                filament_items.push_back(user_preset_alias);
-                                _collect_filament_info(user_preset_alias, preset, query_filament_vendors, query_filament_types);
-
-                                FilamentInfos filament_infos;
-                                filament_infos.filament_id            = filament_it->filament_id;
-                                filament_infos.setting_id             = filament_it->setting_id;
-                                map_filament_items[user_preset_alias] = filament_infos;
-                            }
-                        }
-
-                        if (filament_it->filament_id == ams_filament_id) {
-                            hint_filament_name = from_u8(filament_it->alias);
-                            bambu_filament_name = from_u8(filament_it->alias);
+            if (filament_it->filament_id == ams_filament_id) {
+                hint_filament_name = from_u8(alias);
+                bambu_filament_name = from_u8(alias);
 
 
-                            // update if nozzle_temperature_range is found
-                            ConfigOption *opt_min = filament_it->config.option("nozzle_temperature_range_low");
-                            if (opt_min) {
-                                ConfigOptionInts *opt_min_ints = dynamic_cast<ConfigOptionInts *>(opt_min);
-                                if (opt_min_ints) {
-                                    wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(0));
-                                    m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
-                                }
-                            }
-                            ConfigOption *opt_max = filament_it->config.option("nozzle_temperature_range_high");
-                            if (opt_max) {
-                                ConfigOptionInts *opt_max_ints = dynamic_cast<ConfigOptionInts *>(opt_max);
-                                if (opt_max_ints) {
-                                    wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(0));
-                                    m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
-                                }
-                            }
-                        }
-                        idx++;
+                // update if nozzle_temperature_range is found
+                ConfigOption *opt_min = filament_it->config.option("nozzle_temperature_range_low");
+                if (opt_min) {
+                    ConfigOptionInts *opt_min_ints = dynamic_cast<ConfigOptionInts *>(opt_min);
+                    if (opt_min_ints) {
+                        wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(0));
+                        m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
+                    }
+                }
+                ConfigOption *opt_max = filament_it->config.option("nozzle_temperature_range_high");
+                if (opt_max) {
+                    ConfigOptionInts *opt_max_ints = dynamic_cast<ConfigOptionInts *>(opt_max);
+                    if (opt_max_ints) {
+                        wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(0));
+                        m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
                     }
                 }
             }
-
         }
     }
 
@@ -1251,56 +1237,47 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
             stream << std::fixed << std::setprecision(1) << machine_diameter;
         }
         std::string nozzle_diameter_str = stream.str();
-        std::set<std::string> printer_names = preset_bundle->get_printer_names_by_printer_type_and_nozzle(DevPrinterConfigUtil::get_printer_display_name(obj->printer_type),
-                                                                                                          nozzle_diameter_str);
-        for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++) {
-            if (!m_comboBox_filament->GetValue().IsEmpty()) {
-                auto filament_item = map_filament_items[m_comboBox_filament->GetValue().ToStdString()];
-                std::string filament_id   = filament_item.filament_id;
-                if (it->filament_id.compare(filament_id) == 0) {
-                    ConfigOption *       printer_opt  = it->config.option("compatible_printers");
-                    ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt);
-                    bool has_compatible_printer = false;
-                    for (auto printer_str : printer_strs->values) {
-                        if (printer_names.find(printer_str) != printer_names.end()) {
-                            has_compatible_printer = true;
-                            break;
-                        }
+        // Resolve the selection against the same list Popup() built the dropdown from, so the two
+        // halves of the dialog cannot disagree about which filaments this machine can use.
+        const std::string selected = m_comboBox_filament->GetValue().ToStdString();
+        if (!selected.empty()) {
+            const std::string filament_id = map_filament_items[selected].filament_id;
+            for (Preset *it : preset_bundle->get_filament_presets_for_machine(
+                     DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+                if (it->filament_id != filament_id)
+                    continue;
+                // ) if nozzle_temperature_range is found
+                ConfigOption* opt_min = it->config.option("nozzle_temperature_range_low");
+                if (opt_min) {
+                    ConfigOptionInts* opt_min_ints = dynamic_cast<ConfigOptionInts*>(opt_min);
+                    if (opt_min_ints) {
+                        wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(0));
+                        m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
                     }
-                    if (!it->is_system && !has_compatible_printer) continue;
-                    // ) if nozzle_temperature_range is found
-                    ConfigOption* opt_min = it->config.option("nozzle_temperature_range_low");
-                    if (opt_min) {
-                        ConfigOptionInts* opt_min_ints = dynamic_cast<ConfigOptionInts*>(opt_min);
-                        if (opt_min_ints) {
-                            wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(0));
-                            m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
-                        }
-                    }
-                    ConfigOption* opt_max = it->config.option("nozzle_temperature_range_high");
-                    if (opt_max) {
-                        ConfigOptionInts* opt_max_ints = dynamic_cast<ConfigOptionInts*>(opt_max);
-                        if (opt_max_ints) {
-                            wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(0));
-                            m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
-                        }
-                    }
-                    ConfigOption* opt_type = it->config.option("filament_type");
-                    bool found_filament_type = false;
-                    if (opt_type) {
-                        ConfigOptionStrings* opt_type_strs = dynamic_cast<ConfigOptionStrings*>(opt_type);
-                        if (opt_type_strs) {
-                            found_filament_type = true;
-                            //m_filament_type = opt_type_strs->get_at(0);
-                            std::string display_filament_type;
-                            m_filament_type = it->config.get_filament_type(display_filament_type);
-                        }
-                    }
-                    if (!found_filament_type)
-                        m_filament_type = "";
-
-                    break;
                 }
+                ConfigOption* opt_max = it->config.option("nozzle_temperature_range_high");
+                if (opt_max) {
+                    ConfigOptionInts* opt_max_ints = dynamic_cast<ConfigOptionInts*>(opt_max);
+                    if (opt_max_ints) {
+                        wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(0));
+                        m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
+                    }
+                }
+                ConfigOption* opt_type = it->config.option("filament_type");
+                bool found_filament_type = false;
+                if (opt_type) {
+                    ConfigOptionStrings* opt_type_strs = dynamic_cast<ConfigOptionStrings*>(opt_type);
+                    if (opt_type_strs) {
+                        found_filament_type = true;
+                        //m_filament_type = opt_type_strs->get_at(0);
+                        std::string display_filament_type;
+                        m_filament_type = it->config.get_filament_type(display_filament_type);
+                    }
+                }
+                if (!found_filament_type)
+                    m_filament_type = "";
+
+                break;
             }
         }
     }

src/slic3r/GUI/AmsMappingPopup.hpp

@@ -457,7 +457,6 @@ private:
     ScalableBitmap close_img;
 
     wxStaticBitmap* curr_humidity_img;
-    wxStaticBitmap* m_img;
 
     Label* m_staticText;;
     Label* m_staticText_note;

src/slic3r/GUI/AmsMappingPopupUpdate.cpp

@@ -406,7 +406,7 @@ void AmsMapingPopup::update_ams_data_multi_machines()
         int ams_type = 1;
         int nozzle_id = 0;
 
-        if (ams_type >= 1 || ams_type <= 3) { // 1:ams 2:ams-lite 3:n3f
+        if (ams_type >= 1 && ams_type <= 3) { // 1:ams 2:ams-lite 3:n3f
 
             auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL);
             auto ams_mapping_item_container = new MappingContainer(nozzle_id == 0 ? m_right_marea_panel : m_left_marea_panel, "AMS-1", 4);

src/slic3r/GUI/BBLTopbar.hpp

@@ -93,7 +93,6 @@ private:
     CenteredTitle*    m_title_ctrl { nullptr };
     wxString          m_titleText;
 
-    wxAuiToolBarItem* m_model_store_item;
     
     //wxAuiToolBarItem *m_publish_item;
     wxAuiToolBarItem* m_undo_item;

src/slic3r/GUI/BackgroundSlicingProcess.cpp

@@ -848,7 +848,9 @@ void BackgroundSlicingProcess::finalize_gcode()
     case CopyFileResult::SUCCESS: break; // no error
     case CopyFileResult::FAIL_COPY_FILE:
         throw Slic3r::ExportError(GUI::format(
-            _L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?\nError message: %1%"),
+            m_export_path_on_removable_media ?
+                _L("Copying of the temporary G-code to the output G-code failed. Maybe the SD card is write locked?\nError message: %1%") :
+                _L("Copying of the temporary G-code to the output G-code failed.\nError message: %1%"),
             error_message));
         break;
     case CopyFileResult::FAIL_FILES_DIFFERENT:

src/slic3r/GUI/BindDialog.hpp

@@ -65,18 +65,10 @@ private:
     wxPanel* request_bind_panel;
     wxPanel* binding_panel;
 
-    wxScrolledWindow* m_sw_bind_failed_info;
-    Label* m_bind_failed_info;
-    Label* m_st_txt_error_code{ nullptr };
-    Label* m_st_txt_error_desc{ nullptr };
-    Label* m_st_txt_extra_info{ nullptr };
-    HyperLink*      m_link_network_state{ nullptr };
     wxString        m_result_info;
     wxString        m_result_extra;
     wxString        m_ping_code_wiki;
-    bool            m_show_error_info_state = true;
 
-    int             m_result_code;
     std::shared_ptr<BBLStatusBarBind> m_status_bar;
 
 public:
@@ -110,7 +102,6 @@ private:
     wxBitmap      m_bitmap_show_error_close;
     wxBitmap      m_bitmap_show_error_open;
     wxScrolledWindow* m_sw_bind_failed_info;
-    Label*          m_bind_failed_info;
     Label*          m_st_txt_error_code{ nullptr };
     Label*          m_st_txt_error_desc{ nullptr };
     Label*          m_st_txt_extra_info{ nullptr };

src/slic3r/GUI/CaliHistoryDialog.cpp

@@ -702,7 +702,6 @@ wxArrayString NewCalibrationHistoryDialog::get_all_filaments(const MachineObject
 
     wxArrayString         filament_items;
     std::set<std::string> filament_id_set;
-    std::set<std::string> printer_names;
     std::ostringstream    stream;
     // If the machine didn't report a nozzle diameter (0.0 = unknown), fall back to the currently
     // selected printer preset so the filament list isn't empty.
@@ -714,67 +713,21 @@ wxArrayString NewCalibrationHistoryDialog::get_all_filaments(const MachineObject
     stream << std::fixed << std::setprecision(1) << machine_diameter;
     std::string nozzle_diameter_str = stream.str();
 
-    for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
-        // filter by system preset
-        if (!printer_it->is_system)
-            continue;
-        // get printer_model
-        ConfigOption *      printer_model_opt = printer_it->config.option("printer_model");
-        ConfigOptionString *printer_model_str = dynamic_cast<ConfigOptionString *>(printer_model_opt);
-        if (!printer_model_str)
-            continue;
-
-        // use printer_model as printer type
-        if (printer_model_str->value != DevPrinterConfigUtil::get_printer_display_name(obj->printer_type))
-            continue;
-
-        if (printer_it->name.find(nozzle_diameter_str) != std::string::npos)
-            printer_names.insert(printer_it->name);
-    }
-
     if (preset_bundle) {
         BOOST_LOG_TRIVIAL(trace) << "system_preset_bundle filament number=" << preset_bundle->filaments.size();
-        for (auto filament_it = preset_bundle->filaments.begin(); filament_it != preset_bundle->filaments.end(); filament_it++) {
-            // filter by system preset
-            Preset &preset = *filament_it;
-            /*The situation where the user preset is not displayed is as follows:
-                1. Not a root preset
-                2. Not system preset and the printer firmware does not support user preset */
-            if (preset_bundle->filaments.get_preset_base(*filament_it) != &preset || (!filament_it->is_system && ! obj->is_support_user_preset)) { continue; }
+        for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
+                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+            if (!filament_id_set.insert(filament_it->filament_id).second)
+                continue;
+            const std::string alias = preset_bundle->filaments.get_preset_alias(*filament_it, true);
+            if (alias.empty())
+                continue;
 
-            ConfigOption *       printer_opt  = filament_it->config.option("compatible_printers");
-            ConfigOptionStrings *printer_strs = dynamic_cast<ConfigOptionStrings *>(printer_opt);
-            for (auto printer_str : printer_strs->values) {
-                if (printer_names.find(printer_str) != printer_names.end()) {
-                    if (filament_id_set.find(filament_it->filament_id) != filament_id_set.end()) {
-                        continue;
-                    } else {
-                        filament_id_set.insert(filament_it->filament_id);
-                        // name matched
-                        if (filament_it->is_system) {
-                            filament_items.push_back(filament_it->alias);
-                            FilamentInfos filament_infos;
-                            filament_infos.filament_id             = filament_it->filament_id;
-                            filament_infos.setting_id              = filament_it->setting_id;
-                            map_filament_items[filament_it->alias] = filament_infos;
-                        } else {
-                            char   target = '@';
-                            size_t pos    = filament_it->name.find(target);
-                            if (pos != std::string::npos) {
-                                std::string user_preset_alias    = filament_it->name.substr(0, pos - 1);
-                                wxString    wx_user_preset_alias = wxString(user_preset_alias.c_str(), wxConvUTF8);
-                                user_preset_alias                = wx_user_preset_alias.ToStdString();
-
-                                filament_items.push_back(user_preset_alias);
-                                FilamentInfos filament_infos;
-                                filament_infos.filament_id            = filament_it->filament_id;
-                                filament_infos.setting_id             = filament_it->setting_id;
-                                map_filament_items[user_preset_alias] = filament_infos;
-                            }
-                        }
-                    }
-                }
-            }
+            filament_items.push_back(alias);
+            FilamentInfos filament_infos;
+            filament_infos.filament_id = filament_it->filament_id;
+            filament_infos.setting_id  = filament_it->setting_id;
+            map_filament_items[alias]  = filament_infos;
         }
     }
     return filament_items;

src/slic3r/GUI/CalibrationPanel.hpp

@@ -70,11 +70,7 @@ public:
 
 private:
     int                                 m_my_devices_count{ 0 };
-    int                                 m_other_devices_count{ 0 };
     bool                                m_dismiss{ false };
-    wxWindow*                           m_placeholder_panel   { nullptr };
-    wxWindow*                           m_panel_body{ nullptr };
-    wxBoxSizer*                         m_sizer_body{ nullptr };
     wxBoxSizer*                         m_sizer_my_devices{ nullptr };
     wxScrolledWindow*                   m_scrolledWindow{ nullptr };
     wxTimer*                            m_refresh_timer{ nullptr };

src/slic3r/GUI/CalibrationWizardPresetPage.cpp

@@ -360,7 +360,7 @@ void CaliPresetCustomRangePanel::create_panel(wxWindow* parent)
                 int max_decimal_length;
                 if (i <= 1)
                     max_decimal_length = 3;
-                else if (i >= 2)
+                else
                     max_decimal_length = 4;
                 if (decimal_number > max_decimal_length) {
                     int allowed_length = number.length() - decimal_number + max_decimal_length;

src/slic3r/GUI/CameraPopup.hpp

@@ -72,8 +72,10 @@ private:
     SwitchButton* m_switch_recording;
     wxStaticText* m_text_vcamera;
     SwitchButton* m_switch_vcamera;
+#if !BBL_RELEASE_TO_PUBLIC
     wxStaticText* m_text_liveview_retry;
     SwitchButton* m_switch_liveview_retry;
+#endif //BBL_RELEASE_TO_PUBLIC
     wxStaticText* m_custom_camera_hint;
     TextInput* m_custom_camera_input;
     Button* m_custom_camera_input_confirm;

src/slic3r/GUI/ColorDecomposeSupport.cpp

@@ -62,10 +62,16 @@ std::string decompose_basic_type_from_source(size_t source_config_idx,
     auto& project_config = wxGetApp().preset_bundle->project_config;
     if (auto* filament_id_opt = project_config.option<ConfigOptionStrings>("filament_id")) {
         if (source_config_idx < filament_id_opt->values.size()) {
-            const std::string& filament_id = filament_id_opt->values[source_config_idx];
-            if (filament_id == kDecomposePetgFilamentId)
+            // Dead in practice: "filament_id" is not in PresetBundle's s_project_options, so this
+            // option() lookup (create=false) always returns null and the block never runs. Kept as
+            // found, with the translation the values would need: they would be our OF ids, and the
+            // two constants are the printer's own ids.
+            auto* agent = wxGetApp().getAgent();
+            const std::string& orca_filament_id = filament_id_opt->values[source_config_idx];
+            const std::string  printer_filament_id = agent ? agent->from_orca_filament_id(orca_filament_id) : orca_filament_id;
+            if (printer_filament_id == kDecomposePetgFilamentId)
                 return kDecomposePetgBasicType;
-            if (filament_id == kDecomposePlaFilamentId)
+            if (printer_filament_id == kDecomposePlaFilamentId)
                 return kDecomposePlaBasicType;
         }
     }
@@ -82,9 +88,14 @@ std::string decompose_basic_type_from_source(size_t source_config_idx,
 
 std::string decompose_basic_filament_id(const std::string& basic_type)
 {
-    if (basic_type == kDecomposePetgBasicType)
-        return kDecomposePetgFilamentId;
-    return kDecomposePlaFilamentId;
+    // The result becomes DecomposeOfficialComponent::filament_id, which the rest of this file
+    // reads as one of our OF ids (translating back before it compares against the printer's
+    // ids), so translate on the way out; kDecompose*FilamentId itself stays the printer-side
+    // literal. The only place that would carry it further, project_config's "filament_id", is
+    // dead code: that key is not in PresetBundle's s_project_options.
+    const std::string printer_filament_id = basic_type == kDecomposePetgBasicType ? kDecomposePetgFilamentId : kDecomposePlaFilamentId;
+    auto* agent = wxGetApp().getAgent();
+    return agent ? agent->to_orca_filament_id(printer_filament_id) : printer_filament_id;
 }
 
 void set_created_standard_component_metadata(size_t config_idx, const DecomposeOfficialComponent& component)
@@ -98,8 +109,11 @@ void set_created_standard_component_metadata(size_t config_idx, const DecomposeO
         }
     }
 
-    const std::string type = component.filament_id == kDecomposePetgFilamentId ? kDecomposePetgShortType :
-                             component.filament_id == kDecomposePlaFilamentId ? kDecomposePlaShortType : "";
+    // component.filament_id is our OF id; the two constants are the printer's own ids.
+    auto* agent = wxGetApp().getAgent();
+    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(component.filament_id) : component.filament_id;
+    const std::string type = printer_filament_id == kDecomposePetgFilamentId ? kDecomposePetgShortType :
+                             printer_filament_id == kDecomposePlaFilamentId ? kDecomposePlaShortType : "";
     if (!type.empty()) {
         if (auto* type_opt = project_config.option<ConfigOptionStrings>("filament_type")) {
             while (type_opt->values.size() <= config_idx)
@@ -151,7 +165,12 @@ DecomposeOfficialComponent lookup_decompose_official_component(
                 continue;
             if (item.contains("fila_color") && item["fila_color"].is_array() && !item["fila_color"].empty())
                 result.color_hex = decompose_normalize_color_hex(item["fila_color"][0].get<std::string>());
-            result.filament_id = item.value("fila_id", result.filament_id);
+            // fila_id from this shipped, Bambu-keyed color table is a printer-side id; translate it so
+            // result.filament_id stays an OF id like the rest of this struct (the fallback default,
+            // result.filament_id, is already OF and passes through unchanged).
+            const std::string fila_id = item.value("fila_id", result.filament_id);
+            auto* agent = wxGetApp().getAgent();
+            result.filament_id = agent ? agent->to_orca_filament_id(fila_id) : fila_id;
             return result;
         }
     }
@@ -211,8 +230,11 @@ int find_existing_decompose_component(
     auto* type_opt = project_config.option<ConfigOptionStrings>("filament_type");
     const PresetBundle& preset_bundle = *wxGetApp().preset_bundle;
     const size_t num_physical = physical_colors.size();
-    const std::string expected_basic_type = component.filament_id == kDecomposePetgFilamentId ? kDecomposePetgBasicType :
-                                            component.filament_id == kDecomposePlaFilamentId ? kDecomposePlaBasicType : "";
+    // component.filament_id is our OF id; the two constants are the printer's own ids.
+    auto* agent = wxGetApp().getAgent();
+    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(component.filament_id) : component.filament_id;
+    const std::string expected_basic_type = printer_filament_id == kDecomposePetgFilamentId ? kDecomposePetgBasicType :
+                                            printer_filament_id == kDecomposePlaFilamentId ? kDecomposePlaBasicType : "";
     const std::string expected_short_type = expected_basic_type == kDecomposePetgBasicType ? kDecomposePetgShortType :
                                             expected_basic_type == kDecomposePlaBasicType ? kDecomposePlaShortType : "";
     const std::string expected_preset_part = expected_basic_type.empty() ? "" : std::string(kDecomposeBambuPresetPrefix) + expected_basic_type;

src/slic3r/GUI/CreatePresetsDialog.hpp

@@ -74,7 +74,6 @@ private:
     std::unordered_set<std::string>                                  m_system_filament_types_set;
     std::set<std::string>                                            m_visible_printers;
     CreateType                                                       m_create_type;
-    Button *                                                         m_button_cancel                = nullptr;
     ComboBox *                                                       m_filament_vendor_combobox     = nullptr;
     ::CheckBox *                                                     m_can_not_find_vendor_checkbox = nullptr;
     ComboBox *                                                       m_filament_type_combobox       = nullptr;

src/slic3r/GUI/DailyTips.cpp

@@ -245,7 +245,6 @@ DailyTipsPanel::DailyTipsPanel(bool can_expand, DailyTipsLayout layout)
     m_width(0),
     m_height(0),
     m_can_expand(can_expand),
-    m_layout(layout),
     m_uid(DailyTipsPanel::uid++),
     m_dailytips_renderer(std::make_unique<DailyTipsDataRenderer>(layout))
 {

src/slic3r/GUI/DailyTips.hpp

@@ -51,7 +51,6 @@ private:
     int m_uid;
     bool m_first_enter{ false };
     bool m_is_dark{ false };
-    DailyTipsLayout m_layout{ DailyTipsLayout::Vertical };
     float m_fade_opacity{ 1.0f };
 };
 

src/slic3r/GUI/DeviceCore/DevConfig.h

@@ -54,7 +54,7 @@ public:
     void ParseCalibrationConfig(const json& print_json); //cali
 
 private:
-    MachineObject* m_obj;
+    [[maybe_unused]] MachineObject* m_obj;
 
     /*configure vals*/
     // chamber

src/slic3r/GUI/DeviceCore/DevExtensionTool.h

@@ -31,7 +31,7 @@ protected:
     DevExtensionTool(MachineObject* obj);
 
 private:
-    MachineObject* m_owner = nullptr;
+    [[maybe_unused]] MachineObject* m_owner = nullptr;
 
     enum MountState
     {

src/slic3r/GUI/DeviceCore/DevFilaAmsSetting.h

@@ -28,7 +28,7 @@ public:
     void SetAutoRefillEnabled(bool enable) { m_enable_auto_refill = enable; }
 
 private:
-    DevFilaSystem* m_owner = nullptr;
+    [[maybe_unused]] DevFilaSystem* m_owner = nullptr;
 
     std::optional<bool> m_enable_detect_on_insert = false;
     bool m_enable_detect_on_powerup = false;

src/slic3r/GUI/DeviceCore/DevFilaBlackList.cpp

@@ -241,8 +241,11 @@ void check_filaments(const DevFilaBlacklist::CheckFilamentInfo& check_info, DevF
                 std::set<std::string> white_fila_ids = filament_item.contains("white_fila_ids") ? filament_item["white_fila_ids"].get<std::set<std::string>>() : std::set<std::string>();
                 if (!white_fila_ids.empty() && !check_info.fila_id.empty())
                 {
-                    auto it = std::find_if(white_fila_ids.begin(), white_fila_ids.end(), [&check_info](const std::string& white_fila_id) {
-                        return white_fila_id == check_info.fila_id;
+                    // check_info.fila_id is our OF id; white_fila_ids in filaments_blacklist.json holds the printer's own.
+                    auto* agent = Slic3r::GUI::wxGetApp().getAgent();
+                    const std::string printer_filament_id = agent ? agent->from_orca_filament_id(check_info.fila_id) : check_info.fila_id;
+                    auto it = std::find_if(white_fila_ids.begin(), white_fila_ids.end(), [&printer_filament_id](const std::string& white_fila_id) {
+                        return white_fila_id == printer_filament_id;
                     });
                     if (it != white_fila_ids.end()) { continue; }
                 }

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -5,6 +5,7 @@
 // TODO: remove this include
 #include "slic3r/GUI/DeviceManager.hpp"
 #include "slic3r/GUI/I18N.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
 
 #include "DevUtil.h"
 #include "DevUtilBackend.h"
@@ -95,7 +96,12 @@ std::string DevAmsTray::get_filament_type()
     if (m_fila_type == "Sup.ABS") { return "ABS-S"; }
     if (m_fila_type == "Support W") { return "PLA-S"; }
     if (m_fila_type == "Support G") { return "PA-S"; }
-    if (m_fila_type == "Support") { if (setting_id == "GFS00") { m_fila_type = "PLA-S"; } else if (setting_id == "GFS01") { m_fila_type = "PA-S"; } else { return "PLA-S"; } }
+    // setting_id is our OF id; GFS00/GFS01 are the printer's own support-filament ids.
+    if (m_fila_type == "Support") {
+        auto* agent = GUI::wxGetApp().getAgent();
+        const std::string printer_filament_id = agent ? agent->from_orca_filament_id(setting_id) : setting_id;
+        if (printer_filament_id == "GFS00") { m_fila_type = "PLA-S"; } else if (printer_filament_id == "GFS01") { m_fila_type = "PA-S"; } else { return "PLA-S"; }
+    }
 
     return m_fila_type;
 }
@@ -654,11 +660,14 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                                 curr_tray->setting_id = (*tray_it)["tray_info_idx"].get<std::string>();
                                 //std::string type            = (*tray_it)["tray_type"].get<std::string>();
                                 std::string type = MachineObject::setting_id_to_type(curr_tray->setting_id, (*tray_it)["tray_type"].get<std::string>());
-                                if (curr_tray->setting_id == "GFS00")
+                                // curr_tray->setting_id is our OF id; GFS00/GFS01 are the printer's own support-filament ids.
+                                auto* agent = GUI::wxGetApp().getAgent();
+                                const std::string printer_filament_id = agent ? agent->from_orca_filament_id(curr_tray->setting_id) : curr_tray->setting_id;
+                                if (printer_filament_id == "GFS00")
                                 {
                                     curr_tray->m_fila_type = "PLA-S";
                                 }
-                                else if (curr_tray->setting_id == "GFS01")
+                                else if (printer_filament_id == "GFS01")
                                 {
                                     curr_tray->m_fila_type = "PA-S";
                                 }

src/slic3r/GUI/DeviceCore/DevFilaSystem.h

@@ -58,7 +58,7 @@ public:
 
     std::string              id;
     std::string              tag_uid;             // tag_uid
-    std::string              setting_id;          // tray_info_idx
+    std::string              setting_id;          // tray_info_idx, map to the filament_id
     std::string              filament_setting_id; // setting_id
     std::string              m_fila_type;
     std::string              sub_brands;

src/slic3r/GUI/DeviceCore/DevHMS.h

@@ -21,7 +21,7 @@ public:
     const std::vector<DevHMSItem>& GetHMSItems() const { return m_hms_list; };
 
 private:
-    MachineObject* m_object = nullptr;
+    [[maybe_unused]] MachineObject* m_object = nullptr;
 
     // all hms for this machine
     std::vector<DevHMSItem>  m_hms_list;

src/slic3r/GUI/DeviceCore/DevInfo.h

@@ -34,7 +34,7 @@ private:
     //std::string m_connect_type;
     //std::string m_bind_state;
 
-    MachineObject* m_owner = nullptr;
+    [[maybe_unused]] MachineObject* m_owner = nullptr;
 };
 
 } // namespace Slic3r

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -872,7 +872,7 @@ namespace Slic3r
                         obj->m_is_online = elem["dev_online"].get<bool>();
                     if (elem.contains("dev_model_name") && !elem["dev_model_name"].is_null()) {
                         auto printer_type = elem["dev_model_name"].get<std::string>();
-                        for (const std::pair<std::string, std::vector<std::string>> &pair : device_subseries) {
+                        for (const auto &pair : device_subseries) {
                             auto it = std::find(pair.second.begin(), pair.second.end(), printer_type);
                             if (it != pair.second.end())
                             {

src/slic3r/GUI/DeviceCore/DevStatus.h

@@ -36,7 +36,7 @@ public:
     void ParseStatus(const nlohmann::json& print_jj);
 
 private:
-    MachineObject *m_owner = nullptr;
+    [[maybe_unused]] MachineObject *m_owner = nullptr;
     std::optional<DevJobState> m_job_state; // could be nullopt for some old firmware
 };
 

src/slic3r/GUI/DeviceCore/DevStorage.h

@@ -31,7 +31,7 @@ public:
     bool is_timelapse_storage_low(const std::string& storage) const;
 
 private:
-    MachineObject *m_owner;
+    [[maybe_unused]] MachineObject *m_owner;
     SdcardState    m_sdcard_state  { NO_SDCARD };
     // timelapse storage space info (from device push cam data)
     int tl_internal_free_kb{-1};

src/slic3r/GUI/DeviceManager.cpp

@@ -110,7 +110,9 @@ bool Slic3r::is_stringing_prone_filament(const std::string& filament_id, float n
     if (filament_id.empty()) return false;
     const auto* set = pick_stringing_set(nozzle_diameter);
     if (!set) return false;
-    return set->count(filament_id) > 0;
+    // filament_id is one of our content-addressed OF ids; the table above is keyed by the printer's own.
+    auto* agent = Slic3r::GUI::wxGetApp().getAgent();
+    return set->count(agent ? agent->from_orca_filament_id(filament_id) : filament_id) > 0;
 }
 
 wxString Slic3r::get_stage_string(int stage)
@@ -5048,10 +5050,13 @@ DevAmsTray MachineObject::parse_vt_tray(json vtray)
             vt_tray.setting_id = vtray["tray_info_idx"].get<std::string>();
             //std::string type = vtray["tray_type"].get<std::string>();
             std::string type = setting_id_to_type(vt_tray.setting_id, vtray["tray_type"].get<std::string>());
-            if (vt_tray.setting_id == "GFS00") {
+            // vt_tray.setting_id is our OF id (translated on the way in); the two support ids below are the printer's own.
+            auto* agent = GUI::wxGetApp().getAgent();
+            const std::string printer_filament_id = agent ? agent->from_orca_filament_id(vt_tray.setting_id) : vt_tray.setting_id;
+            if (printer_filament_id == "GFS00") {
                 vt_tray.m_fila_type = "PLA-S";
             }
-            else if (vt_tray.setting_id == "GFS01") {
+            else if (printer_filament_id == "GFS01") {
                 vt_tray.m_fila_type = "PA-S";
             }
             else {
@@ -5592,7 +5597,10 @@ void MachineObject::update_filament_list()
 
         for (auto it = filament_list.begin(); it != filament_list.end(); it++) {
             if (m_filament_list.find(it->first) != m_filament_list.end()) {
-                assert(it->first.size() == 8 && it->first[0] == 'P');
+                // User roots may legitimately carry adopted system-shaped ids (GF*/OF*/P-hex
+                // system), so a non-'P' id here is expected, not an invariant violation.
+                if (it->first.size() != 8 || it->first[0] != 'P')
+                    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": user-root filament_id is not user-shaped: " << it->first;
 
                 if (it->second.first != m_filament_list[it->first].first) {
                     BOOST_LOG_TRIVIAL(info) << "old min temp is not equal to new min temp and filament id: " << it->first;
@@ -5654,6 +5662,17 @@ void MachineObject::update_printer_preset_name()
 void MachineObject::check_ams_filament_valid()
 {
     PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
+    // A tray id carried by ANY system filament preset is not a dangling user-preset id
+    // (ten shipped P-hex system ids pass the 'P' shape gates below), so the destructive
+    // tray-wipe / temp-rewrite handling must never fire for it.
+    auto is_system_filament_id = [preset_bundle](const std::string &id) {
+        if (!preset_bundle)
+            return false;
+        for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++)
+            if (it->is_system && it->filament_id == id)
+                return true;
+        return false;
+    };
     auto printer_model = DevPrinterConfigUtil::get_printer_display_name(this->printer_type);
     std::map<std::string, std::set<std::string>> need_checked_filament_id;
     for (auto &ams_pair : m_fila_system->GetAmsList()) {
@@ -5675,6 +5694,8 @@ void MachineObject::check_ams_filament_valid()
         auto &checked_filament = data.checked_filament;
         for (const auto &[slot_id, curr_tray] : ams->GetTrays()) {
 
+            if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && is_system_filament_id(curr_tray->setting_id))
+                continue;
             if (curr_tray->setting_id.size() == 8 && curr_tray->setting_id[0] == 'P' && filament_list.find(curr_tray->setting_id) == filament_list.end()) {
                 if (checked_filament.find(curr_tray->setting_id) != checked_filament.end()) {
                     need_checked_filament_id[nozzle_diameter_str].insert(curr_tray->setting_id);
@@ -5735,6 +5756,8 @@ void MachineObject::check_ams_filament_valid()
         auto &data = m_nozzle_filament_data[nozzle_diameter_str];
         auto &checked_filament = data.checked_filament;
         auto &filament_list    = data.filament_list;
+        if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && is_system_filament_id(vt_tray.setting_id))
+            continue;
         if (vt_tray.setting_id.size() == 8 && vt_tray.setting_id[0] == 'P' && filament_list.find(vt_tray.setting_id) == filament_list.end()) {
             if (checked_filament.find(vt_tray.setting_id) != checked_filament.end()) {
                 need_checked_filament_id[nozzle_diameter_str].insert(vt_tray.setting_id);

src/slic3r/GUI/ExtrusionCalibration.cpp

@@ -2,6 +2,7 @@
 #include "GUI_App.hpp"
 #include "MsgDialog.hpp"
 #include "libslic3r/Preset.hpp"
+#include <algorithm>
 #include "I18N.hpp"
 #include <boost/log/trivial.hpp>
 #include <wx/dcgraph.h>
@@ -599,8 +600,10 @@ void ExtrusionCalibration::update_combobox_filaments()
     PresetBundle* preset_bundle = wxGetApp().preset_bundle;
     if (preset_bundle && obj) {
         BOOST_LOG_TRIVIAL(trace) << "system_preset_bundle filament number=" << preset_bundle->filaments.size();
-        std::string printer_type = obj->printer_type;
-        std::set<std::string> printer_preset_list;
+        double nozzle_value = 0.4;
+        m_comboBox_nozzle_dia->GetValue().ToDouble(&nozzle_value);
+
+        std::vector<PresetWithVendorProfile> printer_profiles;
         for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
             // only use system printer preset
             if (!printer_it->is_system) continue;
@@ -610,49 +613,42 @@ void ExtrusionCalibration::update_combobox_filaments()
             ConfigOptionFloats* printer_nozzle_vals = nullptr;
             if (printer_nozzle_opt)
                 printer_nozzle_vals = dynamic_cast<ConfigOptionFloats*>(printer_nozzle_opt);
-            double nozzle_value = 0.4;
-            wxString nozzle_value_str = m_comboBox_nozzle_dia->GetValue();
-            try {
-                nozzle_value_str.ToDouble(&nozzle_value);
-            } catch(...) {
-                ;
-            }
             if (!model_id.empty() && model_id.compare(obj->printer_type) == 0
                 && printer_nozzle_vals
                 && abs(printer_nozzle_vals->get_at(0) - nozzle_value) < 1e-3) {
-                    printer_preset_list.insert(printer_it->name);
+                    printer_profiles.push_back(preset_bundle->printers.get_preset_with_vendor_profile(*printer_it));
                     BOOST_LOG_TRIVIAL(trace) << "extrusion_cali: printer_model = " << model_id;
             } else {
                 BOOST_LOG_TRIVIAL(error) << "extrusion_cali: printer_model = " << model_id;
             }
         }
 
+        // Unlike the AMS dialogs this one offers every matching preset by full name rather than one
+        // root preset per alias, so it filters the collection itself instead of calling
+        // PresetBundle::get_filament_presets_for_machine().
         for (auto filament_it = preset_bundle->filaments.begin(); filament_it != preset_bundle->filaments.end(); filament_it++) {
-            ConfigOption* printer_opt = filament_it->config.option("compatible_printers");
-            ConfigOptionStrings* printer_strs = dynamic_cast<ConfigOptionStrings*>(printer_opt);
-            for (auto printer_str : printer_strs->values) {
-                if (printer_preset_list.find(printer_str) != printer_preset_list.end()) {
-                    user_filaments.push_back(&(*filament_it));
+            const PresetWithVendorProfile filament = preset_bundle->filaments.get_preset_with_vendor_profile(*filament_it);
+            if (std::none_of(printer_profiles.begin(), printer_profiles.end(),
+                             [&filament](const PresetWithVendorProfile &printer) { return is_compatible_with_printer(filament, printer); }))
+                continue;
 
-                    // set default filament id
-                    filament_index++;
-                    if (filament_it->is_system
-                        && !ams_filament_id.empty()
-                        && filament_it->filament_id == ams_filament_id
-                        ) {
-                        curr_selection = filament_index;
-                    }
+            user_filaments.push_back(&(*filament_it));
 
-                    if (filament_it->name == obj->extrusion_cali_filament_name && !obj->extrusion_cali_filament_name.empty())
-                    {
-                        curr_selection = filament_index;
-                    }
-
-                    wxString filament_name = wxString::FromUTF8(filament_it->name);
-                    filament_items.Add(filament_name);
-                    break;
-                }
+            // set default filament id
+            filament_index++;
+            if (filament_it->is_system
+                && !ams_filament_id.empty()
+                && filament_it->filament_id == ams_filament_id
+                ) {
+                curr_selection = filament_index;
             }
+
+            if (filament_it->name == obj->extrusion_cali_filament_name && !obj->extrusion_cali_filament_name.empty())
+            {
+                curr_selection = filament_index;
+            }
+
+            filament_items.Add(wxString::FromUTF8(filament_it->name));
         }
         m_comboBox_filament->Set(filament_items);
         m_comboBox_filament->SetSelection(curr_selection);

src/slic3r/GUI/Field.cpp

@@ -2653,7 +2653,8 @@ void ColourPicker::set_value(const boost::any& value, bool change_event)
     auto field = dynamic_cast<wxColourPickerCtrl*>(window);
 
     #ifdef __WXMSW__
-        wxColour clr = (clr_str.IsEmpty() || !clr.IsOk()) ? wxTransparentColour : clr_str;
+        const wxColour parsed_clr(clr_str);
+        wxColour clr = (clr_str.IsEmpty() || !parsed_clr.IsOk()) ? wxTransparentColour : parsed_clr;
         field->SetColour(clr);
         draw_bmp_btn(field, clr);
     #else

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2191,7 +2191,7 @@ void GLCanvas3D::render(bool only_init)
 
 	// Negative coordinate means out of the window, likely because the window was deactivated.
 	// In that case the tooltip should be hidden.
-    if (m_mouse.position.x() >= 0. && m_mouse.position.y() >= 0. || has_mouse_capture()) { // ORCA continue to capture mouse pos mid drag
+    if ((m_mouse.position.x() >= 0. && m_mouse.position.y() >= 0.) || has_mouse_capture()) { // ORCA continue to capture mouse pos mid drag
         if (tooltip.empty())
             tooltip = m_layers_editing.get_tooltip(*this);
 
@@ -2891,23 +2891,37 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
                 DynamicPrintConfig& proj_cfg = wxGetApp().preset_bundle->project_config;
                 float x = dynamic_cast<const ConfigOptionFloats*>(proj_cfg.option("wipe_tower_x"))->get_at(plate_id);
                 float y = dynamic_cast<const ConfigOptionFloats*>(proj_cfg.option("wipe_tower_y"))->get_at(plate_id);
-                float w = dynamic_cast<const ConfigOptionFloat*>(m_config->option("prime_tower_width"))->value;
                 float a = dynamic_cast<const ConfigOptionFloat*>(m_config->option("wipe_tower_rotation_angle"))->value;
-                // BBS
-                float v = dynamic_cast<const ConfigOptionFloat*>(m_config->option("prime_volume"))->value;
                 Vec3d plate_origin = ppl.get_plate(plate_id)->get_origin();
 
-                const Print* print = m_process->fff_print();
                 const Print* current_print = part_plate->fff_print();
-                if (!need_wipe_tower && part_plate->get_extruders(true).size() < 2) continue;
                 if (part_plate->get_objects_on_this_plate().empty()) continue;
 
-                float brim_width = print->wipe_tower_data(filaments_count).brim_width;
-                int nozzle_nums = wxGetApp().preset_bundle->get_printer_extruder_count();
-                Vec3d wipe_tower_size = ppl.get_plate(plate_id)->estimate_wipe_tower_size(full_config, w, v, nozzle_nums, 0, false, dynamic_cast<const ConfigOptionBool*>(dconfig.option("enable_wrapping_detection"))->value);
+                // Body and brim from this plate's own estimate: m_process->fff_print() is the
+                // selected plate's, so an auto brim drew every tower with that plate's brim.
+                const WipeTowerFootprint footprint = part_plate->estimate_wipe_tower_footprint(full_config);
+                // The estimate is also the answer to whether this plate prints a tower;
+                // deciding it here as well only gave the two room to drift.
+                if (footprint.depth <= 0.) continue;
+                float brim_width = float(footprint.brim_width);
+                Vec3d wipe_tower_size(footprint.width, footprint.depth, footprint.height);
+
+                // set_default_wipe_tower_pos_for_plate doesn't rerun when painting changes the
+                // filament count, so redo its clamp here on every reload — unconditionally: a
+                // paint-triggered reload can arrive before the background process invalidates
+                // psWipeTower, so gating on it would skip the clamp exactly when it is needed.
+                {
+                    Vec3d clamped_pos, clamped_size;
+                    part_plate->estimate_wipe_tower_polygon(full_config, plate_id, clamped_pos, clamped_size);
+                    if (std::abs(x - (float) clamped_pos(0)) > EPSILON || std::abs(y - (float) clamped_pos(1)) > EPSILON) {
+                        x = (float) clamped_pos(0);
+                        y = (float) clamped_pos(1);
+                        ConfigOptionFloat wt_x_opt(x), wt_y_opt(y);
+                        dynamic_cast<ConfigOptionFloats*>(proj_cfg.option("wipe_tower_x"))->set_at(&wt_x_opt, plate_id, 0);
+                        dynamic_cast<ConfigOptionFloats*>(proj_cfg.option("wipe_tower_y"))->set_at(&wt_y_opt, plate_id, 0);
+                    }
+                }
 
-                // The stored position is already clamped onto the bed, by
-                // set_default_wipe_tower_pos_for_plate and again on every drag.
                 if (!current_print->is_step_done(psWipeTower) || !current_print->wipe_tower_data().wipe_tower_mesh_data) {
                     // update for wipe tower position
                     int volume_idx_wipe_tower_new = m_volumes.load_wipe_tower_preview(1000 + plate_id, x + plate_origin(0), y + plate_origin(1),
@@ -9766,18 +9780,18 @@ void GLCanvas3D::_render_paint_toolbar() const
         ImVec2 number_label_size = ImGui::CalcTextSize(std::to_string(i + 1).c_str());
         ImGui::SetCursorPosY(cursor_y + text_offset_y);
         ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - number_label_size.x) / 2);
-        ImGui::TextColored(text_color, std::to_string(i + 1).c_str());
+        ImGui::TextColored(text_color, "%s", std::to_string(i + 1).c_str());
         imgui.pop_bold_font();
 
         ImVec2 filament_first_line_label_size = ImGui::CalcTextSize(filament_text_first_line[i].c_str());
         ImGui::SetCursorPosY(cursor_y + text_offset_y + number_label_size.y);
         ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - filament_first_line_label_size.x) / 2);
-        ImGui::TextColored(text_color, filament_text_first_line[i].c_str());
+        ImGui::TextColored(text_color, "%s", filament_text_first_line[i].c_str());
 
         ImVec2 filament_second_line_label_size = ImGui::CalcTextSize(filament_text_second_line[i].c_str());
         ImGui::SetCursorPosY(cursor_y + text_offset_y + number_label_size.y + filament_first_line_label_size.y);
         ImGui::SetCursorPosX(spacing + i * (spacing + button_size.x) + (button_size.x - filament_second_line_label_size.x) / 2);
-        ImGui::TextColored(text_color, filament_text_second_line[i].c_str());
+        ImGui::TextColored(text_color, "%s", filament_text_second_line[i].c_str());
     }
 
     if (ImGui::GetWindowWidth() == constraint_window_width) {
@@ -10004,9 +10018,9 @@ void GLCanvas3D::_render_assemble_info() const
     double size1 = m_selection.get_bounding_box().size()(1);
     double size2 = m_selection.get_bounding_box().size()(2);
     if (!m_selection.is_empty()) {
-        ImGui::Text(_L("Volume:").ToUTF8()); ImGui::SameLine(caption_max);
+        ImGui::Text("%s", _L("Volume:").ToUTF8().data()); ImGui::SameLine(caption_max);
         ImGui::Text("%.2f", size0 * size1 * size2);
-        ImGui::Text(_L("Size:").ToUTF8()); ImGui::SameLine(caption_max);
+        ImGui::Text("%s", _L("Size:").ToUTF8().data()); ImGui::SameLine(caption_max);
         ImGui::Text("%.2f x %.2f x %.2f", size0, size1, size2);
     }
     imgui->end();

src/slic3r/GUI/GUI_App.cpp

@@ -6808,7 +6808,7 @@ bool GUI_App::check_preset_parent_available(const std::pair<std::string, std::ma
 
 void GUI_App::add_pending_vendor_preset(const std::pair<std::string, std::map<std::string, std::string>>& preset_data)
 {
-    Preset::Type type;
+    Preset::Type type = Preset::Type::TYPE_INVALID;
     if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINT_TYPE)
         type = Preset::Type::TYPE_PRINT;
     else if (preset_data.second.at(BBL_JSON_KEY_TYPE) == PRESET_IOT_PRINTER_TYPE)

src/slic3r/GUI/GUI_ObjectTable.hpp

@@ -591,16 +591,11 @@ private:
     wxColour            m_hover_colour;
     wxBoxSizer*         m_top_sizer{nullptr};
     wxBoxSizer*         m_page_sizer{nullptr};
-    wxBoxSizer*         m_page_top_sizer{nullptr};
-    wxTextCtrl*         m_search_line{ nullptr };
     ObjectGrid*         m_object_grid{nullptr};
     ObjectGridTable*    m_object_grid_table{nullptr};
-    wxStaticText*       m_page_text{nullptr};
-    ScalableButton*     m_global_reset{nullptr};
     wxScrolledWindow*   m_side_window{nullptr};
     ObjectTableSettings* m_object_settings{ nullptr };
     Model*              m_model{nullptr};
-    ModelConfig*        m_config {nullptr};
     Plater*             m_plater{nullptr};
 
     int                 m_cur_row { -1 };
@@ -625,8 +620,6 @@ class ObjectTableDialog : public GUI::DPIDialog
     const int POPUP_HEIGHT  = FromDIP(1024);
 
     //wxPanel*             m_panel{ nullptr };
-    wxBoxSizer*          m_top_sizer{ nullptr };
-    wxStaticText*        m_static_title{ nullptr };
     //wxTimer*             m_refresh_timer;
     ObjectTablePanel*    m_obj_panel{ nullptr };
     Model*               m_model{ nullptr };

src/slic3r/GUI/GUI_Utils.cpp

@@ -102,7 +102,7 @@ CopyFileResult copy_file_gui(const std::string &from, const std::string &to, std
     result = ReadFile(handlesrc, buff, size, &dwRead, NULL);
     if (!result) {
         DWORD errCode = GetLastError();
-        error_message = "Error: " + errCode;
+        error_message = "Error: " + std::to_string(errCode);
         ret = FAIL_COPY_FILE;
         goto __finished;
     }
@@ -110,7 +110,7 @@ CopyFileResult copy_file_gui(const std::string &from, const std::string &to, std
     result = WriteFile(handledst,buff,size,&dwWrite,NULL);
     if (!result) {
         DWORD errCode = GetLastError();
-        error_message = "Error: " + errCode;
+        error_message = "Error: " + std::to_string(errCode);
         ret = FAIL_COPY_FILE;
         goto __finished;
     }

src/slic3r/GUI/Gizmos/GLGizmoBrimEars.cpp

@@ -342,7 +342,7 @@ bool GLGizmoBrimEars::on_mouse(const wxMouseEvent& mouse_event)
 // concludes that the event was not intended for it, it should return false.
 bool GLGizmoBrimEars::gizmo_event(SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
 {
-    if (action != SLAGizmoEventType::MouseWheelDown || action != SLAGizmoEventType::MouseWheelUp || action != SLAGizmoEventType::Moving) {
+    if (action != SLAGizmoEventType::MouseWheelDown && action != SLAGizmoEventType::MouseWheelUp && action != SLAGizmoEventType::Moving) {
         apply_radius_change();
     }
 

src/slic3r/GUI/Gizmos/GLGizmoCut.hpp

@@ -94,7 +94,6 @@ class GLGizmoCut3D : public GLGizmoBase
     GLModel m_reference_radius;
     GLModel m_angle_arc;
 
-    Vec3d   m_old_center;
     Vec3d   m_cut_normal;
 
     struct InvalidConnectorsStatistics

src/slic3r/GUI/Gizmos/GLGizmoFdmSupports.cpp

@@ -122,7 +122,7 @@ bool GLGizmoFdmSupports::on_init()
         {ctrl + _L("Mouse wheel"), _L("Gap area")}
     };
 
-    memset(&m_print_instance, 0, sizeof(m_print_instance));
+    m_print_instance = PrintInstance();
     return true;
 }
 

src/slic3r/GUI/Gizmos/GLGizmoSimplify.cpp

@@ -343,12 +343,12 @@ void GLGizmoSimplify::on_render_input_window(float x, float y, float bottom_limi
     ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing,ImVec2(10,20));
     if (is_worker_running) { // apply or preview
         // draw progress bar
-        std::string progress_text = GUI::format("%1%", std::to_string(progress)) + "%%";
+        std::string progress_text = GUI::format("%1%", std::to_string(progress)) + "%";
         ImVec2 progress_size(bottom_left_width - space_size, 0.0f);
         ImGui::BBLProgressBar2(progress / 100., progress_size);
         ImGui::SameLine();
         ImGui::AlignTextToFramePadding();
-        ImGui::TextColored(ImVec4(0.42f, 0.42f, 0.42f, 1.00f), progress_text.c_str());
+        ImGui::TextColored(ImVec4(0.42f, 0.42f, 0.42f, 1.00f), "%s", progress_text.c_str());
         ImGui::SameLine(bottom_left_width + slider_width +  m_imgui->scaled(1.0f));
     } else {
         ImGui::Dummy(ImVec2(bottom_left_width - space_size, -1));

src/slic3r/GUI/HMSPanel.hpp

@@ -25,7 +25,6 @@ class HMSNotifyItem : public wxPanel
     wxStaticBitmap *m_bitmap_notify;
     wxStaticBitmap *m_bitmap_arrow;
     wxStaticText *  m_hms_content;
-    wxHtmlWindow *  m_html;
     wxPanel *       m_staticline;
 
     wxBitmap m_img_notify_lv1;

src/slic3r/GUI/IMSlider.hpp

@@ -216,7 +216,6 @@ private:
     long                m_extra_style;
     float               m_label_koef{1.0};
 
-    float                    m_zero_layer_height = 0.0f;
     std::vector<double>      m_values;
     TickCodeInfo             m_ticks;
     std::vector<double>      m_layers_times;

src/slic3r/GUI/Jobs/ArrangeJob.cpp

@@ -265,8 +265,7 @@ arrangement::ArrangePolygon estimate_wipe_tower_info(int plate_index, std::set<i
     int extruder_size = extruder_ids.size();
 
     Vec3d wipe_tower_size, wipe_tower_pos;
-    int nozzle_nums = wxGetApp().preset_bundle->get_printer_extruder_count();
-    auto arrange_poly = ppl.get_plate(plate_index_valid)->estimate_wipe_tower_polygon(full_config, plate_index, wipe_tower_pos, wipe_tower_size, nozzle_nums, extruder_size);
+    auto arrange_poly = ppl.get_plate(plate_index_valid)->estimate_wipe_tower_polygon(full_config, plate_index, wipe_tower_pos, wipe_tower_size, extruder_size);
     arrange_poly.bed_idx = plate_index;
     return arrange_poly;
 }

src/slic3r/GUI/Jobs/BindJob.hpp

@@ -20,7 +20,6 @@ class BindJob : public Job
     std::string         m_sec_link;
     std::string         m_ssdp_version;
     bool                m_job_finished{ false };
-    int                 m_print_job_completed_id = 0;
     bool                m_improved{false};
 
 public:

src/slic3r/GUI/Jobs/UpgradeNetworkJob.hpp

@@ -27,7 +27,6 @@ class UpgradeNetworkJob : public Job
     wxWindow *           m_event_handle{nullptr};
     std::function<void()> m_success_fun{nullptr};
     bool                m_job_finished{ false };
-    int                 m_print_job_completed_id = 0;
 
     InstallProgressFn pro_fn { nullptr };
 

src/slic3r/GUI/MainFrame.cpp

@@ -4488,10 +4488,9 @@ std::string MainFrame::get_dir_name(const wxString &full_name) const
 // ----------------------------------------------------------------------------
 
 SettingsDialog::SettingsDialog(MainFrame* mainframe)
-:DPIDialog(NULL, wxID_ANY, wxString(SLIC3R_APP_NAME) + " - " + _L("Settings"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, "settings_dialog"),
+:DPIDialog(NULL, wxID_ANY, wxString(SLIC3R_APP_NAME) + " - " + _L("Settings"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE, "settings_dialog")
 //: DPIDialog(mainframe, wxID_ANY, wxString(SLIC3R_APP_NAME) + " - " + _L("Settings"), wxDefaultPosition, wxDefaultSize,
 //        wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX, "settings_dialog"),
-    m_main_frame(mainframe)
 {
     if (wxGetApp().is_gcode_viewer())
         return;

src/slic3r/GUI/MainFrame.hpp

@@ -94,7 +94,6 @@ class SettingsDialog : public DPIDialog//DPIDialog
 {
     //wxNotebook* m_tabpanel { nullptr };
     Notebook* m_tabpanel{ nullptr };
-    MainFrame*      m_main_frame { nullptr };
     wxMenuBar*      m_menubar{ nullptr };
 public:
     SettingsDialog(MainFrame* mainframe);

src/slic3r/GUI/MediaPlayCtrl.cpp

@@ -71,7 +71,7 @@ MediaPlayCtrl::MediaPlayCtrl(wxWindow *parent, wxMediaCtrl3 *media_ctrl, const w
                 auto ip = str.find(' ', ik);
                 if (ip == wxString::npos) ip = str.Length();
                 auto v = str.Mid(ik, ip - ik);
-                if (k == "T:" && v.Length() == 8) {
+                if (strcmp(k, "T:") == 0 && v.Length() == 8) {
                     long h = 0,m = 0,s = 0;
                     v.Left(2).ToLong(&h);
                     v.Mid(3, 2).ToLong(&m);

src/slic3r/GUI/MixedFilamentDialog.cpp

@@ -126,7 +126,6 @@ MixedFilamentDialog::MixedFilamentDialog(wxWindow* parent,
                                          const std::vector<std::string>& physical_types)
     : DPIDialog(parent, wxID_ANY, _L("Add Mixed Filament"), wxDefaultPosition,
                 wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
-    , m_edit_mode(false)
     , m_physical_colors(physical_colors)
     , m_physical_names(physical_names)
     , m_physical_types(physical_types)
@@ -157,7 +156,6 @@ MixedFilamentDialog::MixedFilamentDialog(wxWindow* parent,
     : DPIDialog(parent, wxID_ANY, _L("Edit Mixed Filament"), wxDefaultPosition,
                 wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
     , m_result(existing)
-    , m_edit_mode(true)
     , m_physical_colors(physical_colors)
     , m_physical_names(physical_names)
     , m_physical_types(physical_types)

src/slic3r/GUI/MixedFilamentDialog.hpp

@@ -115,7 +115,6 @@ private:
     wxColour        comp_colour(size_t i) const;
 
     MixedFilamentResult         m_result;
-    bool                        m_edit_mode{false};
     std::vector<std::string>    m_physical_colors;
     std::vector<std::string>    m_physical_names;
     std::vector<std::string>    m_physical_types;

src/slic3r/GUI/Monitor.hpp

@@ -78,7 +78,6 @@ private:
     Tabbook*		m_tabpanel{ nullptr };
     wxSizer*        m_main_sizer{ nullptr };
 
-    AddMachinePanel*    m_status_add_machine_panel;
     StatusPanel*        m_status_info_panel;
     MediaFilePanel*     m_media_file_panel;
     UpgradePanel*       m_upgrade_panel;
@@ -86,8 +85,6 @@ private:
 
 	/* side tools */
     SideTools*      m_side_tools{nullptr};
-    wxStaticBitmap* m_bitmap_arrow;
-    wxStaticBitmap* m_bitmap_wifi_signal;
     SelectMachinePopup m_select_machine;
 
 	/* images */

src/slic3r/GUI/Mouse3DController.cpp

@@ -498,7 +498,7 @@ void Mouse3DController::render_settings_dialog(GLCanvas3D& canvas) const
     ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 20.0f));
     static ImVec2 last_win_size(0.0f, 0.0f);
     bool shown = true;
-    if (imgui.begin(_L("3Dconnexion settings"), &shown, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse || ImGuiWindowFlags_NoTitleBar)) {
+    if (imgui.begin(_L("3Dconnexion settings"), &shown, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar)) {
         if (shown) {
             ImVec2 win_size = ImGui::GetWindowSize();
             if (last_win_size.x != win_size.x || last_win_size.y != win_size.y) {

src/slic3r/GUI/MsgDialog.hpp

@@ -177,7 +177,6 @@ public:
 // Generic rich message dialog, used intead of wxRichMessageDialog
 class RichMessageDialog : public MsgDialog
 {
-	wxCheckBox* m_checkBox{ nullptr };
 	wxString	m_checkBoxText;
 	bool		m_checkBoxValue{ false };
 
@@ -416,7 +415,6 @@ private:
     wxString      m_new_keys;
     Button *      m_update_btn = nullptr;
     Button *      m_later_btn  = nullptr;
-    wxStaticText *m_msg_text   = nullptr;
 };
 
 

src/slic3r/GUI/MultiMachineManagerPage.hpp

@@ -79,7 +79,6 @@ private:
     wxBoxSizer*             m_main_sizer{nullptr};
     wxBoxSizer*             m_sizer_machine_list{nullptr};
     wxScrolledWindow*       m_machine_list{ nullptr };
-    wxStaticText*           m_selected_num{ nullptr };
 
     // table head
     wxPanel*                m_table_head_panel{ nullptr };
@@ -99,8 +98,6 @@ private:
     int                         m_total_count{ 0 };
     int                         m_count_page_item{ 10 };
 
-    bool                        prev{ false };
-    bool                        next{ false };
     Button*                     btn_last_page{ nullptr };
     Button*                     btn_next_page{ nullptr };
     wxStaticText*               st_page_number{ nullptr };

src/slic3r/GUI/MultiMachinePage.hpp

@@ -81,7 +81,6 @@ private:
     AppConfig*          app_config;
     Label*              m_label{ nullptr };
     wxScrolledWindow*     scroll_macine_list{ nullptr };
-    wxBoxSizer*         m_sizer_body{ nullptr };
     wxBoxSizer*                         sizer_machine_list{ nullptr };
     std::map<std::string, DevicePickItem*>  m_device_items;
     int                 m_selected_count{0};

src/slic3r/GUI/MultiTaskManagerPage.hpp

@@ -99,7 +99,6 @@ private:
     wxBoxSizer* page_sizer{ nullptr };
     wxBoxSizer* m_sizer_task_list{ nullptr };
     wxScrolledWindow* m_task_list{ nullptr };
-    wxStaticText* m_selected_num{ nullptr };
 
     // table head
     wxPanel* m_table_head_panel{ nullptr };
@@ -113,7 +112,6 @@ private:
     Button* m_action{ nullptr };
 
     // ctrl button for all
-    int m_sel_number{0};
     wxPanel* m_ctrl_btn_panel{ nullptr };
     wxBoxSizer* m_btn_sizer{ nullptr };
     Button* btn_stop_all{ nullptr };
@@ -160,15 +158,12 @@ private:
     wxBoxSizer* m_sizer_task_list{ nullptr };
     wxBoxSizer* m_main_sizer{ nullptr };
     wxScrolledWindow* m_task_list{ nullptr };
-    wxStaticText* m_selected_num{ nullptr };
 
     // Flipping pages
     int                         m_current_page{ 0 };
     int                         m_total_page{0};
     int                         m_total_count{ 0 };
     int                         m_count_page_item{ 10 };
-    bool                        prev{ false };
-    bool                        next{ false };
     Button*                     btn_last_page{ nullptr };
     Button*                     btn_next_page{ nullptr };
     wxStaticText*               st_page_number{ nullptr };
@@ -191,7 +186,6 @@ private:
     Button*                     m_action{ nullptr };
 
     // ctrl button for all
-    int                         m_sel_number;
     wxPanel*                    m_ctrl_btn_panel{ nullptr };
     wxBoxSizer*                 m_btn_sizer{ nullptr };
     Button*                     btn_pause_all{ nullptr };

src/slic3r/GUI/ObjColorDialog.cpp

@@ -86,8 +86,6 @@ ObjColorDialog::ObjColorDialog(wxWindow *parent, Slic3r::ObjDialogInOut &in_out,
                 wxDefaultPosition,
                 wxDefaultSize,
                 wxDEFAULT_DIALOG_STYLE /* | wxRESIZE_BORDER*/)
-    , m_filament_ids(in_out.filament_ids)
-    , m_first_extruder_id(in_out.first_extruder_id)
 {
     auto m_line_top = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1));
     m_line_top->SetBackgroundColour(wxColour(166, 169, 170));

src/slic3r/GUI/ObjColorDialog.hpp

@@ -94,7 +94,6 @@ private:
     std::vector<int>      m_cluster_map_filaments;//show middle
     int                   m_max_filament_index = 0;
     std::vector<wxColour> m_cluster_colours;//from_algo and show left
-    bool                  m_can_add_filament{true};
     bool                  m_deal_thumbnail_flag{false};
     std::vector<wxColour> m_new_add_colors;
     std::vector<wxColour> m_new_add_final_colors;
@@ -123,8 +122,6 @@ private:
     wxBoxSizer *                      m_main_sizer     = nullptr;
     wxBoxSizer *                      m_buttons_sizer   = nullptr;
     std::unordered_map<int, Button *> m_button_list;
-    std::vector<unsigned char>&      m_filament_ids;
-    unsigned char &                  m_first_extruder_id;
 };
 
 #endif  // _WIPE_TOWER_DIALOG_H_

src/slic3r/GUI/PartPlate.cpp

@@ -1,5 +1,6 @@
 #include <cstddef>
 #include <algorithm>
+#include <limits>
 #include <numeric>
 #include <vector>
 #include <string>
@@ -20,6 +21,7 @@
 
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Polygon.hpp"
+#include "libslic3r/GCode/WipeTowerEstimate.hpp"
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/BoundingBox.hpp"
 #include "libslic3r/Geometry.hpp"
@@ -1531,8 +1533,23 @@ std::vector<int> PartPlate::get_extruders(bool conside_custom_gcode) const
     if (check_objects_empty_and_gcode3mf(plate_extruders)) {
         return plate_extruders;
     }
-	// if 3mf file
-	const DynamicPrintConfig& glb_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
+	return get_extruders(conside_custom_gcode, wxGetApp().preset_bundle->prints.get_edited_preset().config, wxGetApp().preset_bundle->project_config);
+}
+
+// The plate's filaments, with the global keys read from the given configs rather than the
+// application's presets: the wipe tower estimate is also called under the CLI, which has no
+// application object. get_extruders(bool) passes the edited presets; a full config serves both.
+std::vector<int> PartPlate::get_extruders(bool conside_custom_gcode, const DynamicPrintConfig& glb_config, const DynamicPrintConfig& project_config) const
+{
+	std::vector<int> plate_extruders;
+	// A plate from a sliced .gcode.3mf holds no objects, so report the filaments the G-code
+	// used. check_objects_empty_and_gcode3mf does this for get_extruders(bool), but reaches
+	// the plater, which the CLI has none of; slice_filaments_info is only filled for such a plate.
+	if (m_model->objects.empty()) {
+		for (const FilamentInfo &info : slice_filaments_info)
+			plate_extruders.push_back(info.id + 1);
+		return plate_extruders;
+	}
 	int glb_support_intf_extr = glb_config.opt_int("support_interface_filament");
 	int glb_support_extr = glb_config.opt_int("support_filament");
 	int glb_outer_wall_extr = glb_config.opt_int("outer_wall_filament_id");
@@ -1549,7 +1566,9 @@ std::vector<int> PartPlate::get_extruders(bool conside_custom_gcode) const
     glb_support |= glb_config.opt_int("raft_layers") > 0;
 
 	for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
-		if (!contain_instance_totally(obj_idx, 0))
+		// Any instance on the plate counts, as PrintApply does: after an arrange, instance 0
+		// can sit on a different plate.
+		if (!contain_any_instance_totally(obj_idx))
 			continue;
 
 		ModelObject* mo = m_model->objects[obj_idx];
@@ -1662,7 +1681,7 @@ std::vector<int> PartPlate::get_extruders(bool conside_custom_gcode) const
 	if (conside_custom_gcode) {
 		//BBS
         int nums_extruders = 0;
-        if (const ConfigOptionStrings *color_option = dynamic_cast<const ConfigOptionStrings *>(wxGetApp().preset_bundle->project_config.option("filament_colour"))) {
+        if (const ConfigOptionStrings *color_option = dynamic_cast<const ConfigOptionStrings *>(project_config.option("filament_colour"))) {
             nums_extruders = color_option->values.size();
 			if (m_model->plates_custom_gcodes.find(m_plate_index) != m_model->plates_custom_gcodes.end()) {
 				for (auto item : m_model->plates_custom_gcodes.at(m_plate_index).gcodes) {
@@ -1681,9 +1700,8 @@ std::vector<int> PartPlate::get_extruders(bool conside_custom_gcode) const
 	// is never loaded into a tray, so callers (AMS mapping, filament checks) must see the
 	// physical filaments it resolves to instead.
 	{
-		auto& project_config = wxGetApp().preset_bundle->project_config;
-		auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
-		auto* comp_strs_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
+		const auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
+		const auto* comp_strs_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
 		if (is_mixed_opt && comp_strs_opt && has_any_mixed_filament(is_mixed_opt->values)) {
 			std::vector<unsigned int> ext_0based;
 			for (int e : plate_extruders)
@@ -2311,113 +2329,97 @@ bool PartPlate::check_compatible_of_nozzle_and_filament(const DynamicPrintConfig
     return wipe_tower_size;
 }*/
 
-Vec3d PartPlate::estimate_wipe_tower_size(const DynamicPrintConfig & config, const double w, const double wipe_volume, int extruder_count, int plate_extruder_size, bool use_global_objects, bool enable_wrapping_detection) const
+WipeTowerFootprint PartPlate::estimate_wipe_tower_footprint(const DynamicPrintConfig &config, int plate_extruder_size, bool use_global_objects) const
 {
-    Vec3d wipe_tower_size;
-    double layer_height = 0.08f; // hard code layer height
-    double max_height = 0.f;
-    wipe_tower_size.setZero();
+    // The CLI calls this too, so the plate's filaments are derived from the passed config:
+    // get_extruders(bool) reads the same keys off wxGetApp()'s presets, which the CLI has none of.
+    // An explicit count is a floor: init-time and arrange estimates size an empty plate for that
+    // many generic filaments, the lowest ids not already on the plate.
+    std::vector<int> plate_extruders = get_extruders(true, config, config);
+    for (int id = 1; int(plate_extruders.size()) < plate_extruder_size; ++id)
+        if (std::find(plate_extruders.begin(), plate_extruders.end(), id) == plate_extruders.end())
+            plate_extruders.push_back(id);
+    // The wipe tower filament joins the tool ordering even when unused (Print::extruders), so
+    // validation counts it - but only where there is a tower to join, which is the
+    // has_wipe_tower() half of that guard.
+    const ConfigOption *wipe_tower_filament_opt = config.option("wipe_tower_filament");
+    const ConfigOption *enable_prime_tower_opt  = config.option("enable_prime_tower");
+    const int           wipe_tower_filament     = wipe_tower_filament_opt != nullptr ? wipe_tower_filament_opt->getInt() : 0;
+    if (enable_prime_tower_opt != nullptr && enable_prime_tower_opt->getBool() && plate_extruders.size() > 1 && wipe_tower_filament > 0 &&
+        std::find(plate_extruders.begin(), plate_extruders.end(), wipe_tower_filament) == plate_extruders.end())
+        plate_extruders.push_back(wipe_tower_filament);
+    if (plate_extruders.empty())
+        return WipeTowerFootprint();
 
-    const ConfigOption* layer_height_opt = config.option("layer_height");
-    if (layer_height_opt)
-        layer_height = layer_height_opt->getFloat();
-
-    // empty plate
-    if (plate_extruder_size == 0)
-    {
-        std::vector<int> plate_extruders = get_extruders(true);
-        plate_extruder_size = plate_extruders.size();
-    }
-    if (plate_extruder_size == 0)
-        return wipe_tower_size;
-
-    for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
-        if (!use_global_objects && !contain_instance_totally(obj_idx, 0))
+    // Tallest object on this plate and the thinnest layer it is sliced at, resolved per object
+    // as PrintObject resolves them (override, else preset) and over this plate's objects only -
+    // seeding from the global value, or folding in an off-plate override, diverges from Print.
+    const ConfigOption *layer_height_opt    = config.option("layer_height");
+    const double        global_layer_height = layer_height_opt != nullptr ? layer_height_opt->getFloat() : 0.08;
+    double              max_height          = 0.;
+    double              layer_height        = std::numeric_limits<double>::max();
+    for (int obj_idx = 0; obj_idx < int(m_model->objects.size()); ++obj_idx) {
+        const ModelObject *object = m_model->objects[obj_idx];
+        if (!use_global_objects && !contain_any_instance_totally(obj_idx))
             continue;
-
-		BoundingBoxf3 bbox = m_model->objects[obj_idx]->bounding_box_exact();
-        max_height = std::max(bbox.size().z(), max_height);
-    }
-    wipe_tower_size(2) = max_height;
-    //const DynamicPrintConfig &dconfig = wxGetApp().preset_bundle->prints.get_edited_preset().config;
-    auto timelapse_type    = config.option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
-    bool need_wipe_tower = (timelapse_type ? (timelapse_type->value == TimelapseType::tlSmooth) : false) | enable_wrapping_detection;
-    double extra_spacing     = config.option("prime_tower_infill_gap")->getFloat() / 100.;
-    const ConfigOptionEnum<WipeTowerWallType>* use_rib_wall_opt = config.option<ConfigOptionEnum<WipeTowerWallType>>("wipe_tower_wall_type");
-    bool use_rib_wall = use_rib_wall_opt ? use_rib_wall_opt->value == WipeTowerWallType::wtwRib: false;
-    double rib_width = config.option("wipe_tower_rib_width")->getFloat();
-    double depth;
-    double filament_change_volume=0.;
-    {
-        std::vector<double>             filament_change_lengths;
-        auto                filament_change_lengths_opt = m_print->config().option<ConfigOptionFloats>("filament_change_length");
-        if (filament_change_lengths_opt) filament_change_lengths = filament_change_lengths_opt->values;
-        double length = filament_change_lengths.empty() ? 0 : *std::max_element(filament_change_lengths.begin(), filament_change_lengths.end());
-        double diameter = 1.75;
-        std::vector<double> diameters;
-        auto                filament_diameter_opt = m_print->config().option<ConfigOptionFloats>("filament_diameter");
-        if (filament_diameter_opt) diameters = filament_diameter_opt->values;
-        diameter = diameters.empty() ? diameter : *std::max_element(diameters.begin(), diameters.end());
-        filament_change_volume = length * PI * diameter * diameter / 4.;
-    }
-    double volume = wipe_volume * (extruder_count == 2 ? plate_extruder_size : (plate_extruder_size - 1));
-    if (extruder_count == 2) volume += filament_change_volume * (int) (plate_extruder_size / 2);
-    // Read from the passed plate config — m_print may not have been applied yet
-    // (fresh plates, CLI), in which case its PrintConfig still holds defaults.
-    const auto *purge_opt  = config.option<ConfigOptionBool>("purge_in_prime_tower");
-    const auto *semm_opt   = config.option<ConfigOptionBool>("single_extruder_multi_material");
-    const bool  semm_flush = purge_opt && purge_opt->value && semm_opt && semm_opt->value;
-    if (semm_flush) volume = WipeTower2::estimate_semm_flush_volume(config, plate_extruder_size);
-    if (use_rib_wall) {
-        depth = std::sqrt(volume / layer_height * extra_spacing);
-        if (need_wipe_tower || plate_extruder_size > 1) {
-            float min_wipe_tower_depth = WipeTower::get_limit_depth_by_height(max_height);
-            double volume_depth         = depth;
-            depth = std::max((double) min_wipe_tower_depth, depth);
-            rib_width = std::min(rib_width, depth / 2);
-            depth = rib_width / std::sqrt(2) + std::max(depth + m_print->config().wipe_tower_extra_rib_length.value, volume_depth);
-            wipe_tower_size(0) = wipe_tower_size(1) = depth;
+        // Per instance, to match PrintObject::size(); the union over instances differs once
+        // they are rotated apart. The cached convex hull has the mesh's z extent and is cheap
+        // enough for every scene reload.
+        for (int inst_idx = 0; inst_idx < int(object->instances.size()); ++inst_idx) {
+            if (!use_global_objects && !contain_instance_totally(obj_idx, inst_idx))
+                continue;
+            max_height = std::max(max_height, object->instance_convex_hull_bounding_box(inst_idx, true).size().z());
         }
+        const ConfigOption *object_layer_height = object->config.option("layer_height");
+        layer_height = std::min(layer_height, object_layer_height != nullptr ? object_layer_height->getFloat() : global_layer_height);
     }
-    else {
-        depth = volume / (layer_height * w);
-        // The flush volumes already hold the spacing between wipes.
-        if (!semm_flush) depth *= extra_spacing;
-        if (need_wipe_tower || depth > EPSILON) {
-            float min_wipe_tower_depth = WipeTower::get_limit_depth_by_height(max_height);
-            depth = std::max((double)min_wipe_tower_depth, depth);
-        }
-        wipe_tower_size(0) = w;
-        wipe_tower_size(1) = depth;
-    }
+    if (layer_height == std::numeric_limits<double>::max())
+        layer_height = global_layer_height;
 
-    return wipe_tower_size;
+    std::vector<unsigned int> filament_ids;
+    for (int id : plate_extruders)
+        if (id > 0)
+            filament_ids.push_back(static_cast<unsigned int>(id - 1));
+    return Slic3r::estimate_wipe_tower_footprint(config, resolve_wipe_tower_type(config), filament_ids, layer_height, max_height);
 }
 
-arrangement::ArrangePolygon PartPlate::estimate_wipe_tower_polygon(const DynamicPrintConfig& config, int plate_index, Vec3d& wt_pos, Vec3d& wt_size, int extruder_count, int plate_extruder_size, bool use_global_objects) const
+arrangement::ArrangePolygon PartPlate::estimate_wipe_tower_polygon(const DynamicPrintConfig& config, int plate_index, Vec3d& wt_pos, Vec3d& wt_size, int plate_extruder_size, bool use_global_objects) const
 {
 	float x = dynamic_cast<const ConfigOptionFloats*>(config.option("wipe_tower_x"))->get_at(plate_index);
 	float y = dynamic_cast<const ConfigOptionFloats*>(config.option("wipe_tower_y"))->get_at(plate_index);
-	float w = dynamic_cast<const ConfigOptionFloat*>(config.option("prime_tower_width"))->value;
 	//float a = dynamic_cast<const ConfigOptionFloat*>(config.option("wipe_tower_rotation_angle"))->value;
-	float v = dynamic_cast<const ConfigOptionFloat*>(config.option("prime_volume"))->value;
-    float tower_brim_width = dynamic_cast<const ConfigOptionFloat*>(config.option("prime_tower_brim_width"))->value;
-    const ConfigOptionBool * wrapping_opt = dynamic_cast<const ConfigOptionBool *>(config.option("enable_wrapping_detection"));
-	bool enable_wrapping = (wrapping_opt != nullptr) && wrapping_opt->value;
-	wt_size = estimate_wipe_tower_size(config, w, v, extruder_count, plate_extruder_size, use_global_objects, enable_wrapping);
+	const WipeTowerFootprint footprint = estimate_wipe_tower_footprint(config, plate_extruder_size, use_global_objects);
+	wt_size = Vec3d(footprint.width, footprint.depth, footprint.height);
 	int plate_width=m_width, plate_depth=m_depth;
-	w = wt_size(0); // effective width; differs from prime_tower_width when the rib wall squares the tower
+	float w = wt_size(0); // effective width; differs from prime_tower_width when the rib wall squares the tower
 	float depth = wt_size(1);
-	float margin = WIPE_TOWER_MARGIN + tower_brim_width, wp_brim_width = 0.f;
-	const ConfigOption* wipe_tower_brim_width_opt = config.option("prime_tower_brim_width");
-	if (wipe_tower_brim_width_opt) {
-		wp_brim_width = wipe_tower_brim_width_opt->getFloat();
-        if (wp_brim_width < 0) wp_brim_width = WipeTower::get_auto_brim_by_height((float) wt_size.z());
-		BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: wp_brim_width %1%") % wp_brim_width;
-	}
-
-	x = std::clamp(x, margin, (float)plate_width - w - margin - wp_brim_width);
-    y = std::clamp(y, margin, (float)plate_depth - depth - margin - wp_brim_width);
+	// Resolved brim, not the raw option: "Auto" (-1) would yield a margin of 0 and let the
+	// clamp put the brim off the bed. Matches set_default_wipe_tower_pos_for_plate.
+	float wp_brim_width = float(footprint.brim_width);
+	// A Type2 stabilization cone bulges past the body box like a brim does - fold its worst-axis
+	// bulge into the same margin.
+	const BoundingBox outline = get_extents(estimate_wipe_tower_first_layer_outline(config, resolve_wipe_tower_type(config), w, depth, wt_size.z()));
+	wp_brim_width += float(std::max({0., unscaled(outline.max.x()) - w, unscaled(outline.max.y()) - depth, -unscaled(outline.min.x()), -unscaled(outline.min.y())}));
+	// A position valid by WIPE_TOWER_MARGIN is the user's choice and stays untouched; an
+	// invalid one is re-placed with the comfort margin (falling back to the validity bounds
+	// on cramped plates). std::clamp is UB if lo > hi, so keep every hi >= lo.
+	const float margin = WIPE_TOWER_MARGIN + wp_brim_width;
+	BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("arrange wipe_tower: wp_brim_width %1%") % wp_brim_width;
+	const float x_hi   = std::max(margin, (float) plate_width - w - margin);
+	const float y_hi   = std::max(margin, (float) plate_depth - depth - margin);
+	const float margin_c = (float) WIPE_TOWER_AUTO_MARGIN + wp_brim_width;
+	float x_lo_c = margin_c, x_hi_c = (float) plate_width - w - margin_c;
+	if (x_lo_c > x_hi_c) { x_lo_c = margin; x_hi_c = x_hi; }
+	float y_lo_c = margin_c, y_hi_c = (float) plate_depth - depth - margin_c;
+	if (y_lo_c > y_hi_c) { y_lo_c = margin; y_hi_c = y_hi; }
+	// Drag clamps reach this limit through the volume's bounding box (post-slice: the real
+	// mesh, a couple of mm inside this reserved estimate), so a drop can land slightly out
+	// of bounds — snap it onto the bound; only far-out positions get the comfort re-place.
+	const float tol = 5.f;
+	if (x < margin - tol || x > x_hi + tol) x = std::clamp(x, x_lo_c, x_hi_c);
+	else                                    x = std::clamp(x, margin, x_hi);
+	if (y < margin - tol || y > y_hi + tol) y = std::clamp(y, y_lo_c, y_hi_c);
+	else                                    y = std::clamp(y, margin, y_hi);
     wt_pos(0) = x;
     wt_pos(1) = y;
     wt_pos(2) = 0.f;
@@ -2755,6 +2757,20 @@ bool PartPlate::contain_instance_totally(int obj_id, int instance_id) const
 	return result;
 }
 
+//judge whether any of the object's instances is totally included in plate or not
+bool PartPlate::contain_any_instance_totally(int obj_id) const
+{
+	if (obj_id < 0 || obj_id >= int(m_model->objects.size()))
+		return false;
+
+	const ModelObject *object = m_model->objects[obj_id];
+	for (int instance_id = 0; instance_id < int(object->instances.size()); ++instance_id)
+		if (contain_instance_totally(obj_id, instance_id))
+			return true;
+
+	return false;
+}
+
 //check whether instance is outside the plate or not
 bool PartPlate::check_outside(int obj_id, int instance_id, BoundingBoxf3* bounding_box)
 {
@@ -4488,26 +4504,16 @@ void PartPlateList::set_default_wipe_tower_pos_for_plate(int plate_idx, bool ini
         f_volume_maps = wxGetApp().preset_bundle->get_default_nozzle_volume_types_for_filaments(filament_maps);
     }
     DynamicPrintConfig full_config = wxGetApp().preset_bundle->full_config(false, filament_maps, f_volume_maps);
-    float w = dynamic_cast<const ConfigOptionFloat *>(full_config.option("prime_tower_width"))->value;
-    float v = dynamic_cast<const ConfigOptionFloat *>(full_config.option("prime_volume"))->value;
-    bool enable_wrapping = false;
-    const ConfigOptionBool *wrapping_opt = dynamic_cast<const ConfigOptionBool *>(full_config.option("enable_wrapping_detection"));
-    if (wrapping_opt) enable_wrapping = wrapping_opt->value;
-    int nozzle_nums = wxGetApp().preset_bundle->get_printer_extruder_count();
-    Vec3d wipe_tower_size = part_plate->estimate_wipe_tower_size(full_config, w, v, nozzle_nums, init_pos ? 2 : 0, false, enable_wrapping);
+    WipeTowerFootprint footprint = part_plate->estimate_wipe_tower_footprint(full_config, init_pos ? 2 : 0);
 
-    if (!init_pos && (is_approx(wipe_tower_size(0), 0.0) || is_approx(wipe_tower_size(1), 0.0))) {
-        wipe_tower_size = part_plate->estimate_wipe_tower_size(full_config, w, v, nozzle_nums, 2, false, enable_wrapping);
+    if (!init_pos && (is_approx(footprint.width, 0.0) || is_approx(footprint.depth, 0.0))) {
+        footprint = part_plate->estimate_wipe_tower_footprint(full_config, 2);
     }
+    Vec3d wipe_tower_size(footprint.width, footprint.depth, footprint.height);
 
-    // Compute brim-aware margin: brim extends outward from tower position
-    float brim_width = 0.f;
-    const ConfigOptionFloat *brim_opt = full_config.option<ConfigOptionFloat>("prime_tower_brim_width");
-    if (brim_opt) {
-        brim_width = brim_opt->value;
-        if (brim_width < 0) brim_width = WipeTower::get_auto_brim_by_height((float) wipe_tower_size.z());
-    }
-    const float margin = WIPE_TOWER_MARGIN + brim_width;
+    // Brim-aware margin: the brim extends outward from the tower position.
+    const float brim_width = float(footprint.brim_width);
+    const float margin     = WIPE_TOWER_AUTO_MARGIN + brim_width;
 
     // clamp wipe tower position within plate boundaries
     {

src/slic3r/GUI/PartPlate.hpp

@@ -11,6 +11,7 @@
 #include "libslic3r/GCode/GCodeProcessor.hpp"
 #include "libslic3r/Format/bbs_3mf.hpp"
 #include "libslic3r/Slicing.hpp"
+#include "libslic3r/GCode/WipeTowerEstimate.hpp"
 #include "libslic3r/Arrange.hpp"
 #include "Plater.hpp"
 #include "libslic3r/Model.hpp"
@@ -339,11 +340,16 @@ public:
 
     Vec3d get_origin() { return m_origin; }
     //Vec3d calculate_wipe_tower_size(const DynamicPrintConfig &config, const double w, const double wipe_volume, int plate_extruder_size = 0, bool use_global_objects = false) const;
-    Vec3d estimate_wipe_tower_size(const DynamicPrintConfig & config, const double w, const double wipe_volume, int extruder_count = 1, int plate_extruder_size = 0, bool use_global_objects = false, bool enable_wrapping_detection = false) const;
-    arrangement::ArrangePolygon estimate_wipe_tower_polygon(const DynamicPrintConfig & config, int plate_index, Vec3d& wt_pos, Vec3d& wt_size, int extruder_count = 1, int plate_extruder_size = 0, bool use_global_objects = false) const;
+    // plate_extruder_size: a floor on the filaments purged on the plate; its own are always
+    //                      counted, so 0 sizes for exactly those.
+    // use_global_objects skips the containment test, which the CLI needs before objects are
+    // assigned to plates - the layer height is then the project's thinnest, which over-reserves.
+    WipeTowerFootprint estimate_wipe_tower_footprint(const DynamicPrintConfig & config, int plate_extruder_size = 0, bool use_global_objects = false) const;
+    arrangement::ArrangePolygon estimate_wipe_tower_polygon(const DynamicPrintConfig & config, int plate_index, Vec3d& wt_pos, Vec3d& wt_size, int plate_extruder_size = 0, bool use_global_objects = false) const;
     bool check_objects_empty_and_gcode3mf(std::vector<int> &result) const;
     // get used filaments from config, 1 based idx
     std::vector<int> get_extruders(bool conside_custom_gcode = false) const;
+    std::vector<int> get_extruders(bool conside_custom_gcode, const DynamicPrintConfig& glb_config, const DynamicPrintConfig& project_config) const;
     std::vector<int> get_extruders_under_cli(bool conside_custom_gcode, DynamicPrintConfig& full_config) const;
     std::vector<int> get_extruders_without_support(bool conside_custom_gcode = false) const;
     // get used filaments from gcode result, 1 based idx
@@ -366,6 +372,8 @@ public:
     bool contain_instance_totally(ModelObject* object, int instance_id) const;
     //judge whether instance is totally included in plate or not
     bool contain_instance_totally(int obj_id, int instance_id) const;
+    //judge whether any of the object's instances is totally included in plate or not
+    bool contain_any_instance_totally(int obj_id) const;
 
     //judge whether the plate's origin is at the left of instance or not
     bool is_left_top_of(int obj_id, int instance_id);

src/slic3r/GUI/Plater.cpp

@@ -3667,8 +3667,8 @@ void Sidebar::update_presets(Preset::Type preset_type)
                 // so extruders without an explicit sub-nozzle count never offer Hybrid. A nullable-int
                 // nil is INT_MAX (> 1) and would otherwise falsely pass the gate, so exclude it too.
                 if (boost::algorithm::contains(extruder_variants->values[index], type + " " + nozzle_volumes_def->enum_labels[i]) ||
-                    extruder_max_nozzle_count->get_at(index) > 1 && extruder_max_nozzle_count->get_at(index) != ConfigOptionIntsNullable::nil_value() &&
-                    nozzle_volumes_def->enum_keys_map->at(nozzle_volumes_def->enum_values[i]) == nvtHybrid) {
+                    (extruder_max_nozzle_count->get_at(index) > 1 && extruder_max_nozzle_count->get_at(index) != ConfigOptionIntsNullable::nil_value() &&
+                    nozzle_volumes_def->enum_keys_map->at(nozzle_volumes_def->enum_values[i]) == nvtHybrid)) {
                     if (nozzle_volumes_def->enum_keys_map->at(nozzle_volumes_def->enum_values[i]) == NozzleVolumeType::nvtHighFlow &&(diameter == "0.2" ||
                         is_skip_high_flow_printer(printer_model)))
                         continue;
@@ -8824,6 +8824,11 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
                             if (wipe_tower_y_opt)
                                 file_wipe_tower_y = *wipe_tower_y_opt;
 
+                            if (auto* agent = wxGetApp().getAgent()) {
+                                if (auto* ids = config.opt<ConfigOptionStrings>("filament_ids"))
+                                    for (std::string& id : ids->values)
+                                        id = agent->to_orca_filament_id(id);
+                            }
                             preset_bundle->load_config_model(filename.string(), std::move(config), file_version);
 
                             ConfigOption* bed_type_opt = preset_bundle->project_config.option("curr_bed_type");
@@ -18671,6 +18676,8 @@ int Plater::export_3mf(const boost::filesystem::path& output_path, SaveStrategy
         nozzle_diameter_str = nozzle_diameter_option->serialize();
 
     std::string printer_model_id = preset_bundle.printers.get_edited_preset().get_printer_type(&preset_bundle);
+    // The printer reads slice_info.config and knows only its own catalog ids.
+    auto* id_agent = preset_bundle.is_bbl_vendor() ? wxGetApp().getAgent() : nullptr;
 
     for (int i = 0; i < plate_data_list.size(); i++) {
         PlateData *plate_data = plate_data_list[i];
@@ -18680,6 +18687,8 @@ int Plater::export_3mf(const boost::filesystem::path& output_path, SaveStrategy
             std::string display_filament_type;
             it->type  = cfg.get_filament_type(display_filament_type, it->id);
             it->filament_id = filament_id_opt ? filament_id_opt->get_at(it->id) : "";
+            if (id_agent)
+                it->filament_id = id_agent->from_orca_filament_id(it->filament_id);
             it->color = filament_color ? filament_color->get_at(it->id) : "#FFFFFF";
             // save filament info used in curr plate
             int index = p->partplate_list.get_curr_plate_index();

src/slic3r/GUI/PluginPickerDialog.cpp

@@ -20,7 +20,6 @@ PluginPickerDialog::PluginPickerDialog(wxWindow* parent,
                                        const std::vector<Slic3r::PluginDescriptor>& plugins)
     : DPIDialog(parent, wxID_ANY, wxString::Format(_L("Select %s Plugin"), plugin_type_label))
     , m_plugins(plugins)
-    , m_capability_mode(false)
 {
     build_ui(plugin_type_label);
     CentreOnParent();
@@ -31,7 +30,6 @@ PluginPickerDialog::PluginPickerDialog(wxWindow* parent,
                                        std::vector<CapabilityEntry> capabilities)
     : DPIDialog(parent, wxID_ANY, wxString::Format(_L("Select %s Plugin"), plugin_type_label))
     , m_capabilities(std::move(capabilities))
-    , m_capability_mode(true)
 {
     build_capability_ui(plugin_type_label);
     CentreOnParent();

src/slic3r/GUI/PluginPickerDialog.hpp

@@ -55,7 +55,6 @@ private:
     wxStaticText*                  m_description  { nullptr };
     std::vector<Slic3r::PluginDescriptor> m_plugins;
     std::vector<CapabilityEntry>   m_capabilities;
-    bool                           m_capability_mode { false };
 };
 
 }} // namespace Slic3r::GUI

src/slic3r/GUI/Preferences.cpp

@@ -347,7 +347,7 @@ wxBoxSizer *PreferencesDialog::create_item_language_combobox(wxString title, wxS
     wxLanguage supported_languages[]{
         wxLANGUAGE_ENGLISH,
         wxLANGUAGE_CHINESE_SIMPLIFIED,
-        wxLANGUAGE_CHINESE,
+        wxLANGUAGE_CHINESE_TRADITIONAL,
         wxLANGUAGE_GERMAN,
         wxLANGUAGE_CZECH,
         wxLANGUAGE_FRENCH,
@@ -407,7 +407,7 @@ wxBoxSizer *PreferencesDialog::create_item_language_combobox(wxString title, wxS
         if (vlist[i] == wxLocale::GetLanguageInfo(wxLANGUAGE_CHINESE_SIMPLIFIED)) {
             language_name = wxString::FromUTF8("\xe4\xb8\xad\xe6\x96\x87\x28\xe7\xae\x80\xe4\xbd\x93\x29");
         }
-        else if (vlist[i] == wxLocale::GetLanguageInfo(wxLANGUAGE_CHINESE)) {
+        else if (vlist[i] == wxLocale::GetLanguageInfo(wxLANGUAGE_CHINESE_TRADITIONAL)) {
             language_name = wxString::FromUTF8("\xe4\xb8\xad\xe6\x96\x87\x28\xe7\xb9\x81\xe9\xab\x94\x29");
         }
         else if (vlist[i] == wxLocale::GetLanguageInfo(wxLANGUAGE_SPANISH)) {

src/slic3r/GUI/PresetComboBoxes.cpp

@@ -873,10 +873,15 @@ PlaterPresetComboBox::PlaterPresetComboBox(wxWindow *parent, Preset::Type preset
             auto fila_type = Preset::remove_suffix_modified(GetValue().ToUTF8().data());
             bool is_official = boost::algorithm::starts_with(fila_type, "Bambu");
             if (is_official) {
-                // Get filament_id from filament_presets
+                // Get filament_id from filament_presets. FilamentPickerDialog looks up
+                // filaments_color_codes.json, which is downloaded from Bambu and keyed by the
+                // printer's own ids, so translate our OF id (the "GFA00" fallback is already one).
                 const std::string& preset_name = m_preset_bundle->filament_presets[m_filament_idx];
                 const Preset* selected_preset = m_collection->find_preset(preset_name);
-                wxString fila_id = selected_preset ? wxString::FromUTF8(selected_preset->filament_id) : "GFA00";
+                auto* agent = wxGetApp().getAgent();
+                wxString fila_id = "GFA00";
+                if (selected_preset)
+                    fila_id = wxString::FromUTF8(agent ? agent->from_orca_filament_id(selected_preset->filament_id) : selected_preset->filament_id);
                 FilamentColor fila_color = get_cur_color_info();
 
                 // Show filament picker dialog

src/slic3r/GUI/SavePresetDialog.cpp

@@ -114,7 +114,7 @@ SavePresetDialog::Item::Item(Preset::Type type, const std::string &suffix, wxBox
     if (parent->m_mode == comDevelop) {
         // A new user copy of a system preset inherits from the selected system preset.
         const std::string parent_name = sel_preset.is_system ? sel_preset.name : sel_preset.inherits();
-        const bool        can_detach  = !parent_name.empty();
+        const bool        has_parent  = !parent_name.empty();
 
         wxBoxSizer *detach_sizer = new wxBoxSizer(wxHORIZONTAL);
 
@@ -123,8 +123,9 @@ SavePresetDialog::Item::Item(Preset::Type type, const std::string &suffix, wxBox
         auto detach_checkbox = new ::CheckBox(parent);
         detach_checkbox->SetToolTip(detach_tooltip);
 
-        auto detach_label    = new wxStaticText(parent, wxID_ANY, _L("Detach from parent"));
+        auto detach_label    = new wxStaticText(parent, wxID_ANY, has_parent ? _L("Detach from parent") : _L("Save without parent"));
         detach_label->SetFont(::Label::Body_14);
+        detach_label->SetForegroundColour(wxColour("#363636"));
         detach_label->SetToolTip(detach_tooltip);
 
         detach_sizer->Add(detach_checkbox, 0, wxALIGN_LEFT | wxLEFT, BORDER_W);
@@ -132,39 +133,31 @@ SavePresetDialog::Item::Item(Preset::Type type, const std::string &suffix, wxBox
         sizer->Add(detach_sizer, 0, wxEXPAND | wxTOP, BORDER_W);
         sizer->AddSpacer(FromDIP(5));
 
-        const wxString parent_text = can_detach ? from_u8(parent_name) : _L("Unique preset");
+        const wxString parent_text = has_parent ? from_u8(parent_name) : _L("Unique preset");
         auto parent_label          = new wxStaticText(parent, wxID_ANY, parent_text);
         parent_label->SetFont(::Label::Body_12);
         parent_label->SetForegroundColour(wxColour("#6B6B6B"));
-        parent_label->SetToolTip(can_detach ? _L("Parent preset") : _L("This preset does not inherit from another preset."));
+        parent_label->SetToolTip(has_parent ? _L("Parent preset") : _L("This preset does not inherit from another preset."));
         sizer->Add(parent_label, 0, wxEXPAND | wxLEFT, BORDER_W + FromDIP(24));
 
         sizer->AddSpacer(FromDIP(5));
 
-        if (!can_detach) {
-            detach_checkbox->Disable();
-            detach_label->SetForegroundColour(wxColour("#6B6B6B"));
-        } 
-        else {
-            // Set initial state (unchecked by default)
-            detach_checkbox->SetValue(m_detach);
-            // Bind the checkbox event to update the detach state for this item
-            detach_checkbox->Bind(wxEVT_TOGGLEBUTTON, [this, detach_checkbox](wxCommandEvent& event) {
-                m_detach = detach_checkbox->GetValue();
-                event.Skip(); // Let CheckBox update its bitmap for the new state.
-            });
+        // Set initial state (unchecked by default)
+        detach_checkbox->SetValue(m_detach);
+        // Bind the checkbox event to update the detach state for this item
+        detach_checkbox->Bind(wxEVT_TOGGLEBUTTON, [this, detach_checkbox](wxCommandEvent& event) {
+            m_detach = detach_checkbox->GetValue();
+            event.Skip(); // Let CheckBox update its bitmap for the new state.
+        });
 
-            detach_label->SetForegroundColour(wxColour("#363636"));
-
-            auto on_toggle = [detach_checkbox]() {
-                detach_checkbox->SetValue(!detach_checkbox->GetValue());
-                wxCommandEvent ev(wxEVT_TOGGLEBUTTON, detach_checkbox->GetId());
-                ev.SetEventObject(detach_checkbox);
-                detach_checkbox->GetEventHandler()->ProcessEvent(ev);
-            };
-            detach_label->Bind(wxEVT_LEFT_DOWN,   [on_toggle](wxMouseEvent& e) {if(!e.LeftDClick()) on_toggle();});
-            detach_label->Bind(wxEVT_LEFT_DCLICK, [on_toggle](wxMouseEvent& e) {on_toggle();});
-        }
+        auto on_toggle = [detach_checkbox]() {
+            detach_checkbox->SetValue(!detach_checkbox->GetValue());
+            wxCommandEvent ev(wxEVT_TOGGLEBUTTON, detach_checkbox->GetId());
+            ev.SetEventObject(detach_checkbox);
+            detach_checkbox->GetEventHandler()->ProcessEvent(ev);
+        };
+        detach_label->Bind(wxEVT_LEFT_DOWN,   [on_toggle](wxMouseEvent& e) {if(!e.LeftDClick()) on_toggle();});
+        detach_label->Bind(wxEVT_LEFT_DCLICK, [on_toggle](wxMouseEvent& e) {on_toggle();});
     }
     
     m_radio_group->Bind(wxEVT_COMMAND_RADIOBOX_SELECTED, [this](wxCommandEvent &e) {

src/slic3r/GUI/SelectMachine.cpp

@@ -3073,7 +3073,7 @@ static bool _HasExt(const std::vector<FilamentInfo> &ams_mapping_result) {
     };
 
     for (const auto &info : ams_mapping_result) {
-        if (info.ams_id == VIRTUAL_AMS_MAIN_ID_STR || info.ams_id == VIRTUAL_AMS_DEPUTY_ID_STR && !info.ams_id.empty()) {
+        if (info.ams_id == VIRTUAL_AMS_MAIN_ID_STR || (info.ams_id == VIRTUAL_AMS_DEPUTY_ID_STR && !info.ams_id.empty())) {
             return true;
         }
     }
@@ -3845,8 +3845,12 @@ int SelectMachineDialog::update_print_required_data(Slic3r::DynamicPrintConfig c
     m_required_data_config = config;
     m_required_data_model = model;
     //m_required_data_plate_data_list = plate_data_list;
+    auto* agent = wxGetApp().getAgent();
     for (auto i = 0; i < plate_data_list.size(); i++) {
         if (!plate_data_list[i]->gcode_file.empty()) {
+            if (agent)
+                for (auto& info : plate_data_list[i]->slice_filaments_info)
+                    info.filament_id = agent->to_orca_filament_id(info.filament_id);
             m_required_data_plate_data_list.push_back(plate_data_list[i]);
         }
     }
@@ -5051,8 +5055,11 @@ void SelectMachineDialog::update_show_status(MachineObject* obj_)
         const auto& warning_tpu_filaments =
             DevPrinterConfigUtil::get_value_from_config<std::vector<std::string>>(obj_->printer_type, "auto_on_cali_warning_tpu_filaments");
         if (!warning_tpu_filaments.empty()) {
+            auto* agent = wxGetApp().getAgent();
             for (const auto& fila : m_ams_mapping_result) {
-                if (std::find(warning_tpu_filaments.begin(), warning_tpu_filaments.end(), fila.filament_id) != warning_tpu_filaments.end()) {
+                // fila.filament_id is our OF id; the printer config list holds the printer's own.
+                const std::string printer_filament_id = agent ? agent->from_orca_filament_id(fila.filament_id) : fila.filament_id;
+                if (std::find(warning_tpu_filaments.begin(), warning_tpu_filaments.end(), printer_filament_id) != warning_tpu_filaments.end()) {
                     show_status(PrintDialogStatus::PrintStatusTPUUnsuggestCali,
                                 { _L("If 'Dynamic Flow Calibration' is set to Auto/On, the system will use the manual calibration value or the default value and skip the flow calibration process. You can perform a manual flow calibration for TPU filament on the 'Calibration' page.") });
                     break;
@@ -5208,9 +5215,12 @@ bool SelectMachineDialog::can_support_pa_auto_cali()
 
     std::vector<std::string> unsupport_auto_cali_filaments = DevPrinterConfigUtil::get_unsupport_auto_cali_filaments(obj->printer_type);
     if (!unsupport_auto_cali_filaments.empty()) {
+        auto* agent = wxGetApp().getAgent();
         auto iter = std::find_if(m_filaments.begin(), m_filaments.end(),
-            [&unsupport_auto_cali_filaments](const FilamentInfo &item) {
-            auto iter = std::find(unsupport_auto_cali_filaments.begin(), unsupport_auto_cali_filaments.end(), item.filament_id);
+            [&unsupport_auto_cali_filaments, agent](const FilamentInfo &item) {
+            // item.filament_id is our OF id; the printer config list holds the printer's own.
+            const std::string printer_filament_id = agent ? agent->from_orca_filament_id(item.filament_id) : item.filament_id;
+            auto iter = std::find(unsupport_auto_cali_filaments.begin(), unsupport_auto_cali_filaments.end(), printer_filament_id);
             return iter != unsupport_auto_cali_filaments.end();
         });
 

src/slic3r/GUI/SelectMachine.hpp

@@ -662,7 +662,6 @@ private:
     ScalableButton* m_button_question { nullptr };
 
     wxStaticBitmap* m_bed_image{ nullptr };
-    Label*         m_text_bed_type;
 };
 
 

src/slic3r/GUI/SelectMachinePop.hpp

@@ -181,13 +181,11 @@ private:
     PinCodePanel*                     m_panel_direct_connection{nullptr};
     wxWindow*                         m_placeholder_panel{nullptr};
     HyperLink*                        m_hyperlink{nullptr}; // ORCA
-    wxBoxSizer *                      m_sizer_body{nullptr};
     wxBoxSizer *                      m_sizer_my_devices{nullptr};
     wxBoxSizer *                      m_sizer_other_devices{nullptr};
     wxBoxSizer *                      m_sizer_search_bar{nullptr};
     wxSearchCtrl*                     m_search_bar{nullptr};
     wxScrolledWindow *                m_scrolledWindow{nullptr};
-    wxWindow *                        m_panel_body{nullptr};
     wxTimer *                         m_refresh_timer{nullptr};
     std::vector<MachinePanel*>        m_user_list_machine_panel;
     std::vector<MachinePanel*>        m_other_list_machine_panel;

src/slic3r/GUI/Selection.cpp

@@ -1273,10 +1273,9 @@ void Selection::translate(const Vec3d &displacement, TransformationType transfor
                 const Polygons bed_polys{wxGetApp().plater()->get_partplate_list().get_plate(plate_idx)->get_shared_printable_polygon()};
                 Vec3d         tower_origin        = m_cache.volumes_data[i].get_volume_position();
                 Vec3d         actual_displacement = displacement;
-                bool show_read_wipe_tower = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx)->fff_print()->is_step_done(psWipeTower);
-                float brim_width = wxGetApp().preset_bundle->prints.get_edited_preset().config.opt_float("prime_tower_brim_width");
-
-                const double margin = show_read_wipe_tower ? WIPE_TOWER_MARGIN : brim_width + 0.5; // 0.5 is the line width of wipe tower
+                // Both preview volumes carry the brim in their bounding box, and the release
+                // clamp holds it WIPE_TOWER_MARGIN inside — same margin, so drops don't snap.
+                const double margin = WIPE_TOWER_MARGIN;
 
                 actual_displacement = (m_cache.volumes_data[i].get_instance_rotation_matrix() * m_cache.volumes_data[i].get_instance_scale_matrix() *
                                         m_cache.volumes_data[i].get_instance_mirror_matrix())

src/slic3r/GUI/SendToPrinter.hpp

@@ -55,7 +55,6 @@ private:
     void init_timer();
 
     int                                 m_print_plate_idx;
-    int                                 m_current_filament_id;
     int                                 m_print_error_code = 0;
     int                                 timeout_count = 0;
     int                                 m_connect_try_times = 0;
@@ -77,7 +76,6 @@ private:
     TextInput*                          m_rename_input{ nullptr };
     wxSimplebook*                       m_rename_switch_panel{ nullptr };
     Plater*                             m_plater{ nullptr };
-    wxStaticBitmap*                     m_staticbitmap{ nullptr };
     ThumbnailPanel*                     m_thumbnailPanel{ nullptr };
     ComboBox*                           m_comboBox_printer{ nullptr };
     Button*                             m_rename_button{ nullptr };
@@ -97,8 +95,6 @@ private:
     wxPanel *                           m_connecting_panel{nullptr};
     wxSimplebook*                       m_simplebook{ nullptr };
     wxStaticText*                       m_statictext_finish{ nullptr };
-    wxStaticText*                       m_stext_sending{ nullptr };
-    wxStaticText*                       m_staticText_bed_title{ nullptr };
     wxStaticText*                       m_statictext_printer_msg{ nullptr };
     wxStaticText *                      m_connecting_printer_msg{nullptr};
     wxStaticText*                       m_stext_printer_title{ nullptr };
@@ -115,7 +111,6 @@ private:
     wxBoxSizer*                         sizer_thumbnail;
     wxBoxSizer*                         m_sizer_scrollable_region;
     wxBoxSizer*                         m_sizer_main;
-    wxStaticText*                       m_file_name;
     PrintDialogStatus                   m_print_status{ PrintStatusInit };
     AnimaIcon *                         m_animaicon{nullptr};
 
@@ -134,8 +129,6 @@ private:
     std::vector<RadioBox *>             m_storage_radioBox;
     std::string                         m_selected_storage;
     bool                                m_if_has_sdcard;
-    bool                                m_waiting_support{ false };
-    bool                                m_waiting_enable{ false };
     std::vector<std::string>            m_ability_list;
 
 public:

src/slic3r/GUI/SliceInfoPanel.hpp

@@ -28,7 +28,6 @@ public:
 
 private:
     wxScrolledWindow *m_panel;
-    BBLSliceInfo *m_info { nullptr };
 
     void OnMouse(wxMouseEvent &event);
     void OnSize(wxSizeEvent &event);

src/slic3r/GUI/SyncAmsInfoDialog.cpp

@@ -631,7 +631,6 @@ void SyncAmsInfoDialog::updata_ui_when_priner_not_same() {
 SyncAmsInfoDialog::SyncAmsInfoDialog(wxWindow *parent, SyncInfo &info) :
     DPIDialog(static_cast<wxWindow *>(wxGetApp().mainframe), wxID_ANY, _L("Synchronize AMS Filament Information"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
     , m_input_info(info)
-    , m_export_3mf_cancel(false)
     , m_mapping_popup(AmsMapingPopup(this,true))
     , m_mapping_tip_popup(AmsMapingTipPopup(this))
     , m_mapping_tutorial_popup(AmsTutorialPopup(this))
@@ -679,7 +678,7 @@ SyncAmsInfoDialog::SyncAmsInfoDialog(wxWindow *parent, SyncInfo &info) :
 
         wxBoxSizer *loading_Sizer = new wxBoxSizer(wxHORIZONTAL);
         m_gif_ctrl = new wxAnimationCtrl(m_loading_page, wxID_ANY, wxNullAnimation, wxDefaultPosition, wxDefaultSize, wxAC_DEFAULT_STYLE);
-        auto gif_path = Slic3r::var("loading.gif").c_str();
+        const wxString gif_path = from_u8(Slic3r::var("loading.gif"));
         if (m_gif_ctrl->LoadFile(gif_path)){
             m_gif_ctrl->SetSize(m_gif_ctrl->GetAnimation().GetSize());
             m_gif_ctrl->Play();
@@ -1548,7 +1547,7 @@ bool SyncAmsInfoDialog::is_nozzle_type_match(DevExtderSystem data, wxString &err
                     auto sai_nz_pt = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
                     if (target_machine_nozzle_id == DEPUTY_EXTRUDER_ID) {
                         pos = _L(DevPrinterConfigUtil::get_toolhead_display_name(sai_nz_pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase));
-                    } else if ((target_machine_nozzle_id == MAIN_EXTRUDER_ID)) {
+                    } else if (target_machine_nozzle_id == MAIN_EXTRUDER_ID) {
                         pos = _L(DevPrinterConfigUtil::get_toolhead_display_name(sai_nz_pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase));
                     }
 

src/slic3r/GUI/SyncAmsInfoDialog.hpp

@@ -21,15 +21,11 @@ class SyncAmsInfoDialog : public DPIDialog
     bool              m_only_exist_ext_spool_flag{false};
     int               m_current_filament_id{0};
     int               m_print_plate_idx{0};
-    int               m_print_plate_total{0};
     int               m_timeout_count{0};
     int               m_print_error_code{0};
     bool              m_is_in_sending_mode{false};
     bool              m_ams_mapping_res{false};
     bool              m_ams_mapping_valid{false};
-    bool              m_export_3mf_cancel{false};
-    bool              m_is_canceled{false};
-    bool              m_is_rename_mode{false};
     bool              m_check_flag{false};
     PrintPageMode     m_print_page_mode{PrintPageMode::PrintPageModePrepare};
     std::string       m_print_error_msg;

src/slic3r/GUI/Tab.hpp

@@ -630,7 +630,6 @@ private:
     std::vector<PageShp>			m_pages_fff;
     std::vector<PageShp>			m_pages_sla;
 
-    wxBoxSizer*         m_presets_sizer                 {nullptr};
 public:
 	ScalableButton*	m_reset_to_filament_color = nullptr;
 

src/slic3r/GUI/TextureImportDialog.cpp

@@ -519,7 +519,6 @@ public:
         , m_entries(entries)
         , m_colors_rgba(colors_rgba)
         , m_names(names)
-        , m_existing_count(existing_count)
         , m_dialog_anchor(dialog_anchor)
         , m_on_select(std::move(on_select))
         , m_on_add_filament(std::move(on_add_filament))
@@ -877,7 +876,6 @@ private:
     std::vector<TextureFilamentEntry>          m_entries;
     std::vector<std::array<float, 4>>          m_colors_rgba;
     std::vector<std::string>                   m_names;
-    size_t                                     m_existing_count = 0;
     wxWindow*                                  m_dialog_anchor = nullptr;
     std::function<void(int)>                   m_on_select;
     std::function<void(wxColour)>              m_on_add_filament;

src/slic3r/GUI/UnsavedChangesDialog.cpp

@@ -1281,8 +1281,8 @@ static wxString get_string_value(std::string opt_key, const DynamicPrintConfig&
     }
     auto opt_vector = dynamic_cast<const ConfigOptionVectorBase *>(option);
 
-    if (option->is_scalar() && config.option(opt_key)->is_nil() ||
-        option->is_vector() && opt_vector && opt_idx >= 0 && opt_idx < opt_vector->size() && opt_vector->is_nil(opt_idx))
+    if ((option->is_scalar() && config.option(opt_key)->is_nil()) ||
+        (option->is_vector() && opt_vector && opt_idx >= 0 && opt_idx < opt_vector->size() && opt_vector->is_nil(opt_idx)))
         return _L("N/A");
 
     wxString out;

src/slic3r/GUI/UpdateDialogs.hpp

@@ -33,7 +33,6 @@ public:
 
 	void on_hyperlink(wxHyperlinkEvent& evt);
 private:
-	wxCheckBox *cbox;
 };
 
 

src/slic3r/GUI/WebViewDialog.hpp

@@ -108,13 +108,16 @@ public:
 private:
 
     wxWebView* m_browser;
+    wxButton *  m_button_stop;
+    wxTextCtrl *m_url;
+#if !BBL_RELEASE_TO_PUBLIC
+    // Created only by the internal-build toolbar in the constructor.
     wxBoxSizer *bSizer_toolbar;
     wxButton *  m_button_back;
     wxButton *  m_button_forward;
-    wxButton *  m_button_stop;
     wxButton *  m_button_reload;
-    wxTextCtrl *m_url;
     wxButton *  m_button_tools;
+#endif //BBL_RELEASE_TO_PUBLIC
 
     wxMenu* m_tools_menu;
     wxMenuItem* m_tools_handle_navigation;
@@ -143,7 +146,6 @@ private:
     wxMenuItem* m_dev_tools;
 
     wxInfoBar *m_info;
-    wxStaticText* m_info_text;
 
     long m_zoomFactor;
 

src/slic3r/GUI/Widgets/AMSItem.hpp

@@ -641,17 +641,11 @@ private:
     AMSRoadShowMode              m_road_mode      = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR};
     AMSPassRoadSTEP              m_load_step      = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};
 
-    bool     m_selected       = {false};
-    int      m_passroad_width = {6};
-    double   m_radius         = {4};
     wxColour m_road_def_color;
     wxColour m_road_color;
 
     std::vector<ScalableBitmap> ams_humidity_img;
 
-    int      m_humidity      = {0};
-    bool     m_show_humidity = {false};
-    bool     m_vams_loading{false};
     AMSModel m_ams_model;
 };
 
@@ -690,14 +684,10 @@ private:
 
     int             m_left_road_length     = {-1};
     int             m_right_road_length    = {-1};
-    int             m_passroad_width       = {6};
-    double          m_radius               = {4};
     AMSPassRoadSTEP m_pass_road_left_step  = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};
     AMSPassRoadSTEP m_pass_road_right_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};
 
     std::map<int, wxColour> m_road_color;
-    bool m_vams_loading{false};
-    AMSModel m_ams_model;
 };
 
 /*************************************************

src/slic3r/GUI/Widgets/FanControl.hpp

@@ -212,7 +212,6 @@ private:
     wxGridSizer* m_sizer_fanControl { nullptr };
 
     wxBoxSizer *m_mode_sizer{ nullptr };
-    wxBoxSizer *m_bottom_sizer{ nullptr };
 
     // mode switch buttons
     std::unordered_map<int, SendModeSwitchButton*> m_mode_switch_btns; //<mode_id, SendModeSwitchButton>

src/slic3r/GUI/Widgets/MultiNozzleSync.hpp

@@ -89,8 +89,6 @@ private:
 
     bool m_right_on{ true };
     wxStaticBitmap* badget;
-    Label* left;
-    Label* right;
     Label* left_diameter_desp;
     Label* right_diameter_desp;
     Label* left_flow_desp;