feat: introduce plugin APIs for mutable presets

src/slic3r/GUI/OptionsGroup.cpp

@@ -1332,6 +1332,21 @@ boost::any ConfigOptionsGroup::get_config_value2(const DynamicPrintConfig& confi
     return ret;
 }
 
+bool ConfigOptionsGroup::commit_config_value(const t_config_option_key& opt_key, int opt_index)
+{
+    if (m_config == nullptr)
+        return false;
+
+    // m_opt_map is filled while the option lines are created, so it still resolves the option when
+    // the group's controls (and thus its fields) have not been built yet.
+    const std::string opt_id = option_id_in_map(m_opt_map, opt_key, opt_index);
+    if (opt_id.empty())
+        return false;
+
+    on_change_OG(opt_id, get_config_value2(*m_config, opt_key, opt_index));
+    return true;
+}
+
 Field* ConfigOptionsGroup::get_fieldc(const t_config_option_key& opt_key, int opt_index)
 {
     Field* field = get_field(opt_key);

src/slic3r/GUI/OptionsGroup.hpp

@@ -119,6 +119,37 @@ using column_t = std::function<wxWindow*(wxWindow* parent, const Line&)>;
 using t_optionfield_map = std::map<t_config_option_key, t_field>;
 using t_opt_map = std::map< std::string, std::pair<std::string, int> >;
 
+// The option id a group's option map holds for opt_key, and the index it carries. `opt_index` is
+// an in/out parameter: a negative value asks for the option's single entry, an explicit one selects
+// that index. Returns an empty string when the map does not own the option, or when a negative index
+// matches several entries -- a vector option the GUI edits one index at a time, which has no single
+// value to commit. A group fills the map while its option lines are created (OptionsGroup::append_line
+// / ConfigOptionsGroup::get_option), so this resolves an option even before its controls (and its
+// field) have been built.
+inline std::string option_id_in_map(const t_opt_map& options, const t_config_option_key& opt_key, int& opt_index)
+{
+    if (opt_index >= 0) {
+        for (const auto& opt : options) {
+            if (opt.second.first == opt_key && opt.second.second == opt_index) {
+                opt_index = opt.second.second;
+                return opt.first;
+            }
+        }
+        return {};
+    }
+
+    std::string opt_id;
+    for (const auto& opt : options) {
+        if (opt.second.first != opt_key)
+            continue;
+        if (!opt_id.empty())
+            return {}; // several entries: a vector option, not one value
+        opt_id    = opt.first;
+        opt_index = opt.second.second;
+    }
+    return opt_id;
+}
+
 class OptionsGroup {
 public:
     const bool staticbox{true};
@@ -332,6 +363,15 @@ public:
 	boost::any	get_config_value(const DynamicPrintConfig& config, const std::string& opt_key, int opt_index = -1);
 	// BBS: restore all pages in preset
 	boost::any	get_config_value2(const DynamicPrintConfig& config, const std::string& opt_key, int opt_index = -1);
+	// Re-run this group's committed-change path for one of its options without a widget event:
+	// build the option's value from the config this group edits (get_config_value2, the same form
+	// the option's field reports) and dispatch on_change_OG(), so the group's option-specific
+	// conversion (e.g. the printer_agent canonicalization) and its registered change handler run
+	// exactly as for a hand edit. The option map is filled while the option lines are created, so
+	// this resolves an option whose field is not built yet (a lazy page, or an option the GUI has
+	// no field for). Returns false when this group does not own the option, or when opt_index < 0
+	// matches several entries (a vector option the GUI edits index by index has no single value).
+	bool		commit_config_value(const t_config_option_key& opt_key, int opt_index = -1);
 	Field*		get_fieldc(const t_config_option_key& opt_key, int opt_index);
 	std::pair<OG_CustomCtrl*, bool*>	get_custom_ctrl_with_blinking_ptr(const t_config_option_key& opt_key, int opt_index/* = -1*/);
 

src/slic3r/GUI/Tab.cpp

@@ -46,6 +46,7 @@
 #include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
 #include <deque>
 #include <exception>
+#include <stdexcept>
 #include "libslic3r/LifecycleEvents.hpp"
 #include "libslic3r/Point.hpp"
 #include "slic3r/GUI/SettingsIndex.hpp"
@@ -1645,6 +1646,101 @@ void Tab::load_config(const DynamicPrintConfig& config)
     }
 }
 
+// The option keys a preset of `type` may hold. The tab's config shares the global
+// print_config_def with every other preset type, so membership has to be checked against the
+// preset type's own key list instead of the config definition, or a printer setting could be
+// written into the process preset.
+static const std::vector<std::string>& preset_type_options(Preset::Type type)
+{
+    static const std::vector<std::string> none;
+    switch (type) {
+    case Preset::TYPE_PRINT:    return Preset::print_options();
+    case Preset::TYPE_FILAMENT: return Preset::filament_options();
+    case Preset::TYPE_PRINTER:  return Preset::printer_options();
+    default:                    return none;
+    }
+}
+
+static const char* preset_type_name(Preset::Type type)
+{
+    switch (type) {
+    case Preset::TYPE_PRINT:    return "process";
+    case Preset::TYPE_FILAMENT: return "filament";
+    case Preset::TYPE_PRINTER:  return "printer";
+    default:                    return "preset";
+    }
+}
+
+// Set one option of the currently edited preset from its serialized string form, then run the
+// same update path a hand edit runs. The edited preset is not saved: it only becomes dirty,
+// exactly as if the field had been edited by hand.
+void Tab::apply_preset_config_value(const std::string& opt_key, const std::string& value)
+{
+    if (m_config == nullptr)
+        throw std::runtime_error("The preset configuration is not available");
+    if (wxGetApp().plater() == nullptr)
+        throw std::runtime_error("OrcaSlicer main window is not available");
+
+    const std::vector<std::string>& options = preset_type_options(m_type);
+    if (std::find(options.begin(), options.end(), opt_key) == options.end())
+        throw std::invalid_argument(format("Unknown %1% preset setting \"%2%\"", preset_type_name(m_type), opt_key));
+
+    // Parse strictly, keeping a backup: the strict deserializer can already have mutated the option
+    // when it rejects a bad value, so a failed update has to restore the preset it was given.
+    const ConfigOption*           previous_option = m_config->option(opt_key);
+    std::unique_ptr<ConfigOption> previous(previous_option != nullptr ? previous_option->clone() : nullptr);
+    try {
+        m_config->set_deserialize_strict(opt_key, value);
+    } catch (const ConfigurationError& err) {
+        if (previous)
+            m_config->set_key_value(opt_key, previous.release());
+        else
+            m_config->erase(opt_key);
+        throw std::invalid_argument(err.what());
+    }
+
+    // Run the same commit path the GUI runs for this setting, so its key-specific behaviour
+    // (ConfigOptionsGroup::on_change_OG, including the printer_agent canonicalization, the group's
+    // pre-checks and Tab::on_value_change()) runs exactly as for a hand edit. A built field supplies
+    // the field's typed/clamped value; otherwise the owning ConfigOptionsGroup builds the value from
+    // the config it edits and dispatches the same on_change_OG(). The field is refreshed from the
+    // config just committed first, so it reports the committed value rather than a stale one.
+    bool committed = false;
+    if (Page* field_page = nullptr; Field* field = get_field(opt_key, &field_page)) {
+        field_page->reload_config();
+        field->field_changed();
+        committed = true;
+    } else {
+        for (const PageShp& page : m_pages) {
+            for (const ConfigOptionsGroupShp& group : page->m_optgroups) {
+                if (group->commit_config_value(opt_key)) {
+                    committed = true;
+                    break;
+                }
+            }
+            if (committed)
+                break;
+        }
+    }
+
+    if (committed) {
+        // The commit path already ran update_dirty() (dirty flag, preset combo and, on the printer
+        // tab, the printer-agent switch); refresh the visible page and push the config to the plater.
+        reload_config();
+        update();
+    } else {
+        // The GUI edits this setting through a custom widget rather than a group (e.g.
+        // compatible_printers), so take the same shared no-field commit path the widget uses. Saved
+        // mode skips the value write (the strict parse above already did it) and keeps the path's
+        // compatibility recompute, dirty flag, preset-combo and plater updates.
+        load_key_value(opt_key, boost::any(), /*saved_value=*/true);
+        // The widget itself normally re-reads its value after load_key_value(); with no widget to do
+        // that, sync the visible page so a custom widget (the compatible-printers row) reflects the
+        // new value.
+        reload_config();
+    }
+}
+
 // Reload current $self->{config} (aka $self->{presets}->edited_preset->config) into the UI fields.
 void Tab::reload_config()
 {

src/slic3r/GUI/Tab.hpp

@@ -424,6 +424,17 @@ public:
 	//BBS update plater presets if update_plater_presets = true
 	void			update_tab_ui(bool update_plater_presets = false);
 	void			load_config(const DynamicPrintConfig& config);
+	// Host/plugin API: set one option of this tab's currently edited preset from its serialized
+	// string value, then run the same committed-change path a field edit runs. `opt_key` must be a
+	// setting of this tab's preset type, so a key of another preset type (e.g. a printer setting
+	// passed to the process tab) is rejected instead of written silently. `value` is parsed by the
+	// strict config deserializer, which raises std::invalid_argument for an unknown key or a value
+	// the option cannot parse, and leaves the preset unchanged. The key-specific behaviour runs
+	// through its ConfigOptionsGroup::on_change_OG(): with the option's built field it uses the
+	// field's typed value, otherwise the owning group builds the value and dispatches the same call,
+	// so a not-yet-built field still gets it. A key the GUI edits through a custom widget instead
+	// takes the shared no-field commit path, Tab::load_key_value() in saved mode.
+	void			apply_preset_config_value(const std::string& opt_key, const std::string& value);
 	virtual void	reload_config();
     void            update_mode();
     void            update_visibility();

src/slic3r/plugin/host/PluginHostPresets.cpp

@@ -17,6 +17,7 @@
 #include <slic3r/GUI/GUI_App.hpp>
 #include <slic3r/GUI/MainFrame.hpp>
 #include <slic3r/GUI/Plater.hpp>
+#include <slic3r/GUI/PresetComboBoxes.hpp> // TabPresetComboBox::set_filament_idx
 #include <slic3r/GUI/Tab.hpp>
 
 #include <pybind11/stl.h>
@@ -48,6 +49,110 @@ PresetCollection& printer_presets(PresetBundle& bundle)
     return static_cast<PresetCollection&>(bundle.printers);
 }
 
+// Handle to one category of currently edited preset. It is a category, not a snapshot: it always
+// resolves the preset the matching tab edits now, so it stays valid across preset switches.
+struct PresetEditor
+{
+    Preset::Type type = Preset::TYPE_INVALID;
+};
+
+const char* preset_tab_name(Preset::Type type)
+{
+    switch (type) {
+    case Preset::TYPE_PRINT:    return "process";
+    case Preset::TYPE_FILAMENT: return "filament";
+    case Preset::TYPE_PRINTER:  return "printer";
+    default:                    return "preset";
+    }
+}
+
+void update_edited_preset(Preset::Type type, const std::string& key, const std::string& value)
+{
+    PluginHostUi::run_on_ui_thread([&] {
+        GUI::GUI_App& app = GUI::wxGetApp();
+        if (app.is_closing())
+            throw std::runtime_error("OrcaSlicer is closing");
+        if (app.preset_bundle == nullptr)
+            throw std::runtime_error("Preset bundle is not available");
+        if (app.plater() == nullptr)
+            throw std::runtime_error("OrcaSlicer main window is not available");
+
+        GUI::Tab* tab = app.get_tab(type);
+        if (tab == nullptr)
+            throw std::runtime_error(std::string("The ") + preset_tab_name(type) + " preset tab is not available");
+        // The tab for this preset type exists, but the selected printer's technology may not use it
+        // (the print tab no-ops under SLA); refuse instead of writing a value the UI cannot apply.
+        if (!tab->supports_printer_technology(app.preset_bundle->printers.get_selected_preset().printer_technology()))
+            throw std::runtime_error(std::string("The ") + preset_tab_name(type)
+                                     + " preset is not available for the selected printer technology");
+
+        tab->apply_preset_config_value(key, value);
+    });
+}
+
+// Slot-addressed filament update. `slot_number` is 1-based, matching the GUI's filament slots and
+// the values PresetBundle::filament_presets holds. The slot's assigned preset is resolved to its
+// internal name; when that is not the preset the filament tab edits, the tab is switched through
+// Tab::select_preset() - the normal UI preselection flow, so a dirty edited preset still prompts
+// the user and a declined prompt cancels the call with a clear error and no change.
+void update_filament_slot(int slot_number, const std::string& key, const std::string& value)
+{
+    PluginHostUi::run_on_ui_thread([&] {
+        GUI::GUI_App& app = GUI::wxGetApp();
+        if (app.is_closing())
+            throw std::runtime_error("OrcaSlicer is closing");
+        if (app.preset_bundle == nullptr)
+            throw std::runtime_error("Preset bundle is not available");
+        if (app.plater() == nullptr)
+            throw std::runtime_error("OrcaSlicer main window is not available");
+
+        PresetBundle& bundle = *app.preset_bundle;
+        if (slot_number < 1 || static_cast<size_t>(slot_number) > bundle.filament_presets.size())
+            throw std::out_of_range("Filament slot " + std::to_string(slot_number) + " is out of range; slot numbers are 1-based and this printer has "
+                                    + std::to_string(bundle.filament_presets.size()) + " filament slot(s)");
+
+        const std::string& assigned_name = bundle.filament_presets[static_cast<size_t>(slot_number) - 1];
+        if (assigned_name.empty())
+            throw std::runtime_error("Filament slot " + std::to_string(slot_number) + " has no assigned filament preset");
+
+        // Resolve the assigned name the way the app does, so a renamed/aliased entry maps to the
+        // internal preset it now identifies. Copy the name out before selecting anything: the
+        // collection can be reallocated while switching.
+        Preset* slot_preset = bundle.filaments.find_preset(assigned_name);
+        if (slot_preset == nullptr)
+            throw std::runtime_error("Filament slot " + std::to_string(slot_number) + " is assigned \"" + assigned_name
+                                     + "\", which does not resolve to a filament preset");
+        const std::string target_name = slot_preset->name;
+
+        GUI::Tab* tab = app.get_tab(Preset::TYPE_FILAMENT);
+        if (tab == nullptr)
+            throw std::runtime_error("The filament preset tab is not available");
+        if (!tab->supports_printer_technology(bundle.printers.get_selected_preset().printer_technology()))
+            throw std::runtime_error("The filament preset is not available for the selected printer technology");
+
+        // Switch to the slot's preset through the normal preset selection, never a forced one, so the
+        // user's unsaved-changes prompt is honoured. A declined prompt returns false here.
+        if (bundle.filaments.get_edited_preset().name != target_name) {
+            if (!tab->select_preset(target_name))
+                throw std::runtime_error("Switching the edited filament preset to \"" + target_name + "\" for filament slot "
+                                         + std::to_string(slot_number) + " was canceled; the setting was not changed");
+        }
+
+        // select_preset() can still leave a different preset edited (e.g. the target disappeared), so
+        // re-check before writing anything.
+        if (bundle.filaments.get_edited_preset().name != target_name)
+            throw std::runtime_error("The edited filament preset is \"" + bundle.filaments.get_edited_preset().name
+                                     + "\", not \"" + target_name + "\"; the setting was not changed");
+
+        // Match PlaterPresetComboBox::switch_to_tab(): record which 0-based filament slot this tab
+        // combobox now edits, so the GUI shows the slot the value was written for.
+        if (GUI::TabPresetComboBox* combo = tab->get_combo_box())
+            combo->set_filament_idx(slot_number - 1);
+
+        tab->apply_preset_config_value(key, value);
+    });
+}
+
 void reload_local_bundle(const std::string& bundle_id)
 {
     bool        reloaded = false;
@@ -119,6 +224,47 @@ void host_bindings::register_presets(py::module_& host)
         .value("Plate", Preset::TYPE_PLATE)
         .value("Model", Preset::TYPE_MODEL);
 
+    py::class_<PresetEditor>(preset, "PresetEditor",
+                             "Handle to a category of currently edited preset. It is not a snapshot: it always "
+                             "resolves the preset the matching tab edits now, so it stays usable across preset "
+                             "switches. update() edits the preset in place; the change is not saved to disk.")
+        .def_readonly("type", &PresetEditor::type)
+        .def(
+            "update",
+            [](const PresetEditor& editor, const std::string& key, const std::string& value) {
+                update_edited_preset(editor.type, key, value);
+            },
+            py::arg("key"), py::arg("value"),
+            "Set one setting of the currently edited preset and run the same committed-change path as "
+            "editing the setting in the GUI; the edited preset becomes dirty until saved/exported. "
+            "key must be a setting of this preset category and value its serialized string form, "
+            "otherwise ValueError is raised and nothing is written. A setting edited through a field "
+            "runs that field's validation even before its page has been opened; one the GUI edits "
+            "outside a field (such as compatible printers) also recomputes preset compatibility.")
+        .def(
+            "update",
+            [](const PresetEditor& editor, int slot_number, const std::string& key, const std::string& value) {
+                if (editor.type != Preset::TYPE_FILAMENT)
+                    throw std::invalid_argument("The slot_number form of update() is only available on "
+                                                "orca.host.preset.filament; call update(key, value) on this editor");
+                update_filament_slot(slot_number, key, value);
+            },
+            py::arg("slot_number"), py::arg("key"), py::arg("value"),
+            "Set one setting of the filament preset assigned to a 1-based filament slot. When that preset "
+            "is not the one currently edited the call switches to it through the normal preset-selection "
+            "flow, so an unsaved edited preset still prompts the user and a declined prompt cancels the "
+            "call with an error and no change. An out-of-range, empty or unresolved slot is rejected with "
+            "a clear error. Other preset editors accept only update(key, value); this form raises "
+            "ValueError on them.");
+
+    // The three preset categories edited by the main tabs. `process` is the print/process preset,
+    // `printer` the machine preset and `filament` the currently edited filament preset (its
+    // 3-argument form addresses a 1-based filament slot); each only accepts its own settings, so a
+    // printer setting passed to `process` is rejected instead of written silently.
+    preset.attr("process")  = py::cast(PresetEditor{Preset::TYPE_PRINT});
+    preset.attr("printer")  = py::cast(PresetEditor{Preset::TYPE_PRINTER});
+    preset.attr("filament") = py::cast(PresetEditor{Preset::TYPE_FILAMENT});
+
     py::class_<Preset, std::unique_ptr<Preset, py::nodelete>>(host, "Preset")
         .def_readonly("type", &Preset::type)
         .def_readonly("name", &Preset::name)