Classes
struct	PresetEditor
struct	SelectionCancelled
struct	PresetUpdateResult
struct	PresetTransaction
struct	ComboPresetMatch

Functions
py::list	current_filament_presets (PresetBundle &bundle)
PresetCollection &	printer_presets (PresetBundle &bundle)
const char *	preset_tab_name (Preset::Type type)
PresetCollection &	collection_for (PresetBundle &bundle, Preset::Type type)
GUI::GUI_App &	require_gui_app ()
GUI::Tab *	require_tab (GUI::GUI_App &app, Preset::Type type)
bool	combo_item_is_marker (GUI::PresetComboBox &combo, int item)
ComboPresetMatch	resolve_combo_preset (GUI::PresetComboBox &combo, const std::string &requested)
int	combo_item_for_preset (GUI::PresetComboBox &combo, const std::string &preset_name)
std::string	resolve_preset_in_combo (GUI::PresetComboBox &combo, const std::string &requested, const std::string &category, const std::string &selector)
std::string	resolved_slot_preset (PresetBundle &bundle, int slot_number)
void	bind_preset_target (Preset::Type type, const std::string &preset_name, PresetTransaction &transaction)
PresetTransaction	begin_preset_update (Preset::Type type, const std::string &preset_name)
void	bind_filament_target (int slot_number, const std::string &preset_name, PresetTransaction &transaction)
PresetTransaction	begin_filament_update (int slot_number, const std::string &preset_name)
void	update_edited_preset (Preset::Type type, const std::string &key, const std::string &value)
void	update_filament_slot (int slot_number, const std::string &key, const std::string &value)
void	reload_local_bundle (const std::string &bundle_id)
std::vector< std::string >	list_bundle_ids ()

Class Documentation

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetEditor

struct Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetEditor

Class Members
Type	type = Preset::TYPE_INVALID

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetUpdateResult

struct Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetUpdateResult

Collaboration diagram for Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetUpdateResult:

Class Members
bool	dirty = false
vector< string >	keys
bool	selection_changed = false
vector< int >	shared_slots
bool	slot_assignment_changed = false
int	slot_number = -1
string	target_name
Type	type = Preset::TYPE_INVALID

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch

struct Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch

Collaboration diagram for Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch:

Class Members
bool	ambiguous = false
string	internal_name
int	item = -1

Function Documentation

◆ begin_filament_update()

PresetTransaction Slic3r::anonymous_namespace{PluginHostPresets.cpp}::begin_filament_update	(	int	slot_number,
		const std::string &	preset_name )

{
    PresetTransaction transaction;
    PluginHostUi::run_on_ui_thread([&] { bind_filament_target(slot_number, preset_name, transaction); });
    return transaction;
}

References begin_filament_update(), bind_filament_target(), and Slic3r::PluginHostUi::run_on_ui_thread().

Referenced by begin_filament_update(), and update_filament_slot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ begin_preset_update()

PresetTransaction Slic3r::anonymous_namespace{PluginHostPresets.cpp}::begin_preset_update	(	Preset::Type	type,
		const std::string &	preset_name )

{
    PresetTransaction transaction;
    PluginHostUi::run_on_ui_thread([&] { bind_preset_target(type, preset_name, transaction); });
    return transaction;
}

References begin_preset_update(), bind_preset_target(), and Slic3r::PluginHostUi::run_on_ui_thread().

Referenced by begin_preset_update(), and update_edited_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_filament_target()

void Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target	(	int	slot_number,
		const std::string &	preset_name,
		PresetTransaction &	transaction )

{
    GUI::GUI_App& app    = require_gui_app();
    PresetBundle& bundle = *app.preset_bundle;
    GUI::Plater*  plater = app.plater();
 
    // A mixed-color virtual slot has no single filament preset behind it, so every form of this
    // call is rejected: with or without a preset_name there is no one preset to edit or assign.
    // Range-guarded so an out-of-range slot still gets resolved_slot_preset()'s clear error.
    if (slot_number >= 1 && static_cast<size_t>(slot_number) <= bundle.filament_presets.size()
        && bundle.is_mixed_filament(static_cast<size_t>(slot_number) - 1))
        throw std::invalid_argument("Filament slot " + std::to_string(slot_number)
                                    + " is a mixed-color virtual slot; it has no single filament preset to edit or assign");
 
    // Resolve and validate before any selection, so a bad slot fails without a prompt.
    const std::string assigned_internal = resolved_slot_preset(bundle, slot_number);
 
    GUI::Tab* tab = require_tab(app, Preset::TYPE_FILAMENT);
 
    const size_t slot_index = static_cast<size_t>(slot_number) - 1;
 
    std::string target = assigned_internal;
    if (!preset_name.empty()) {
        // Resolve against the requested sidebar slot's own selector, not the tab's: that is the
        // model the user picks this slot's filament from, including its compatibility filter. The
        // selector matches the exact name shown (display label or item alias).
        std::vector<GUI::PlaterPresetComboBox*>& slot_combos = plater->sidebar().combos_filament();
        GUI::PlaterPresetComboBox* slot_combo = slot_index < slot_combos.size() ? slot_combos[slot_index] : nullptr;
        std::string                resolved;
        if (slot_combo != nullptr && slot_combo->GetCount() > 0) {
            const ComboPresetMatch match = resolve_combo_preset(*slot_combo, preset_name);
            if (match.ambiguous)
                throw std::invalid_argument("The filament name \"" + preset_name
                                            + "\" is ambiguous in the filament preset selector for filament slot "
                                            + std::to_string(slot_number)
                                            + "; more than one entry shows it, so name the preset by its own entry");
            if (match.item >= 0) {
                resolved = match.internal_name;
            } else {
                // Not shown by this slot's selector. Only the slot's current assignment stays
                // targetable (a hidden or incompatible-but-selected preset the dropdown omits);
                // resolve it by internal name or by display alias and accept only that preset. A
                // different preset the tab happens to edit is a globally edited target, not an
                // offered choice for this slot, and is rejected.
                Preset* by_name = bundle.filaments.find_preset(preset_name);
                if (by_name == nullptr) {
                    const std::string& alias_name = bundle.filaments.get_preset_name_by_alias(preset_name);
                    by_name                       = bundle.filaments.find_preset(alias_name);
                }
                if (by_name == nullptr || by_name->name != assigned_internal)
                    throw std::invalid_argument("Filament preset \"" + preset_name
                                                + "\" is not offered by the filament preset selector for filament slot "
                                                + std::to_string(slot_number));
                resolved = by_name->name;
            }
        } else {
            // The slot selector is not populated; fall back to the tab selector, then to collection
            // internal names, so the call still works when the sidebar has not been laid out.
            GUI::TabPresetComboBox* tab_combo = tab->get_combo_box();
            if (tab_combo != nullptr && tab_combo->GetCount() > 0)
                resolved = resolve_preset_in_combo(*tab_combo, preset_name, "filament",
                                                   "filament preset selector for the selected printer");
            else
                resolved = preset_name;
        }
 
        Preset* requested = bundle.filaments.find_preset(resolved);
        if (requested == nullptr)
            throw std::invalid_argument("No filament preset named \"" + resolved + "\" is available to select");
        target = requested->name;
    }
 
    bool selection_changed = false;
    if (bundle.filaments.get_edited_preset().name != target) {
        // A declined prompt is a user cancellation: it is thrown before any slot-assignment change,
        // so neither the mapping nor a setting is touched.
        if (!tab->select_preset(target))
            throw SelectionCancelled("Switching the edited filament preset to \"" + target + "\" for filament slot "
                                     + std::to_string(slot_number)
                                     + " was canceled; neither the slot assignment nor any setting was changed");
        if (bundle.filaments.get_edited_preset().name != target)
            throw std::runtime_error("The edited filament preset is \"" + bundle.filaments.get_edited_preset().name
                                     + "\", not \"" + target + "\"; the transaction was not created");
        selection_changed = true;
    }
 
    bool assignment_changed = false;
    if (!preset_name.empty() && target != assigned_internal) {
        if (app.app_config == nullptr)
            throw std::runtime_error("Application configuration is not available");
        // Mirror the filament branch of Plater::priv::on_select_preset() (the sidebar's normal
        // preset selection): update the mapping, then every dependent project/UI side effect,
        // rather than the vector entry alone.
        const bool was_support = GUI::is_support_filament(static_cast<int>(slot_index));
        bundle.set_filament_preset(slot_index, target);
        plater->update_project_dirty_from_presets();
        bundle.export_selections(*app.app_config);
        plater->sidebar().update_dynamic_filament_list();
        // Assigning a support filament (or moving away from one) changes which filaments the
        // flush rules apply to, so the normal flow recalculates the flushing volumes when
        // auto-calc covers every filament.
        if (GUI::is_support_filament(static_cast<int>(slot_index)) != was_support
            && app.app_config->get("auto_calculate_flush") == "all")
            plater->sidebar().auto_calc_flushing_volumes(static_cast<int>(slot_index));
        // Refresh the requested slot's own sidebar combo so its list and current selection show the
        // newly assigned target (the list may not have contained it), matching the sidebar
        // selection path. Fetch the pointer after update_dynamic_filament_list(), which may
        // rebuild the combo vector.
        std::vector<GUI::PlaterPresetComboBox*>& slot_combos = plater->sidebar().combos_filament();
        if (slot_index < slot_combos.size() && slot_combos[slot_index] != nullptr) {
            GUI::PlaterPresetComboBox* slot_combo = slot_combos[slot_index];
            slot_combo->update();
            // Keep the slot's AMS sync badge truthful, reading the item's own flag, the same source
            // on_select_preset() reads, so no UI state is invented here.
            const int item = combo_item_for_preset(*slot_combo, target);
            if (item >= 0)
                slot_combo->set_sync_badge(slot_combo->GetFlag(item)
                                           == static_cast<int>(GUI::PresetComboBox::FilamentAMSType::FROM_AMS));
        }
        plater->on_filament_change(slot_index);
        assignment_changed = true;
    }
 
    // 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);
 
    transaction.type                     = Preset::TYPE_FILAMENT;
    transaction.filament                 = true;
    transaction.slot_number              = slot_number;
    transaction.target_name              = target;
    transaction.selection_changed        = selection_changed;
    transaction.slot_assignment_changed  = assignment_changed;
    // Snapshot the mapping after the explicit assignment, as the slot's resolved internal name,
    // so commit() compares like with like (a stored alias resolves to the same internal preset).
    transaction.slot_assignment_snapshot = resolved_slot_preset(bundle, slot_number);
}

Referenced by begin_filament_update(), and bind_filament_target().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bind_preset_target()

void Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target	(	Preset::Type	type,
		const std::string &	preset_name,
		PresetTransaction &	transaction )

{
    GUI::GUI_App&     app        = require_gui_app();
    GUI::Tab*         tab        = require_tab(app, type);
    PresetCollection& collection = collection_for(*app.preset_bundle, type);
 
    const std::string current = collection.get_edited_preset().name;
    std::string       target  = current;
    bool              selection_changed = false;
 
    if (!preset_name.empty()) {
        // Resolve by the name the tab's dropdown actually shows (display label or item alias), so a
        // plugin can pass exactly what the user sees. With no populated dropdown there is nothing
        // to resolve against, so fall back to collection internal names.
        GUI::TabPresetComboBox* combo = tab->get_combo_box();
        std::string             resolved;
        if (combo != nullptr && combo->GetCount() > 0)
            resolved = resolve_preset_in_combo(*combo, preset_name, preset_tab_name(type),
                                               "preset selector for the selected printer");
        else
            resolved = preset_name;
 
        Preset* requested = collection.find_preset(resolved);
        if (requested == nullptr)
            throw std::invalid_argument("No " + std::string(preset_tab_name(type)) + " preset named \"" + resolved
                                        + "\" is available to select");
        target = requested->name;
        if (target != current) {
            // Normal UI selection: honours the unsaved-edit prompt; a declined prompt returns false
            // and is a user cancellation, distinct from any other resolution failure.
            if (!tab->select_preset(target))
                throw SelectionCancelled("Switching the edited " + std::string(preset_tab_name(type)) + " preset to \""
                                         + target + "\" was canceled; nothing was staged");
            selection_changed = true;
        }
    }
 
    // select_preset() can still leave a different preset edited (e.g. the target is not an
    // allowed dropdown choice), so confirm before binding.
    if (collection.get_edited_preset().name != target)
        throw std::runtime_error("The edited " + std::string(preset_tab_name(type)) + " preset is \""
                                 + collection.get_edited_preset().name + "\", not \"" + target
                                 + "\"; the transaction was not created");
 
    transaction.type              = type;
    transaction.target_name       = target;
    transaction.selection_changed = selection_changed;
}

References bind_preset_target(), collection_for(), Slic3r::PresetCollection::find_preset(), Slic3r::GUI::Tab::get_combo_box(), Slic3r::PresetCollection::get_edited_preset(), ComboBox::GetCount(), Slic3r::Preset::name, Slic3r::GUI::GUI_App::preset_bundle, preset_tab_name(), require_gui_app(), require_tab(), resolve_preset_in_combo(), Slic3r::GUI::Tab::select_preset(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::selection_changed, Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::target_name, and Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::type.

Referenced by begin_preset_update(), and bind_preset_target().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collection_for()

PresetCollection & Slic3r::anonymous_namespace{PluginHostPresets.cpp}::collection_for	(	PresetBundle &	bundle,
		Preset::Type	type )

{
    switch (type) {
    case Preset::TYPE_PRINT:    return bundle.prints;
    case Preset::TYPE_FILAMENT: return bundle.filaments;
    case Preset::TYPE_PRINTER:  return printer_presets(bundle);
    default:                    throw std::invalid_argument("Unsupported preset category");
    }
}

References collection_for(), Slic3r::PresetBundle::filaments, printer_presets(), Slic3r::PresetBundle::prints, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by bind_preset_target(), collection_for(), and Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ combo_item_for_preset()

int Slic3r::anonymous_namespace{PluginHostPresets.cpp}::combo_item_for_preset	(	GUI::PresetComboBox &	combo,
		const std::string &	preset_name )

{
    const std::string want       = Preset::remove_suffix_modified(preset_name);
    const int         item_count = combo.GetCount();
    for (int item = 0; item < item_count; ++item) {
        if (combo_item_is_marker(combo, item))
            continue;
        const wxString    alias = combo.GetItemAlias(item);
        const std::string alias_name = alias.empty() ? std::string()
                                                     : Preset::remove_suffix_modified(alias.ToUTF8().data());
        if (!alias_name.empty() && alias_name == want)
            return item;
    }
    return -1;
}

References combo_item_for_preset(), combo_item_is_marker(), ComboBox::GetCount(), ComboBox::GetItemAlias(), and Slic3r::Preset::remove_suffix_modified().

Referenced by bind_filament_target(), and combo_item_for_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ combo_item_is_marker()

bool Slic3r::anonymous_namespace{PluginHostPresets.cpp}::combo_item_is_marker	(	GUI::PresetComboBox &	combo,
		int	item )

{
    const auto marker = reinterpret_cast<std::size_t>(combo.GetClientData(item));
    return marker >= GUI::PresetComboBox::LABEL_ITEM_DISABLED && marker < GUI::PresetComboBox::LABEL_ITEM_MAX;
}

References combo_item_is_marker(), Slic3r::GUI::PresetComboBox::LABEL_ITEM_DISABLED, and Slic3r::GUI::PresetComboBox::LABEL_ITEM_MAX.

Referenced by combo_item_for_preset(), combo_item_is_marker(), and resolve_combo_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ current_filament_presets()

py::list Slic3r::anonymous_namespace{PluginHostPresets.cpp}::current_filament_presets ( PresetBundle & bundle )

{
    py::list presets;
    for (const std::string& preset_name : bundle.filament_presets) {
        Preset* preset = bundle.filaments.find_preset(preset_name);
        if (preset == nullptr)
            presets.append(py::none());
        else
            presets.append(py::cast(preset, py::return_value_policy::reference));
    }
    return presets;
}

References current_filament_presets(), Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, and Slic3r::PresetCollection::find_preset().

Referenced by current_filament_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_bundle_ids()

std::vector< std::string > Slic3r::anonymous_namespace{PluginHostPresets.cpp}::list_bundle_ids ( )

{
    std::vector<std::string> ids;
    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.app_config == nullptr)
            throw std::runtime_error("Application configuration is not available");
 
        ids = app.preset_bundle->list_local_bundle_ids(app.app_config->get("preset_folder"));
    });
    return ids;
}

References Slic3r::GUI::GUI_App::app_config, Slic3r::AppConfig::get(), Slic3r::GUI::GUI_App::is_closing(), list_bundle_ids(), Slic3r::PresetBundle::list_local_bundle_ids(), Slic3r::GUI::GUI_App::preset_bundle, and Slic3r::PluginHostUi::run_on_ui_thread().

Referenced by list_bundle_ids().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preset_tab_name()

const char * Slic3r::anonymous_namespace{PluginHostPresets.cpp}::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";
    }
}

References preset_tab_name(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by bind_preset_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), preset_tab_name(), and require_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ printer_presets()

PresetCollection & Slic3r::anonymous_namespace{PluginHostPresets.cpp}::printer_presets ( PresetBundle & bundle )

{
    return static_cast<PresetCollection&>(bundle.printers);
}

References printer_presets(), and Slic3r::PresetBundle::printers.

Referenced by collection_for(), and printer_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reload_local_bundle()

void Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle ( const std::string & bundle_id )

{
    bool        reloaded = false;
    std::string error;
    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.app_config == nullptr)
            throw std::runtime_error("Application configuration is not available");
        if (app.mainframe == nullptr)
            throw std::runtime_error("OrcaSlicer main window is not available");
 
        reloaded = app.preset_bundle->reload_local_bundle(app.app_config->get("preset_folder"), bundle_id, &error);
        if (!reloaded)
            return;
 
        app.mainframe->update_side_preset_ui();
        for (GUI::Tab* tab : app.tabs_list) {
            tab->reload_config();
            tab->update_changed_ui();
        }
        if (GUI::Plater* plater = app.plater())
            plater->sidebar().update_all_preset_comboboxes();
    });
    if (!reloaded)
        throw std::runtime_error(error.empty() ? "Local bundle was not reloaded" : error);
}

References Slic3r::GUI::GUI_App::app_config, Slic3r::AppConfig::get(), Slic3r::GUI::GUI_App::is_closing(), Slic3r::GUI::GUI_App::mainframe, Slic3r::GUI::GUI_App::plater(), Slic3r::GUI::GUI_App::preset_bundle, Slic3r::GUI::Tab::reload_config(), reload_local_bundle(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::PluginHostUi::run_on_ui_thread(), Slic3r::GUI::GUI_App::tabs_list, Slic3r::GUI::Tab::update_changed_ui(), and Slic3r::GUI::MainFrame::update_side_preset_ui().

Referenced by reload_local_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require_gui_app()

GUI::GUI_App & Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_gui_app ( )

{
    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");
    return app;
}

References Slic3r::GUI::GUI_App::is_closing(), Slic3r::GUI::GUI_App::plater(), Slic3r::GUI::GUI_App::preset_bundle, and require_gui_app().

Referenced by bind_filament_target(), bind_preset_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), and require_gui_app().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ require_tab()

GUI::Tab * Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_tab	(	GUI::GUI_App &	app,
		Preset::Type	type )

{
    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");
    return tab;
}

References Slic3r::PresetCollection::get_selected_preset(), Slic3r::GUI::GUI_App::get_tab(), Slic3r::GUI::GUI_App::preset_bundle, preset_tab_name(), Slic3r::Preset::printer_technology(), Slic3r::PresetBundle::printers, require_tab(), and Slic3r::GUI::Tab::supports_printer_technology().

Referenced by bind_filament_target(), bind_preset_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), and require_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_combo_preset()

ComboPresetMatch Slic3r::anonymous_namespace{PluginHostPresets.cpp}::resolve_combo_preset	(	GUI::PresetComboBox &	combo,
		const std::string &	requested )

{
    ComboPresetMatch  match;
    const std::string want       = Preset::remove_suffix_modified(requested);
    const int         item_count = combo.GetCount();
    for (int item = 0; item < item_count; ++item) {
        if (combo_item_is_marker(combo, item))
            continue;
        const wxString    alias      = combo.GetItemAlias(item);
        const std::string alias_name = alias.empty() ? std::string()
                                                     : Preset::remove_suffix_modified(alias.ToUTF8().data());
        const std::string label_name = Preset::remove_suffix_modified(combo.GetString(item).ToUTF8().data());
        if ((alias_name.empty() || alias_name != want) && label_name != want)
            continue;
        if (match.item >= 0 && match.item != item) {
            match.ambiguous = true;
            return match;
        }
        match.item          = item;
        match.internal_name = alias_name.empty() ? label_name : alias_name;
    }
    return match;
}

References Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::ambiguous, combo_item_is_marker(), ComboBox::GetCount(), ComboBox::GetItemAlias(), ComboBox::GetString(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::internal_name, Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::item, Slic3r::Preset::remove_suffix_modified(), and resolve_combo_preset().

Referenced by bind_filament_target(), resolve_combo_preset(), and resolve_preset_in_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_preset_in_combo()

std::string Slic3r::anonymous_namespace{PluginHostPresets.cpp}::resolve_preset_in_combo	(	GUI::PresetComboBox &	combo,
		const std::string &	requested,
		const std::string &	category,
		const std::string &	selector )

{
    const ComboPresetMatch match = resolve_combo_preset(combo, requested);
    if (match.ambiguous)
        throw std::invalid_argument("The " + category + " name \"" + requested + "\" is ambiguous in the " + selector
                                    + "; more than one entry shows it, so name the preset by its own entry");
    if (match.item < 0)
        throw std::invalid_argument("The " + category + " preset \"" + requested + "\" is not offered by the " + selector);
    return match.internal_name;
}

References Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::ambiguous, Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::internal_name, Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch::item, resolve_combo_preset(), and resolve_preset_in_combo().

Referenced by bind_filament_target(), bind_preset_target(), and resolve_preset_in_combo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolved_slot_preset()

std::string Slic3r::anonymous_namespace{PluginHostPresets.cpp}::resolved_slot_preset	(	PresetBundle &	bundle,
		int	slot_number )

{
    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");
    Preset* preset = bundle.filaments.find_preset(assigned_name);
    if (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");
    return preset->name;
}

References Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::Preset::name, and resolved_slot_preset().

Referenced by bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), and resolved_slot_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_edited_preset()

void Slic3r::anonymous_namespace{PluginHostPresets.cpp}::update_edited_preset	(	Preset::Type	type,
		const std::string &	key,
		const std::string &	value )

{
    PresetTransaction transaction = begin_preset_update(type, std::string());
    transaction.set(key, value);
    transaction.commit();
}

References begin_preset_update(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::set(), and update_edited_preset().

Referenced by update_edited_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_filament_slot()

void Slic3r::anonymous_namespace{PluginHostPresets.cpp}::update_filament_slot	(	int	slot_number,
		const std::string &	key,
		const std::string &	value )

{
    PresetTransaction transaction = begin_filament_update(slot_number, std::string());
    transaction.set(key, value);
    transaction.commit();
}

References begin_filament_update(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::set(), and update_filament_slot().

Referenced by update_filament_slot().

Here is the call graph for this function:

Here is the caller graph for this function:

	OrcaSlicer latest OrcaSlicer

Classes

Functions

Class Documentation

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetEditor

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetUpdateResult

◆ Slic3r::anonymous_namespace{PluginHostPresets.cpp}::ComboPresetMatch

Function Documentation

◆ begin_filament_update()

◆ begin_preset_update()

◆ bind_filament_target()

◆ bind_preset_target()

◆ collection_for()

◆ combo_item_for_preset()

◆ combo_item_is_marker()

◆ current_filament_presets()

◆ list_bundle_ids()

◆ preset_tab_name()

◆ printer_presets()

◆ reload_local_bundle()

◆ require_gui_app()

◆ require_tab()

◆ resolve_combo_preset()

◆ resolve_preset_in_combo()

◆ resolved_slot_preset()

◆ update_edited_preset()

◆ update_filament_slot()