Merge branch 'main' into feature/filament_id

src/slic3r/GUI/AMSMaterialsSetting.cpp

@@ -4,6 +4,7 @@
 #include "GUI_App.hpp"
 #include "libslic3r/Preset.hpp"
 #include "I18N.hpp"
+#include <algorithm>
 #include <boost/log/trivial.hpp>
 #include <wx/colordlg.h>
 #include <wx/dcgraph.h>
@@ -1075,54 +1076,105 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
 
     // Sort the filaments
     {
-        static std::unordered_map<wxString, int> sorted_names
-        {   {"Bambu PLA Basic",        0},
-            {"Bambu PLA Matte",        1},
-            {"Bambu PETG HF",          2},
-            {"Bambu ABS",              3},
-            {"Bambu PLA Silk",         4},
-            {"Bambu PLA-CF" ,          5},
-            {"Bambu PLA Galaxy",       6},
-            {"Bambu PLA Metal",        7},
-            {"Bambu PLA Marble",       8},
-            {"Bambu PETG-CF",          9},
-            {"Bambu PETG Translucent", 10},
-            {"Bambu ABS-GF",           11}
+        std::unordered_map<wxString, int> selected_filament_ranks;
+
+        // Helper lambda to find a filament Preset by name. We can call this multiple times to walk the inheritance chain and find the base filament.
+        auto find_filament_by_name = [](const std::string& wanted, const PresetCollection& filaments) -> const Preset* {
+            for (auto it = filaments.begin(); it != filaments.end(); ++it) {
+                if (it->name == wanted) {
+                    return &(*it);
+                }
+            }
+            return nullptr;
         };
 
-        static std::vector<wxString> sorted_vendors { "Bambu Lab", "Generic" };
-        static std::vector<wxString> sorted_types { "PLA", "PETG", "ABS", "TPU" };
-        auto _filament_sorter = [&query_filament_vendors, &query_filament_types](const wxString& left, const wxString& right) -> bool
-        {
-            { // Compare name order
-                const auto& iter1 = sorted_names.find(left);
-                int name_order1 = (iter1 != sorted_names.end()) ? iter1->second : INT_MAX;
+        // For each active filament preset, find its base filament alias and promote it in extruder order.
+        auto        bundle       = wxGetApp().preset_bundle;
+        const auto& preset_names = bundle->filament_presets;
+        for (size_t i = preset_names.size(); i-- > 0; ) {
+            std::string wanted = preset_names[i];
+            const int sort_rank = -static_cast<int>(preset_names.size() - i);
+            
+            const Preset* match = nullptr;
 
-                const auto& iter2 = sorted_names.find(right);
-                int name_order2 = (iter2 != sorted_names.end()) ? iter2->second : INT_MAX;
-                if (name_order1 != name_order2)
+            do {
+                auto find_result = find_filament_by_name(wanted, bundle->filaments);
+                if (!find_result) {
+                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " No available filament name matches " << wanted;
+                    break;
+                }
+
+                match = find_result;
+
+                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Found available filament matching current preset name " << wanted
+                                        << " - Name: " << match->name << " - Alias: " << match->alias
+                                        << " - Inherits: " << match->inherits();
+
+                if (match->inherits().length() == 0) {
+                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " No more inherits so we reached the base filament";
+                    break;
+                }
+
+                wanted = match->inherits();
+            } while (1); // Or loop while (match->alias.length() == 0) because existence of alias and inherits on a Preset seem to be exclusive
+
+            if (!match) {
+                continue;
+            }
+
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Update filament rank to " + std::to_string(sort_rank) + " for preset Name: "
+                                    << match->name << " - Alias: " << match->alias;
+            selected_filament_ranks.insert_or_assign(match->alias, sort_rank);
+        }
+        
+        static const std::vector<wxString> sorted_vendors { "Generic" };
+        static const std::vector<wxString> sorted_types { "PLA", "PETG", "ABS", "TPU" };
+        auto priority_rank = [](const std::vector<wxString>& priorities, const wxString& value) {
+            const auto iter = std::find_if(priorities.begin(), priorities.end(), [&value](const wxString& priority) {
+                return priority.CmpNoCase(value) == 0;
+            });
+            return iter - priorities.begin();
+        };
+        auto _filament_sorter = [&query_filament_vendors, &query_filament_types, &selected_filament_ranks, &priority_rank](const wxString& left, const wxString& right) -> bool
+        {
+            { // Compare selected filament order
+                const auto& iter1 = selected_filament_ranks.find(left);
+                int selected_order1 = (iter1 != selected_filament_ranks.end()) ? iter1->second : INT_MAX;
+
+                const auto& iter2 = selected_filament_ranks.find(right);
+                int selected_order2 = (iter2 != selected_filament_ranks.end()) ? iter2->second : INT_MAX;
+                if (selected_order1 != selected_order2)
                 {
-                    return name_order1 < name_order2;
+                    return selected_order1 < selected_order2;
                 }
             }
             { // Compare vendor
-                auto iter1 = std::find(sorted_vendors.begin(), sorted_vendors.end(), query_filament_vendors[left]);
-                auto iter2 = std::find(sorted_vendors.begin(), sorted_vendors.end(), query_filament_vendors[right]);
-                if (iter1 != iter2)
-                {
-                    return iter1 < iter2;
-                };
+                const wxString& vendor1 = query_filament_vendors.at(left);
+                const wxString& vendor2 = query_filament_vendors.at(right);
+                const auto      rank1   = priority_rank(sorted_vendors, vendor1);
+                const auto      rank2   = priority_rank(sorted_vendors, vendor2);
+                if (rank1 != rank2)
+                    return rank1 < rank2;
+
+                const int vendor_compare = vendor1.CmpNoCase(vendor2);
+                if (vendor_compare != 0)
+                    return vendor_compare < 0;
             }
             { // Compare type
-                auto iter1 = std::find(sorted_types.begin(), sorted_types.end(), query_filament_types[left]);
-                auto iter2 = std::find(sorted_types.begin(), sorted_types.end(), query_filament_types[right]);
-                if (iter1 != iter2)
-                {
-                    return iter1 < iter2;
-                }
+                const wxString& type1 = query_filament_types.at(left);
+                const wxString& type2 = query_filament_types.at(right);
+                const auto      rank1 = priority_rank(sorted_types, type1);
+                const auto      rank2 = priority_rank(sorted_types, type2);
+                if (rank1 != rank2)
+                    return rank1 < rank2;
+
+                const int type_compare = type1.CmpNoCase(type2);
+                if (type_compare != 0)
+                    return type_compare < 0;
             }
 
-            return left < right;
+            const int name_compare = left.CmpNoCase(right);
+            return name_compare != 0 ? name_compare < 0 : left < right;
         };
 
         std::sort(filament_items.begin(), filament_items.end(), _filament_sorter);

src/slic3r/GUI/Auxiliary.cpp

@@ -869,11 +869,11 @@ void AuxiliaryPanel::init_tabpanel()
     m_assembly_panel          = new AuFolderPanel(m_tabpanel, AuxiliaryFolderType::ASSEMBLY_GUIDE);
     m_others_panel            = new AuFolderPanel(m_tabpanel, AuxiliaryFolderType::OTHERS);
 
-    m_tabpanel->AddPage(m_designer_panel, _L("Basic Info"), "", true);
-    m_tabpanel->AddPage(m_pictures_panel, _L("Pictures"), "", false);
-    m_tabpanel->AddPage(m_bill_of_materials_panel, _L("Bill of Materials"), "", false);
-    m_tabpanel->AddPage(m_assembly_panel, _L("Assembly Guide"), "", false);
-    m_tabpanel->AddPage(m_others_panel, _L("Others"), "", false);
+    m_tabpanel->AddPage(m_designer_panel, _L("Basic Info"), true);
+    m_tabpanel->AddPage(m_pictures_panel, _L("Pictures"), false);
+    m_tabpanel->AddPage(m_bill_of_materials_panel, _L("Bill of Materials"), false);
+    m_tabpanel->AddPage(m_assembly_panel, _L("Assembly Guide"), false);
+    m_tabpanel->AddPage(m_others_panel, _L("Others"), false);
 }
 
 wxWindow *AuxiliaryPanel::create_side_tools()

src/slic3r/GUI/CalibrationPanel.cpp

@@ -488,7 +488,6 @@ void CalibrationPanel::init_tabpanel() {
             selected = true;
         m_tabpanel->AddPage(m_cali_panels[i],
             get_calibration_type_name(m_cali_panels[i]->get_calibration_mode()),
-            "",
             selected);
     }
 

src/slic3r/GUI/ConfigManipulation.cpp

@@ -752,7 +752,7 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, in
     bool has_top_shell    = has_top_shell_layers && config->option<ConfigOptionPercent>("top_surface_density")->value > 0;
     bool has_bottom_shell = config->opt_int("bottom_shell_layers") > 0;
     bool has_solid_infill = has_top_shell_layers || has_bottom_shell;
-    toggle_line("sparse_infill_smooth_factor", pattern == ipHilbertCurve);
+    toggle_line("sparse_infill_smooth_factor", is_smoothable_infill_pattern(pattern, config->opt_int("fill_multiline")));
     toggle_field("top_surface_pattern", has_top_shell);
     toggle_field("bottom_surface_pattern", has_bottom_shell);
     toggle_field("top_surface_density", has_top_shell_layers);

src/slic3r/GUI/ConfigWizard.cpp

@@ -66,41 +66,41 @@ using Config::SnapshotDB;
 
 // Configuration data structures extensions needed for the wizard
 //BBS: set BBL as default
-bool Bundle::load(fs::path source_path, bool ais_in_resources, bool ais_bbl_bundle)
+bool Bundle::load(fs::path dir, const std::string &vendor_name, bool ais_in_resources, bool ais_bbl_bundle)
 {
     this->preset_bundle = std::make_unique<PresetBundle>();
     this->is_in_resources = ais_in_resources;
     this->is_bbl_bundle = ais_bbl_bundle;
 
-    std::string path_string = source_path.string();
-    std::string parent_path = source_path.parent_path().string();
     //BBS: add json logic for vendor bundles
-    std::string vendor_name = source_path.filename().string();
-    if (Slic3r::is_json_file(path_string)) {
-        // Remove the .json suffix.
-        vendor_name.erase(vendor_name.size() - 5);
-    }
-    else
+    // Orca: served from the vendor's preset cache where one covers it — which is
+    // how a shipped build carries its vendors — and parsed from the JSONs otherwise.
+    // A vendor that can be neither read nor parsed — a cache the build cannot use
+    // with the preset JSONs behind it pruned, say — is one the wizard cannot offer.
+    // Every other vendor still can be, so it is left out rather than thrown over.
+    size_t presets_loaded = 0;
+    try {
+        auto [config_substitutions, loaded] = preset_bundle->load_vendor_configs_from_json(
+            dir.string(), vendor_name, PresetBundle::LoadConfigBundleAttribute::LoadSystem, ForwardCompatibilitySubstitutionRule::Disable);
+        UNUSED(config_substitutions);
+        // No substitutions shall be reported when loading a system config bundle, no substitutions are allowed.
+        assert(config_substitutions.empty());
+        presets_loaded = loaded;
+    } catch (const std::exception &e) {
+        BOOST_LOG_TRIVIAL(fatal) << boost::format("Vendor bundle: `%1%`: cannot be loaded, leaving it out: %2%") % vendor_name % e.what();
         return false;
-
-    // Throw when parsing invalid configuration. Only valid configuration is supposed to be provided over the air.
-    //BBS: add json logic for vendor bundles
-    auto [config_substitutions, presets_loaded] = preset_bundle->load_vendor_configs_from_json(
-        parent_path, vendor_name, PresetBundle::LoadConfigBundleAttribute::LoadSystem, ForwardCompatibilitySubstitutionRule::Disable);
-    UNUSED(config_substitutions);
-    // No substitutions shall be reported when loading a system config bundle, no substitutions are allowed.
-    assert(config_substitutions.empty());
+    }
     auto first_vendor = preset_bundle->vendors.begin();
     if (first_vendor == preset_bundle->vendors.end()) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No vendor information defined, cannot install.") % path_string;
+        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No vendor information defined, cannot install.") % vendor_name;
         return false;
     }
     if (presets_loaded == 0) {
-        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No profile loaded.") % path_string;
+        BOOST_LOG_TRIVIAL(error) << boost::format("Vendor bundle: `%1%`: No profile loaded.") % vendor_name;
         return false;
-    } 
+    }
 
-    BOOST_LOG_TRIVIAL(trace) << boost::format("Vendor bundle: `%1%`: %2% profiles loaded.") % path_string % presets_loaded;
+    BOOST_LOG_TRIVIAL(trace) << boost::format("Vendor bundle: `%1%`: %2% profiles loaded.") % vendor_name % presets_loaded;
     this->vendor_profile = &first_vendor->second;
     return true;
 }
@@ -125,15 +125,10 @@ BundleMap BundleMap::load()
 
     //Orca: add custom as default
     //Orca: add json logic for vendor bundle
-    auto orca_bundle_path = (vendor_dir / PresetBundle::ORCA_DEFAULT_BUNDLE).replace_extension(".json");
-    auto orca_bundle_rsrc = false;
-    if (!boost::filesystem::exists(orca_bundle_path)) {
-        orca_bundle_path = (rsrc_vendor_dir / PresetBundle::ORCA_DEFAULT_BUNDLE).replace_extension(".json");
-        orca_bundle_rsrc = true;
-    }
     {
+        const bool from_rsrc = ! is_vendor_installed(PresetBundle::ORCA_DEFAULT_BUNDLE);
         Bundle bbl_bundle;
-        if (bbl_bundle.load(std::move(orca_bundle_path), orca_bundle_rsrc, true))
+        if (bbl_bundle.load(from_rsrc ? rsrc_vendor_dir : vendor_dir, PresetBundle::ORCA_DEFAULT_BUNDLE, from_rsrc, true))
             res.emplace(PresetBundle::ORCA_DEFAULT_BUNDLE, std::move(bbl_bundle));
     }
 
@@ -141,18 +136,13 @@ BundleMap BundleMap::load()
     // and then additionally from resources/profiles.
     bool is_in_resources = false;
     for (auto dir : { &vendor_dir, &rsrc_vendor_dir }) {
-        for (const auto &dir_entry : boost::filesystem::directory_iterator(*dir)) {
-            //BBS: add json logic for vendor bundle
-            if (Slic3r::is_json_file(dir_entry.path().string())) {
-                std::string id = dir_entry.path().stem().string();  // stem() = filename() without the trailing ".json" part
+        for (const std::string &id : vendor_names_in(*dir)) {
+            // Don't load this bundle if we've already loaded it.
+            if (res.find(id) != res.end()) { continue; }
 
-                // Don't load this bundle if we've already loaded it.
-                if (res.find(id) != res.end()) { continue; }
-
-                Bundle bundle;
-                if (bundle.load(dir_entry.path(), is_in_resources))
-                    res.emplace(std::move(id), std::move(bundle));
-            }
+            Bundle bundle;
+            if (bundle.load(*dir, id, is_in_resources))
+                res.emplace(id, std::move(bundle));
         }
 
         is_in_resources = true;

src/slic3r/GUI/ConfigWizard_private.hpp

@@ -71,9 +71,11 @@ struct Bundle
 	Bundle() = default;
 	Bundle(Bundle&& other);
 
+	// Load the vendor `vendor_name` as it is installed in `dir`, from its preset
+	// cache or its profile JSONs, whichever is usable.
 	// Returns false if not loaded. Reason for that is logged as boost::log error.
 	//BBS: set BBL as default
-	bool load(fs::path source_path, bool is_in_resources, bool is_bbl_bundle = false);
+	bool load(fs::path dir, const std::string &vendor_name, bool is_in_resources, bool is_bbl_bundle = false);
 
 	const std::string& vendor_id() const { return vendor_profile->id; }
 };

src/slic3r/GUI/ConnectPrinter.cpp

@@ -156,6 +156,8 @@ void ConnectPrinterDialog::on_input_enter(wxCommandEvent& evt)
 void ConnectPrinterDialog::on_button_confirm(wxCommandEvent &event)
 {
     wxString code = m_textCtrl_code->GetTextCtrl()->GetValue();
+    if (code.empty())
+        code = "88888888";
     for (char c : code) {
         if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))) {
             show_error(this, _L("Invalid input"));
@@ -163,7 +165,7 @@ void ConnectPrinterDialog::on_button_confirm(wxCommandEvent &event)
         }
     }
     if (m_obj) {
-        m_obj->set_user_access_code(code.ToStdString());
+        m_obj->set_access_code(code.ToStdString());
     }
     EndModal(wxID_OK);
 }

src/slic3r/GUI/CreatePresetsDialog.cpp

@@ -2201,25 +2201,14 @@ bool CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model(Pre
     } else {
         selected_vendor_id = m_printer_preset_vendor_selected.id;
 
-        if (boost::filesystem::exists(boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR / selected_vendor_id)) {
-            preset_path = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).string();
-        } else if (boost::filesystem::exists(boost::filesystem::path(Slic3r::resources_dir()) / "profiles" / selected_vendor_id)) {
-            preset_path = (boost::filesystem::path(Slic3r::resources_dir()) / "profiles").string();
-        }
-
-        if (preset_path.empty()) {
-            BOOST_LOG_TRIVIAL(info) << "Preset path was not found";
-            MessageDialog dlg(this, _L("Preset path was not found; please reselect vendor."), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"),
-                              wxYES_NO | wxYES_DEFAULT | wxCENTRE);
-            dlg.ShowModal();
-            return false;
-        }
-
         try {
             // Pass the app's preset bundle (which already holds OrcaFilamentLibrary) as the base
             // bundle so vendor filaments that inherit OFL bases resolve via the existing
             // cross-vendor inheritance path.
-            temp_preset_bundle.load_vendor_configs_from_json(preset_path, selected_vendor_id,
+            // Orca: served from the vendor's preset cache where one covers it — a shipped
+            // build carries that instead of the raw preset JSONs — and parsed otherwise.
+            temp_preset_bundle.load_vendor_configs_from_json((boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).string(),
+                                                             selected_vendor_id,
                                                              PresetBundle::LoadConfigBundleAttribute::LoadSystem,
                                                              ForwardCompatibilitySubstitutionRule::EnableSilent,
                                                              wxGetApp().preset_bundle);

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -10,11 +10,39 @@
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Plater.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
 
 #include "libslic3r/Time.hpp"
 
 using namespace nlohmann;
 
+namespace {
+    // Orca: access_code lives on BBLocalMachine::access_code (keyed by dev_id via
+    // get_local_machines(), scoped by the record's own printer_agent_id field) - so binding a
+    // printer under one agent doesn't silently appear as already-bound under a different,
+    // independent agent. This only covers LAN devices (BBLocalMachine's own scope); access_code
+    // and user_access_code used to be the only, flat dev_id-only AppConfig keys before
+    // BBLocalMachine::access_code existed, and codes saved back then are still stored flat (no
+    // agent association at all). Since BBL was the only agent that existed at the time, honor
+    // those flat legacy keys as implicitly BBL's - but only for the BBL agent, so they aren't
+    // leaked to other agents that never bound the device themselves.
+    std::string get_access_code_with_legacy_fallback(Slic3r::AppConfig* config, const std::string& dev_id, const std::string& agent_id)
+    {
+        const auto& machines = config->get_local_machines();
+        auto        it       = machines.find(dev_id);
+        if (it != machines.end() && it->second.printer_agent_id == agent_id && !it->second.access_code.empty())
+            return it->second.access_code;
+
+        if (agent_id == Slic3r::BBL_PRINTER_AGENT_ID || agent_id.empty()) {
+            std::string code = config->get("access_code", dev_id);
+            if (code.empty())
+                code = config->get("user_access_code", dev_id);
+            return code;
+        }
+        return "";
+    }
+}
+
 namespace Slic3r
 {
     DeviceManager::DeviceManager(NetworkAgent* agent)
@@ -43,13 +71,13 @@ namespace Slic3r
                 continue;
             MachineObject* obj       = new MachineObject(this, m_agent, m.dev_name, m.dev_id, m.dev_ip);
             obj->printer_type        = m.printer_type;
+            obj->printer_agent_id    = m.printer_agent_id;
             obj->dev_connection_type = "lan";
             obj->bind_state          = "free";
             obj->bind_sec_link       = "secure";
             obj->m_is_online         = true;
             obj->last_alive          = Slic3r::Utils::get_current_time_utc();
-            obj->set_access_code(config->get("access_code", m.dev_id), false);
-            obj->set_user_access_code(config->get("user_access_code", m.dev_id), false);
+            obj->set_access_code(get_access_code_with_legacy_fallback(config, m.dev_id, obj->printer_agent_id), false);
             if (obj->has_access_right()) {
                 localMachineList.insert(std::make_pair(m.dev_id, obj));
             } else {
@@ -66,10 +94,12 @@ namespace Slic3r
             if (m.is_lan_mode_printer()) {
                 if (m.has_access_right()) {
                     BBLocalMachine local_machine;
-                    local_machine.dev_id       = m.get_dev_id();
-                    local_machine.dev_name     = m.get_dev_name();
-                    local_machine.dev_ip       = m.get_dev_ip();
-                    local_machine.printer_type = m.printer_type;
+                    local_machine.dev_id           = m.get_dev_id();
+                    local_machine.dev_name         = m.get_dev_name();
+                    local_machine.dev_ip           = m.get_dev_ip();
+                    local_machine.printer_type     = m.printer_type;
+                    local_machine.printer_agent_id = m.printer_agent_id;
+                    local_machine.access_code      = m.get_access_code();
                     config->update_local_machine(local_machine);
                 }
             } else {
@@ -132,6 +162,14 @@ namespace Slic3r
         }
     }
 
+    std::string DeviceManager::get_current_printer_agent_id() const
+    {
+        if (!m_agent)
+            return "";
+        auto printer_agent = m_agent->get_printer_agent();
+        return printer_agent ? printer_agent->get_agent_info().id : "";
+    }
+
     void DeviceManager::EnableMultiMachine(bool enable)
     {
         m_agent->enable_multi_machine(enable);
@@ -328,6 +366,7 @@ namespace Slic3r
                 /* insert a new machine */
                 obj = new MachineObject(this, m_agent, dev_name, dev_id, dev_ip);
                 obj->printer_type = _parse_printer_type(printer_type_str);
+                obj->printer_agent_id = get_current_printer_agent_id();
                 obj->wifi_signal = printer_signal;
                 obj->dev_connection_type = connect_type;
                 obj->bind_state     = bind_state;
@@ -339,8 +378,7 @@ namespace Slic3r
                 //load access code
                 AppConfig* config = Slic3r::GUI::wxGetApp().app_config;
                 if (config) {
-                    obj->set_access_code(Slic3r::GUI::wxGetApp().app_config->get("access_code", dev_id), false);
-                    obj->set_user_access_code(Slic3r::GUI::wxGetApp().app_config->get("user_access_code", dev_id), false);
+                    obj->set_access_code(get_access_code_with_legacy_fallback(config, dev_id, obj->printer_agent_id), false);
                 }
                 localMachineList.insert(std::make_pair(dev_id, obj));
 
@@ -369,6 +407,7 @@ namespace Slic3r
             obj = it->second;
         } else {
             obj = new MachineObject(this, m_agent, machine.dev_name, machine.dev_id, machine.dev_ip);
+            obj->printer_agent_id = get_current_printer_agent_id();
             localMachineList.insert(std::make_pair(machine.dev_id, obj));
         }
         if (machine.printer_type.empty())
@@ -382,7 +421,6 @@ namespace Slic3r
         obj->m_is_online = true;
         obj->last_alive = Slic3r::Utils::get_current_time_utc();
         obj->set_access_code(access_code, false);
-        obj->set_user_access_code(access_code, false);
 
         update_local_machine(*obj);
 
@@ -496,16 +534,26 @@ namespace Slic3r
         OnSelectedMachineChanged(previous_selected_machine, selected_machine);
     }
 
-    void DeviceManager::clear_other_devices()
+    void DeviceManager::clear_other_devices(const std::string& target_agent_id)
     {
         // why: on agent swap, keep "My Devices" but drop the transient "Other Devices"
         // Those belong to the previous agent's network scan; the new agent's start_discovery re-populates its own.
+        //
+        // Also drop "My Devices" stamped by a different agent than the one we're swapping to
+        // (target_agent_id, passed by the caller since the live agent hasn't been repointed yet
+        // at this point): otherwise a device first discovered under agent A survives every swap
+        // with a stale printer_agent_id, stays hidden from every agent's filtered list, and only
+        // gets re-tagged if something happens to delete and re-create it (e.g. account logout).
+        // Dropping it here instead lets the new agent's start_discovery re-insert and re-stamp it
+        // like any other fresh device.
         const auto my = get_my_machine_list();
         for (auto it = localMachineList.begin(); it != localMachineList.end();)
         {
-            if (my.find(it->first) == my.end())
+            const bool is_my_device = my.find(it->first) != my.end();
+            const bool agent_mismatch = !target_agent_id.empty() && it->second &&
+                                         it->second->printer_agent_id != target_agent_id;
+            if (!is_my_device || agent_mismatch)
             {
-                // not a "My Device" -> an "Other Device"
                 delete it->second;
                 it = localMachineList.erase(it);
             }
@@ -688,13 +736,16 @@ namespace Slic3r
             m_agent->add_subscribe(subscribe_list_cache);
     }
 
-    std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list()
+    std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list(const std::string& agent_id)
     {
         std::map<std::string, MachineObject*> result;
 
         for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
         {
-            if (it->second && !it->second->is_lan_mode_printer())
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (!it->second->is_lan_mode_printer())
             {
                 result.insert(std::make_pair(it->first, it->second));
             }
@@ -702,7 +753,10 @@ namespace Slic3r
 
         for (auto it = localMachineList.begin(); it != localMachineList.end(); it++)
         {
-            if (it->second && it->second->has_access_right() && it->second->is_avaliable() && it->second->is_lan_mode_printer())
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (it->second->has_access_right() && it->second->is_avaliable() && it->second->is_lan_mode_printer())
             {
                 // remove redundant in userMachineList
                 if (result.find(it->first) == result.end())
@@ -714,12 +768,15 @@ namespace Slic3r
         return result;
     }
 
-    std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list()
+    std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list(const std::string& agent_id)
     {
         std::map<std::string, MachineObject*> result;
         for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
         {
-            if (it->second && !it->second->is_lan_mode_printer()) { result.emplace(*it); }
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (!it->second->is_lan_mode_printer()) { result.emplace(*it); }
         }
         return result;
     }
@@ -792,6 +849,7 @@ namespace Slic3r
                     else
                     {
                         obj = new MachineObject(this, m_agent, "", "", "");
+                        obj->printer_agent_id = get_current_printer_agent_id();
                         if (m_agent)
                         {
                             obj->set_bind_status(m_agent->get_user_name(provider));

src/slic3r/GUI/DeviceCore/DevManager.h

@@ -74,7 +74,10 @@ public:
     void erase_user_machine(std::string dev_id) { userMachineList.erase(dev_id); }
     void clean_user_info(bool keep_local_selection = false);
 
-    void clear_other_devices();
+    // target_agent_id: id of the agent being swapped to (empty = no agent-mismatch check,
+    // just the original "drop Other Devices" behavior). Pass the incoming agent's id, not the
+    // live one - this runs before the live agent is repointed.
+    void clear_other_devices(const std::string& target_agent_id = "");
 
     void load_last_machine();
     void update_user_machine_list_info(const std::string& provider);
@@ -90,10 +93,15 @@ public:
 
     /* my machine*/
     MachineObject* get_my_machine(std::string dev_id);
-    std::map<std::string, MachineObject*> get_my_machine_list();
-    std::map<std::string, MachineObject*> get_my_cloud_machine_list();
+    std::map<std::string, MachineObject*> get_my_machine_list(const std::string& agent_id = "");
+    std::map<std::string, MachineObject*> get_my_cloud_machine_list(const std::string& agent_id = "");
     void modify_device_name(std::string dev_id, std::string dev_name, const std::string& provider);
 
+    // id of the currently live IPrinterAgent (IPrinterAgent::get_agent_info().id), or empty if
+    // m_agent has no printer agent set yet. Pass to get_my_machine_list()/get_my_cloud_machine_list()
+    // to scope results to the active agent.
+    std::string get_current_printer_agent_id() const;
+
     /* create machine or update machine properties */
     void on_machine_alive(std::string json_str);
     int query_bind_status(std::string& msg, const std::string& provider);

src/slic3r/GUI/DeviceManager.cpp

@@ -3,6 +3,7 @@
 #include "libslic3r/Time.hpp"
 #include "libslic3r/Thread.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
 #include "GuiColor.hpp"
 
 #include "GUI_App.hpp"
@@ -449,9 +450,7 @@ bool MachineObject::HasRecentLanMessage()
 
 std::string MachineObject::get_access_code() const
 {
-    if (get_user_access_code().empty())
-        return access_code;
-    return get_user_access_code();
+    return access_code;
 }
 
 void MachineObject::set_access_code(std::string code, bool only_refresh)
@@ -460,47 +459,46 @@ void MachineObject::set_access_code(std::string code, bool only_refresh)
     if (only_refresh) {
         AppConfig* config = GUI::wxGetApp().app_config;
         if (config) {
-            if (!code.empty()) {
-                GUI::wxGetApp().app_config->set_str("access_code", get_dev_id(), code);
-                DeviceManager::update_local_machine(*this);
+            if (is_lan_mode_printer()) {
+                // why: LAN codes are scoped via BBLocalMachine::access_code, keyed by dev_id and
+                // scoped by that record's own printer_agent_id field - see the matching comment
+                // on get_access_code_with_legacy_fallback() in DevManager.cpp - so binding this
+                // device under one printer agent doesn't silently read as already-bound under a
+                // different, independent one. Cloud devices (the else branch below) aren't
+                // scoped this way: they're never recalled from a stale local cache across a
+                // session boundary, since parse_user_print_info() always overwrites their code
+                // fresh from the cloud API's current response, so there's no cross-agent leakage
+                // risk to guard against there.
+                if (!code.empty()) {
+                    DeviceManager::update_local_machine(*this);
+                } else {
+                    // Only patch an existing record's code - don't persist a brand-new
+                    // never-bound entry just because set_access_code("") was called on it.
+                    const auto& machines = config->get_local_machines();
+                    auto        it       = machines.find(get_dev_id());
+                    if (it != machines.end()) {
+                        BBLocalMachine local_machine = it->second;
+                        local_machine.access_code    = "";
+                        config->update_local_machine(local_machine);
+                    }
+                    // Also clear the pre-scoping flat legacy key when unbinding under BBL, so an
+                    // old BBL-era code can't silently "re-bind" this device again via
+                    // get_access_code_with_legacy_fallback()'s legacy fallback.
+                    if (printer_agent_id == BBL_PRINTER_AGENT_ID || printer_agent_id.empty()) {
+                        config->erase("access_code", get_dev_id());
+                        config->erase("user_access_code", get_dev_id());
+                    }
+                }
             } else {
-                GUI::wxGetApp().app_config->erase("access_code", get_dev_id());
+                if (!code.empty())
+                    config->set_str("access_code", get_dev_id(), code);
+                else
+                    config->erase("access_code", get_dev_id());
             }
         }
     }
 }
 
-void MachineObject::erase_user_access_code()
-{
-    this->user_access_code = "";
-    AppConfig* config = GUI::wxGetApp().app_config;
-    if (config) {
-        GUI::wxGetApp().app_config->erase("user_access_code", get_dev_id());
-        //GUI::wxGetApp().app_config->save();
-    }
-}
-
-void MachineObject::set_user_access_code(std::string code, bool only_refresh)
-{
-    this->user_access_code = code;
-    if (only_refresh && !code.empty()) {
-        AppConfig* config = GUI::wxGetApp().app_config;
-        if (config && !code.empty()) {
-            GUI::wxGetApp().app_config->set_str("user_access_code", get_dev_id(), code);
-            DeviceManager::update_local_machine(*this);
-        }
-    }
-}
-
-std::string MachineObject::get_user_access_code() const
-{
-    AppConfig* config = GUI::wxGetApp().app_config;
-    if (config) {
-        return GUI::wxGetApp().app_config->get("user_access_code", get_dev_id());
-    }
-    return "";
-}
-
 std::string MachineObject::get_show_printer_type() const
 {
     std::string printer_type = this->printer_type;
@@ -2915,7 +2913,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                         std::string access_code = j_pre["system"]["access_code"].get<std::string>();
                         if (!access_code.empty()) {
                             set_access_code(access_code);
-                            set_user_access_code(access_code);
                         }
                     }
                 }

src/slic3r/GUI/DeviceManager.hpp

@@ -113,7 +113,6 @@ private:
     std::string dev_name;
     std::string dev_ip;
     std::string access_code;
-    std::string user_access_code;
 
     // type, time stamp, delay
     std::vector<std::tuple<std::string, uint64_t, uint64_t>> message_delay;
@@ -228,13 +227,18 @@ public:
     std::string get_access_code() const;
     void set_access_code(std::string code, bool only_refresh = true);
 
-    /*user access code*/
-    void set_user_access_code(std::string code, bool only_refresh = true);
-    void erase_user_access_code();
-    std::string get_user_access_code() const;
-
     //PRINTER_TYPE printer_type = PRINTER_3DPrinter_UKNOWN;
     std::string printer_type;       /* model_id */
+
+    // id of the IPrinterAgent that was used to discover or bind this device (IPrinterAgent::get_agent_info().id,
+    // e.g. "bbl"), stamped at creation time — not derived from get_agent(), since m_agent is a single
+    // process-wide NetworkAgent shared by every MachineObject and gets repointed on agent swap
+    // (see DeviceManager::set_agent()), so it can't tell which agent originally found this device.
+    // We persist this as well so that when the printer agent is swapped, we don't show unrelated devices,
+    // e.g. if the current printer agent is elegoo, we shouldn't show printers connected by BBL printer agent
+    // under local machines.
+    std::string printer_agent_id;
+
     std::string   get_show_printer_type() const;
     PrinterSeries get_printer_series() const;
     PrinterArch get_printer_arch() const;

src/slic3r/GUI/Downloader.cpp

@@ -134,7 +134,7 @@ void Downloader::start_download(const std::string& full_url)
     Plater* plater = wxGetApp().plater();
 
     mainframe->Freeze();
-    mainframe->select_tab((size_t)MainFrame::TabPosition::tp3DEditor);
+    mainframe->select_tab(TAB_ID_PREPARE);
     plater->select_view_3D("3D");
     plater->select_view("plate");
     plater->get_current_canvas3D()->zoom_to_bed();

src/slic3r/GUI/Field.cpp

@@ -331,8 +331,10 @@ void Field::PostInitialize()
                 }
 			    default: break;
 			    }
-			    if (tab_id >= 0)
-					wxGetApp().mainframe->select_tab(tab_id);
+			    if (tab_id >= 0) {
+					static constexpr const char* kShortcutTabIds[] = {TAB_ID_HOME, TAB_ID_PREPARE, TAB_ID_PREVIEW, TAB_ID_MONITOR};
+					wxGetApp().mainframe->select_tab(kShortcutTabIds[tab_id]);
+				}
 				if (tab_id > 0)
 					// tab panel should be focused for correct navigation between tabs
 				    wxGetApp().tab_panel()->SetFocus();

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2887,7 +2887,7 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
                 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*>(proj_cfg.option("wipe_tower_rotation_angle"))->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();
@@ -9196,7 +9196,7 @@ void GLCanvas3D::_render_imgui_select_plate_toolbar()
                                     view3d_canvas->get_gizmos_manager().reset_all_states(); // close all gizmos
                                     view3d_canvas->reload_scene(true);
                                 }
-                                app.mainframe->select_tab((size_t)MainFrame::TabPosition::tp3DEditor);
+                                app.mainframe->select_tab(TAB_ID_PREPARE);
                             }
                         }
                     });
@@ -10602,9 +10602,8 @@ void GLCanvas3D::_set_warning_notification(EWarning warning, bool state)
                         wxString    region = L"en";
                         if (language.find("zh") == 0)
                         	region = L"zh";
-                        // Use the generic dual-nozzle PLA+PETG guide rather than the H2D-specific page
-                        // so the link is relevant for all dual-extrusion printers, not just Bambu H2D. (#12073)
-                        wxGetApp().open_browser_with_warning_dialog(wxString::Format(L"https://wiki.bambulab.com/%s/filament-acc/filament/pla-and-petg-dual-extrusion", region));
+                        // Although this link looks like it's only for the H2D, its guidance is generic.
+                        wxGetApp().open_browser_with_warning_dialog(wxString::Format(L"https://wiki.bambulab.com/%s/filament-acc/filament/h2d-pla-and-petg-mutual-support", region));
                         return false;
                     });
             }
@@ -10738,24 +10737,14 @@ bool GLCanvas3D::is_flushing_matrix_error() {
     if (!Sidebar::should_show_SEMM_buttons())
         return false;
 
+    std::vector<int> plate_extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_extruders(true);
+    if (plate_extruders.size() < 2)
+        return false;
+
     const auto                &project_config = wxGetApp().preset_bundle->project_config;
     const std::vector<double> &config_matrix  = (project_config.option<ConfigOptionFloats>("flush_volumes_matrix"))->values;
     const std::vector<double> &config_multiplier = (project_config.option<ConfigOptionFloats>("flush_multiplier"))->values;
-
-    for (auto multiplier : config_multiplier) {
-        if (multiplier == 0) return true;
-    }
-
-    int  matrix_len = config_matrix.size() / config_multiplier.size();
-    int  row_len    = std::sqrt(matrix_len);
-    for (int i = 0; i < config_matrix.size(); i++)
-    {
-        int relative_id = i % matrix_len;
-        int row_id      = relative_id / row_len;
-        int col_id      = relative_id % row_len;
-        if (row_id != col_id && config_matrix[i] == 0) return true;
-    }
-    return false;
+    return has_zero_flush_volume_for_used_filaments(config_matrix, config_multiplier, plate_extruders);
 }
 
 bool GLCanvas3D::_is_any_volume_outside() const

src/slic3r/GUI/GUI_App.cpp

@@ -813,12 +813,12 @@ void GUI_App::post_init()
             m_open_method = "url";
         } else {
             if (this->init_params->input_gcode) {
-                mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+                mainframe->select_tab(TAB_ID_PREPARE);
                 plater_->select_view_3D("3D");
                 this->plater()->load_gcode(from_u8(this->init_params->input_files.front()));
                 m_open_method = "gcode";
             } else {
-                mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+                mainframe->select_tab(TAB_ID_PREPARE);
                 plater_->select_view_3D("3D");
                 wxArrayString input_files;
                 for (auto& file : this->init_params->input_files) {
@@ -852,7 +852,7 @@ void GUI_App::post_init()
         mainframe->Freeze();
 #endif
         plater_->canvas3D()->enable_render(false);
-        mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+        mainframe->select_tab(TAB_ID_PREPARE);
         plater_->select_view_3D("3D");
         //BBS init the opengl resource here
         if (!plater_->canvas3D()->get_wxglcanvas()->IsShownOnScreen() ||
@@ -890,9 +890,9 @@ void GUI_App::post_init()
             }
         }
         if (is_editor())
-            mainframe->select_tab(size_t(0));
+            mainframe->select_tab(TAB_ID_HOME);
         if (app_config->get("default_page") == "1")
-            mainframe->select_tab(size_t(1));
+            mainframe->select_tab(TAB_ID_PREPARE);
 #ifndef __linux__
         mainframe->Thaw();
 #endif
@@ -1829,10 +1829,10 @@ bool GUI_App::hot_reload_network_plugin()
     wxWindowDisabler disabler;
 
     if (mainframe) {
-        int current_tab = mainframe->m_tabpanel->GetSelection();
-        if (current_tab == MainFrame::TabPosition::tpMonitor) {
+        wxString current_tab = mainframe->m_tabpanel->GetSelectedPageName();
+        if (current_tab == TAB_ID_MONITOR) {
             BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": navigating away from Monitor tab before unload";
-            mainframe->m_tabpanel->SetSelection(MainFrame::TabPosition::tp3DEditor);
+            mainframe->m_tabpanel->SelectPageByName(TAB_ID_PREPARE);
         }
     }
 
@@ -2166,7 +2166,6 @@ void GUI_App::init_networking_callbacks()
                     obj->is_tunnel_mqtt = tunnel;
                     obj->command_request_push_all(true);
                     obj->command_get_version();
-                    obj->erase_user_access_code();
                     obj->command_get_access_code();
                     if (m_agent)
                         m_agent->install_device_cert(obj->get_dev_id(), obj->is_lan_mode_printer());
@@ -2216,7 +2215,6 @@ void GUI_App::init_networking_callbacks()
                                 wxString text;
                                 if (msg == "5") {
                                     obj->set_access_code("");
-                                    obj->erase_user_access_code();
                                     text = wxString::Format(_L("Incorrect password"));
                                     wxGetApp().show_dialog(text);
                                 } else {
@@ -2853,6 +2851,16 @@ void GUI_App::init_plugin_gui_wiring()
     plugin_mgr.subscribe_on_unload_callback([refresh_plugins_dialog](const std::string&) { refresh_plugins_dialog(); });
     plugin_mgr.subscribe_on_load_callback(NetworkAgentFactory::register_python_plugin);
     plugin_mgr.subscribe_on_unload_callback(NetworkAgentFactory::deregister_python_plugin);
+    plugin_mgr.subscribe_on_load_callback([](const std::string& plugin_key) {
+        if (wxTheApp == nullptr || wxGetApp().is_closing() || wxGetApp().mainframe == nullptr)
+            return;
+        wxGetApp().mainframe->plugin_pages().on_plugin_register(plugin_key);
+    });
+    plugin_mgr.subscribe_on_unload_callback([](const std::string& plugin_key) {
+        if (wxTheApp == nullptr || wxGetApp().is_closing() || wxGetApp().mainframe == nullptr)
+            return;
+        wxGetApp().mainframe->plugin_pages().on_plugin_deregister(plugin_key);
+    });
     plugin_mgr.subscribe_on_load_callback(refresh_printer_agent_dropdown_after_load);
     plugin_mgr.subscribe_on_unload_callback(switch_printer_agent_after_unload);
     plugin_mgr.subscribe_on_capability_load_callback(
@@ -2868,11 +2876,15 @@ void GUI_App::init_plugin_gui_wiring()
                     if (Plater* plater = wxGetApp().plater())
                         plater->revalidate_current_plate_if_plugins_missing();
                 });
+            if (capability.type == PluginCapabilityType::Pages && wxTheApp && !wxGetApp().is_closing() && wxGetApp().mainframe)
+                wxGetApp().mainframe->plugin_pages().on_cap_register(capability);
         });
     plugin_mgr.subscribe_on_capability_unload_callback(
         [refresh_plugins_dialog, switch_printer_agent_after_unload](const PluginCapabilityId& capability) {
             if (capability.type == PluginCapabilityType::PrinterConnection)
                 NetworkAgentFactory::deregister_python_printer_agent(capability.plugin_key, capability.name);
+            if (capability.type == PluginCapabilityType::Pages && wxTheApp && !wxGetApp().is_closing() && wxGetApp().mainframe)
+                wxGetApp().mainframe->plugin_pages().on_cap_deregister(capability);
             refresh_plugins_dialog();
             switch_printer_agent_after_unload(capability.plugin_key);
         });
@@ -3275,15 +3287,12 @@ bool GUI_App::on_init_inner()
         }
     } */
 
-    copy_network_if_available();
 
     if (scrn) {
         scrn->SetText(_L("Loading Plugins") + dots, 20);
         wxYield();
     }
 
-    on_init_network();
-
     // Initialize plugins after network then register on_load callbacks so once the plugin loads finish, it gets registered automatically.
     // initialize() also installs the libslic3r hooks (capability resolver,
     // slicing-pipeline dispatcher) via plugin_hooks::install() -- no
@@ -3312,6 +3321,9 @@ bool GUI_App::on_init_inner()
         }
     }
 
+    copy_network_if_available();
+    on_init_network();
+
     if (m_agent)
         plugin_mgr.set_cloud_agent(std::dynamic_pointer_cast<OrcaCloudServiceAgent>(m_agent->get_cloud_agent()));
 
@@ -3384,7 +3396,7 @@ bool GUI_App::on_init_inner()
     mainframe = new MainFrame();
     // hide settings tabs after first Layout
     if (is_editor()) {
-        mainframe->select_tab(size_t(0));
+        mainframe->select_tab(TAB_ID_HOME);
     }
 
     sidebar().obj_list()->init();
@@ -3939,7 +3951,13 @@ void GUI_App::set_live_printer_agent(std::shared_ptr<IPrinterAgent> agent)
         m_agent->set_user_selected_machine("");
         // note: belt-and-suspenders (precedent: DeviceManagerRefresher::on_timer)
         dev->OnSelectedMachineLost(); // why: clear stale sidebar sync-status / AMS
-        dev->clear_other_devices(); // why: drop stale LAN discoveries; keep My Devices
+        // why: drop stale LAN discoveries; keep My Devices, but only those belonging to the
+        // agent we're about to swap to, so a device stamped by the outgoing agent doesn't
+        // linger hidden - the new agent's start_discovery re-inserts and re-stamps it fresh.
+        // agent is null when clearing the live agent entirely (e.g. plugin unload); there's no
+        // target to filter against then, so fall back to the original "keep all My Devices"
+        // behavior rather than guessing.
+        dev->clear_other_devices(agent ? agent->get_agent_info().id : std::string());
     }
 
     m_agent->set_printer_agent(agent);
@@ -4592,7 +4610,7 @@ void GUI_App::recreate_GUI(const wxString &msg_name)
     mainframe = new MainFrame();
     if (is_editor())
         // hide settings tabs after first Layout
-        mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+        mainframe->select_tab(TAB_ID_PREPARE);
     // Propagate model objects to object list.
     sidebar().obj_list()->init();
     //sidebar().aux_list()->init_auxiliary();
@@ -6799,6 +6817,12 @@ void GUI_App::add_pending_vendor_preset(const std::pair<std::string, std::map<st
 
     // Add the corresponding vendor
     std::string vendor_name = PresetBundle::find_preset_vendor(inherits_name, type);
+    if (vendor_name.empty()) {
+        // No vendor ships this preset's parent. An unnamed entry here becomes an
+        // unnamed bundle at install time, which nothing can install.
+        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": no vendor carries " << inherits_name << ", skipping";
+        return;
+    }
     if (need_add_vendors.find(vendor_name) == need_add_vendors.end())
         need_add_vendors[vendor_name] = std::map<std::string, std::set<std::string>>();
 
@@ -8286,7 +8310,7 @@ bool GUI_App::show_modal_ip_address_enter_dialog(bool input_sn, wxString title)
                 wxGetApp().app_config->save();
 
                 obj->set_dev_ip(ip_address.ToStdString());
-                obj->set_user_access_code(access_code.ToStdString());
+                obj->set_access_code(access_code.ToStdString());
             }
         }
     });
@@ -9851,7 +9875,7 @@ bool GUI_App::check_url_association(std::wstring url_prefix, std::wstring& reg_b
 {
     reg_bin = L"";
 #ifdef WIN32
-    wxRegKey key_full(wxRegKey::HKCU, "Software\\Classes\\" + url_prefix + "\\shell\\open\\command");
+    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
     if (!key_full.Exists()) {
         return false;
     }
@@ -9877,8 +9901,8 @@ void GUI_App::associate_url(std::wstring url_prefix)
 
     wxString key_string = "\"" + wbinary + "\" \"%1\"";
 
-    wxRegKey key_first(wxRegKey::HKCU, "Software\\Classes\\" + url_prefix);
-    wxRegKey key_full(wxRegKey::HKCU, "Software\\Classes\\" + url_prefix + "\\shell\\open\\command");
+    wxRegKey key_first(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix);
+    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
     if (!key_first.Exists()) {
         key_first.Create(false);
     }
@@ -9898,7 +9922,7 @@ void GUI_App::disassociate_url(std::wstring url_prefix)
 #ifdef WIN32
     if (is_running_in_msix())
         return;
-    wxRegKey key_full(wxRegKey::HKCU, "Software\\Classes\\" + url_prefix + "\\shell\\open\\command");
+    wxRegKey key_full(wxRegKey::HKCU, L"Software\\Classes\\" + url_prefix + L"\\shell\\open\\command");
     if (!key_full.Exists()) {
         return;
     }

src/slic3r/GUI/HMS.cpp

@@ -1,6 +1,7 @@
 #include "HMS.hpp"
 
 #include "GUI.hpp"
+#include "GUI_App.hpp"
 #include "DeviceManager.hpp"
 #include "DeviceCore/DevManager.h"
 #include "DeviceCore/DevUtil.h"

src/slic3r/GUI/HMS.hpp

@@ -1,7 +1,6 @@
 #ifndef slic3r_HMS_hpp_
 #define slic3r_HMS_hpp_
 
-#include "GUI_App.hpp"
 #include "GUI.hpp"
 #include "I18N.hpp"
 #include "Widgets/Label.hpp"
@@ -11,7 +10,11 @@
 #include "slic3r/Utils/Http.hpp"
 #include "libslic3r/Thread.hpp"
 #include "nlohmann/json.hpp"
+#include <ctime>
 #include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 namespace Slic3r {
 
@@ -26,12 +29,12 @@ namespace GUI {
 class HMSQuery {
 
 protected:
-    std::unordered_map<string, json> m_hms_info_jsons;  // key-> device id type, the first three digits of SN number
-    std::unordered_map<string, json> m_hms_action_jsons;// key-> device id type
+    std::unordered_map<std::string, nlohmann::json> m_hms_info_jsons;  // key-> device id type, the first three digits of SN number
+    std::unordered_map<std::string, nlohmann::json> m_hms_action_jsons;// key-> device id type
     std::unordered_map<wxString, wxImage> m_hms_local_images; // key-> image name
     mutable std::mutex m_hms_mutex;
 
-    std::unordered_map<string, time_t> m_cloud_hms_last_update_time;
+    std::unordered_map<std::string, std::time_t> m_cloud_hms_last_update_time;
 
 public:
     HMSQuery() { }
@@ -61,18 +64,18 @@ private:
     // load hms
     void init_hms_info(const std::string& dev_type_id);
     void copy_from_data_dir_to_local();
-    int  download_hms_related(const std::string& hms_type, const std::string& dev_id_type, json* receive_json);
-    int  load_from_local(const std::string& hms_type, const std::string& dev_id_type, json* receive_json, std::string& version_info);
-    int  save_to_local(std::string lang, std::string hms_type, std::string dev_id_type, json save_json);
+    int  download_hms_related(const std::string& hms_type, const std::string& dev_id_type, nlohmann::json* receive_json);
+    int  load_from_local(const std::string& hms_type, const std::string& dev_id_type, nlohmann::json* receive_json, std::string& version_info);
+    int  save_to_local(std::string lang, std::string hms_type, std::string dev_id_type, nlohmann::json save_json);
     std::string get_hms_file(std::string hms_type, std::string lang = std::string("en"), std::string dev_id_type = "");
 
     // internal query
-    string    get_dev_id_type(const MachineObject* obj) const;
-    wxString _query_hms_msg(const string& dev_id_type, const string& long_error_code, const string& lang_code = std::string("en"));
+    std::string get_dev_id_type(const MachineObject* obj) const;
+    wxString _query_hms_msg(const std::string& dev_id_type, const std::string& long_error_code, const std::string& lang_code = std::string("en"));
 
-    bool     _is_internal_error(const string &dev_id_type, const string &long_error_code, const string &lang_code = std::string("en"));
-    wxString _query_error_msg(const string& dev_id_type, const std::string& long_error_code, const std::string& lang_code = std::string("en"));
-    wxString _query_error_image_action(const string& dev_id_type, const std::string& long_error_code, std::vector<int>& button_action);
+    bool     _is_internal_error(const std::string &dev_id_type, const std::string &long_error_code, const std::string &lang_code = std::string("en"));
+    wxString _query_error_msg(const std::string& dev_id_type, const std::string& long_error_code, const std::string& lang_code = std::string("en"));
+    wxString _query_error_image_action(const std::string& dev_id_type, const std::string& long_error_code, std::vector<int>& button_action);
 };
 
 int get_hms_info_version(std::string &version);
@@ -85,4 +88,4 @@ std::string get_error_message(int error_code);
 }
 
 
-#endif
+#endif

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -2809,12 +2809,26 @@ void ImGuiWrapper::init_font(bool compress)
         }
     }
 
+    if (m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesThai()) {
+        ImFontConfig fallback_cfg = cfg;
+        fallback_cfg.MergeMode = true;
+        static constexpr ImWchar celsius_range[] = { 0x2103, 0x2103, 0 };
+        io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Regular.ttf").c_str(), m_font_size, &fallback_cfg, celsius_range);
+    }
+
     bold_font        = io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/" + font_name_bold).c_str(), m_font_size, &cfg, ranges.Data);
     if (bold_font == nullptr) {
         bold_font = io.Fonts->AddFontDefault();
         if (bold_font == nullptr) { throw Slic3r::RuntimeError("ImGui: Could not load deafult font"); }
     }
 
+    if (m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesThai()) {
+        ImFontConfig fallback_cfg = cfg;
+        fallback_cfg.MergeMode = true;
+        static constexpr ImWchar celsius_range[] = { 0x2103, 0x2103, 0 };
+        io.Fonts->AddFontFromFileTTF((Slic3r::resources_dir() + "/fonts/HarmonyOS_Sans_SC_Bold.ttf").c_str(), m_font_size, &fallback_cfg, celsius_range);
+    }
+
     if (m_glyph_ranges == ImGui::GetIO().Fonts->GetGlyphRangesThai()) {
         default_font->Scale *= 1.25f;
         bold_font->Scale *= 1.25f;

src/slic3r/GUI/Jobs/CreateFontStyleImagesJob.cpp

@@ -45,24 +45,26 @@ void CreateFontStyleImagesJob::process(Ctl &ctl)
         for (const ExPolygon &shape : shapes)
             bounding_box.merge(BoundingBox(shape.contour.points));
         for (ExPolygon &shape : shapes) shape.translate(-bounding_box.min);
-        
-        // calculate conversion from FontPoint to screen pixels by size of font
-        double scale = get_text_shape_scale(item.prop, *item.font.font_file) * m_input.ppm;
-        scales[index] = scale;
 
-        //double scale = font_prop.size_in_mm * SCALING_FACTOR;
-        BoundingBoxf bb2(bounding_box.min.cast<double>(),
-                         bounding_box.max.cast<double>());
+        if (bounding_box.size().x() < 1 || bounding_box.size().y() < 1)
+            continue; // or however the font job's degenerate-box case is handled
+
+        // Normalize to fit max_size, exactly like CreateFontImageJob does against m_input.size.
+        // Fit by height (matches row height), then clamp width if needed.
+        constexpr float preview_padding_px = 2.f; // margin for AA sampling, tune to your AA kernel radius
+
+        double scale = m_input.max_size.y() / (double) bounding_box.size().y();
+        BoundingBoxf bb2(bounding_box.min.cast<double>(), bounding_box.max.cast<double>());
         bb2.scale(scale);
-        image.tex_size.x = std::ceil(bb2.max.x() - bb2.min.x());
-        image.tex_size.y = std::ceil(bb2.max.y() - bb2.min.y());
 
-        // crop image width
-        if (image.tex_size.x > m_input.max_size.x()) 
+        // crop width only if the (now height-normalized) text is too wide
+        image.tex_size.x = std::ceil(bb2.max.x() - bb2.min.x()) + 2 * preview_padding_px;
+        image.tex_size.y = std::ceil(bb2.max.y() - bb2.min.y()) + 2 * preview_padding_px;
+
+        if (image.tex_size.x > m_input.max_size.x())
             image.tex_size.x = m_input.max_size.x();
-        // crop image height
-        if (image.tex_size.y > m_input.max_size.y())
-            image.tex_size.y = m_input.max_size.y();
+
+        scales[index] = scale;
     }
 
     // arrange bounding boxes

src/slic3r/GUI/MainFrame.cpp

@@ -493,9 +493,8 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
     });
 
     //BBS
-    Bind(EVT_SELECT_TAB, [this](wxCommandEvent&evt) {
-        TabPosition pos = (TabPosition)evt.GetInt();
-        m_tabpanel->SetSelection(pos);
+    Bind(EVT_SELECT_TAB, [this](wxCommandEvent& evt) {
+        m_tabpanel->SelectPageByName(evt.GetString());
     });
 
     Bind(EVT_SYNC_CLOUD_PRESET, &MainFrame::on_select_default_preset, this);
@@ -702,7 +701,7 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
             }
             return;}
 #endif
-        if (evt.CmdDown() && evt.GetKeyCode() == 'R') { if (m_slice_enable) { wxGetApp().plater()->update(true, true); wxPostEvent(m_plater, SimpleEvent(EVT_GLTOOLBAR_SLICE_PLATE)); this->m_tabpanel->SetSelection(tpPreview); } return; }
+        if (evt.CmdDown() && evt.GetKeyCode() == 'R') { if (m_slice_enable) { wxGetApp().plater()->update(true, true); wxPostEvent(m_plater, SimpleEvent(EVT_GLTOOLBAR_SLICE_PLATE)); this->m_tabpanel->SelectPageByName(TAB_ID_PREVIEW); } return; }
         if (evt.CmdDown() && evt.ShiftDown() && evt.GetKeyCode() == 'G') {
             m_plater->apply_background_progress();
             m_print_enable = get_enable_print_status();
@@ -723,7 +722,7 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
         if (evt.CmdDown() && evt.ShiftDown() && evt.GetKeyCode() == 'S') { if (can_save_as()) m_plater->save_project(true); return;}
         else if (evt.CmdDown() && evt.GetKeyCode() == 'S') { if (can_save()) m_plater->save_project(); return;}
         if (evt.CmdDown() && evt.GetKeyCode() == 'F') {
-            if (m_plater && (m_tabpanel->GetSelection() == TabPosition::tp3DEditor || m_tabpanel->GetSelection() == TabPosition::tpPreview)) {
+            if (m_plater && is_prepare_or_preview_tab()) {
                 m_plater->sidebar().can_search();
             }
         }
@@ -1007,8 +1006,8 @@ void MainFrame::update_layout()
     m_layout = layout;
 
     // From the very beginning the Print settings should be selected
-    //m_last_selected_tab = m_layout == ESettingsLayout::Dlg ? 0 : 1;
-    m_last_selected_tab = 1;
+    //m_last_selected_tab = m_layout == ESettingsLayout::Dlg ? TAB_ID_HOME : TAB_ID_PREPARE;
+    m_last_selected_tab = TAB_ID_PREPARE;
 
     // Set new settings
     switch (m_layout)
@@ -1016,14 +1015,18 @@ void MainFrame::update_layout()
     case ESettingsLayout::Old:
     {
         m_plater->Reparent(m_tabpanel);
-        m_tabpanel->InsertPage(tp3DEditor, m_plater, _L("Prepare"), std::string("tab_3d_active"), std::string("tab_3d_active"), false);
-        m_tabpanel->InsertPage(tpPreview, m_plater, _L("Preview"), std::string("tab_preview_active"), std::string("tab_preview_active"), false);
+        // Right after Home — or first, when there is no Home tab (PositionAfter() would
+        // append instead, and by now the other built-in tabs are already in place).
+        const int home_idx = m_tabpanel->FindPageByName(TAB_ID_HOME);
+        const size_t prepare_pos = (home_idx == wxNOT_FOUND) ? 0 : static_cast<size_t>(home_idx) + 1;
+        m_tabpanel->InsertPage(prepare_pos, TAB_ID_PREPARE, m_plater, _L("Prepare"), "tab_3d_active");
+        m_tabpanel->InsertPage(prepare_pos + 1, TAB_ID_PREVIEW, m_plater, _L("Preview"), "tab_preview_active");
         m_main_sizer->Add(m_tabpanel, 1, wxEXPAND | wxTOP, 0);
 
         m_tabpanel->Bind(wxCUSTOMEVT_NOTEBOOK_SEL_CHANGED, [this](wxCommandEvent& evt)
         {
             // jump to 3deditor under preview_only mode
-            if (evt.GetId() == tp3DEditor){
+            if (evt.GetId() == m_tabpanel->FindPageByName(TAB_ID_PREPARE)) {
                 Sidebar& sidebar = GUI::wxGetApp().sidebar();
                 if (sidebar.need_auto_sync_after_connect_printer()) {
                     sidebar.set_need_auto_sync_after_connect_printer(false);
@@ -1107,6 +1110,9 @@ void MainFrame::update_edge_panels()
 void MainFrame::shutdown()
 {
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "MainFrame::shutdown enter";
+    if (m_project != nullptr)
+        m_project->shutdown();
+    m_plugin_pages.shutdown();
 #ifdef __WXGTK__
     // Edge panels are child windows — wxWidgets destroys them automatically.
     m_edge_bottom = nullptr;
@@ -1252,15 +1258,14 @@ void MainFrame::init_tabpanel() {
 #endif
         //BBS
         wxWindow* panel = m_tabpanel->GetCurrentPage();
-        int sel = m_tabpanel->GetSelection();
         //wxString page_text = m_tabpanel->GetPageText(sel);
-        m_last_selected_tab = m_tabpanel->GetSelection();
+        m_last_selected_tab = m_tabpanel->GetSelectedPageName();
         if (panel == m_plater) {
-            if (sel == tp3DEditor) {
+            if (m_last_selected_tab == TAB_ID_PREPARE) {
                 wxPostEvent(m_plater, SimpleEvent(EVT_GLVIEWTOOLBAR_3D));
                 m_param_panel->OnActivate();
             }
-            else if (sel == tpPreview) {
+            else if (m_last_selected_tab == TAB_ID_PREVIEW) {
                 m_plater->reset_check_status();
                 if (!m_plater->check_ams_status(m_slice_select == eSliceAll))
                     return;
@@ -1275,7 +1280,7 @@ void MainFrame::init_tabpanel() {
             //monitor
         }
 #ifndef __APPLE__
-        if (sel == tp3DEditor) {
+        if (m_last_selected_tab == TAB_ID_PREPARE) {
             m_topbar->EnableUndoRedoItems();
         }
         else {
@@ -1285,34 +1290,16 @@ void MainFrame::init_tabpanel() {
 
         if (panel)
             panel->SetFocus();
-
-        /*switch (sel) {
-        case TabPosition::tpHome:
-            show_option(false);
-            break;
-        case TabPosition::tp3DEditor:
-            show_option(true);
-            break;
-        case TabPosition::tpPreview:
-            show_option(true);
-            break;
-        case TabPosition::tpMonitor:
-            show_option(false);
-            break;
-        default:
-            show_option(false);
-            break;
-        }*/
     });
 
     if (wxGetApp().is_editor()) {
         m_webview         = new WebViewPanel(m_tabpanel);
         Bind(EVT_LOAD_URL, [this](wxCommandEvent &evt) {
             wxString url = evt.GetString();
-            select_tab(MainFrame::tpHome);
+            select_tab(TAB_ID_HOME);
             m_webview->load_url(url);
         });
-        m_tabpanel->AddPage(m_webview, "", "tab_home_active", "tab_home_active", false);
+        m_tabpanel->AddPage(TAB_ID_HOME, m_webview, "", "tab_home_active");
         m_param_panel = new ParamsPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL);
     }
 
@@ -1327,7 +1314,7 @@ void MainFrame::init_tabpanel() {
         //BBS add pages
     m_monitor = new MonitorPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
     m_monitor->SetBackgroundColour(*wxWHITE);
-    m_tabpanel->AddPage(m_monitor, _L("Device"), std::string("tab_monitor_active"), std::string("tab_monitor_active"), false);
+    m_tabpanel->AddPage(TAB_ID_MONITOR, m_monitor, _L("Device"), "tab_monitor_active");
 
     m_printer_view = new PrinterWebView(m_tabpanel);
     Bind(EVT_LOAD_PRINTER_URL, [this](LoadPrinterViewEvent &evt) {
@@ -1342,16 +1329,20 @@ void MainFrame::init_tabpanel() {
         m_multi_machine = new MultiMachinePage(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
         m_multi_machine->SetBackgroundColour(*wxWHITE);
         // TODO: change the bitmap
-        m_tabpanel->AddPage(m_multi_machine, _L("Multi-device"), std::string("tab_multi_active"), std::string("tab_multi_active"), false);
+        m_tabpanel->AddPage(TAB_ID_MULTI_DEVICE, m_multi_machine, _L("Multi-device"), "tab_multi_active");
     }
 
     m_project = new ProjectPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
     m_project->SetBackgroundColour(*wxWHITE);
-    m_tabpanel->AddPage(m_project, _L("Project"), std::string("tab_auxiliary_active"), std::string("tab_auxiliary_active"), false);
+    m_tabpanel->AddPage(TAB_ID_PROJECT, m_project, _L("Project"), "tab_auxiliary_active");
 
     m_calibration = new CalibrationPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
     m_calibration->SetBackgroundColour(*wxWHITE);
-    m_tabpanel->AddPage(m_calibration, _L("Calibration"), std::string("tab_calibration_active"), std::string("tab_calibration_active"), false);
+    m_tabpanel->AddPage(TAB_ID_CALIBRATION, m_calibration, _L("Calibration"), "tab_calibration_active");
+
+    // Plugin pages are appended after the built-in tabs; their ids are namespaced
+    // (plugin.<plugin_key>.<name>) so they can't collide with the built-in TAB_ID_* constants.
+    m_plugin_pages.initialize(m_tabpanel);
 
     if (m_plater) {
         // load initial config
@@ -1373,10 +1364,15 @@ void MainFrame::show_device(bool should_use_native) {
 
     const bool use_printer_agents = wxGetApp().app_config->get_bool("use_printer_agents");
 
-    // The legacy page is appended when printer agents are enabled. Remove that
-    // extra page before switching back to the normal native/legacy layout.
-    if (!use_printer_agents) {
-        if ((idx = m_tabpanel->FindPage(m_printer_view)) != wxNOT_FOUND && idx != tpMonitor) {
+    // The web Device page is the extra tab printer-agents mode shows alongside the native one.
+    // Printers that drive the native Bambu device tab have nothing to put in it, so they don't
+    // get it — otherwise a Bambu user sees two Device tabs, one of them permanently empty.
+    const bool want_web_device_tab = use_printer_agents && wxGetApp().preset_bundle != nullptr &&
+                                     !wxGetApp().preset_bundle->use_bbl_device_tab();
+
+    // Remove the extra page before switching to any layout that shouldn't have it.
+    if (!want_web_device_tab) {
+        if ((idx = m_tabpanel->FindPageByName(TAB_ID_MONITOR_WEB)) != wxNOT_FOUND) {
             m_printer_view->Show(false);
             m_tabpanel->RemovePage(idx);
         }
@@ -1394,8 +1390,8 @@ void MainFrame::show_device(bool should_use_native) {
                 m_tabpanel->RemovePage(idx);
             }
             m_monitor->Show(false);
-            m_tabpanel->InsertPage(tpMonitor, m_monitor, _L("Device"), std::string("tab_monitor_active"),
-                                   std::string("tab_monitor_active"));
+            m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_PREVIEW}), TAB_ID_MONITOR, m_monitor,
+                                   _L("Device"), "tab_monitor_active");
         }
 
         if (m_printer_view == nullptr) {
@@ -1416,28 +1412,31 @@ void MainFrame::show_device(bool should_use_native) {
             // TODO: change the bitmap
             if (m_tabpanel->FindPage(m_multi_machine) == wxNOT_FOUND) {
                 m_multi_machine->Show(false);
-                m_tabpanel->InsertPage(tpMultiDevice, m_multi_machine, _L("Multi-device"), std::string("tab_multi_active"),
-                                       std::string("tab_multi_active"), false);
+                // Past the web Device tab when it is already there, so enabling multi-machine
+                // later can't wedge this page between the two Device tabs.
+                m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_MONITOR_WEB, TAB_ID_MONITOR}),
+                                       TAB_ID_MULTI_DEVICE, m_multi_machine, _L("Multi-device"), "tab_multi_active");
             }
         }
         if (!m_calibration) {
             m_calibration = new CalibrationPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
             m_calibration->SetBackgroundColour(*wxWHITE);
         }
-        // Calibration is always the last page, so don't use InsertPage here. Otherwise, if multi_machine page is not enabled,
-        // the calibration tab won't be properly added as well, due to the TabPosition::tpCalibration no longer matches the real tab position.
         if (m_tabpanel->FindPage(m_calibration) == wxNOT_FOUND) {
             m_calibration->Show(false);
-            m_tabpanel->AddPage(m_calibration, _L("Calibration"), std::string("tab_calibration_active"),
-                                std::string("tab_calibration_active"), false);
+            m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_PROJECT}), TAB_ID_CALIBRATION, m_calibration,
+                                   _L("Calibration"), "tab_calibration_active");
         }
 
-        if ((idx = m_tabpanel->FindPage(m_printer_view)) == wxNOT_FOUND) {
-            m_printer_view->Show(false);
-            m_tabpanel->AddPage(m_printer_view, _L("Device (legacy)"), std::string("tab_monitor_active"),
-                                std::string("tab_monitor_active"), false);
-        } else {
-            m_tabpanel->SetPageText(idx, _L("Device (legacy)"));
+        if (want_web_device_tab) {
+            if ((idx = m_tabpanel->FindPage(m_printer_view)) == wxNOT_FOUND) {
+                m_printer_view->Show(false);
+                // Immediately right of the native Device tab, not at the end of the tab bar.
+                m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_MONITOR}), TAB_ID_MONITOR_WEB,
+                                       m_printer_view, _L("Device (Web)"), "tab_monitor_active");
+            } else {
+                m_tabpanel->SetPageText(idx, _L("Device (Web)"));
+            }
         }
 
 #ifdef _MSW_DARK_MODE
@@ -1445,6 +1444,7 @@ void MainFrame::show_device(bool should_use_native) {
 #endif // _MSW_DARK_MODE
 
         fit_tab_labels(); // ORCA on printer change
+        m_plugin_pages.relayout(); // re-sync plugin tabs against the native tabs just mutated above
 
         return;
     }
@@ -1466,7 +1466,8 @@ void MainFrame::show_device(bool should_use_native) {
             m_monitor->SetBackgroundColour(*wxWHITE);
         }
         m_monitor->Show(false);
-        m_tabpanel->InsertPage(tpMonitor, m_monitor, _L("Device"), std::string("tab_monitor_active"), std::string("tab_monitor_active"));
+        m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_PREVIEW}), TAB_ID_MONITOR, m_monitor,
+                               _L("Device"), "tab_monitor_active");
 
         if (wxGetApp().is_enable_multi_machine()) {
             if (!m_multi_machine) {
@@ -1475,18 +1476,18 @@ void MainFrame::show_device(bool should_use_native) {
             }
             // TODO: change the bitmap
             m_multi_machine->Show(false);
-            m_tabpanel->InsertPage(tpMultiDevice, m_multi_machine, _L("Multi-device"), std::string("tab_multi_active"),
-                                   std::string("tab_multi_active"), false);
+            m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_MONITOR}), TAB_ID_MULTI_DEVICE, m_multi_machine,
+                                   _L("Multi-device"), "tab_multi_active");
         }
         if (!m_calibration) {
             m_calibration = new CalibrationPanel(m_tabpanel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
             m_calibration->SetBackgroundColour(*wxWHITE);
         }
         m_calibration->Show(false);
-        // Calibration is always the last page, so don't use InsertPage here. Otherwise, if multi_machine page is not enabled,
-        // the calibration tab won't be properly added as well, due to the TabPosition::tpCalibration no longer matches the real tab position.
-        m_tabpanel->AddPage(m_calibration, _L("Calibration"), std::string("tab_calibration_active"),
-                               std::string("tab_calibration_active"), false);
+        // Last of the built-in tabs, but plugin tabs already sit past it — anchor rather than
+        // append, so its position doesn't depend on the relayout() below running afterwards.
+        m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_PROJECT}), TAB_ID_CALIBRATION, m_calibration,
+                               _L("Calibration"), "tab_calibration_active");
 
 #ifdef _MSW_DARK_MODE
         wxGetApp().UpdateDarkUIWin(this);
@@ -1519,10 +1520,17 @@ void MainFrame::show_device(bool should_use_native) {
             });
         }
         m_printer_view->Show(false);
-        m_tabpanel->InsertPage(tpMonitor, m_printer_view, _L("Device"), std::string("tab_monitor_active"),
-                               std::string("tab_monitor_active"));
+        m_tabpanel->InsertPage(m_tabpanel->PositionAfter({TAB_ID_PREVIEW}), TAB_ID_MONITOR, m_printer_view,
+                               _L("Device"), "tab_monitor_active");
     }
     fit_tab_labels(); // ORCA on printer change
+    m_plugin_pages.relayout(); // re-sync plugin tabs against the native tabs just mutated above
+}
+
+bool MainFrame::is_prepare_or_preview_tab() const
+{
+    const wxString tab = m_tabpanel->GetSelectedPageName();
+    return tab == TAB_ID_PREPARE || tab == TAB_ID_PREVIEW;
 }
 
 void MainFrame::fit_tab_labels()
@@ -1554,7 +1562,7 @@ void MainFrame::fit_tab_labels()
 bool MainFrame::preview_only_hint()
 {
     if (m_plater && (m_plater->only_gcode_mode() || (m_plater->using_exported_file()))) {
-        BOOST_LOG_TRIVIAL(info) << boost::format("skipped tab switch from %1% to %2% in preview mode")%m_tabpanel->GetSelection() %tp3DEditor;
+        BOOST_LOG_TRIVIAL(info) << boost::format("skipped tab switch from %1% to %2% in preview mode")%m_tabpanel->GetSelectedPageName() %wxString(TAB_ID_PREPARE);
 
         ConfirmBeforeSendDialog confirm_dlg(this, wxID_ANY, _L("Warning"));
         confirm_dlg.Bind(EVT_SECONDARY_CHECK_CONFIRM, [this](wxCommandEvent& e) {
@@ -1872,22 +1880,22 @@ bool MainFrame::can_clone() const {
 
 bool MainFrame::can_select() const
 {
-    return (m_plater != nullptr) && (m_tabpanel->GetSelection() == TabPosition::tp3DEditor) && !m_plater->model().objects.empty();
+    return (m_plater != nullptr) && (m_tabpanel->GetSelectedPageName() == TAB_ID_PREPARE) && !m_plater->model().objects.empty();
 }
 
 bool MainFrame::can_deselect() const
 {
-    return (m_plater != nullptr) && (m_tabpanel->GetSelection() == TabPosition::tp3DEditor) && !m_plater->is_selection_empty();
+    return (m_plater != nullptr) && (m_tabpanel->GetSelectedPageName() == TAB_ID_PREPARE) && !m_plater->is_selection_empty();
 }
 
 bool MainFrame::can_delete() const
 {
-    return (m_plater != nullptr) && (m_tabpanel->GetSelection() == TabPosition::tp3DEditor) && !m_plater->is_selection_empty();
+    return (m_plater != nullptr) && (m_tabpanel->GetSelectedPageName() == TAB_ID_PREPARE) && !m_plater->is_selection_empty();
 }
 
 bool MainFrame::can_delete_all() const
 {
-    return (m_plater != nullptr) && (m_tabpanel->GetSelection() == TabPosition::tp3DEditor) && !m_plater->model().objects.empty();
+    return (m_plater != nullptr) && (m_tabpanel->GetSelectedPageName() == TAB_ID_PREPARE) && !m_plater->model().objects.empty();
 }
 
 bool MainFrame::can_reslice() const
@@ -1996,7 +2004,7 @@ wxBoxSizer* MainFrame::create_side_tools()
                     wxPostEvent(m_plater, SimpleEvent(EVT_GLTOOLBAR_SLICE_ALL));
                 else
                     wxPostEvent(m_plater, SimpleEvent(EVT_GLTOOLBAR_SLICE_PLATE));
-                this->m_tabpanel->SetSelection(tpPreview);
+                this->m_tabpanel->SelectPageByName(TAB_ID_PREVIEW);
             }
         });
 
@@ -3143,7 +3151,7 @@ void MainFrame::init_menubar_as_editor()
                 wxGetApp().app_config->set_bool("auto_perspective", !wxGetApp().app_config->get_bool("auto_perspective"));
                 m_plater->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT));
             },
-            this, [this]() { return m_tabpanel->GetSelection() == TabPosition::tp3DEditor || m_tabpanel->GetSelection() == TabPosition::tpPreview; },
+            this, [this]() { return is_prepare_or_preview_tab(); },
             [this]() { return wxGetApp().app_config->get_bool("auto_perspective"); }, this);
 
         viewMenu->AppendSeparator();
@@ -3152,7 +3160,7 @@ void MainFrame::init_menubar_as_editor()
                 wxGetApp().toggle_show_gcode_window();
                 m_plater->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT));
             },
-            this, [this]() { return m_tabpanel->GetSelection() == tpPreview; },
+            this, [this]() { return m_tabpanel->GetSelectedPageName() == TAB_ID_PREVIEW; },
             [this]() { return wxGetApp().show_gcode_window(); }, this);
 
         append_menu_check_item(
@@ -3161,7 +3169,7 @@ void MainFrame::init_menubar_as_editor()
                 wxGetApp().toggle_show_3d_navigator();
                 m_plater->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT));
             },
-            this, [this]() { return m_tabpanel->GetSelection() == TabPosition::tp3DEditor || m_tabpanel->GetSelection() == TabPosition::tpPreview; },
+            this, [this]() { return is_prepare_or_preview_tab(); },
             [this]() { return wxGetApp().show_3d_navigator(); }, this);
 
         append_menu_check_item(viewMenu, wxID_ANY, _L("Show Gridlines"), _L("Show Gridlines on plate"),
@@ -3169,15 +3177,14 @@ void MainFrame::init_menubar_as_editor()
                 wxGetApp().toggle_show_plate_gridlines();
                 m_plater->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT));
             }, this,
-            [this]() { return m_tabpanel->GetSelection() == TabPosition::tp3DEditor || m_tabpanel->GetSelection() == TabPosition::tpPreview; },
+            [this]() { return is_prepare_or_preview_tab(); },
             [this]() { return wxGetApp().show_plate_gridlines(); }, this);
 
         append_menu_item(
             viewMenu, wxID_ANY, _L("Reset Window Layout"), _L("Reset to default window layout"),
             [this](wxCommandEvent&) { m_plater->reset_window_layout(); }, "", this,
             [this]() {
-                return (m_tabpanel->GetSelection() == TabPosition::tp3DEditor || m_tabpanel->GetSelection() == TabPosition::tpPreview) &&
-                       m_plater->is_sidebar_enabled();
+                return is_prepare_or_preview_tab() && m_plater->is_sidebar_enabled();
             },
             this);
 
@@ -3199,7 +3206,7 @@ void MainFrame::init_menubar_as_editor()
                 wxGetApp().toggle_show_outline();
                 m_plater->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT));
             },
-            this, [this]() { return m_tabpanel->GetSelection() == TabPosition::tp3DEditor; },
+            this, [this]() { return m_tabpanel->GetSelectedPageName() == TAB_ID_PREPARE; },
             [this]() { return wxGetApp().show_outline(); }, this);
 
         /*viewMenu->AppendSeparator();
@@ -4000,13 +4007,16 @@ void MainFrame::select_tab(wxPanel* panel)
         wxGetApp().params_dialog()->Popup();
         return;
     }
+    // Not panel->GetName(): Prepare and Preview share the single m_plater window, so the
+    // window has no one correct name. The slot -> id lookup is the only correct resolution.
     int page_idx = m_tabpanel->FindPage(panel);
-    if (page_idx == tp3DEditor && m_tabpanel->GetSelection() == tpPreview)
+    wxString page_name = (page_idx == wxNOT_FOUND) ? wxString() : m_tabpanel->GetPageName(static_cast<size_t>(page_idx));
+    if (page_name == TAB_ID_PREPARE && m_tabpanel->GetSelectedPageName() == TAB_ID_PREVIEW)
         return;
     //BBS GUI refactor: remove unused layout new/dlg
     /*if (page_idx != wxNOT_FOUND && m_layout == ESettingsLayout::Dlg)
         page_idx++;*/
-    select_tab(size_t(page_idx));
+    select_tab(page_name);
 }
 
 //BBS
@@ -4014,7 +4024,7 @@ void MainFrame::jump_to_monitor(std::string dev_id)
 {
     if(!m_monitor)
         return;
-    m_tabpanel->SetSelection(tpMonitor);
+    m_tabpanel->SelectPageByName(TAB_ID_MONITOR);
     if (!dev_id.empty()) {
         ((MonitorPanel*)m_monitor)->select_machine(dev_id);
     }
@@ -4024,26 +4034,26 @@ void MainFrame::jump_to_multipage()
 {
     if(!m_multi_machine)
         return;
-    m_tabpanel->SetSelection(tpMultiDevice);
+    m_tabpanel->SelectPageByName(TAB_ID_MULTI_DEVICE);
     ((MultiMachinePage*)m_multi_machine)->jump_to_send_page();
 }
 
 
 //BBS GUI refactor: remove unused layout new/dlg
-void MainFrame::select_tab(size_t tab/* = size_t(-1)*/)
+void MainFrame::select_tab(const wxString& id/* = wxString()*/)
 {
     //bool tabpanel_was_hidden = false;
 
     // Controls on page are created on active page of active tab now.
     // We should select/activate tab before its showing to avoid an UI-flickering
-    auto select = [this, tab](bool was_hidden) {
-        // when tab == -1, it means we should show the last selected tab
+    auto select = [this, id](bool was_hidden) {
+        // when id is empty, it means we should show the last selected tab
         //BBS GUI refactor: remove unused layout new/dlg
         //size_t new_selection = tab == (size_t)(-1) ? m_last_selected_tab : (m_layout == ESettingsLayout::Dlg && tab != 0) ? tab - 1 : tab;
-        size_t new_selection = tab == (size_t)(-1) ? m_last_selected_tab : tab;
+        wxString new_selection = id.empty() ? m_last_selected_tab : id;
 
-        if (m_tabpanel->GetSelection() != (int)new_selection)
-            m_tabpanel->SetSelection(new_selection);
+        if (m_tabpanel->GetSelectedPageName() != new_selection)
+            m_tabpanel->SelectPageByName(new_selection);
 #ifdef _MSW_DARK_MODE
         /*if (wxGetApp().tabs_as_menu()) {
             if (Tab* cur_tab = dynamic_cast<Tab*>(m_tabpanel->GetPage(new_selection)))
@@ -4052,10 +4062,12 @@ void MainFrame::select_tab(size_t tab/* = size_t(-1)*/)
                 m_plater->get_current_canvas3D()->render();
         }*/
 #endif
-        if (tab == MainFrame::tp3DEditor && m_layout == ESettingsLayout::Old)
+        // Intentionally `id`, not `new_selection`: the fallback-to-last-tab path must not
+        // trigger this render even when the last selected tab was Prepare.
+        if (id == TAB_ID_PREPARE && m_layout == ESettingsLayout::Old)
             m_plater->canvas3D()->render();
         else if (was_hidden) {
-            Tab* cur_tab = dynamic_cast<Tab*>(m_tabpanel->GetPage(new_selection));
+            Tab* cur_tab = dynamic_cast<Tab*>(m_tabpanel->GetPageByName(new_selection));
             if (cur_tab)
                 cur_tab->OnActivate();
         }
@@ -4064,10 +4076,10 @@ void MainFrame::select_tab(size_t tab/* = size_t(-1)*/)
     select(false);
 }
 
-void MainFrame::request_select_tab(TabPosition pos)
+void MainFrame::request_select_tab(const wxString& id)
 {
     wxCommandEvent* evt = new wxCommandEvent(EVT_SELECT_TAB);
-    evt->SetInt(pos);
+    evt->SetString(id);
     wxQueueEvent(this, evt);
 }
 
@@ -4333,21 +4345,33 @@ void MainFrame::load_printer_url(wxString url, wxString apikey)
 void MainFrame::load_printer_url()
 {
     PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
-    if (preset_bundle.use_bbl_device_tab() || wxGetApp().app_config->get_bool("use_printer_agents"))
+    if (preset_bundle.use_bbl_device_tab() && !wxGetApp().app_config->get_bool("use_printer_agents"))
         return;
 
     auto     cfg = preset_bundle.printers.get_edited_preset().config;
+    if (cfg.opt_string("print_host").empty()) {
+        if (auto *device_manager = wxGetApp().getDeviceManager()) {
+            auto *machine = device_manager->get_selected_machine();
+            if (!machine) {
+                auto machines = device_manager->get_my_machine_list();
+                if (machines.size() == 1)
+                    machine = machines.begin()->second;
+            }
+            if (machine && !machine->get_dev_ip().empty())
+                cfg.opt_string("print_host") = machine->get_dev_ip();
+        }
+    }
     wxString url = from_u8(PrintHost::get_print_host_webui(&cfg));
     wxString apikey;
     const auto host_type = cfg.option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
-    if (cfg.has("printhost_apikey") && (host_type == htPrusaLink || host_type == htPrusaConnect))
+    if (cfg.has("printhost_apikey") && host_type != htSimplyPrint)
         apikey = cfg.opt_string("printhost_apikey");
     if (!url.empty()) {
         load_printer_url(url, apikey);
     }
 }
 
-bool MainFrame::is_printer_view() const { return m_tabpanel->GetSelection() == TabPosition::tpMonitor; }
+bool MainFrame::is_printer_view() const { return m_tabpanel->GetSelectedPageName() == TAB_ID_MONITOR; }
 
 
 void MainFrame::refresh_plugin_tips()

src/slic3r/GUI/MainFrame.hpp

@@ -35,6 +35,21 @@
 #include "PrinterWebView.hpp"
 #include "calib_dlg.hpp"
 #include "MultiMachinePage.hpp"
+#include "slic3r/plugin/host/PluginPages.hpp"
+
+// Stable identifiers for MainFrame::m_tabpanel's built-in pages. These are
+// names rather than positional indices so optional pages cannot shift them.
+#define TAB_ID_HOME          "home"
+#define TAB_ID_PREPARE       "prepare"
+#define TAB_ID_PREVIEW       "preview"
+#define TAB_ID_MONITOR       "monitor"
+// Printer-agents mode shows the legacy web page alongside the native Device tab, so it needs an
+// id of its own: sharing TAB_ID_MONITOR makes every name lookup resolve to whichever of the two
+// comes first, which silently defeats PluginPages' selection round-trip across a tab relayout.
+#define TAB_ID_MONITOR_WEB   "monitor_web"
+#define TAB_ID_MULTI_DEVICE  "multi_device"
+#define TAB_ID_PROJECT       "project"
+#define TAB_ID_CALIBRATION   "calibration"
 
 #define ENABEL_PRINT_ALL 0
 
@@ -115,7 +130,7 @@ class MainFrame : public DPIFrame
     wxMenuItem* m_menu_item_reslice_now { nullptr };
     wxSizer*    m_main_sizer{ nullptr };
 
-    size_t      m_last_selected_tab;
+    wxString    m_last_selected_tab;
 
     std::string     get_base_name(const wxString &full_name, const char *extension = nullptr) const;
     std::string     get_dir_name(const wxString &full_name) const;
@@ -214,19 +229,6 @@ public:
 #ifdef __APPLE__
     bool get_mac_full_screen() { return m_mac_fullscreen; }
 #endif
-    //BBS GUI refactor
-    enum TabPosition
-    {
-        tpHome          = 0,
-        tp3DEditor      = 1,
-        tpPreview       = 2,
-        tpMonitor       = 3,
-        tpMultiDevice   = 4,
-        tpProject       = 5,
-        tpCalibration   = 6,
-        tpAuxiliary     = 7,
-        toDebugTool     = 8,
-    };
 
     //BBS: add slice&&print status update logic
     enum SlicePrintEventType
@@ -326,8 +328,8 @@ public:
     // When tab == -1, will be selected last selected tab
     //BBS: GUI refactor
     void        select_tab(wxPanel* panel);
-    void        select_tab(size_t tab = size_t(-1));
-    void        request_select_tab(TabPosition pos);
+    void        select_tab(const wxString& id = wxString());
+    void        request_select_tab(const wxString& id);
     int         get_calibration_curr_tab();
     void        select_view(const std::string& direction);
     // Propagate changed configuration from the Tab to the Plater and save changes to the AppConfig
@@ -360,6 +362,9 @@ public:
     //SoftFever
     void show_device(bool should_use_native);
     void fit_tab_labels(); // ORCA
+    // True while either of the two tabs backed by m_plater is selected.
+    bool is_prepare_or_preview_tab() const;
+    PluginPages& plugin_pages() { return m_plugin_pages; }
 
     PA_Calibration_Dlg* m_pa_calib_dlg{ nullptr };
     FlowRateCalibrationDialog* m_flow_rate_calib_dlg{ nullptr };
@@ -385,7 +390,8 @@ public:
     CalibrationPanel*     m_calibration{ nullptr };
     WebViewPanel*         m_webview { nullptr };
     PrinterWebView*       m_printer_view{nullptr};
-        wxLogWindow*          m_log_window { nullptr };
+    PluginPages           m_plugin_pages;
+    wxLogWindow*          m_log_window { nullptr };
     // BBS
     //wxBookCtrlBase*       m_tabpanel { nullptr };
     Notebook*             m_tabpanel{ nullptr };

src/slic3r/GUI/Monitor.cpp

@@ -186,17 +186,17 @@ void MonitorPanel::init_tabpanel()
 
     //m_status_add_machine_panel = new AddMachinePanel(m_tabpanel);
     m_status_info_panel        = new StatusPanel(m_tabpanel);
-    m_tabpanel->AddPage(m_status_info_panel, _L("Status"), "", true);
+    m_tabpanel->AddPage(m_status_info_panel, _L("Status"), true);
 
     m_media_file_panel = new MediaFilePanel(m_tabpanel);
-    m_tabpanel->AddPage(m_media_file_panel, _L("Storage"), "", false);
-    //m_tabpanel->AddPage(m_media_file_panel, _L("Internal Storage"), "", false);
+    m_tabpanel->AddPage(m_media_file_panel, _L("Storage"), false);
+    //m_tabpanel->AddPage(m_media_file_panel, _L("Internal Storage"), false);
 
     m_upgrade_panel = new UpgradePanel(m_tabpanel);
-    m_tabpanel->AddPage(m_upgrade_panel, _L_CONTEXT(L_CONTEXT("Update", "Firmware"), "Firmware"), "", false);
+    m_tabpanel->AddPage(m_upgrade_panel, _L_CONTEXT(L_CONTEXT("Update", "Firmware"), "Firmware"), false);
 
     m_hms_panel = new HMSPanel(m_tabpanel);
-    m_tabpanel->AddPage(m_hms_panel, _L("Assistant(HMS)"),    "", false);
+    m_tabpanel->AddPage(m_hms_panel, _L("Assistant(HMS)"),    false);
 
     std::string network_ver = Slic3r::NetworkAgent::get_version();
     if (!network_ver.empty()) {
@@ -413,7 +413,10 @@ void MonitorPanel::update_hms_tag()
 bool MonitorPanel::Show(bool show)
 {
 #ifdef __APPLE__
-    wxGetApp().mainframe->SetMinSize(wxGetApp().plater()->GetMinSize());
+    // Notebook::InsertPage() hides every page it appends, so this also runs while MainFrame is
+    // still constructing, before GUI_App::mainframe is assigned. Same guard as Plater::Show().
+    if (wxGetApp().mainframe)
+        wxGetApp().mainframe->SetMinSize(wxGetApp().plater()->GetMinSize());
 #endif
 
     NetworkAgent* m_agent = wxGetApp().getAgent();

src/slic3r/GUI/MultiMachinePage.cpp

@@ -86,9 +86,9 @@ void MultiMachinePage::init_tabpanel()
     m_cloud_task_manager = new CloudTaskManagerPage(m_tabpanel);
     m_machine_manager = new MultiMachineManagerPage(m_tabpanel);
 
-    m_tabpanel->AddPage(m_machine_manager, _L("Device"), "", true);
-    m_tabpanel->AddPage(m_local_task_manager, _L("Task Sending"), "", false);
-    m_tabpanel->AddPage(m_cloud_task_manager, _L("Task Sent"), "", false);
+    m_tabpanel->AddPage(m_machine_manager, _L("Device"), true);
+    m_tabpanel->AddPage(m_local_task_manager, _L("Task Sending"), false);
+    m_tabpanel->AddPage(m_cloud_task_manager, _L("Task Sent"), false);
 }
 
 void MultiMachinePage::init_timer()

src/slic3r/GUI/Notebook.cpp

@@ -120,11 +120,11 @@ void ButtonsListCtrl::Rescale()
 
 void ButtonsListCtrl::SetSelection(int sel)
 {
-    if (m_selection == sel)
+    if (m_selection == sel && sel >= 0 && sel < static_cast<int>(m_pageButtons.size()))
         return;
     // BBS: change button color
     wxColour selected_btn_bg("#009688");    // Gradient #009688
-    if (m_selection >= 0) {
+    if (m_selection >= 0 && m_selection < static_cast<int>(m_pageButtons.size())) {
         StateColor bg_color = StateColor(
         std::pair{wxColour(107, 107, 107), (int) StateColor::Hovered},
         std::pair{wxColour(59, 68, 70), (int) StateColor::Normal});
@@ -132,9 +132,15 @@ void ButtonsListCtrl::SetSelection(int sel)
         StateColor text_color = StateColor(
         std::pair{wxColour(254,254, 254), (int) StateColor::Normal}
         );
-        m_pageButtons[m_selection]->SetSelected(false);
         m_pageButtons[m_selection]->SetTextColor(text_color);
     }
+
+    if (sel < 0 || sel >= static_cast<int>(m_pageButtons.size())) {
+        m_selection = -1;
+        Refresh();
+        return;
+    }
+
     m_selection = sel;
 
     StateColor bg_color = StateColor(
@@ -145,17 +151,19 @@ void ButtonsListCtrl::SetSelection(int sel)
     StateColor text_color = StateColor(
         std::pair{wxColour(254, 254, 254), (int) StateColor::Normal}
         );
-    m_pageButtons[m_selection]->SetSelected(true);
     m_pageButtons[m_selection]->SetTextColor(text_color);
     
     Refresh();
 }
 
-bool ButtonsListCtrl::InsertPage(size_t n, const wxString &text, bool bSelect /* = false*/, const std::string &bmp_name /* = ""*/, const std::string &inactive_bmp_name)
+bool ButtonsListCtrl::InsertPage(size_t n, const wxString &text, bool bSelect /* = false*/, const std::string &bmp_name /* = ""*/, const wxBitmap &bmp /* = wxNullBitmap */)
 {
     Button * btn = new Button(this, text.empty() ? text : " " + text, bmp_name, wxNO_BORDER);
     btn->SetCornerRadius(0);
 
+    if (bmp_name.empty() && bmp.IsOk())
+        btn->SetIcon(bmp);
+
     int em = em_unit(this);
     //BBS set size for button
     btn->SetMinSize({(text.empty() ? 40 : 136) * em / 10, 36 * em / 10});
@@ -168,8 +176,6 @@ bool ButtonsListCtrl::InsertPage(size_t n, const wxString &text, bool bSelect /*
     StateColor text_color = StateColor(
         std::pair{wxColour(254,254, 254), (int) StateColor::Normal});
     btn->SetTextColor(text_color);
-    btn->SetInactiveIcon(inactive_bmp_name);
-    btn->SetSelected(false);
     btn->Bind(wxEVT_BUTTON, [this, btn](wxCommandEvent& event) {
         if (auto it = std::find(m_pageButtons.begin(), m_pageButtons.end(), btn); it != m_pageButtons.end()) {
             auto sel = it - m_pageButtons.begin();
@@ -192,6 +198,14 @@ bool ButtonsListCtrl::InsertPage(size_t n, const wxString &text, bool bSelect /*
 
 void ButtonsListCtrl::RemovePage(size_t n)
 {
+    if (n >= m_pageButtons.size())
+        return;
+
+    if (m_selection == static_cast<int>(n))
+        m_selection = -1;
+    else if (m_selection > static_cast<int>(n))
+        --m_selection;
+
     Button* btn = m_pageButtons[n];
     m_pageButtons.erase(m_pageButtons.begin() + n);
     m_pageLabels.erase(m_pageLabels.begin() + n); // ORCA
@@ -240,6 +254,24 @@ wxString ButtonsListCtrl::GetPageText(size_t n) const
     return btn->GetLabel();
 }
 
+// ORCA
+void ButtonsListCtrl::SetOverflowButton(wxWindow* button)
+{
+    if (m_overflow_button == button)
+        return;
+
+    if (m_overflow_button != nullptr)
+        m_sizer->Detach(m_overflow_button);
+
+    m_overflow_button = button;
+
+    if (m_overflow_button != nullptr)
+        // Right after the tab buttons (index 0), ahead of any stretch spacer / side_tools.
+        m_sizer->Insert(1, m_overflow_button, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxBOTTOM, m_btn_margin);
+
+    m_sizer->Layout();
+}
+
 //#endif // _WIN32
 
 void Notebook::Init()
@@ -253,6 +285,8 @@ void Notebook::Init()
 
     m_showTimeout = m_hideTimeout = 0;
 
+    m_pageNames.clear();
+
     /* On Linux, Gstreamer wxMediaCtrl does not seem to get along well with
      * 32-bit X11 visuals (the overlay does not work).  Is this a wxWindows
      * bug?  Is this a Gstreamer bug?  No idea, but it is our problem ... 

src/slic3r/GUI/Notebook.hpp

@@ -3,7 +3,11 @@
 
 //#ifdef _WIN32
 
+#include <initializer_list>
+#include <string>
+#include <vector>
 #include <wx/bookctrl.h>
+#include <wx/bitmap.h>
 #include <wx/sizer.h>
 
 class ScalableButton;
@@ -23,13 +27,16 @@ public:
     void SetSelection(int sel);
     void UpdateMode();
     void Rescale();
-    bool InsertPage(size_t n, const wxString &text, bool bSelect = false, const std::string &bmp_name = "", const std::string &inactive_bmp_name = "");
+    bool InsertPage(size_t n, const wxString &text, bool bSelect = false, const std::string &bmp_name = "", const wxBitmap &bmp = wxNullBitmap);
     void RemovePage(size_t n);
     bool SetPageImage(size_t n, const std::string& bmp_name) const;
     void SetPageText(size_t n, const wxString& strText);
     void SetCompact(size_t n, bool compact); // ORCA
     wxString GetPageText(size_t n) const;
     wxFlexGridSizer* GetBtnsSizer(){return m_buttons_sizer;}; // ORCA
+    // ORCA: a companion widget shown right after the tab buttons (before any side_tools), e.g.
+    // an overflow indicator. Pass nullptr to remove it; ownership stays with the caller.
+    void SetOverflowButton(wxWindow* button);
 
 private:
     wxFlexGridSizer*                m_buttons_sizer;
@@ -40,9 +47,10 @@ private:
     int                             m_btn_margin;
     int                             m_line_margin;
     std::vector<wxString>           m_pageLabels; // ORCA
+    wxWindow*                       m_overflow_button{nullptr}; // ORCA
 };
 
-class Notebook: public wxBookCtrlBase
+class Notebook : public wxBookCtrlBase
 {
 public:
     Notebook(wxWindow * parent,
@@ -103,7 +111,7 @@ public:
     // by this control) and show it immediately.
     bool ShowNewPage(wxWindow * page)
     {
-        return AddPage(page, wxString(), "", "");
+        return AddPage(page, wxString(), false, NO_IMAGE);
     }
 
 
@@ -135,51 +143,56 @@ public:
 
     // Implement base class pure virtual methods.
 
-    // adds a new page to the control
-    bool AddPage(wxWindow* page,
+    // Page management. Every insertion funnels through the InsertPage() below; `id` is the
+    // stable page name FindPageByName() resolves. Built-in tabs name a resource bitmap,
+    // plugin pages hand over a ready wxBitmap; wx's own imageId overloads carry neither.
+    bool AddPage(const wxString& id,
+                 wxWindow* page,
                  const wxString& text,
-                 const std::string& bmp_name,
-                 const std::string& inactive_bmp_name,
+                 const std::string& bmp_name = "",
                  bool bSelect = false)
     {
         DoInvalidateBestSize();
-        return InsertPage(GetPageCount(), page, text, bmp_name, inactive_bmp_name, bSelect);
+        return InsertPage(GetPageCount(), id, page, text, bmp_name, bSelect);
     }
 
-    // Page management
-    virtual bool InsertPage(size_t n,
-                            wxWindow * page,
-                            const wxString & text,
-                            bool bSelect = false,
-                            int imageId = NO_IMAGE) override
+    bool AddPage(wxWindow* page, const wxString& text, bool bSelect = false, int imageId = NO_IMAGE) override
     {
-        if (!wxBookCtrlBase::InsertPage(n, page, text, bSelect, imageId))
+        DoInvalidateBestSize();
+        return InsertPage(GetPageCount(), page, text, bSelect, imageId);
+    }
+
+    bool InsertPage(size_t n,
+                    const wxString& id,
+                    wxWindow * page,
+                    const wxString & text,
+                    const std::string& bmp_name = "",
+                    bool bSelect = false,
+                    const wxBitmap& bmp = wxNullBitmap)
+    {
+        if (!wxBookCtrlBase::InsertPage(n, page, text, bSelect))
             return false;
 
-        GetBtnsListCtrl()->InsertPage(n, text, bSelect);
+        m_pageNames.insert(m_pageNames.begin() + n, id);
+        GetBtnsListCtrl()->InsertPage(n, text, bSelect, bmp_name, bmp);
 
+        // wxBookCtrlBase::InsertPage() only inserts into the page list and sizes the new
+        // page to the current page's rect — it never touches visibility, and a freshly
+        // constructed page defaults to shown. Without this it renders on top of whatever
+        // page is currently selected until the next SetSelection() call hides it.
         if (!DoSetSelectionAfterInsertion(n, bSelect))
             page->Hide();
 
         return true;
     }
 
-    bool InsertPage(size_t n,
-                    wxWindow * page,
-                    const wxString & text,
-                    const std::string& bmp_name = "",
-                    const std::string& inactive_bmp_name = "",
-                    bool bSelect = false)
+    virtual bool InsertPage(size_t n,
+                            wxWindow * page,
+                            const wxString & text,
+                            bool bSelect = false,
+                            int WXUNUSED(imageId) = NO_IMAGE) override
     {
-        if (!wxBookCtrlBase::InsertPage(n, page, text, bSelect))
-            return false;
-
-        GetBtnsListCtrl()->InsertPage(n, text, bSelect, bmp_name, inactive_bmp_name);
-
-        if (bSelect)
-            SetSelection(n);
-
-        return true;
+        return InsertPage(n, wxString(), page, text, "", bSelect);
     }
 
     virtual int SetSelection(size_t n) override
@@ -211,8 +224,8 @@ public:
         return DoSetSelection(n);
     }
 
-    // Neither labels nor images are supported but we still store the labels
-    // just in case the user code attaches some importance to them.
+    // Labels are stored by the custom button list; wx's image-list API is unused — tab icons
+    // are set directly on the buttons, either from a resource name or a ready wxBitmap.
     virtual bool SetPageText(size_t n, const wxString & strText) override
     {
         wxCHECK_MSG(n < GetPageCount(), false, wxS("Invalid page"));
@@ -251,7 +264,64 @@ public:
             page->SetFocus();
     }
 
+    // The base clears its page list directly instead of calling DoRemovePage() per page,
+    // which would leave m_pageNames behind. No caller today; kept in sync regardless.
+    virtual bool DeleteAllPages() override
+    {
+        m_pageNames.clear();
+        return wxBookCtrlBase::DeleteAllPages();
+    }
+
     ButtonsListCtrl* GetBtnsListCtrl() const { return static_cast<ButtonsListCtrl*>(m_bookctrl); }
+    void SetOverflowButton(wxWindow* button) { GetBtnsListCtrl()->SetOverflowButton(button); }
+
+    // Insertion index just past the first of `ids` that is present, or the end of the bar
+    // if none is — lets call sites state tab order as "after X" instead of re-deriving it.
+    size_t PositionAfter(std::initializer_list<const char*> ids) const
+    {
+        for (const char* id : ids)
+            if (const int idx = FindPageByName(id); idx != wxNOT_FOUND)
+                return static_cast<size_t>(idx) + 1;
+        return GetPageCount();
+    }
+
+    int FindPageByName(const wxString& id) const
+    {
+        if (id.empty())
+            return wxNOT_FOUND;
+        for (size_t i = 0; i < m_pageNames.size(); ++i)
+            if (m_pageNames[i] == id)
+                return static_cast<int>(i);
+        return wxNOT_FOUND;
+    }
+
+    wxWindow* GetPageByName(const wxString& id) const
+    {
+        const int idx = FindPageByName(id);
+        return idx == wxNOT_FOUND ? nullptr : GetPage(static_cast<size_t>(idx));
+    }
+
+    bool SelectPageByName(const wxString& id)
+    {
+        const int idx = FindPageByName(id);
+        if (idx == wxNOT_FOUND)
+            return false;
+        SetSelection(static_cast<size_t>(idx));
+        return true;
+    }
+
+    // Inverse of FindPageByName: index -> id. Empty string for an out-of-range
+    // index or a page that was never given an id (e.g. settings Tab pages).
+    wxString GetPageName(size_t n) const
+    {
+        return n < m_pageNames.size() ? m_pageNames[n] : wxString();
+    }
+
+    wxString GetSelectedPageName() const
+    {
+        const int sel = GetSelection();
+        return sel < 0 ? wxString() : GetPageName(static_cast<size_t>(sel));
+    }
 
     void UpdateMode()
     {
@@ -369,6 +439,7 @@ protected:
         wxWindow* const win = wxBookCtrlBase::DoRemovePage(page);
         if (win)
         {
+            m_pageNames.erase(m_pageNames.begin() + page);
             GetBtnsListCtrl()->RemovePage(page);
             DoSetSelectionAfterRemoval(page);
         }
@@ -394,6 +465,8 @@ protected:
 private:
     void Init();
 
+    std::vector<wxString> m_pageNames; // index-parallel to wxBookCtrlBase::m_pages
+
     wxShowEffect m_showEffect,
                  m_hideEffect;
 

src/slic3r/GUI/NotificationManager.cpp

@@ -1918,7 +1918,7 @@ void NotificationManager::push_validate_error_notification(StringObjectException
 				wxGetApp().sidebar().jump_to_option(opt, Preset::TYPE_PRINT, L"");
 			}
 			else {
-				wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+				wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 			}
 			return false;
 		};
@@ -1985,7 +1985,7 @@ void NotificationManager::push_validate_error_notification(StringObjectException
 				wxGetApp().sidebar().jump_to_option(opt, opt_type, L"");
 			}
 			else {
-				wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+				wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 			}
 			return false;
 		};
@@ -2015,7 +2015,7 @@ void NotificationManager::push_slicing_error_notification(const std::string &tex
 				if (iter != objects.end()) { ovs.push_back({ *iter, nullptr }); }
 			}
 			if (!ovs.empty()) {
-				wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+				wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 				wxGetApp().obj_list()->select_items(ovs);
 			}
 			return false;
@@ -2046,7 +2046,7 @@ void NotificationManager::push_slicing_warning_notification(const std::string& t
 			auto& objects = wxGetApp().model().objects;
 			auto iter = std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; });
 			if (iter != objects.end()) {
-				wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+				wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 				wxGetApp().obj_list()->select_items({ {*iter, nullptr} });
 			}
 			return false;
@@ -2693,7 +2693,7 @@ void NotificationManager::push_slicing_serious_warning_notification(const std::s
 				if (iter != objects.end()) { ovs.push_back({ *iter, nullptr }); }
 			}
 			if (!ovs.empty()) {
-				wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+				wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 				wxGetApp().obj_list()->select_items(ovs);
 				wxGetApp().obj_list()->update_selections_on_canvas();
 			}
@@ -2777,7 +2777,7 @@ void NotificationManager::push_slicing_serious_warning_notification(const std::s
                 }
             }
             
-            wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+            wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
             
             if (!sel_items.empty()) {
                 obj_list->select_items(sel_items);

src/slic3r/GUI/Plater.cpp

@@ -3287,7 +3287,9 @@ void Sidebar::update_all_preset_comboboxes()
                                  : MainFrame::PrintSelectType::eSendGcode;
         }
 
-        if (!use_native_device_tab || use_printer_agents)
+        if (use_printer_agents)
+            p_mainframe->load_printer_url();
+        else if (!use_native_device_tab)
             p_mainframe->load_printer_url(url, apikey);
 
 
@@ -5781,6 +5783,8 @@ private:
     bool show_warning_dialog { false };
 };
 
+Plater::~Plater() = default;
+
 const std::regex Plater::priv::pattern_bundle(".*[.](amf|amf[.]xml|zip[.]amf|3mf)", std::regex::icase);
 const std::regex Plater::priv::pattern_3mf(".*3mf", std::regex::icase);
 const std::regex Plater::priv::pattern_zip_amf(".*[.]zip[.]amf", std::regex::icase);
@@ -5795,7 +5799,7 @@ bool PlaterDropTarget::OnDropFiles(wxCoord x, wxCoord y, const wxArrayString &fi
 #endif // WIN32
 
     m_mainframe.Raise();
-    m_mainframe.select_tab(size_t(MainFrame::tp3DEditor));
+    m_mainframe.select_tab(TAB_ID_PREPARE);
     if (wxGetApp().is_editor())
         m_plater.select_view_3D("3D");
 
@@ -6577,9 +6581,9 @@ void Plater::priv::select_next_view_3D()
 {
     
     if (current_panel == view3D)
-        wxGetApp().mainframe->select_tab(size_t(MainFrame::tpPreview));
+        wxGetApp().mainframe->select_tab(TAB_ID_PREVIEW);
     else if (current_panel == preview)
-        wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 //    else if (current_panel == assemble_view)
 //        set_current_panel(view3D);
 }
@@ -7878,7 +7882,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
                 q->select_plate(first_plate_index);
                 //set to 3d tab
                 q->select_view_3D("Preview");
-                wxGetApp().mainframe->select_tab(MainFrame::tpPreview);
+                wxGetApp().mainframe->select_tab(TAB_ID_PREVIEW);
             }
             else {
                 //set to 3d tab
@@ -7897,7 +7901,7 @@ std::vector<size_t> Plater::priv::load_files(const std::vector<fs::path>& input_
     else {
         //always set to 3D after loading files
         q->select_view_3D("3D");
-        wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     }
 
     if (load_model) {
@@ -8805,7 +8809,7 @@ void Plater::priv::process_validation_warning(StringObjectException const &warni
                           }
                       }
 
-                      wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+                      wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
                       if (inst_idx != -1) {
                          auto* model = wxGetApp().obj_list()->GetModel();
@@ -8834,7 +8838,7 @@ void Plater::priv::process_validation_warning(StringObjectException const &warni
             } else {
 		        auto iter = id.id ? std::find_if(objects.begin(), objects.end(), [id](auto o) { return o->id() == id; }) : objects.end();
                 if (iter != objects.end()) {
-                    wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+                    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 			        wxGetApp().obj_list()->select_items({{*iter, nullptr}});
                     wxGetApp().obj_list()->update_selections_on_canvas();
                 }
@@ -11218,13 +11222,19 @@ void Plater::priv::on_tab_selection_changing(wxBookCtrlEvent& e)
     }
 
     const int new_sel = e.GetSelection();
-    sidebar_layout.show = new_sel == MainFrame::tp3DEditor || new_sel == MainFrame::tpPreview;
+    if (new_sel == wxNOT_FOUND) {
+        // GetPage(new_sel) below needs a valid index.
+        e.Skip();
+        return;
+    }
+    const wxString new_name = main_frame->m_tabpanel->GetPageName(new_sel);
+    sidebar_layout.show = new_name == TAB_ID_PREPARE || new_name == TAB_ID_PREVIEW;
     update_sidebar();
     int old_sel = e.GetOldSelection();
     const bool use_printer_agents = wxGetApp().app_config->get_bool("use_printer_agents");
     const bool use_native_device_tab = wxGetApp().preset_bundle &&
         (wxGetApp().preset_bundle->use_bbl_device_tab() || use_printer_agents);
-    if (use_native_device_tab && new_sel == MainFrame::tpMonitor) {
+    if (use_native_device_tab && new_name == TAB_ID_MONITOR) {
         // BBL network module is only required for BBL-vendor printers.
         // Non-BBL Python plugins (e.g. moonraker) drive the Device tab without it.
         if (!use_printer_agents && wxGetApp().preset_bundle->is_bbl_vendor() && !Slic3r::NetworkAgent::is_network_module_loaded()) {
@@ -11236,9 +11246,17 @@ void Plater::priv::on_tab_selection_changing(wxBookCtrlEvent& e)
             }
         }
     } else {
-        if (new_sel == MainFrame::tpMonitor && wxGetApp().preset_bundle != nullptr) {
+        // Pointer test, not a name lookup: in printer-agents mode this page is TAB_ID_MONITOR_WEB
+        // while the native Device tab holds TAB_ID_MONITOR, and in legacy-web mode it holds
+        // TAB_ID_MONITOR itself.
+        const bool selecting_web_device_tab = main_frame->m_printer_view &&
+            main_frame->m_tabpanel->GetPage(new_sel) == main_frame->m_printer_view;
+        if (selecting_web_device_tab) {
+            // Use the selected discovered machine when the preset has no host.
+            main_frame->load_printer_url();
+        } else if (new_name == TAB_ID_MONITOR && wxGetApp().preset_bundle != nullptr) {
             auto     cfg = wxGetApp().preset_bundle->printers.get_edited_preset().config;
-            wxString url = cfg.opt_string("print_host_webui").empty() ? cfg.opt_string("print_host") : cfg.opt_string("print_host_webui");
+            wxString url = from_u8(PrintHost::get_print_host_webui(&cfg));
             if (main_frame->m_printer_view && url.empty()) {
                 // It's missing_connection page, reload so that we can replay the gif image
                 main_frame->m_printer_view->reload();
@@ -12099,7 +12117,7 @@ bool Plater::priv::check_ams_status_impl(bool is_slice_all)
                         wxPostEvent(q, SimpleEvent(EVT_GLTOOLBAR_SLICE_ALL));
                     else
                         wxPostEvent(q, SimpleEvent(EVT_GLTOOLBAR_SLICE_PLATE));
-                    wxGetApp().mainframe->m_tabpanel->SetSelection(MainFrame::TabPosition::tpPreview);
+                    wxGetApp().mainframe->m_tabpanel->SelectPageByName(TAB_ID_PREVIEW);
                 }
                 return false;
             }
@@ -12667,7 +12685,7 @@ void Plater::priv::take_snapshot(const std::string& snapshot_name, const UndoRed
             ModelWipeTower& tower = model.wipe_tower;
 
             tower.positions[plate_idx] = Vec2d(tower_x_opt->get_at(plate_idx), tower_y_opt->get_at(plate_idx));
-            tower.rotation = proj_cfg.opt_float("wipe_tower_rotation_angle");
+            tower.rotation = config.opt_float("wipe_tower_rotation_angle");
         }
     }
     const GLGizmosManager& gizmos = get_current_canvas3D()->get_canvas_type() == GLCanvas3D::CanvasAssembleView ? assemble_view->get_canvas3d()->get_gizmos_manager() : view3D->get_canvas3d()->get_gizmos_manager();
@@ -12777,7 +12795,7 @@ void Plater::priv::undo_redo_to(std::vector<UndoRedo::Snapshot>::const_iterator
             ModelWipeTower& tower = model.wipe_tower;
 
             tower.positions[plate_idx] = Vec2d(tower_x_opt->get_at(plate_idx), tower_y_opt->get_at(plate_idx));
-            tower.rotation = proj_cfg.opt_float("wipe_tower_rotation_angle");
+            tower.rotation = config.opt_float("wipe_tower_rotation_angle");
         }
     }
     const int layer_range_idx = it_snapshot->snapshot_data.layer_range_idx;
@@ -13056,7 +13074,7 @@ int Plater::new_project(bool skip_confirm, bool silent, const wxString& project_
     get_notification_manager()->clear_all();
 
     if (!silent)
-        wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
     //get_partplate_list().reinit();
     //get_partplate_list().update_slice_context_to_current_plate(p->background_process);
@@ -13205,7 +13223,7 @@ void Plater::load_project(wxString const& filename2,
     if (!m_exported_file) {
         p->select_view("topfront");
         p->camera.requires_zoom_to_plate = REQUIRES_ZOOM_TO_ALL_PLATE;
-        wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     }
     else {
         p->partplate_list.select_plate_view();
@@ -13319,7 +13337,7 @@ void Plater::import_model_id(wxString download_info)
     const int max_retries = 3;
 
     /* jump to 3D eidtor */
-    wxGetApp().mainframe->select_tab((size_t)MainFrame::TabPosition::tp3DEditor);
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
     /* prepare progress dialog */
     bool cont = true;
@@ -13628,7 +13646,7 @@ void Plater::calib_pa(const Calib_Params& params)
 {
     const auto calib_pa_name = wxString::Format(L"Pressure Advance Test");
     new_project(false, false, calib_pa_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     auto print_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
     auto printer_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
     print_config->set_key_value("overhang_reverse", new ConfigOptionBool(false));
@@ -14109,7 +14127,7 @@ void Plater::calib_flowrate(bool is_linear, int pass, InfillPattern pattern) {
     if (new_project(false, false, calib_name) == wxID_CANCEL)
         return;
 
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
 
     if (is_linear) {
         if (pass == 1)
@@ -14146,7 +14164,7 @@ void Plater::calib_temp(const Calib_Params& params) {
 
     const auto calib_temp_name = wxString::Format(L"Nozzle temperature test");
     new_project(false, false, calib_temp_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Temp_Tower) return;
     
     if (!add_model(false, Slic3r::resources_dir() + "/calib/temperature_tower/temperature_tower.drc"))
@@ -14226,7 +14244,7 @@ void Plater::calib_max_vol_speed(const Calib_Params& params)
 {
     const auto calib_vol_speed_name = wxString::Format(L"Max volumetric speed test");
     new_project(false, false, calib_vol_speed_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Vol_speed_Tower)
         return;
     if (!add_model(false, Slic3r::resources_dir() + "/calib/volumetric_speed/SpeedTestStructure.drc"))
@@ -14305,7 +14323,7 @@ void Plater::calib_retraction(const Calib_Params& params)
 {
     const auto calib_retraction_name = wxString::Format(L"Retraction");
     new_project(false, false, calib_retraction_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Retraction_tower)
         return;
 
@@ -14365,7 +14383,7 @@ void Plater::calib_VFA(const Calib_Params& params)
 {
     const auto calib_vfa_name = wxString::Format(L"VFA test");
     new_project(false, false, calib_vfa_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_VFA_Tower)
         return;
 
@@ -14448,7 +14466,7 @@ void Plater::calib_input_shaping_freq(const Calib_Params& params)
 {
     const auto calib_input_shaping_name = wxString::Format(L"Input shaping Frequency test");
     new_project(false, false, calib_input_shaping_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Input_shaping_freq)
         return;
 
@@ -14514,7 +14532,7 @@ void Plater::calib_input_shaping_damp(const Calib_Params& params)
 {
     const auto calib_input_shaping_name = wxString::Format(L"Input shaping Damping test");
     new_project(false, false, calib_input_shaping_name);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Input_shaping_damp)
         return;
 
@@ -14579,7 +14597,7 @@ void Plater::Calib_Cornering(const Calib_Params& params)
 {
     const auto Calib_Cornering = wxString::Format(L"Cornering test");
     new_project(false, false, Calib_Cornering);
-    wxGetApp().mainframe->select_tab(size_t(MainFrame::tp3DEditor));
+    wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     if (params.mode != CalibMode::Calib_Cornering)
         return;
 
@@ -14712,7 +14730,7 @@ void Plater::load_gcode(const wxString& filename)
     //p->gcode_result.reset();
     //reset_gcode_toolpaths();
     p->preview->reload_print(m_only_gcode);
-    wxGetApp().mainframe->select_tab(MainFrame::tpPreview);
+    wxGetApp().mainframe->select_tab(TAB_ID_PREVIEW);
     p->set_current_panel(p->preview, true);
     p->get_current_canvas3D()->render();
     //p->notification_manager->bbl_show_plateinfo_notification(into_u8(_L("Preview only mode for gcode file.")));
@@ -15385,7 +15403,7 @@ LoadType determine_load_type(std::string filename, std::string override_setting)
             wxGetApp().app_config->set("import_project_action", std::to_string(choice));
 
             // BBS: jump to plater panel
-            wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+            wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
             return load_type;
         }
 
@@ -15614,7 +15632,7 @@ void Plater::reset_with_confirm()
                                             .ShowModal() == wxID_YES) {
         reset();
         // BBS: jump to plater panel
-        wxGetApp().mainframe->select_tab(size_t(0));
+        wxGetApp().mainframe->select_tab(TAB_ID_HOME);
     }
 }
 
@@ -17428,7 +17446,7 @@ int Plater::export_config_3mf(int plate_idx, Export3mfProgressFn proFn)
 //BBS
 void Plater::send_calibration_job_finished(wxCommandEvent & evt)
 {
-    p->main_frame->request_select_tab(MainFrame::TabPosition::tpCalibration);
+    p->main_frame->request_select_tab(TAB_ID_CALIBRATION);
     auto calibration_panel = p->main_frame->m_calibration;
     if (calibration_panel) {
         auto curr_wizard = static_cast<CalibrationWizard*>(calibration_panel->get_tabpanel()->GetPage(evt.GetInt()));
@@ -17460,7 +17478,7 @@ void Plater::print_job_finished(wxCommandEvent &evt)
     if (!dev) return;
 
     dev->set_selected_machine(evt.GetString().ToStdString());
-    p->main_frame->request_select_tab(MainFrame::TabPosition::tpMonitor);
+    p->main_frame->request_select_tab(TAB_ID_MONITOR);
     //jump to monitor and select device status panel
     MonitorPanel* curr_monitor = p->main_frame->m_monitor;
     if(curr_monitor)
@@ -17475,7 +17493,7 @@ void Plater::send_job_finished(wxCommandEvent& evt)
 
     send_gcode_finish(evt.GetString());
     p->hide_send_to_printer_dlg();
-    //p->main_frame->request_select_tab(MainFrame::TabPosition::tpMonitor);
+    //p->main_frame->request_select_tab(TAB_ID_MONITOR);
     ////jump to monitor and select device status panel
     //MonitorPanel* curr_monitor = p->main_frame->m_monitor;
     //if (curr_monitor)
@@ -18369,7 +18387,7 @@ void Plater::pop_warning_and_go_to_device_page(wxString printer_name, PrinterWar
     MessageDialog dlg(this, content, title, wxOK | wxFORWARD | wxICON_WARNING, _L("Device Page"));
     auto          result = dlg.ShowModal();
     if (result == wxFORWARD) {
-        wxGetApp().mainframe->select_tab(size_t(MainFrame::tpMonitor));
+        wxGetApp().mainframe->select_tab(TAB_ID_MONITOR);
     }
 }
 

src/slic3r/GUI/Plater.hpp

@@ -290,7 +290,7 @@ public:
     Plater(const Plater &) = delete;
     Plater &operator=(Plater &&) = delete;
     Plater &operator=(const Plater &) = delete;
-    ~Plater() = default;
+    ~Plater();
 
     bool Show(bool show = true);
 
@@ -1020,4 +1020,4 @@ wxArrayString get_all_camera_view_type();
 } // namespace GUI
 } // namespace Slic3r
 
-#endif
+#endif

src/slic3r/GUI/PluginWebDialog.cpp

@@ -15,39 +15,6 @@ namespace Slic3r { namespace GUI {
 
 namespace {
 
-// Low-specificity element defaults (no !important) for UNSTYLED plugin HTML, so a bare
-// plugin page looks native while any CSS the plugin ships still wins. Built on the
-// --orca-* variables the host injects (see WebViewHostDialog); document-start injected
-// AFTER the host contract so the variables are defined (shares the base injector's
-// WebView2 timing guard).
-std::string plugin_defaults_user_script()
-{
-    std::string css;
-    css += "<style id=\"orca-plugin-defaults\">";
-    css += "html,body{background:var(--orca-bg);color:var(--orca-fg);"
-           "font-family:var(--orca-font);font-size:13px;}";
-    css += "body{margin:0;}";
-    css += "h1,h2,h3,h4,h5,h6{color:var(--orca-fg);font-weight:600;}";
-    css += "a{color:var(--orca-accent);}";
-    css += "hr{border:0;border-top:1px solid var(--orca-border);}";
-    css += "button{font:inherit;color:var(--orca-accent-fg);background:var(--orca-accent);"
-           "border:1px solid var(--orca-accent);border-radius:4px;padding:5px 14px;cursor:pointer;}";
-    css += "button:hover{filter:brightness(1.1);}";
-    css += "button:disabled{opacity:.5;cursor:default;}";
-    css += "input,select,textarea{font:inherit;color:var(--orca-fg);"
-           "background:var(--orca-bg);border:1px solid var(--orca-border);"
-           "border-radius:4px;padding:4px 8px;}";
-    css += "input:focus,select:focus,textarea:focus{outline:none;border-color:var(--orca-accent);}";
-    css += "table{border-collapse:collapse;}";
-    css += "th,td{text-align:left;padding:6px 10px;border-bottom:1px solid var(--orca-border);}";
-    css += "th{color:var(--orca-muted);font-weight:600;}";
-    css += "::-webkit-scrollbar{width:12px;height:12px;}";
-    css += "::-webkit-scrollbar-thumb{background:var(--orca-border);border-radius:6px;}";
-    css += "::-webkit-scrollbar-track{background:transparent;}";
-    css += "</style>";
-    return WebViewHostDialog::document_start_injector(css, "orca-plugin-defaults", "beforeend");
-}
-
 // Injected into the top-level page at document start (before the plugin's own
 // scripts). Defines window.orca as the only host surface the page may use. It
 // references window.wx lazily (at call time) so it never races the backend's
@@ -129,7 +96,7 @@ PluginWebDialog::PluginWebDialog(wxWindow*          parent,
 void PluginWebDialog::add_user_scripts()
 {
     if (wxWebView* wv = browser()) {
-        wv->AddUserScript(wxString::FromUTF8(plugin_defaults_user_script()));
+        wv->AddUserScript(wxString::FromUTF8(WebViewHostDialog::plugin_defaults_user_script()));
         wv->AddUserScript(ORCA_BRIDGE_JS);
     }
 }

src/slic3r/GUI/Preferences.cpp

@@ -1748,11 +1748,26 @@ void PreferencesDialog::create_items()
     g_sizer->Add(item_pop_up_filament_map_dialog);
 #endif
 
+    //// GENERAL > Plugins
+    g_sizer->Add(create_item_title(_L("Plugins")), 1, wxEXPAND);
+
+    auto item_plugin_pages_visible_count = create_item_spinctrl(
+        _L("Visible plugin pages"),
+        "",
+        _L("pages"),
+        _L("Number of plugin pages shown as fixed tabs before the remaining pages collapse into a dropdown on the last tab."),
+        SETTING_PLUGIN_PAGES_VISIBLE_COUNT,
+        PLUGIN_PAGES_VISIBLE_COUNT_MIN,
+        PLUGIN_PAGES_VISIBLE_COUNT_MAX,
+        [](int value) { wxGetApp().mainframe->plugin_pages().set_visible_page_count(value); }
+    );
+    g_sizer->Add(item_plugin_pages_visible_count);
+
     g_sizer->AddSpacer(FromDIP(10));
     sizer_page->Add(g_sizer, 0, wxEXPAND);
 
     //////////////////////////
-    //// CONTROL TAB 
+    //// CONTROL TAB
     /////////////////////////////////////
     m_pref_tabs->AppendItem(_L("Control"));
     f_sizers.push_back(new wxFlexGridSizer(1, 1, v_gap, 0));

src/slic3r/GUI/PresetComboBoxes.cpp

@@ -1049,7 +1049,7 @@ bool PlaterPresetComboBox::switch_to_tab()
 
     //BBS  Select NoteBook Tab params
     if (tab->GetParent() == wxGetApp().params_panel())
-        wxGetApp().mainframe->select_tab(MainFrame::tp3DEditor);
+        wxGetApp().mainframe->select_tab(TAB_ID_PREPARE);
     else {
         wxGetApp().params_dialog()->Popup();
         tab->OnActivate();

src/slic3r/GUI/PresetComboBoxes.hpp

@@ -39,7 +39,7 @@ public:
     PresetComboBox(wxWindow* parent, Preset::Type preset_type, const wxSize& size = wxDefaultSize, PresetBundle* preset_bundle = nullptr);
     ~PresetComboBox();
 
-	enum LabelItemType {
+	enum LabelItemType : std::size_t {
 		LABEL_ITEM_PHYSICAL_PRINTER = 0xffffff01,
         LABEL_ITEM_PRINTER_MODELS,
 		LABEL_ITEM_DISABLED,

src/slic3r/GUI/Project.cpp

@@ -74,7 +74,18 @@ ProjectPanel::ProjectPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos,
     Fit();
 }
 
-ProjectPanel::~ProjectPanel() {}
+ProjectPanel::~ProjectPanel()
+{
+    shutdown();
+}
+
+void ProjectPanel::shutdown()
+{
+    m_reload_cancel_token->store(true, std::memory_order_release);
+    if (m_reload_task && m_reload_task->joinable())
+        m_reload_task->join();
+    m_reload_task.reset();
+}
 
 // Helper to convert newlines to <br>
 static std::string convert_newlines_to_br(const std::string& text) {
@@ -101,7 +112,17 @@ void ProjectPanel::onWebNavigating(wxWebViewEvent& evt)
 
 void ProjectPanel::on_reload(wxCommandEvent& evt)
 {
-    boost::thread reload = boost::thread([this] {
+    if (wxTheApp == nullptr || wxGetApp().is_closing() ||
+        m_reload_cancel_token->load(std::memory_order_acquire))
+        return;
+
+    if (m_reload_task && m_reload_task->joinable())
+        m_reload_task->join();
+
+    const auto cancel_token = m_reload_cancel_token;
+    m_reload_task = std::make_unique<boost::thread>([this, cancel_token] {
+        if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
+            return;
         std::string update_type;
         std::string license;
         std::string model_name;
@@ -115,6 +136,9 @@ void ProjectPanel::on_reload(wxCommandEvent& evt)
 
         std::map<std::string, std::vector<json>> files;
 
+        if (wxGetApp().plater() == nullptr)
+            return;
+
         Model model = wxGetApp().plater()->model();
 
         auto model_info = model.model_info;
@@ -156,7 +180,14 @@ void ProjectPanel::on_reload(wxCommandEvent& evt)
         std::string file_path = encode_path(wxGetApp().plater()->model().get_auxiliary_file_temp_path().c_str());
         if (!file_path.empty()) {
             files = Reload(file_path);
-            wxGetApp().CallAfter([this, file_path, files] { m_auxiliary->Reload(file_path, files); });
+            if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
+                return;
+
+            wxGetApp().CallAfter([this, cancel_token, file_path, files] {
+                if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
+                    return;
+                m_auxiliary->Reload(file_path, files);
+            });
         } else {
             clear_model_info();
             return;
@@ -215,15 +246,18 @@ void ProjectPanel::on_reload(wxCommandEvent& evt)
 
         json m_Res = json::object();
         m_Res["command"] = "show_3mf_info";
-        m_Res["sequence_id"] = std::to_string(ProjectPanel::m_sequence_id++);
+        m_Res["sequence_id"] = std::to_string(ProjectPanel::m_sequence_id.fetch_add(1, std::memory_order_relaxed));
         m_Res["model"] = j;
 
         wxString strJS = wxString::Format("HandleStudio(%s)", m_Res.dump(-1, ' ', false, json::error_handler_t::ignore));
 
-        if (m_web_init_completed) {
-            wxGetApp().CallAfter([this, strJS] {
+        if (m_web_init_completed.load(std::memory_order_acquire) &&
+            !cancel_token->load(std::memory_order_acquire) && wxTheApp != nullptr && !wxGetApp().is_closing()) {
+            wxGetApp().CallAfter([this, cancel_token, strJS] {
+                if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
+                    return;
                 RunScript(strJS.ToStdString());
-                });
+            });
         }
     });
 }
@@ -264,7 +298,7 @@ void ProjectPanel::OnScriptMessage(wxWebViewEvent& evt)
             }
         }
         else if (strCmd == "request_3mf_info") {
-            m_web_init_completed = true;
+            m_web_init_completed.store(true, std::memory_order_release);
         }
         else if (strCmd == "edit_project_info") {
             show_info_editor(true);
@@ -307,13 +341,20 @@ void ProjectPanel::update_model_data()
 
 void ProjectPanel::clear_model_info()
 {
+    if (wxTheApp == nullptr || wxGetApp().is_closing() ||
+        m_reload_cancel_token->load(std::memory_order_acquire))
+        return;
+
     json m_Res = json::object();
     m_Res["command"] = "clear_3mf_info";
-    m_Res["sequence_id"] = std::to_string(ProjectPanel::m_sequence_id++);
+    m_Res["sequence_id"] = std::to_string(ProjectPanel::m_sequence_id.fetch_add(1, std::memory_order_relaxed));
 
     wxString strJS = wxString::Format("HandleStudio(%s)", m_Res.dump(-1, ' ', false, json::error_handler_t::ignore));
 
-    wxGetApp().CallAfter([this, strJS] {
+    const auto cancel_token = m_reload_cancel_token;
+    wxGetApp().CallAfter([this, cancel_token, strJS] {
+        if (cancel_token->load(std::memory_order_acquire) || wxTheApp == nullptr || wxGetApp().is_closing())
+            return;
         RunScript(strJS.ToStdString());
     });
 }

src/slic3r/GUI/Project.hpp

@@ -26,9 +26,11 @@
 #include "nlohmann/json.hpp"
 #include "slic3r/Utils/json_diff.hpp"
 
+#include <atomic>
 #include <map>
 #include <vector>
 #include <memory>
+#include <boost/thread.hpp>
 #include "Event.hpp"
 #include "libslic3r/ProjectTask.hpp"
 #include "wxExtensions.hpp"
@@ -60,14 +62,17 @@ struct project_file{
 class ProjectPanel : public wxPanel
 {
 private:
-    bool       m_web_init_completed = {false};
+    std::atomic<bool> m_web_init_completed{false};
     bool       m_reload_already = {false};
 
+    std::shared_ptr<std::atomic<bool>> m_reload_cancel_token{std::make_shared<std::atomic<bool>>(false)};
+    std::unique_ptr<boost::thread> m_reload_task;
+
     wxWebView* m_browser = {nullptr};
     AuxiliaryPanel*   m_auxiliary{nullptr};
     wxString   m_project_home_url;
     wxString   m_root_dir;
-    static inline int m_sequence_id = 8000;
+    static inline std::atomic<int> m_sequence_id{8000};
 
     void show_info_editor(bool show);
     
@@ -75,6 +80,7 @@ private:
 public:
     ProjectPanel(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
     ~ProjectPanel();
+    void shutdown();
 
     
     void onWebNavigating(wxWebViewEvent& evt);

src/slic3r/GUI/ReleaseNote.cpp

@@ -1991,7 +1991,7 @@ void InputIpAddressDialog::workerThreadFunc(std::string str_ip, std::string str_
         if (w.expired()) return;
 
         if (m_obj) {
-            m_obj->set_user_access_code(str_access_code);
+            m_obj->set_access_code(str_access_code);
             wxGetApp().getDeviceManager()->set_selected_machine(m_obj->get_dev_id());
         }
 
@@ -2055,6 +2055,11 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
 {
     auto str_ip              = m_input_ip->GetTextCtrl()->GetValue();
     auto str_access_code     = m_input_access_code->GetTextCtrl()->GetValue();
+
+    if (str_access_code.empty()) {
+        str_access_code = "88888888";
+    }
+
     auto str_name            = m_input_printer_name->GetTextCtrl()->GetValue().Strip(wxString::both);
     auto str_sn              = m_input_sn->GetTextCtrl()->GetValue().Strip(wxString::both);
     bool invalid_access_code = true;
@@ -2062,7 +2067,7 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
     for (char c : str_access_code) {
         if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))) {
             invalid_access_code = false;
-            return;
+            break;
         }
     }
 

src/slic3r/GUI/SavePresetDialog.cpp

@@ -111,18 +111,20 @@ SavePresetDialog::Item::Item(Preset::Type type, const std::string &suffix, wxBox
 
     sizer->Add(m_radio_group, 0, wxEXPAND | wxTOP | wxLEFT, BORDER_W);
 
-    std::string inherits_str = sel_preset.inherits();
-    if (parent->m_mode == comDevelop && !inherits_str.empty()) {
+    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();
+
         wxBoxSizer *detach_sizer = new wxBoxSizer(wxHORIZONTAL);
 
-        auto detach_tooltip  = _L("Copies all inherited values from the parent preset into this preset and removes the connection with the parent preset.");
+        auto detach_tooltip  = _L("Copies all inherited values from the parent into this preset and removes the parent relationship. Presets compatible only with the parent may become unsupported.");
 
         auto detach_checkbox = new ::CheckBox(parent);
         detach_checkbox->SetToolTip(detach_tooltip);
 
         auto detach_label    = new wxStaticText(parent, wxID_ANY, _L("Detach from 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);
@@ -130,27 +132,36 @@ SavePresetDialog::Item::Item(Preset::Type type, const std::string &suffix, wxBox
         sizer->Add(detach_sizer, 0, wxEXPAND | wxTOP, BORDER_W);
         sizer->AddSpacer(FromDIP(5));
 
-        auto parent_label    = new wxStaticText(parent, wxID_ANY, inherits_str);
+        const wxString parent_text = can_detach ? 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(_L("Parent preset"));
+        parent_label->SetToolTip(can_detach ? _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));
 
-        // 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&) { m_detach = detach_checkbox->GetValue(); });
+        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&) { m_detach = detach_checkbox->GetValue(); });
 
-        auto on_toggle = [this, 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();});
+            detach_label->SetForegroundColour(wxColour("#363636"));
+
+            auto on_toggle = [this, 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

@@ -1088,8 +1088,8 @@ void SelectMachineDialog::sync_ams_mapping_result(std::vector<FilamentInfo> &res
         }
     }
     relayout_nozzle_cards();
-    auto tab_index = (MainFrame::TabPosition) dynamic_cast<Notebook *>(wxGetApp().tab_panel())->GetSelection();
-    if (tab_index == MainFrame::TabPosition::tp3DEditor || tab_index == MainFrame::TabPosition::tpPreview) {
+    wxString tab_name = wxGetApp().tab_panel()->GetSelectedPageName();
+    if (tab_name == TAB_ID_PREPARE || tab_name == TAB_ID_PREVIEW) {
         updata_thumbnail_data_after_connected_printer();
     }
 }
@@ -3912,7 +3912,7 @@ _collect_sorted_machines(Slic3r::DeviceManager* dev_manager,
     };
 
     // collect from user machine list
-    const auto& user_machine_list = dev_manager->get_my_machine_list();// user machine list
+    const auto& user_machine_list = dev_manager->get_my_machine_list(dev_manager->get_current_printer_agent_id());// user machine list
     for (const auto& elem : user_machine_list)
     {
         MachineObject* mobj = elem.second;

src/slic3r/GUI/SelectMachinePop.cpp

@@ -501,6 +501,7 @@ void SelectMachinePopup::update_other_devices()
     DeviceManager* dev = wxGetApp().getDeviceManager();
     if (!dev) return;
     m_free_machine_list = dev->get_local_machinelist();
+    const std::string current_agent_id = dev->get_current_printer_agent_id();
 
     BOOST_LOG_TRIVIAL(trace) << "SelectMachinePopup update_other_devices start";
     this->Freeze();
@@ -512,6 +513,10 @@ void SelectMachinePopup::update_other_devices()
         /* do not show printer bind state is empty */
         if (!mobj->is_avaliable()) continue;
 
+        /* do not show devices discovered/bound by a different printer agent */
+        if (mobj->printer_agent_id != current_agent_id)
+            continue;
+
         if (!wxGetApp().is_user_login(wxGetApp().get_printer_cloud_provider()) && !mobj->is_lan_mode_printer())
             continue;
 
@@ -634,7 +639,7 @@ void SelectMachinePopup::update_user_devices()
     }
 
     m_bind_machine_list.clear();
-    m_bind_machine_list = dev->get_my_machine_list();
+    m_bind_machine_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
     //sort list
     std::vector<std::pair<std::string, MachineObject*>> user_machine_list;
@@ -704,7 +709,6 @@ void SelectMachinePopup::update_user_devices()
                     }
 
                     mobj->set_access_code("");
-                    mobj->erase_user_access_code();
                 }
 
                 if (GUI::wxGetApp().plater())

src/slic3r/GUI/SyncAmsInfoDialog.cpp

@@ -1218,8 +1218,8 @@ void SyncAmsInfoDialog::sync_ams_mapping_result(std::vector<FilamentInfo> &resul
             iter++;
         }
     }
-    auto tab_index = (MainFrame::TabPosition) dynamic_cast<Notebook *>(wxGetApp().tab_panel())->GetSelection();
-    if (tab_index == MainFrame::TabPosition::tp3DEditor || tab_index == MainFrame::TabPosition::tpPreview) {
+    wxString tab_name = wxGetApp().tab_panel()->GetSelectedPageName();
+    if (tab_name == TAB_ID_PREPARE || tab_name == TAB_ID_PREVIEW) {
         updata_thumbnail_data_after_connected_printer();
     }
 }

src/slic3r/GUI/Tab.cpp

@@ -2790,7 +2790,7 @@ void TabPrint::build()
         optgroup->append_single_option_line("fill_multiline", "strength_settings_infill#fill-multiline");
         optgroup->append_single_option_line("sparse_infill_pattern", "strength_settings_infill#sparse-infill-pattern");
         optgroup->append_single_option_line("gyroid_optimized", "strength_settings_patterns#gyroid-optimized");
-        optgroup->append_single_option_line("sparse_infill_smooth_factor", "strength_settings_patterns#sparse-infill-smooth-factor");
+        optgroup->append_single_option_line("sparse_infill_smooth_factor", "strength_settings_infill#sparse-infill-smooth-factor");
         optgroup->append_single_option_line("infill_direction", "strength_settings_infill#direction");
         optgroup->append_single_option_line("sparse_infill_rotate_template", "strength_settings_infill_rotation_template_metalanguage");
         optgroup->append_single_option_line("skin_infill_density", "strength_settings_patterns#locked-zag");
@@ -6458,7 +6458,7 @@ void Tab::load_current_preset()
                             std::string bmp_name = tab->type() == Slic3r::Preset::TYPE_FILAMENT      ? "spool" :
                                                    tab->type() == Slic3r::Preset::TYPE_SLA_MATERIAL  ? "" : "cog";
                             tab->Hide(); // #ys_WORKAROUND : Hide tab before inserting to avoid unwanted rendering of the tab
-                            dynamic_cast<Notebook*>(wxGetApp().tab_panel())->InsertPage(wxGetApp().tab_panel()->FindPage(this), tab, tab->title(), bmp_name);
+                            dynamic_cast<Notebook*>(wxGetApp().tab_panel())->InsertPage(wxGetApp().tab_panel()->FindPage(this), wxString(), tab, tab->title(), bmp_name);
                         }
                         else
 #endif
@@ -8537,8 +8537,12 @@ void Page::activate(ConfigOptionMode mode, std::function<void()> throw_if_cancel
 
 #ifdef __WXMSW__
     // BBS: fix field control position
-    wxTheApp->CallAfter([this]() {
-        for (auto group : m_optgroups) {
+    wxTheApp->CallAfter([wp = std::weak_ptr<Page>(shared_from_this())]() {
+        auto page = wp.lock();
+        if (!page)
+            return;
+
+        for (auto group : page->m_optgroups) {
             if (group->custom_ctrl)
                 group->custom_ctrl->fixup_items_positions();
         }

src/slic3r/GUI/Tabbook.hpp

@@ -108,7 +108,7 @@ public:
     // by this control) and show it immediately.
     bool ShowNewPage(wxWindow * page)
     {
-        return AddPage(page, wxString(), ""/*true *//* select it */);
+        return AddPage(page, wxString());
     }
 
     // Set effect to use for showing/hiding pages.
@@ -139,14 +139,13 @@ public:
 
     // Implement base class pure virtual methods.
 
-    // adds a new page to the control
     bool AddPage(wxWindow* page,
                  const wxString& text,
-                 const std::string& bmp_name,
-                 bool bSelect = false)
+                 bool bSelect = false,
+                 int imageId = NO_IMAGE) override
     {
         DoInvalidateBestSize();
-        return InsertNewPage(GetPageCount(), page, text, bmp_name, bSelect);
+        return InsertPage(GetPageCount(), page, text, bSelect, imageId);
     }
 
     //// Page management
@@ -167,23 +166,6 @@ public:
         return true;
     }
 
-    bool InsertNewPage(size_t n,
-                    wxWindow * page,
-                    const wxString & text,
-                    const std::string& bmp_name = "",
-                    bool bSelect = false)
-    {
-        if (!wxBookCtrlBase::InsertPage(n, page, text, bSelect))
-            return false;
-
-        GetBtnsListCtrl()->InsertPage(n, text, bSelect, bmp_name);
-
-        if (bSelect)
-            SetSelection(n);
-
-        return true;
-    }
-
     bool RemovePage(size_t n)
     {
         if (!wxBookCtrlBase::RemovePage(n))

src/slic3r/GUI/WebGuideDialog.cpp

@@ -1,7 +1,9 @@
 #include "WebGuideDialog.hpp"
 #include "ConfigWizard.hpp"
 
+#include <boost/algorithm/string/join.hpp>
 #include <boost/filesystem/operations.hpp>
+#include <boost/nowide/fstream.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/iostreams/detail/select.hpp>
 #include <boost/log/trivial.hpp>
@@ -9,7 +11,9 @@
 #include "I18N.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "libslic3r/Config.hpp"
+#include "libslic3r/Preset.hpp"
 #include "libslic3r/PresetBundle.hpp"
+#include "libslic3r/PresetCacheFormat.hpp"
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "libslic3r_version.h"
@@ -41,8 +45,6 @@ using namespace nlohmann;
 
 namespace Slic3r { namespace GUI {
 
-json m_ProfileJson;
-
 static wxString update_custom_filaments()
 {
     json m_Res                                                                     = json::object();
@@ -190,12 +192,10 @@ GuideFrame::GuideFrame(GUI_App *pGUI, long style)
 
 GuideFrame::~GuideFrame()
 {
-    m_destroy = true;
-    if (m_load_task && m_load_task->joinable()) {
+    *m_cancel_token = true; // stop the loading thread and any queued CallAfter lambdas before join
+    if (m_load_task && m_load_task->joinable())
         m_load_task->join();
-        delete m_load_task;
-        m_load_task = nullptr;
-    }
+    m_load_task.reset();
     if (m_browser) {
         delete m_browser;
         m_browser = nullptr;
@@ -301,15 +301,71 @@ void GuideFrame::OnNavigationRequest(wxWebViewEvent &evt)
 /**
  * Callback invoked when a navigation request was accepted
  */
+// The empty shape every profile-loading path starts from or falls back to.
+void GuideFrame::reset_profile_json()
+{
+    m_ProfileJson["model"]    = json::array();
+    m_ProfileJson["machine"]  = json::object();
+    m_ProfileJson["filament"] = json::object();
+    m_ProfileJson["process"]  = json::array();
+}
+
+void GuideFrame::init_guide_paths()
+{
+    m_ProfileJson = json::parse("{}");
+    reset_profile_json();
+
+    vendor_dir      = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
+    rsrc_vendor_dir = (boost::filesystem::path(resources_dir()) / "profiles").make_preferred();
+    orca_bundle_rsrc = true;
+
+    if (boost::filesystem::exists(vendor_dir)) {
+        for (const auto& entry : boost::filesystem::directory_iterator(vendor_dir)) {
+            if (!boost::filesystem::is_directory(entry) &&
+                boost::iequals(entry.path().extension().string(), ".json") &&
+                !boost::iequals(entry.path().stem().string(), PresetBundle::ORCA_FILAMENT_LIBRARY)) {
+                orca_bundle_rsrc = false;
+                break;
+            }
+        }
+    }
+
+    auto lib_json = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
+    m_OrcaFilaLibPath = boost::filesystem::exists(vendor_dir / lib_json)
+        ? (vendor_dir      / PresetBundle::ORCA_FILAMENT_LIBRARY).string()
+        : (rsrc_vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
+}
+
+void GuideFrame::on_profile_loaded()
+{
+    // Must be called on the main thread.
+    SaveProfileData();
+    const std::string strAll = m_ProfileJson.dump(-1, ' ', false, json::error_handler_t::ignore);
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished, json contents:\n" << strAll;
+    json res;
+    res["command"]     = "userguide_profile_load_finish";
+    res["sequence_id"] = "10001";
+    RunScript(wxString::Format("HandleStudio(%s)", res.dump(-1, ' ', true)));
+}
+
 void GuideFrame::OnNavigationComplete(wxWebViewEvent &evt)
 {
     //wxLogMessage("%s", "Navigation complete; url='" + evt.GetURL() + "'");
     if (!bFirstComplete) {
-        m_load_task = new boost::thread(boost::bind(&GuideFrame::LoadProfileData, this));
-       // boost::thread LoadProfileThread(boost::bind(&GuideFrame::LoadProfileData, this));
-        //LoadProfileThread.detach();
-
         bFirstComplete = true;
+        try {
+            init_guide_paths();
+            if (BuildProfileDataFromPresetBundle()) {
+                if (!*m_cancel_token)
+                    on_profile_loaded();
+            } else {
+                // Presets not yet in memory — delegate to background thread.
+                m_load_task = std::make_unique<boost::thread>(boost::bind(&GuideFrame::LoadProfileData, this));
+            }
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", init error: " << e.what();
+            m_load_task = std::make_unique<boost::thread>(boost::bind(&GuideFrame::LoadProfileData, this));
+        }
     }
 
     m_browser->Show();
@@ -762,11 +818,9 @@ bool GuideFrame::apply_config(AppConfig *app_config, PresetBundle *preset_bundle
     bool check_unsaved_preset_changes = false;
     std::vector<std::string> install_bundles;
     std::vector<std::string> remove_bundles;
-    const auto vendor_dir = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
     for (const auto &it : enabled_vendors) {
         if (it.second.size() > 0) {
-            auto vendor_file = vendor_dir/(it.first + ".json");
-            if (!fs::exists(vendor_file)) {
+            if (!is_vendor_installed(it.first)) {
                 install_bundles.emplace_back(it.first);
             }
         }
@@ -777,8 +831,7 @@ bool GuideFrame::apply_config(AppConfig *app_config, PresetBundle *preset_bundle
         if (it.second.size() > 0) {
             if (enabled_vendors.find(it.first) != enabled_vendors.end())
                 continue;
-            auto vendor_file = vendor_dir/(it.first + ".json");
-            if (fs::exists(vendor_file)) {
+            if (is_vendor_installed(it.first)) {
                 remove_bundles.emplace_back(it.first);
             }
         }
@@ -1127,99 +1180,324 @@ int GuideFrame::GetFilamentInfo( std::string VendorDirectory, json & pFilaList,
     return status;
 }
 
-int GuideFrame::LoadProfileData()
+bool GuideFrame::BuildProfileJson(const PresetBundle& bundle, bool require_all_resource_vendors)
 {
     try {
-        m_ProfileJson             = json::parse("{}");
-        m_ProfileJson["model"]    = json::array();
-        m_ProfileJson["machine"]  = json::object();
-        m_ProfileJson["filament"] = json::object();
-        m_ProfileJson["process"]  = json::array();
+        // Models from vendor profiles
+        for (const auto& [vendor_id, vp] : bundle.vendors) {
+            for (const auto& model : vp.models) {
+                std::string nozzle_str;
+                for (const auto& v : model.variants) {
+                    if (!nozzle_str.empty()) nozzle_str += ";";
+                    nozzle_str += v.name;
+                }
+                const std::string materials_str = boost::algorithm::join(model.default_materials, ";");
+                boost::filesystem::path cover_path =
+                    (boost::filesystem::path(resources_dir()) / "profiles" / vp.id / (model.id + "_cover.png"))
+                        .make_preferred();
+                if (!boost::filesystem::exists(cover_path))
+                    cover_path =
+                        (boost::filesystem::path(resources_dir()) / "web/image/printer" / (model.id + "_cover.png"))
+                            .make_preferred();
 
-        vendor_dir      = (boost::filesystem::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR).make_preferred();
-        rsrc_vendor_dir = (boost::filesystem::path(resources_dir()) / "profiles").make_preferred();
-
-        // Orca: add custom as default
-        // Orca: add json logic for vendor bundle
-        orca_bundle_rsrc = true;
-
-        // search if there exists a .json file in vendor_dir folder, if exists, set orca_bundle_rsrc to false
-        for (const auto& entry : boost::filesystem::directory_iterator(vendor_dir)) {
-            if (!boost::filesystem::is_directory(entry) && boost::iequals(entry.path().extension().string(), ".json") && !boost::iequals(entry.path().stem().string(), PresetBundle::ORCA_FILAMENT_LIBRARY)) {
-                orca_bundle_rsrc = false;
-                break;
+                json entry;
+                entry["model"]           = model.id;
+                entry["name"]            = model.name;
+                entry["vendor"]          = vp.id;
+                entry["nozzle_diameter"] = nozzle_str;
+                entry["materials"]       = materials_str;
+                entry["cover"]           = cover_path.string();
+                entry["nozzle_selected"] = "";
+                entry["sub_path"]        = "";
+                m_ProfileJson["model"].push_back(entry);
             }
         }
 
-        // load the default filament library first
-        std::set<std::string> loaded_vendors;
-        auto filament_library_name = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
-        if (boost::filesystem::exists(vendor_dir / filament_library_name)) {
-            m_OrcaFilaLibPath = (vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
-            LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (vendor_dir / filament_library_name).string());
-        } else {
-            m_OrcaFilaLibPath = (rsrc_vendor_dir / PresetBundle::ORCA_FILAMENT_LIBRARY).string();
-            LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (rsrc_vendor_dir / filament_library_name).string());
-        }
-        loaded_vendors.insert(PresetBundle::ORCA_FILAMENT_LIBRARY);
+        // Machine map: preset name -> {model, nozzle variant}
+        for (const Preset& p : bundle.printers()) {
+            if (!p.is_system || !p.vendor) continue;
+            const auto* printer_model   = p.config.option<ConfigOptionString>("printer_model");
+            const auto* printer_variant = p.config.option<ConfigOptionString>("printer_variant");
+            if (!printer_model || printer_model->value.empty() || !printer_variant) continue;
 
-        //load custom bundle from user data path
-        boost::filesystem::directory_iterator endIter;
-        for (boost::filesystem::directory_iterator iter(vendor_dir); iter != endIter; iter++) {
-            if (!boost::filesystem::is_directory(*iter)) {
-                wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
-                strVendor          = strVendor.AfterLast('\\');
-                strVendor          = strVendor.AfterLast('/');
-
-                wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
-                if(strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
-                    continue;
-
-                LoadProfileFamily(w2s(strVendor), iter->path().string());
-                loaded_vendors.insert(w2s(strVendor));
-            }
-            if (m_destroy)
-                return 0;
+            json mach;
+            mach["model"]  = printer_model->value;
+            mach["nozzle"] = printer_variant->value;
+            m_ProfileJson["machine"][p.name] = mach;
         }
 
-        boost::filesystem::directory_iterator others_endIter;
-        for (boost::filesystem::directory_iterator iter(rsrc_vendor_dir); iter != others_endIter; iter++) {
-            if (!boost::filesystem::is_directory(*iter)) {
-                wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
-                strVendor          = strVendor.AfterLast('\\');
-                strVendor          = strVendor.AfterLast('/');
-                wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
-                if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
-                    continue;
+        // Filament map from system filament presets (vendor/type already resolved in config)
+        const json& machines = m_ProfileJson["machine"];
+        for (const Preset& p : bundle.filaments()) {
+            if (!p.is_system || !p.vendor) continue;
+            const auto* fila_vendor     = p.config.option<ConfigOptionStrings>("filament_vendor");
+            const auto* fila_type       = p.config.option<ConfigOptionStrings>("filament_type");
+            const auto* compat_printers = p.config.option<ConfigOptionStrings>("compatible_printers");
 
-                LoadProfileFamily(w2s(strVendor), iter->path().string());
-                loaded_vendors.insert(w2s(strVendor));
+            std::string vendor = (fila_vendor && !fila_vendor->values.empty()) ? fila_vendor->values[0] : "";
+            std::string type   = (fila_type   && !fila_type->values.empty())   ? fila_type->values[0]   : "";
+
+            std::string model_list;
+            if (compat_printers) {
+                for (const std::string& pname : compat_printers->values) {
+                    auto it = machines.find(pname);
+                    if (it != machines.end()) {
+                        const std::string m = (*it)["model"];
+                        const std::string n = (*it)["nozzle"];
+                        model_list += "[" + m + "++" + n + "]";
+                    }
+                }
             }
-            if (m_destroy)
-                return 0;
+
+            json ff;
+            ff["name"]     = p.name;
+            ff["sub_path"] = p.file;
+            ff["vendor"]   = vendor;
+            ff["type"]     = type;
+            ff["models"]   = model_list;
+            ff["selected"] = 0;
+            m_ProfileJson["filament"][p.name] = ff;
         }
 
-        wxGetApp().CallAfter([this] {
-            if (!m_destroy) {
-                //sync to appconfig first to populate current selections
-                SaveProfileData();
+        // Process list from visible system print presets
+        for (const Preset& p : bundle.prints()) {
+            if (!p.is_system || !p.vendor || !p.is_visible) continue;
+            json entry;
+            entry["name"]     = p.name;
+            entry["sub_path"] = p.file;
+            m_ProfileJson["process"].push_back(entry);
+        }
 
-                //sync to web after selections are populated
-                std::string strAll = m_ProfileJson.dump(-1, ' ', false, json::error_handler_t::ignore);
+        if (require_all_resource_vendors) {
+            // If rsrc_vendor_dir has vendors (profile JSONs, or the preset caches a
+            // packaged build ships instead) not covered by the current bundle, the
+            // bundle is incomplete (e.g. dev env where data_dir/system only has
+            // OrcaFilamentLibrary+Custom). Fall back so the slow path reads both dirs.
+            try {
+                for (const std::string& name : vendor_names_in(rsrc_vendor_dir)) {
+                    if (bundle.vendors.find(name) == bundle.vendors.end()) {
+                        BOOST_LOG_TRIVIAL(info) << "GuideFrame: vendor '" << name
+                            << "' in resources but not in preset_bundle — falling back to JSON loading";
+                        reset_profile_json();
+                        return false;
+                    }
+                }
+            } catch (const std::exception&) {}
+        }
 
-                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", finished, json contents: " << std::endl << strAll;
-                json m_Res           = json::object();
-                m_Res["command"]     = "userguide_profile_load_finish";
-                m_Res["sequence_id"] = "10001";
-                wxString strJS       = wxString::Format("HandleStudio(%s)", m_Res.dump(-1, ' ', true));
+        BOOST_LOG_TRIVIAL(info) << "GuideFrame: built profile data ("
+                                << m_ProfileJson["model"].size()    << " models, "
+                                << m_ProfileJson["machine"].size()  << " machines, "
+                                << m_ProfileJson["filament"].size() << " filaments)";
+        return !m_ProfileJson["machine"].empty();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "GuideFrame::BuildProfileJson failed: " << e.what()
+                                   << " — falling back to JSON loading";
+        reset_profile_json();
+        return false;
+    }
+}
 
-                RunScript(strJS);
+bool GuideFrame::BuildProfileDataFromPresetBundle()
+{
+    PresetBundle* pb = wxGetApp().preset_bundle;
+    if (!pb || pb->vendors.empty())
+        return false;
+    return BuildProfileJson(*pb, /*require_all_resource_vendors=*/true);
+}
+
+bool GuideFrame::BuildProfileDataFromVendors()
+{
+    try {
+        // Same vendor set and precedence as the JSON scan in LoadProfileData: a
+        // vendor in the user's system dir shadows the bundled one of that name.
+        // vendor_names_in names a vendor by its profile or, where a build ships
+        // preset caches instead, by its cache alone.
+        std::map<std::string, boost::filesystem::path> vendor_sources;
+        for (const boost::filesystem::path& dir : { vendor_dir, rsrc_vendor_dir }) {
+            boost::system::error_code ec;
+            if (boost::filesystem::exists(dir, ec))
+                for (const std::string& name : vendor_names_in(dir))
+                    vendor_sources.emplace(name, dir);   // first dir wins
+        }
+
+        // The load order: the filament library first, because the others'
+        // filaments inherit from it, then every versioned vendor — each loaded
+        // from the directory it was found in, so a vendor that is not installed
+        // is served from the shipped profiles. Each is stamped by name and
+        // version alone: a profile change requires a version bump, so those two
+        // determine content wherever the vendor's copy sits.
+        struct VendorSource { std::string name; boost::filesystem::path dir; std::string version; };
+        std::vector<VendorSource> ordered;
+        auto add_vendor = [&ordered](const std::string& name, const boost::filesystem::path& dir) {
+            // The version a load from `dir` would serve: the profile's where one
+            // exists (a cache is only served while it covers the profile beside
+            // it), the cache's own stamp where the cache is the whole vendor.
+            // A profile without a version (blacklist.json) carries no presets
+            // and is passed over.
+            const boost::filesystem::path profile = dir / (name + ".json");
+            if (boost::filesystem::exists(profile)) {
+                const Semver v = get_version_from_json(profile.string());
+                if (v.valid())
+                    ordered.push_back({name, dir, v.to_string()});
+            } else {
+                ordered.push_back({name, dir,
+                    VendorCacheFile::peek_version((dir / (name + ".opc")).string(), name)});
             }
+        };
+        const std::string filament_library(PresetBundle::ORCA_FILAMENT_LIBRARY);
+        if (auto it = vendor_sources.find(filament_library); it != vendor_sources.end())
+            add_vendor(filament_library, it->second);
+        for (const auto& [name, dir] : vendor_sources)
+            if (name != filament_library)
+                add_vendor(name, dir);
+        if (ordered.empty())
+            return false;
+        json stamps = json::array();
+        for (const VendorSource& v : ordered)
+            stamps.push_back({v.name, v.version});
+
+        // What this function derives is a pure function of that stamped set, so
+        // the derived JSON is cached whole: a fresh cache makes an open one
+        // file read, with no bundle built and no preset installed. Stale or
+        // absent, the bundle is rebuilt below and the result written back.
+        const boost::filesystem::path cache_file =
+            boost::filesystem::path(Slic3r::data_dir()) / "cache" / "wizard_profile_data.json";
+        try {
+            // Slurped whole and parsed from the buffer — nlohmann's fastest
+            // input path; a stream adapter costs real time on a multi-MB file.
+            boost::nowide::ifstream ifs(cache_file.string(), std::ios::binary);
+            if (ifs.is_open()) {
+                const std::string text{std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>()};
+                json cached = json::parse(text);
+                if (cached.value("format", 0) == 1 && cached["vendors"] == stamps &&
+                    ! cached["profile"]["machine"].empty()) {
+                    for (const char* key : { "model", "machine", "filament", "process" })
+                        m_ProfileJson[key] = std::move(cached["profile"][key]);
+                    BOOST_LOG_TRIVIAL(info) << "GuideFrame: profile data served from " << cache_file;
+                    return true;
+                }
+            }
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(info) << "GuideFrame: rejecting cached profile data: " << e.what();
+        }
+
+        // Each vendor comes from its preset cache where one covers it, which is
+        // what makes this worth doing instead of the scan below; loading into a
+        // bundle per vendor keeps the install order the startup path has.
+        PresetBundle bundle;
+        auto load_vendor = [](PresetBundle& into, const std::string& vendor,
+                              const boost::filesystem::path& dir, const PresetBundle* base) {
+            into.load_vendor_configs_from_json(dir.string(), vendor, PresetBundle::LoadSystem,
+                                               ForwardCompatibilitySubstitutionRule::EnableSilent, base);
+        };
+        for (const VendorSource& v : ordered) {
+            if (*m_cancel_token)
+                return false;   // as in the scan below: a vendor without a cache is parsed, and that takes time
+            if (v.name == filament_library) {
+                load_vendor(bundle, v.name, v.dir, nullptr);
+            } else {
+                PresetBundle tmp;
+                load_vendor(tmp, v.name, v.dir, &bundle);
+                bundle.merge_presets(std::move(tmp));
+            }
+        }
+        if (bundle.vendors.empty())
+            return false;
+        if (! BuildProfileJson(bundle, /*require_all_resource_vendors=*/false))
+            return false;
+
+        // Written through a temp file and moved into place, as the preset caches
+        // are: half a cache must never be readable, and the PID suffix keeps two
+        // instances from interleaving on one temp file.
+        const std::string tmp_path = cache_file.string() + "." + std::to_string(get_current_pid()) + ".tmp";
+        try {
+            json out;
+            out["format"]  = 1;
+            out["vendors"] = std::move(stamps);
+            json& profile  = out["profile"];
+            for (const char* key : { "model", "machine", "filament", "process" })
+                profile[key] = m_ProfileJson[key];
+            boost::filesystem::create_directories(cache_file.parent_path());
+            {
+                boost::nowide::ofstream ofs(tmp_path, std::ios::binary | std::ios::trunc);
+                ofs << out.dump(-1, ' ', false, json::error_handler_t::ignore);
+                ofs.close();
+                if (! ofs.good())
+                    throw std::runtime_error("write failed");
+            }
+            if (const std::error_code ec = rename_file(tmp_path, cache_file.string()))
+                throw std::runtime_error(ec.message());
+        } catch (const std::exception& e) {
+            boost::system::error_code rm;
+            boost::filesystem::remove(tmp_path, rm);
+            BOOST_LOG_TRIVIAL(warning) << "GuideFrame: could not write the profile data cache: " << e.what();
+        }
+        return true;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " failed: " << e.what();
+        reset_profile_json();
+        return false;
+    }
+}
+
+int GuideFrame::LoadProfileData()
+{
+    // Background thread: the fast path in OnNavigationComplete failed (presets not yet loaded).
+    // Loading order (fastest to slowest):
+    //   1. Load every vendor, from its preset cache wherever one covers it
+    //   2. Read all vendor JSONs by hand
+    try {
+        if (!BuildProfileDataFromVendors()) {
+            // Last resort — read all vendor JSONs
+            std::set<std::string> loaded_vendors;
+            auto filament_library_name = boost::filesystem::path(PresetBundle::ORCA_FILAMENT_LIBRARY).replace_extension(".json");
+            if (boost::filesystem::exists(vendor_dir / filament_library_name))
+                LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (vendor_dir / filament_library_name).string());
+            else
+                LoadProfileFamily(PresetBundle::ORCA_FILAMENT_LIBRARY, (rsrc_vendor_dir / filament_library_name).string());
+            loaded_vendors.insert(PresetBundle::ORCA_FILAMENT_LIBRARY);
+
+            boost::filesystem::directory_iterator endIter;
+            for (boost::filesystem::directory_iterator iter(vendor_dir); iter != endIter; iter++) {
+                if (!boost::filesystem::is_directory(*iter)) {
+                    wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
+                    strVendor          = strVendor.AfterLast('\\');
+                    strVendor          = strVendor.AfterLast('/');
+                    wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
+                    if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
+                        continue;
+                    LoadProfileFamily(w2s(strVendor), iter->path().string());
+                    loaded_vendors.insert(w2s(strVendor));
+                }
+                if (*m_cancel_token) return 0;
+            }
+
+            boost::filesystem::directory_iterator others_endIter;
+            for (boost::filesystem::directory_iterator iter(rsrc_vendor_dir); iter != others_endIter; iter++) {
+                if (!boost::filesystem::is_directory(*iter)) {
+                    wxString strVendor = from_u8(iter->path().string()).BeforeLast('.');
+                    strVendor          = strVendor.AfterLast('\\');
+                    strVendor          = strVendor.AfterLast('/');
+                    wxString strExtension = from_u8(iter->path().string()).AfterLast('.').Lower();
+                    if (strExtension.CmpNoCase("json") != 0 || loaded_vendors.find(w2s(strVendor)) != loaded_vendors.end())
+                        continue;
+                    LoadProfileFamily(w2s(strVendor), iter->path().string());
+                    loaded_vendors.insert(w2s(strVendor));
+                }
+                if (*m_cancel_token) return 0;
+            }
+        }
+
+        // Capture the cancel token by value (shared_ptr) so the lambda doesn't
+        // touch `this` if GuideFrame is destroyed before the event fires.
+        auto tok = m_cancel_token;
+        wxGetApp().CallAfter([this, tok] {
+            if (!*tok)
+                on_profile_loaded();
         });
-    } catch (std::exception& e) {
-        // wxLogMessage("GUIDE: load_profile_error  %s ", e.what());
-        //  wxMessageBox(e.what(), "", MB_OK);
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", error: " << e.what() << std::endl;
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ", error: " << e.what();
     }
 
     filament_info_cache.clear();

src/slic3r/GUI/WebGuideDialog.hpp

@@ -30,10 +30,14 @@
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/Utils/PresetUpdater.hpp"
 
+#include <atomic>
+#include <memory>
 #include <unordered_map>
 
 #include <nlohmann/json.hpp>
 
+#include <boost/thread.hpp>
+
 namespace Slic3r { namespace GUI {
 
 class GuideFrame : public DPIDialog
@@ -78,6 +82,12 @@ public:
     int LoadProfileData();
     int SaveProfileData();
     int LoadProfileFamily(std::string strVendor, std::string strFilePath);
+    void init_guide_paths();
+    void on_profile_loaded();
+    bool BuildProfileJson(const PresetBundle& bundle, bool require_all_resource_vendors);
+    bool BuildProfileDataFromPresetBundle();
+    bool BuildProfileDataFromVendors();
+    void reset_profile_json();
     int SaveProfile();
     int GetFilamentInfo( std::string VendorDirectory,json & pFilaList, std::string filepath, std::string &sVendor, std::string &sType);
 
@@ -112,8 +122,11 @@ private:
 
     //First Load
     bool bFirstComplete{false};
-    bool m_destroy{false};
-    boost::thread* m_load_task{ nullptr };
+    // Set once in the destructor. Read through `this` by the loading thread
+    // (joined before `this` dies) and captured as the shared_ptr by CallAfter
+    // lambdas so they don't touch `this` after the object is freed.
+    std::shared_ptr<std::atomic<bool>> m_cancel_token{std::make_shared<std::atomic<bool>>(false)};
+    std::unique_ptr<boost::thread> m_load_task;
 
     // User Config
     bool PrivacyUse;
@@ -123,6 +136,7 @@ private:
     bool InstallNetplugin;
     bool network_plugin_ready {false};
 
+    json m_ProfileJson;
     json m_OrcaFilaList;
     std::string m_OrcaFilaLibPath;
 

src/slic3r/GUI/Widgets/Button.cpp

@@ -95,14 +95,11 @@ void Button::SetIcon(const wxString& icon)
     }
 }
 
-void Button::SetInactiveIcon(const wxString &icon)
+void Button::SetIcon(const wxBitmap& icon)
 {
-    if (!icon.IsEmpty()) {
-        // BBS set button icon default size to 20
-        this->inactive_icon = ScalableBitmap(this, icon.ToStdString(), this->active_icon.px_cnt());
-    } else {
-        this->inactive_icon = ScalableBitmap();
-    }
+    this->active_icon = ScalableBitmap();
+    this->active_icon.bmp() = icon;
+    messureSize();
     Refresh();
 }
 
@@ -257,12 +254,10 @@ void Button::SetStyle(const ButtonStyle style, const ButtonType type)
 
 void Button::Rescale()
 {
-    if (this->active_icon.bmp().IsOk())
+    // Only a named icon can be re-rasterized; one set from a wxBitmap has no source file,
+    if (!this->active_icon.name().empty())
         this->active_icon.msw_rescale();
 
-    if (this->inactive_icon.bmp().IsOk())
-        this->inactive_icon.msw_rescale();
-
     messureSize();
 
     if(m_has_style)
@@ -293,11 +288,7 @@ void Button::render(wxDC& dc)
     wxSize szIcon;
     wxSize textSize = this->textSize.GetSize();
 
-    ScalableBitmap icon;
-    if (m_selected || ((states & (int)StateColor::State::Hovered) != 0))
-        icon = active_icon;
-    else
-        icon = inactive_icon;
+    const ScalableBitmap& icon = active_icon;
     wxSize padding = this->paddingSize;
     int spacing = 5;
     // Wrap text

src/slic3r/GUI/Widgets/Button.hpp

@@ -34,7 +34,6 @@ class Button : public StaticBox
     wxSize minSize; // set by outer
     wxSize paddingSize;
     ScalableBitmap active_icon;
-    ScalableBitmap inactive_icon;
 
     StateColor   text_color;
 
@@ -61,8 +60,7 @@ public:
     bool SetFont(const wxFont& font) override;
 
     void SetIcon(const wxString& icon);
-
-    void SetInactiveIcon(const wxString& icon);
+    void SetIcon(const wxBitmap& icon);
 
     void SetMinSize(const wxSize& size) override;
     void SetMaxSize(const wxSize& size) override;

src/slic3r/GUI/Widgets/WebViewHostDialog.cpp

@@ -57,18 +57,6 @@ std::string host_theme_vars_css()
     return s;
 }
 
-// Document-start user script: injects the contract <style>, stamps data-orca-theme before
-// first paint, and raises a JS flag so the legacy globalapi.js dark.css poll stands down for
-// host-themed pages. The WebView2 timing guard lives in document_start_injector().
-std::string host_theme_user_script()
-{
-    const std::string style = "<style id=\"orca-host-theme-vars\">" + host_theme_vars_css() + "</style>";
-    return WebViewHostDialog::document_start_injector(
-        style, "orca-host-theme-vars", "afterbegin",
-        "window.__orcaHostThemed=true;var theme=\"" + host_theme_name() + "\";",
-        "if(document.documentElement)document.documentElement.setAttribute('data-orca-theme',theme);");
-}
-
 // JS to re-theme an already-loaded document live (no reload): replace the injected
 // style's contents and update data-orca-theme. Everything downstream (theme.css
 // tokens, plugin element defaults, page layout) re-cascades from these values.
@@ -87,6 +75,46 @@ if(document.documentElement)
 
 } // namespace
 
+// Document-start user script: injects the contract <style>, stamps data-orca-theme before
+// first paint, and raises a JS flag so the legacy globalapi.js dark.css poll stands down for
+// host-themed pages. The WebView2 timing guard lives in document_start_injector().
+std::string WebViewHostDialog::theme_user_script()
+{
+    const std::string style = "<style id=\"orca-host-theme-vars\">" + host_theme_vars_css() + "</style>";
+    return document_start_injector(
+        style, "orca-host-theme-vars", "afterbegin",
+        "window.__orcaHostThemed=true;var theme=\"" + host_theme_name() + "\";",
+        "if(document.documentElement)document.documentElement.setAttribute('data-orca-theme',theme);");
+}
+
+std::string WebViewHostDialog::plugin_defaults_user_script()
+{
+    std::string css;
+    css += "<style id=\"orca-plugin-defaults\">";
+    css += "html,body{background:var(--orca-bg);color:var(--orca-fg);"
+           "font-family:var(--orca-font);font-size:13px;}";
+    css += "body{margin:0;}";
+    css += "h1,h2,h3,h4,h5,h6{color:var(--orca-fg);font-weight:600;}";
+    css += "a{color:var(--orca-accent);}";
+    css += "hr{border:0;border-top:1px solid var(--orca-border);}";
+    css += "button{font:inherit;color:var(--orca-accent-fg);background:var(--orca-accent);"
+           "border:1px solid var(--orca-accent);border-radius:4px;padding:5px 14px;cursor:pointer;}";
+    css += "button:hover{filter:brightness(1.1);}";
+    css += "button:disabled{opacity:.5;cursor:default;}";
+    css += "input,select,textarea{font:inherit;color:var(--orca-fg);"
+           "background:var(--orca-bg);border:1px solid var(--orca-border);"
+           "border-radius:4px;padding:4px 8px;}";
+    css += "input:focus,select:focus,textarea:focus{outline:none;border-color:var(--orca-accent);}";
+    css += "table{border-collapse:collapse;}";
+    css += "th,td{text-align:left;padding:6px 10px;border-bottom:1px solid var(--orca-border);}";
+    css += "th{color:var(--orca-muted);font-weight:600;}";
+    css += "::-webkit-scrollbar{width:12px;height:12px;}";
+    css += "::-webkit-scrollbar-thumb{background:var(--orca-border);border-radius:6px;}";
+    css += "::-webkit-scrollbar-track{background:transparent;}";
+    css += "</style>";
+    return document_start_injector(css, "orca-plugin-defaults", "beforeend");
+}
+
 std::string WebViewHostDialog::document_start_injector(const std::string& markup,
                                                        const char*        dom_id,
                                                        const char*        position,
@@ -244,7 +272,7 @@ void WebViewHostDialog::register_theme_user_scripts()
     // script message handler is registered separately (AddScriptMessageHandler), but on
     // some backends RemoveAllUserScripts() drops it too, which would break
     // window.wx.postMessage / HandleStudio. Live re-theme goes through apply_theme_live().
-    m_browser->AddUserScript(wxString::FromUTF8(host_theme_user_script()));
+    m_browser->AddUserScript(wxString::FromUTF8(theme_user_script()));
     add_user_scripts();
 }
 

src/slic3r/GUI/Widgets/WebViewHostDialog.hpp

@@ -49,6 +49,10 @@ public:
                                                const std::string& prelude   = {},
                                                const std::string& on_inject = {});
 
+    // Shared by modeless Pages tabs and PluginWebDialog.
+    static std::string theme_user_script();
+    static std::string plugin_defaults_user_script();
+
 protected:
     wxWebView* browser() const { return m_browser; }