Slic3r::PrinterPresetCollection Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Preset.hpp>

Inheritance diagram for Slic3r::PrinterPresetCollection:

Collaboration diagram for Slic3r::PrinterPresetCollection:

Public Types
enum class	LoadAndSelect { Never , Always , OnlyIfModified }
typedef std::deque< Preset >::iterator	Iterator
typedef std::deque< Preset >::const_iterator	ConstIterator
typedef std::function< void(Preset *preset, std::string sync_info)>	SyncFunc

Public Member Functions
	PrinterPresetCollection (Preset::Type type, const std::vector< std::string > &keys, const Slic3r::StaticPrintConfig &defaults, const std::string &default_name="Default Printer")
const Preset &	default_preset_for (const DynamicPrintConfig &config) const override
const Preset *	find_system_preset_by_model_and_variant (const std::string &model_id, const std::string &variant) const
const Preset *	find_custom_preset_by_model_and_variant (const std::string &model_id, const std::string &variant) const
bool	only_default_printers () const
Iterator	lbegin ()
bool	validate_preset (const std::string &name, std::string &inherit)
Iterator	begin ()
ConstIterator	begin () const
ConstIterator	cbegin () const
Iterator	end ()
ConstIterator	end () const
ConstIterator	cend () const
Iterator	erase (Iterator it)
void	set_sync_func (SyncFunc func)
void	lock ()
void	unlock ()
void	reset (bool delete_files)
Preset::Type	type () const
std::string	name () const
std::string	section_name () const
const std::deque< Preset > &	operator() () const
void	add_default_preset (const std::vector< std::string > &keys, const Slic3r::StaticPrintConfig &defaults, const std::string &preset_name)
void	load_presets (const std::string &dir_path, const std::string &subdir, PresetsConfigSubstitutions &substitutions, ForwardCompatibilitySubstitutionRule rule, std::function< void(Preset &)> preset_loaded_fn=nullptr, const PresetOrigin &load_origin=PresetOrigin(), bool read_only=false)
void	update_user_presets_directory (const std::string &dir_path, const std::string &type)
void	save_user_presets (const std::string &dir_path, const std::string &type, std::map< std::string, std::string > &need_to_delete_list)
bool	load_user_preset (std::string name, std::map< std::string, std::string > preset_values, PresetsConfigSubstitutions &substitutions, ForwardCompatibilitySubstitutionRule rule, const PresetOrigin &load_origin=PresetOrigin(PresetOrigin::Kind::User))
void	update_after_user_presets_loaded ()
std::vector< LegacyUserFilamentPreset >	legacy_user_filament_presets (const std::map< std::string, std::vector< std::string > > &printers_by_parent)
void	apply_legacy_user_filament_presets (const std::vector< LegacyUserFilamentPreset > &written)
int	get_user_presets (PresetBundle *preset_bundle, std::vector< Preset > &result_presets)
void	set_sync_info_and_save (std::string name, std::string setting_id, std::string syncinfo, long long update_time, const std::string &user_id)
bool	need_sync (std::string name, std::string setting_id, long long update_time)
Preset *	get_preset_differed_for_save (Preset &preset)
int	get_differed_values_to_update (Preset &preset, std::map< std::string, std::string > &key_values)
void	load_project_embedded_presets (std::vector< Preset * > &project_presets, const std::string &type, PresetsConfigSubstitutions &substitutions, ForwardCompatibilitySubstitutionRule rule)
std::vector< Preset * >	get_project_embedded_presets ()
bool	reset_project_embedded_presets ()
Preset &	load_preset (const std::string &path, const std::string &name, const DynamicPrintConfig &config, bool select=true, Semver file_version=Semver())
Preset &	load_preset (const std::string &path, const std::string &name, DynamicPrintConfig &&config, bool select=true, Semver file_version=Semver())
bool	clone_presets (std::vector< Preset const * > const &presets, std::vector< std::string > &failures, std::function< void(Preset &, Preset::Type &)> modifier, bool force_rewritten=false)
bool	clone_presets_for_printer (std::vector< Preset const * > const &templates, std::vector< std::string > &failures, std::string const &printer, std::function< std::string(std::string)> create_filament_id, bool force_rewritten=false)
bool	clone_presets_for_filament (Preset const *const &preset, std::vector< std::string > &failures, std::string const &filament_name, std::string const &filament_id, const DynamicConfig &dynamic_config, const std::string &compatible_printers, bool force_rewritten=false)
std::map< std::string, std::vector< Preset const * > >	get_filament_presets () const
std::pair< Preset *, bool >	load_external_preset (const std::string &path, const std::string &name, const std::string &original_name, const DynamicPrintConfig &config, const std::set< std::string > &different_settings_list, LoadAndSelect select=LoadAndSelect::Always, const Semver file_version=Semver(), const std::string filament_id=std::string())
void	save_current_preset (const std::string &new_name, bool detach=false, bool save_to_project=false, Preset *_curr_preset=nullptr)
std::string	add_detached_preset (const std::string &name_base, DynamicPrintConfig config, const std::string &filament_id=std::string())
bool	delete_current_preset ()
bool	delete_preset (const std::string &name, bool force=false)
void	check_and_fix_syncinfo (Preset &preset, const std::string &user_id)
void	set_default_suppressed (bool default_suppressed)
bool	is_default_suppressed () const
Preset &	select_preset (size_t idx)
Preset &	get_selected_preset ()
const Preset &	get_selected_preset () const
size_t	get_selected_idx () const
std::string	get_selected_preset_name () const
const Preset *	get_selected_preset_parent () const
const Preset *	get_preset_parent (const Preset &child) const
const Preset *	get_preset_base (const Preset &child) const
Preset &	get_edited_preset ()
const Preset &	get_edited_preset () const
const Preset &	get_selected_preset_base () const
PresetWithVendorProfile	get_preset_with_vendor_profile (const Preset &preset) const
PresetWithVendorProfile	get_edited_preset_with_vendor_profile () const
const std::string &	get_preset_name_by_alias (const std::string &alias) const
const std::string *	get_preset_name_renamed (const std::string &old_name) const
bool	is_alias_exist (const std::string &alias, Preset *preset=nullptr)
void	set_printer_hold_alias (const std::string &alias, Preset &preset, bool remove=false)
const std::deque< Preset > &	get_presets () const
size_t	get_idx_selected ()
Preset &	default_preset (size_t idx=0)
const Preset &	default_preset (size_t idx=0) const
Preset &	preset (size_t idx, bool real=false)
const Preset &	preset (size_t idx) const
void	discard_current_changes ()
Preset *	find_preset (const std::string &name, bool first_visible_if_not_found=false, bool real=false, bool only_from_library=false)
const Preset *	find_preset (const std::string &name, bool first_visible_if_not_found=false) const
Preset *	find_preset2 (const std::string &name, bool auto_match=true)
const Preset *	find_preset2 (const std::string &name, bool auto_match=true) const
size_t	first_visible_idx () const
size_t	first_visible_idx_by_type (const std::string &filament_type) const
std::string	filament_id_by_type (const std::string &filament_type) const
template<typename PreferedCondition>
size_t	first_compatible_idx (PreferedCondition prefered_condition) const
size_t	first_compatible_idx () const
std::vector< std::string >	diameters_of_selected_printer ()
Preset &	first_visible ()
const Preset &	first_visible () const
Preset &	first_compatible ()
template<typename PreferedCondition>
Preset &	first_compatible (PreferedCondition prefered_condition)
const Preset &	first_compatible () const
size_t	size () const
bool	has_defaults_only () const
int	error_count () const
template<typename PreferedCondition>
void	update_compatible (const PresetWithVendorProfile &active_printer, const PresetWithVendorProfile *active_print, PresetSelectCompatibleType select_other_if_incompatible, PreferedCondition prefered_condition)
void	update_compatible (const PresetWithVendorProfile &active_printer, const PresetWithVendorProfile *active_print, PresetSelectCompatibleType select_other_if_incompatible)
size_t	num_visible () const
bool	current_is_dirty () const
std::vector< std::string >	current_dirty_options (const bool deep_compare=false) const
std::vector< std::string >	current_different_from_parent_options (const bool deep_compare=false) const
bool	saved_is_dirty () const
void	update_saved_preset_from_current_preset ()
std::vector< std::string >	system_preset_names () const
bool	update_dirty ()
bool	select_preset_by_name (const std::string &name, bool force)
bool	is_base_preset (const Preset &preset) const
std::string	path_from_name (const std::string &new_name, bool detach=false) const
std::string	path_for_preset (const Preset &preset) const
std::string	get_preset_alias (Preset &preset, bool force=false)
size_t	num_default_presets ()

Static Public Member Functions
static bool	write_legacy_user_filament_preset (const LegacyUserFilamentPreset &legacy)
static const std::string &	get_suffix_modified ()
static bool	is_dirty (const Preset *edited, const Preset *reference)
static std::vector< std::string >	dirty_options (const Preset *edited, const Preset *reference, const bool deep_compare=false)
static std::vector< std::string >	dirty_options_without_option_list (const Preset *edited, const Preset *reference, const std::set< std::string > &option_ignore_list, const bool deep_compare=false)

Public Attributes
SyncFunc	sync_func { nullptr }

Protected Member Functions
void	update_vendor_ptrs_after_copy (const VendorMap &vendors)
bool	select_preset_by_name_strict (const std::string &name)
std::vector< std::vector< std::string > >	merge_presets (const std::vector< PresetCollection * > &others, const VendorMap &new_vendors)
void	update_map_alias_to_profile_name ()
void	update_map_system_profile_renamed ()
void	update_library_profile_excluded_from ()
void	set_custom_preset_alias (Preset &preset)

Private Member Functions
	PrinterPresetCollection ()=default
	PrinterPresetCollection (const PrinterPresetCollection &other)=delete
PrinterPresetCollection &	operator= (const PrinterPresetCollection &other)=default
UserPresetLoad	resolve_user_preset (const boost::filesystem::path &file, const std::string &canonical_name, const PresetOrigin &load_origin, ForwardCompatibilitySubstitutionRule substitution_rule, const std::string &extruder_id_name, const std::string &extruder_variant_name, std::set< std::string > *key_set1, std::set< std::string > *key_set2, bool read_only) const
void	commit_user_preset (UserPresetLoad &&loaded, std::deque< Preset > &presets_loaded, PresetsConfigSubstitutions &substitutions, const std::function< void(Preset &)> &preset_loaded_fn, bool read_only)
std::string	canonical_preset_name (const std::string &name, const PresetOrigin &load_origin=PresetOrigin()) const
Preset &	append_preset (std::string &&path, const std::string &name, DynamicPrintConfig &&config)
void	sort_presets ()
std::deque< Preset >::iterator	find_preset_internal (const std::string &name, bool from_orca_lib_only=false)
std::deque< Preset >::const_iterator	find_preset_internal (const std::string &name) const
std::deque< Preset >::iterator	find_preset_renamed (const std::string &name)
std::deque< Preset >::const_iterator	find_preset_renamed (const std::string &name) const
size_t	update_compatible_internal (const PresetWithVendorProfile &active_printer, const PresetWithVendorProfile *active_print, PresetSelectCompatibleType unselect_if_incompatible)

Static Private Member Functions
static bool	filament_preset_less (const Preset &a, const Preset &b)

Private Attributes
Preset::Type	m_type
std::deque< Preset >	m_presets
std::map< std::string, std::vector< std::string > >	m_map_alias_to_profile_name
std::unordered_map< std::string, std::unordered_set< std::string > >	m_printer_hold_alias
std::map< std::string, std::string >	m_map_system_profile_renamed
Preset	m_edited_preset
Preset	m_saved_preset
size_t	m_idx_selected
bool	m_default_suppressed = true
size_t	m_num_default_presets = 0
std::string	m_dir_path
std::recursive_mutex	m_mutex
int	m_errors = 0

Friends
class	PresetBundle

Detailed Description

Member Typedef Documentation

ConstIterator

typedef std::deque<Preset>::const_iterator Slic3r::PresetCollection::ConstIterator

inherited

Iterator

typedef std::deque<Preset>::iterator Slic3r::PresetCollection::Iterator

inherited

SyncFunc

typedef std::function<void(Preset* preset, std::string sync_info)> Slic3r::PresetCollection::SyncFunc

inherited

Member Enumeration Documentation

LoadAndSelect

enum class Slic3r::PresetCollection::LoadAndSelect

stronginherited

Enumerator
Never
Always
OnlyIfModified

                             {
        // Never select
        Never,
        // Always select
        Always,
        // Select a profile only if it was modified.
        OnlyIfModified,
    };

Constructor & Destructor Documentation

PrinterPresetCollection() [1/3]

Slic3r::PrinterPresetCollection::PrinterPresetCollection ( Preset::Type type, const std::vector< std::string > & keys, const Slic3r::StaticPrintConfig & defaults, const std::string & default_name = "Default Printer" )

inline

                                                                                                                                                                           :
    PresetCollection(type, keys, defaults, default_name) {}

References Slic3r::PresetCollection::PresetCollection(), and Slic3r::PresetCollection::type().

Referenced by PrinterPresetCollection(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

PrinterPresetCollection() [2/3]

Slic3r::PrinterPresetCollection::PrinterPresetCollection ( )

privatedefault

PrinterPresetCollection() [3/3]

Slic3r::PrinterPresetCollection::PrinterPresetCollection ( const PrinterPresetCollection & other )

privatedelete

References PrinterPresetCollection().

Here is the call graph for this function:

Member Function Documentation

add_default_preset()

void Slic3r::PresetCollection::add_default_preset ( const std::vector< std::string > & keys, const Slic3r::StaticPrintConfig & defaults, const std::string & preset_name )

inherited

{
    // Insert just the default preset.
    m_presets.emplace_back(Preset(this->type(), preset_name, true));
    m_presets.back().config.apply_only(defaults, keys.empty() ? defaults.keys() : keys);
    m_presets.back().loaded = true;
    ++ m_num_default_presets;
}

References Slic3r::StaticConfig::keys(), m_num_default_presets, m_presets, Slic3r::Preset, and type().

Referenced by PresetCollection().

Here is the call graph for this function:

Here is the caller graph for this function:

add_detached_preset()

std::string Slic3r::PresetCollection::add_detached_preset ( const std::string & name_base, DynamicPrintConfig config, const std::string & filament_id = std::string() )

inherited

{
    if (name_base.empty())
        return std::string();
    Preset stored(m_type, name_base);
    stored.config = std::move(config);
    stored.filament_id = filament_id;
 
    // Uniquify verbatim; only on collision append " (Published)" then " (Published 2)".
    const std::string base_name = name_base;
    std::string       final_name = base_name;
    auto exists = [this](const std::string &candidate) -> bool {
        const auto it = this->find_preset_internal(candidate);
        return it != m_presets.end() && it->name == candidate;
    };
    if (exists(final_name)) {
        final_name = base_name + " (Published)";
        for (int i = 2; exists(final_name); ++i)
            final_name = base_name + " (Published " + std::to_string(i) + ")";
    }
 
    // Creation branch of save_current_preset(detach=true), without its selection side
    // effects or project-embedded path.
    lock();
    const auto it = this->find_preset_internal(final_name);
    if (m_presets.begin() + m_idx_selected >= it)
        ++m_idx_selected;
    Preset &preset = *m_presets.insert(it, stored);
    preset.name = final_name;
    preset.vendor = nullptr;
    preset.alias.clear();
    preset.renamed_from.clear();
    preset.m_excluded_from.clear();
    preset.setting_id.clear();
    preset.inherits().clear();
    preset.version = Semver::parse(SoftFever_VERSION).value_or(Semver());
    preset.is_default  = false;
    preset.is_system   = false;
    preset.is_external = false;
    preset.bundle_id.clear();
    preset.file                = this->path_for_preset(preset);
    preset.is_visible          = true;
    preset.is_project_embedded = true;
    if (m_type == Preset::TYPE_PRINT)
        preset.config.option<ConfigOptionString>("print_settings_id", true)->value = final_name;
    else if (m_type == Preset::TYPE_FILAMENT)
        preset.config.option<ConfigOptionStrings>("filament_settings_id", true)->values[0] = final_name;
    else if (m_type == Preset::TYPE_PRINTER)
        preset.config.option<ConfigOptionString>("printer_settings_id", true)->value = final_name;
    unlock();
 
    return final_name;
}

References Slic3r::Preset::config, Slic3r::Preset::filament_id, find_preset_internal(), lock(), m_idx_selected, m_presets, m_type, Slic3r::Semver::parse(), path_for_preset(), preset(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and unlock().

Here is the call graph for this function:

append_preset()

Preset & Slic3r::PresetCollection::append_preset ( std::string && path, const std::string & name, DynamicPrintConfig && config )

privateinherited

{
    lock();
    Preset &preset = m_presets.emplace_back(m_type, name, false);
    preset.file = std::move(path);
    preset.config = std::move(config);
    preset.loaded = true;
    preset.is_dirty = false;
    unlock();
    return preset;
}

References lock(), m_presets, m_type, name(), preset(), and unlock().

Referenced by Slic3r::PresetBundle::commit_vendor_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_legacy_user_filament_presets()

void Slic3r::PresetCollection::apply_legacy_user_filament_presets ( const std::vector< LegacyUserFilamentPreset > & written )

inherited

{
    lock();
    for (const LegacyUserFilamentPreset &legacy : written) {
        auto it = this->find_preset_internal(legacy.preset);
        if (it == m_presets.end() || it->name != legacy.preset)
            continue; // deleted by the preset sync thread meanwhile
        std::vector<std::string> &saved  = it->config.option<ConfigOptionStrings>("compatible_printers", true)->values;
        std::vector<std::string> &edited = m_edited_preset.config.option<ConfigOptionStrings>("compatible_printers", true)->values;
        // Added to the list the preset holds now rather than replacing it: the cloud sync may have given the
        // preset a newer list since it was found, and that list is still to be written out.
        std::vector<std::string> printers = saved;
        for (const std::string &printer : legacy.printers)
            if (std::find(printers.begin(), printers.end(), printer) == printers.end())
                printers.push_back(printer);
        // A change to the list pending in the settings tab stays pending. Without one, the edited copy and the
        // snapshot unsaved changes are measured against take the written list, so nothing reads as modified.
        if (m_idx_selected == static_cast<size_t>(it - m_presets.begin()) && edited == saved) {
            edited = printers;
            if (m_saved_preset.name == it->name)
                m_saved_preset.config.option<ConfigOptionStrings>("compatible_printers", true)->values = printers;
        }
        saved = printers;
        // Push the change to the cloud copy, as an edit in the settings tab would. A sync already pending for
        // the preset (a download waiting to be saved, a deletion) keeps its state.
        if (!it->setting_id.empty() && it->sync_info.empty()) {
            it->sync_info = "update";
            it->save_info();
        }
    }
    unlock();
}

References find_preset_internal(), lock(), m_edited_preset, m_idx_selected, m_presets, m_saved_preset, and unlock().

Here is the call graph for this function:

begin() [1/2]

Iterator Slic3r::PresetCollection::begin ( )

inlineinherited

{ return m_presets.begin() + m_num_default_presets; }

References m_num_default_presets, and m_presets.

Referenced by Slic3r::MachineObject::check_ams_filament_valid(), Slic3r::GUI::ExtrusionCalibration::get_bed_type_incompatible(), Slic3r::PresetBundle::get_current_project_embedded_presets(), Slic3r::GUI::get_default_name(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), Slic3r::GUI::get_printer_preset(), Slic3r::PresetBundle::get_similar_printer_preset(), Slic3r::GUI::ExtrusionCalibration::on_click_cali(), Slic3r::GUI::ExtrusionCalibration::on_click_save(), Slic3r::GUI::AMSMaterialsSetting::on_select_reset(), Slic3r::GUI::Plater::post_process_string_object_exception(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::MachineObject::setting_id_to_type(), Slic3r::GUI::ExtrusionCalibration::update_combobox_filaments(), and Slic3r::GUI::ExtrusionCalibration::update_filament_info().

Here is the caller graph for this function:

begin() [2/2]

ConstIterator Slic3r::PresetCollection::begin ( ) const

inlineinherited

{ return m_presets.cbegin() + m_num_default_presets; }

References m_num_default_presets, and m_presets.

canonical_preset_name()

std::string Slic3r::PresetCollection::canonical_preset_name ( const std::string & name, const PresetOrigin & load_origin = PresetOrigin() ) const

privateinherited

{
    const ParsedName parsed = parse_preset_name(name);
    PresetOrigin origin = load_origin;
    if (origin.kind == PresetOrigin::Kind::Auto) {
        origin.kind      = parsed.kind;
        origin.bundle_id = parsed.bundle_id;
    } else if (origin.is_bundle() && origin.bundle_id.empty()) {
        origin.bundle_id = parsed.bundle_id;
    }
    return get_preset_canonical_name(parsed.bare, origin);
}

References Slic3r::PresetOrigin::Auto, Slic3r::PresetOrigin::bundle_id, Slic3r::get_preset_canonical_name(), Slic3r::PresetOrigin::is_bundle(), Slic3r::PresetOrigin::kind, and name().

Referenced by load_presets(), load_user_preset(), select_preset_by_name(), select_preset_by_name_strict(), set_sync_info_and_save(), and validate_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

cbegin()

ConstIterator Slic3r::PresetCollection::cbegin ( ) const

inlineinherited

{ return m_presets.cbegin() + m_num_default_presets; }

References m_num_default_presets, and m_presets.

Referenced by Slic3r::PrinterPresetCollection::find_custom_preset_by_model_and_variant(), and Slic3r::PrinterPresetCollection::find_system_preset_by_model_and_variant().

Here is the caller graph for this function:

cend()

ConstIterator Slic3r::PresetCollection::cend ( ) const

inlineinherited

{ return m_presets.cend(); }

References m_presets.

Referenced by Slic3r::PrinterPresetCollection::find_custom_preset_by_model_and_variant(), and Slic3r::PrinterPresetCollection::find_system_preset_by_model_and_variant().

Here is the caller graph for this function:

check_and_fix_syncinfo()

void Slic3r::PresetCollection::check_and_fix_syncinfo ( Preset & preset, const std::string & user_id )

inherited

{
    // user id can't be empty
    if (user_id.empty())
        return;
    // correct the sync info if preset.user_id is empty(the profile json file is copied to the user folder with missing .info file) or preset.user_id
    // is not equal to the current user id or preset.setting_id is not in expected format(the .info is copied from the older format)
    if (preset.user_id.empty() || preset.user_id != user_id || preset.setting_id.find('-') == std::string::npos) {
        preset.user_id    = user_id;
        preset.setting_id = "";
 
        if (preset.base_id.empty()) {
            const std::string inherits      = Preset::inherits(preset.config);
            Preset*           parent_preset = find_preset2(inherits, true);
            if (parent_preset)
                preset.base_id = parent_preset->setting_id;
        }
        // tell the sync logic to sync it as a new preset
        preset.updated_time = 0;
        preset.sync_info    = "create";
        preset.save_info();
        return;
    }
 
    const auto inherits = Preset::inherits(preset.config);
    Preset* parent      = find_preset2(inherits, true);
    if (!inherits.empty() && parent) {
        const std::string expected = parent->setting_id;
        if (expected.empty()) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": Direct parent of " << preset.name << " does not have a setting_id";
            return;
        }
        // Reconcile a missing or stale base_id against the direct parent's setting_id.
        if (preset.base_id != expected) {
            preset.base_id = expected;
            // Already-synced preset whose base changed -> re-push it.
            if (!preset.setting_id.empty() && preset.sync_info.empty())
                preset.sync_info = "update";
            preset.save_info();
        }
    }
}

References find_preset2(), Slic3r::Preset::inherits(), preset(), and Slic3r::Preset::setting_id.

Here is the call graph for this function:

clone_presets()

bool Slic3r::PresetCollection::clone_presets ( std::vector< Preset const * > const & presets, std::vector< std::string > & failures, std::function< void(Preset &, Preset::Type &)> modifier, bool force_rewritten = false )

inherited

{
    std::vector<Preset> new_presets;
    for (auto curr_preset : presets) {
        new_presets.push_back(*curr_preset);
        auto &preset = new_presets.back();
        preset.vendor         = nullptr;
        preset.renamed_from.clear();
        preset.m_excluded_from.clear();
        preset.setting_id.clear();
        preset.inherits().clear();
        preset.is_default  = false;
        preset.is_system   = false;
        preset.is_external = false;
        preset.is_visible = true;
        preset.is_project_embedded = false;
        modifier(preset, m_type);
        if (find_preset(preset.name) && !force_rewritten) {
            failures.push_back(preset.name);
        }
        preset.file                = this->path_for_preset(preset);
        if (m_type == Preset::TYPE_PRINT)
            preset.config.option<ConfigOptionString>("print_settings_id", true)->value = preset.name;
        else if (m_type == Preset::TYPE_FILAMENT)
            preset.config.option<ConfigOptionStrings>("filament_settings_id", true)->values[0] = preset.name;
        else if (m_type == Preset::TYPE_PRINTER)
            preset.config.option<ConfigOptionString>("printer_settings_id", true)->value = preset.name;
    }
    if (!failures.empty() && !force_rewritten)
        return false;
    lock();
    auto old_name = this->get_edited_preset().name;
    for (auto preset : new_presets) {
        preset.alias.clear();
        set_custom_preset_alias(preset);
        preset.base_id.clear();
        auto it = this->find_preset_internal(preset.name);
        assert((it == m_presets.end() || it->name != preset.name) || force_rewritten);
        if (it == m_presets.end() || it->name != preset.name) {
            Preset &new_preset = *m_presets.insert(it, preset);
            new_preset.save(nullptr);
        } else if (force_rewritten) {
            *it = preset;
            (*it).save(nullptr);
        }
    }
    this->select_preset_by_name(old_name, true);
    unlock();
    return true;
}

References find_preset(), find_preset_internal(), get_edited_preset(), lock(), m_presets, m_type, Slic3r::Preset::name, path_for_preset(), preset(), Slic3r::Preset::save(), select_preset_by_name(), set_custom_preset_alias(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and unlock().

Referenced by clone_presets_for_filament(), and clone_presets_for_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

clone_presets_for_filament()

bool Slic3r::PresetCollection::clone_presets_for_filament ( Preset const *const & preset, std::vector< std::string > & failures, std::string const & filament_name, std::string const & filament_id, const DynamicConfig & dynamic_config, const std::string & compatible_printers, bool force_rewritten = false )

inherited

{
    std::vector<Preset const *> const presets = {preset};
    return clone_presets(presets, failures, [&filament_name, &filament_id, &dynamic_config, &compatible_printers](Preset &preset, Preset::Type &type) {
        preset.name        = filament_name + " @" + compatible_printers;
        if (type == Preset::TYPE_FILAMENT) {
            preset.config.apply_only(dynamic_config, {"filament_vendor", "compatible_printers", "filament_type"},true);
 
            preset.filament_id = filament_id;
            auto compatible = dynamic_cast<ConfigOptionStrings *>(preset.config.option("compatible_printers"));
            if (compatible->values.empty()) {
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " " << __LINE__ << preset.name << " apply compatible_printer failed";
                compatible->values.push_back(compatible_printers);
            }
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << preset.name << " is cloned and filament_id: " << filament_id;
         }
        },
        force_rewritten);
}

References clone_presets(), preset(), type(), and Slic3r::Preset::TYPE_FILAMENT.

Referenced by Slic3r::GUI::CreatePresetForPrinterDialog::create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

clone_presets_for_printer()

bool Slic3r::PresetCollection::clone_presets_for_printer ( std::vector< Preset const * > const & templates, std::vector< std::string > & failures, std::string const & printer, std::function< std::string(std::string)> create_filament_id, bool force_rewritten = false )

inherited

{
    return clone_presets(templates, failures, [printer, create_filament_id](Preset &preset, Preset::Type &type) {
            std::string prefix          = preset.name.substr(0, preset.name.find(" @"));
            std::replace(prefix.begin(), prefix.end(), '/', '-');
            preset.name                 = prefix + " @" + printer;
            auto *compatible_printers   = dynamic_cast<ConfigOptionStrings *>(preset.config.option("compatible_printers"));
            compatible_printers->values = std::vector<std::string>{printer};
            preset.is_visible           = true;
            if (type == Preset::TYPE_FILAMENT) {
                preset.filament_id = create_filament_id(prefix);
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << preset.name << " create filament_id: " << preset.filament_id;
            }
    }, force_rewritten);
}

References clone_presets(), preset(), type(), Slic3r::Preset::TYPE_FILAMENT, and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

commit_user_preset()

void Slic3r::PresetCollection::commit_user_preset ( UserPresetLoad && loaded, std::deque< Preset > & presets_loaded, PresetsConfigSubstitutions & substitutions, const std::function< void(Preset &)> & preset_loaded_fn, bool read_only )

privateinherited

{
    Preset &preset = loaded.preset;
    if (! loaded.info_file.empty())
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " load info from: " << loaded.info_file << " and base_id: " << preset.base_id;
    append(substitutions, std::move(loaded.substitutions));
    for (const std::string &error : loaded.errors) {
        ++m_errors;
        BOOST_LOG_TRIVIAL(error) << error;
    }
    if (loaded.discard_file)
        remove_preset_files(loaded.preset.file, read_only);
    if (!loaded.install)
        return;
 
    if (loaded.complete) {
        if (loaded.save_compatible_printers) {
            // A filesystem error from the rewrite is counted, and the preset still loads.
            try {
                if (read_only)
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name << " (not written back)";
                else if (preset.save(nullptr))
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " added compatible_printers for preset: " << preset.name;
                else
                    ++m_errors; // save() logged why
            } catch (const std::runtime_error &err) {
                ++m_errors;
                BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " can not write compatible_printers back to " << preset.file << ": " << err.what();
            }
        }
        //BBS: add some workaround for previous incorrect settings
        if ((!preset.setting_id.empty())&&(preset.setting_id == preset.base_id))
            preset.setting_id.clear();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " load preset: " << preset.name << " and filament_id: " << preset.filament_id << " and base_id: " << preset.base_id;
        //BBS: add config related logs
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", preset type %1%, name %2%, path %3%, is_system %4%, is_default %5% is_visible %6%")%Preset::get_type_string(m_type) %preset.name %preset.file %preset.is_system %preset.is_default %preset.is_visible;
        // add alias for custom filament preset
        set_custom_preset_alias(preset);
    }
 
    if (preset_loaded_fn != nullptr)
        preset_loaded_fn(preset);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " load config successful and preset name is:" << preset.name;
    presets_loaded.emplace_back(std::move(preset));
}

References Slic3r::append(), Slic3r::Preset::get_type_string(), m_errors, m_type, preset(), Slic3r::remove_preset_files(), and set_custom_preset_alias().

Here is the call graph for this function:

current_different_from_parent_options()

std::vector< std::string > Slic3r::PresetCollection::current_different_from_parent_options ( const bool deep_compare = false ) const

inlineinherited

        { return dirty_options(&this->get_edited_preset(), this->get_selected_preset_parent(), deep_compare); }

References dirty_options(), get_edited_preset(), and get_selected_preset_parent().

Here is the call graph for this function:

current_dirty_options()

std::vector< std::string > Slic3r::PresetCollection::current_dirty_options ( const bool deep_compare = false ) const

inlineinherited

        { return dirty_options(&this->get_edited_preset(), &this->get_selected_preset(), deep_compare); }

References dirty_options(), get_edited_preset(), and get_selected_preset().

Referenced by Slic3r::collect_dirty_settings_keys(), and Slic3r::PresetBundle::reload_local_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

current_is_dirty()

bool Slic3r::PresetCollection::current_is_dirty ( ) const

inlineinherited

        { return is_dirty(&this->get_edited_preset(), &this->get_selected_preset()); }

References get_edited_preset(), get_selected_preset(), and is_dirty().

Referenced by Slic3r::GUI::Tab::select_preset(), and update_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

default_preset() [1/2]

Preset & Slic3r::PresetCollection::default_preset ( size_t idx = 0 )

inlineinherited

{ assert(idx < m_num_default_presets); return m_presets[idx]; }

References m_num_default_presets, and m_presets.

Referenced by default_preset_for(), Slic3r::PrinterPresetCollection::default_preset_for(), get_selected_preset_parent(), load_preset(), load_project_embedded_presets(), load_user_preset(), resolve_user_preset(), and Slic3r::CLI::run().

Here is the caller graph for this function:

default_preset() [2/2]

const Preset & Slic3r::PresetCollection::default_preset ( size_t idx = 0 ) const

inlineinherited

{ assert(idx < m_num_default_presets); return m_presets[idx]; }

References m_num_default_presets, and m_presets.

default_preset_for()

const Preset & Slic3r::PrinterPresetCollection::default_preset_for ( const DynamicPrintConfig & config ) const

overridevirtual

Reimplemented from Slic3r::PresetCollection.

{
    const ConfigOptionEnumGeneric *opt_printer_technology = config.opt<ConfigOptionEnumGeneric>("printer_technology");
    return this->default_preset((opt_printer_technology == nullptr || opt_printer_technology->value == ptFFF) ? 0 : 1);
}

References Slic3r::PresetCollection::default_preset(), Slic3r::DynamicConfig::opt(), Slic3r::ptFFF, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_current_preset()

bool Slic3r::PresetCollection::delete_current_preset ( )

inherited

{
    Preset &selected = this->get_selected_preset();
    if (!selected.can_overwrite())
        return false;
 
    if (get_preset_base(selected) == &selected) {
        for (auto &preset2 : m_presets)
            if (preset2.inherits() == selected.name)
                return false;
    }
 
    //BBS: add project embedded preset logic and refine is_external
    //if (! selected.is_external && ! selected.is_system) {
    if (! selected.is_system) {
        //BBS Erase the preset file.
        selected.remove_files();
    }
    //BBS: add lock logic for sync preset in background
    lock();
    // Remove the preset from the list.
    m_presets.erase(m_presets.begin() + m_idx_selected);
    unlock();
 
    // Find the next visible preset.
    size_t new_selected_idx = m_idx_selected;
    if (new_selected_idx < m_presets.size())
        for (; new_selected_idx < m_presets.size() && ! m_presets[new_selected_idx].is_visible; ++ new_selected_idx) ;
    if (new_selected_idx == m_presets.size())
        for (--new_selected_idx; new_selected_idx > 0 && !m_presets[new_selected_idx].is_visible; --new_selected_idx);
    this->select_preset(new_selected_idx);
    return true;
}

References Slic3r::Preset::can_overwrite(), get_preset_base(), get_selected_preset(), Slic3r::Preset::is_system, lock(), m_idx_selected, m_presets, Slic3r::Preset::name, Slic3r::Preset::remove_files(), select_preset(), and unlock().

Here is the call graph for this function:

delete_preset()

bool Slic3r::PresetCollection::delete_preset ( const std::string & name, bool force = false )

inherited

{
    Preset *preset_ptr = this->find_preset(name, false, true);
    if (preset_ptr == nullptr)
        return false;
 
    auto it = this->find_preset_internal(preset_ptr->name);
    if (it == m_presets.end() || it->name != preset_ptr->name)
        return false;
 
    Preset& preset = *it;
    // ORCA: if the preset can't be overridden then don't allow deletion
    // force=true bypasses this for bundle preset cleanup from cloud sync
    if (!force && !preset.can_overwrite())
        return false;
 
    preset.remove_files();
 
    //BBS: add lock logic for sync preset in background
    lock();
    set_printer_hold_alias(it->alias, *it, true);
    m_presets.erase(it);
    unlock();
 
    return true;
}

References find_preset(), find_preset_internal(), lock(), m_presets, Slic3r::Preset::name, name(), preset(), set_printer_hold_alias(), and unlock().

Referenced by Slic3r::GUI::delete_filament_preset_by_name(), save_user_presets(), Slic3r::GUI::Tab::select_preset(), and Slic3r::PresetBundle::update_subscribed_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

diameters_of_selected_printer()

std::vector< std::string > Slic3r::PresetCollection::diameters_of_selected_printer ( )

inherited

{
    std::set<std::string> diameters;
    auto printer_model = m_edited_preset.config.opt_string("printer_model");
    for (auto &preset : m_presets) {
        if (preset.config.opt_string("printer_model") == printer_model)
            diameters.insert(preset.config.opt_string("printer_variant"));
    }
    return std::vector<std::string>{diameters.begin(), diameters.end()};
}

References m_edited_preset, m_presets, and preset().

Here is the call graph for this function:

dirty_options()

std::vector< std::string > Slic3r::PresetCollection::dirty_options ( const Preset * edited, const Preset * reference, const bool deep_compare = false )

staticinherited

{
    std::vector<std::string> changed;
    if (edited != nullptr && reference != nullptr) {
        // Only compares options existing in both configs.
        changed = deep_compare ?
                deep_diff(edited->config, reference->config) :
                reference->config.diff(edited->config);
        // The "compatible_printers" option key is handled differently from the others:
        // It is not mandatory. If the key is missing, it means it is compatible with any printer.
        // If the key exists and it is empty, it means it is compatible with no printer.
        for (auto &opt_key : optional_keys)
            if (reference->config.has(opt_key) != edited->config.has(opt_key))
                changed.emplace_back(opt_key);
    }
    return changed;
}

References Slic3r::Preset::config, Slic3r::deep_diff(), Slic3r::DynamicConfig::diff(), Slic3r::ConfigOptionResolver::has(), and Slic3r::optional_keys.

Referenced by current_different_from_parent_options(), current_dirty_options(), get_differed_values_to_update(), get_preset_differed_for_save(), Slic3r::PresetBundle::reload_local_bundle(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

dirty_options_without_option_list()

std::vector< std::string > Slic3r::PresetCollection::dirty_options_without_option_list ( const Preset * edited, const Preset * reference, const std::set< std::string > & option_ignore_list, const bool deep_compare = false )

staticinherited

{
    std::vector<std::string> changed;
    if (edited != nullptr && reference != nullptr) {
        // Only compares options existing in both configs.
        changed = deep_compare ?
                deep_diff(edited->config, reference->config) :
                reference->config.diff(edited->config);
        // The "compatible_printers" option key is handled differently from the others:
        // It is not mandatory. If the key is missing, it means it is compatible with any printer.
        // If the key exists and it is empty, it means it is compatible with no printer.
        for (auto &opt_key : optional_keys) {
            if (reference->config.has(opt_key) != edited->config.has(opt_key))
                changed.emplace_back(opt_key);
        }
        auto iter = changed.begin();
        while (iter != changed.end()) {
            if (option_ignore_list.find(*iter) != option_ignore_list.end()) {
                iter = changed.erase(iter);
            }
            else {
                ++iter;
            }
        }
    }
    return changed;
}

References Slic3r::Preset::config, Slic3r::deep_diff(), Slic3r::DynamicConfig::diff(), Slic3r::ConfigOptionResolver::has(), and Slic3r::optional_keys.

Here is the call graph for this function:

discard_current_changes()

void Slic3r::PresetCollection::discard_current_changes ( )

inlineinherited

                                              {
        m_presets[m_idx_selected].reset_dirty();
        m_edited_preset = m_presets[m_idx_selected];
//        update_saved_preset_from_current_preset();
    }

References m_edited_preset, m_idx_selected, and m_presets.

Referenced by Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes(), Slic3r::GUI::delete_filament_preset_by_name(), and Slic3r::GUI::Tab::select_preset().

Here is the caller graph for this function:

end() [1/2]

Iterator Slic3r::PresetCollection::end ( )

inlineinherited

{ return m_presets.end(); }

References m_presets.

Referenced by Slic3r::MachineObject::check_ams_filament_valid(), Slic3r::GUI::ExtrusionCalibration::get_bed_type_incompatible(), Slic3r::PresetBundle::get_current_project_embedded_presets(), Slic3r::GUI::get_default_name(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), Slic3r::GUI::get_printer_preset(), Slic3r::PresetBundle::get_similar_printer_preset(), is_alias_exist(), Slic3r::GUI::ExtrusionCalibration::on_click_cali(), Slic3r::GUI::ExtrusionCalibration::on_click_save(), Slic3r::GUI::AMSMaterialsSetting::on_select_reset(), Slic3r::GUI::Plater::post_process_string_object_exception(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::MachineObject::setting_id_to_type(), Slic3r::GUI::ExtrusionCalibration::update_combobox_filaments(), Slic3r::GUI::ExtrusionCalibration::update_filament_info(), and Slic3r::warn_ambiguous_filament_id_match().

Here is the caller graph for this function:

end() [2/2]

ConstIterator Slic3r::PresetCollection::end ( ) const

inlineinherited

{ return m_presets.cend(); }

References m_presets.

erase()

Iterator Slic3r::PresetCollection::erase ( Iterator it )

inlineinherited

{ return m_presets.erase(it); }

References m_presets.

error_count()

int Slic3r::PresetCollection::error_count ( ) const

inlineinherited

{ return m_errors; }

References m_errors.

Referenced by Slic3r::PresetBundle::reload_local_bundle().

Here is the caller graph for this function:

filament_id_by_type()

std::string Slic3r::PresetCollection::filament_id_by_type ( const std::string & filament_type ) const

inherited

{
    return preset(first_visible_idx_by_type(filament_type)).filament_id;
}

References Slic3r::Preset::filament_id, Slic3r::filament_type(), first_visible_idx_by_type(), and preset().

Referenced by Slic3r::CrealityPrintAgent::match_filament_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_preset_less()

bool Slic3r::PresetCollection::filament_preset_less ( const Preset & a, const Preset & b )

inlinestaticprivateinherited

                                                                       {
        bool a_generic = boost::starts_with(a.name, GENERIC_PREFIX);
        bool b_generic = boost::starts_with(b.name, GENERIC_PREFIX);
        if (a_generic != b_generic)
            return a_generic; // generics first
        return a.name < b.name;
    }

References GENERIC_PREFIX, and Slic3r::Preset::name.

Referenced by merge_presets(), and sort_presets().

Here is the caller graph for this function:

find_custom_preset_by_model_and_variant()

const Preset * Slic3r::PrinterPresetCollection::find_custom_preset_by_model_and_variant	(	const std::string &	model_id,
		const std::string &	variant ) const

{
    if (model_id.empty()) { return nullptr; }
 
    const auto it = std::find_if(cbegin(), cend(), [&](const Preset &preset) {
        if (preset.config.opt_string("printer_model") != model_id)
            return false;
        if (variant.empty())
            return true;
        return preset.config.opt_string("printer_variant") == variant;
    });
 
    return it != cend() ? &*it : nullptr;
}

References Slic3r::PresetCollection::cbegin(), Slic3r::PresetCollection::cend(), and Slic3r::PresetCollection::preset().

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model().

Here is the call graph for this function:

Here is the caller graph for this function:

find_preset() [1/2]

const Preset * Slic3r::PresetCollection::find_preset ( const std::string & name, bool first_visible_if_not_found = false ) const

inlineinherited

    {
        return const_cast<PresetCollection*>(this)->find_preset(name, first_visible_if_not_found);
    }

References PresetCollection(), find_preset(), and name().

Here is the call graph for this function:

find_preset() [2/2]

Preset * Slic3r::PresetCollection::find_preset ( const std::string & name, bool first_visible_if_not_found = false, bool real = false, bool only_from_library = false )

inherited

{
    const ParsedName  parsed    = parse_preset_name(name);
    const std::string canonical = get_preset_canonical_name(parsed.bare, PresetOrigin(parsed.kind, parsed.bundle_id));
    auto it = this->find_preset_internal(canonical, only_from_library);
    if (it != m_presets.end() && it->name == canonical)
        return &this->preset(it - m_presets.begin(), real);
    // Resolve the "renamed_from" field: a system preset may have been renamed (e.g. by a
    // vendor profile sync), which records its old name in "renamed_from". Try the rename
    // map before the first-visible fallback so every caller - including those passing
    // real/only_from_library or first_visible_if_not_found - resolves to the renamed preset
    // rather than a mismatched one. Recursion follows multi-step renames (A->B->C) and
    // terminates as soon as a name resolves or has no further rename entry.
    if (const std::string* renamed = get_preset_name_renamed(name))
        return find_preset(*renamed, first_visible_if_not_found, real, only_from_library);
    return first_visible_if_not_found ? &this->first_visible() : nullptr;
}

References find_preset(), find_preset_internal(), first_visible(), Slic3r::get_preset_canonical_name(), get_preset_name_renamed(), m_presets, name(), and preset().

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::capabilities_in_use(), Slic3r::GUI::ConfigWizard::priv::check_and_install_missing_materials(), clone_presets(), Slic3r::GUI::collect_imex_warnings(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::current_filament_presets(), Slic3r::GUI::delete_filament_preset_by_name(), delete_preset(), find_preset(), find_preset(), find_preset2(), Slic3r::GUI::Plater::force_filament_colors_update(), generate_custom_presets(), Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::get_cached_selected_filament_for_multi_extruder(), get_differed_values_to_update(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine(), Slic3r::GUI::AMSMaterialsSetting::get_filament_variant_index(), get_preset_differed_for_save(), get_preset_parent(), get_selected_preset_parent(), Slic3r::GUI::PublishSettingsDialog::GetPublishedMaterialKeys(), Slic3r::PresetBundle::import_json_presets(), load_presets(), load_project_embedded_presets(), Slic3r::GUI::ConfigWizard::priv::load_vendors(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_title(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), need_sync(), Slic3r::normalize_compatible_field(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::ExportPresetBundleDialog::OnRequestPresets(), Slic3r::refresh_missing_plugins(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::GUI::GUI_App::reload_settings(), Slic3r::PresetBundle::resolve_system_preset(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::resolved_slot_preset(), Slic3r::GUI::CalibrationWizard::save_preset(), Slic3r::GUI::CalibrationWizard::save_preset_with_index(), save_user_presets(), Slic3r::GUI::ExportConfigsDialog::select_curr_radiobox(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), Slic3r::GUI::DiffPresetDialog::update_compatibility(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::PresetBundle::update_subscribed_presets(), Slic3r::PresetBundle::update_system_preset_setting_ids(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

find_preset2() [1/2]

Preset * Slic3r::PresetCollection::find_preset2 ( const std::string & name, bool auto_match = true )

inherited

{
    auto preset = find_preset(name, false, true);
    if (preset == nullptr) {
        if (auto_match) {
            //Orca: one more try, find the most likely preset in OrcaFilamentLibrary
            if (name.find("Generic") != std::string::npos) {
                // The regex pattern matches an optional prefix ending in '_' then "Generic" followed by the material name.
                static const std::regex re(R"(^(?:.*?\b(?:\w+_)?)(Generic)\b\s+([^@]+?)\s*(?:@.*)?$)");
                auto       alter_name = std::regex_replace(name, re, "Generic $2 @System");
                preset                = find_preset2(alter_name, false);
                // print preset file name
                if (preset != nullptr) {
                    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << " " << "Failed to find: " << name
                                               << ". fallback to library preset: " << preset->file;
                }
            }
        }
    }
    return preset;
}

References find_preset(), find_preset2(), name(), and preset().

Referenced by check_and_fix_syncinfo(), find_preset2(), find_preset2(), get_preset_base(), Slic3r::PresetBundle::import_json_presets(), load_external_preset(), load_project_embedded_presets(), load_user_preset(), resolve_user_preset(), Slic3r::CLI::run(), save_current_preset(), and Slic3r::PresetBundle::save_preset_to_bundle_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

find_preset2() [2/2]

const Preset * Slic3r::PresetCollection::find_preset2 ( const std::string & name, bool auto_match = true ) const

inlineinherited

    {
        return const_cast<PresetCollection*>(this)->find_preset2(name, auto_match);
    }

References PresetCollection(), find_preset2(), and name().

Here is the call graph for this function:

find_preset_internal() [1/2]

std::deque< Preset >::const_iterator Slic3r::PresetCollection::find_preset_internal ( const std::string & name ) const

inlineprivateinherited

        { return const_cast<PresetCollection*>(this)->find_preset_internal(name); }

References PresetCollection(), find_preset_internal(), and name().

Here is the call graph for this function:

find_preset_internal() [2/2]

std::deque< Preset >::iterator Slic3r::PresetCollection::find_preset_internal ( const std::string & name, bool from_orca_lib_only = false )

inlineprivateinherited

    {
        auto it = Slic3r::lower_bound_by_predicate(m_presets.begin() + m_num_default_presets, m_presets.end(),
            [&name, this](const auto& l) {
                if (m_type == Preset::TYPE_FILAMENT) {
                    bool l_generic = boost::starts_with(l.name, GENERIC_PREFIX);
                    bool name_generic = boost::starts_with(name, GENERIC_PREFIX);
                    if (l_generic && !name_generic) return true;
                    if (!l_generic && name_generic) return false;
                }
                return l.name < name;
            });
        if (it == m_presets.end() || it->name != name) {
            // Preset has not been not found in the sorted list of non-default presets. Try the defaults.
            for (size_t i = 0; i < m_num_default_presets; ++ i)
                if (m_presets[i].name == name && (!from_orca_lib_only || m_presets[i].m_from_orca_filament_lib)) {
                    it = m_presets.begin() + i;
                    break;
                }
        }
        return it;
    }

References Slic3r::lower_bound_by_predicate(), m_num_default_presets, m_presets, and name().

Referenced by add_detached_preset(), apply_legacy_user_filament_presets(), clone_presets(), delete_preset(), find_preset(), find_preset_internal(), find_preset_renamed(), get_preset_name_by_alias(), load_external_preset(), load_preset(), load_user_preset(), save_current_preset(), select_preset_by_name(), select_preset_by_name_strict(), and validate_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

find_preset_renamed() [1/2]

std::deque< Preset >::iterator Slic3r::PresetCollection::find_preset_renamed ( const std::string & name )

inlineprivateinherited

                                                                            {
      auto it_renamed = m_map_system_profile_renamed.find(name);
      auto it = (it_renamed == m_map_system_profile_renamed.end()) ? m_presets.end() : this->find_preset_internal(it_renamed->second);
      assert((it_renamed == m_map_system_profile_renamed.end()) || (it != m_presets.end() && it->name == it_renamed->second));
      return it;
    }

References find_preset_internal(), m_map_system_profile_renamed, m_presets, and name().

Referenced by find_preset_renamed(), load_external_preset(), and validate_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

find_preset_renamed() [2/2]

std::deque< Preset >::const_iterator Slic3r::PresetCollection::find_preset_renamed ( const std::string & name ) const

inlineprivateinherited

        { return const_cast<PresetCollection*>(this)->find_preset_renamed(name); }

References PresetCollection(), find_preset_renamed(), and name().

Here is the call graph for this function:

find_system_preset_by_model_and_variant()

const Preset * Slic3r::PrinterPresetCollection::find_system_preset_by_model_and_variant	(	const std::string &	model_id,
		const std::string &	variant ) const

{
    if (model_id.empty()) { return nullptr; }
 
    const auto it = std::find_if(cbegin(), cend(), [&](const Preset &preset) {
        if (!preset.is_system || preset.config.opt_string("printer_model") != model_id)
            return false;
        if (variant.empty())
            return true;
        return preset.config.opt_string("printer_variant") == variant;
    });
 
    return it != cend() ? &*it : nullptr;
}

References Slic3r::PresetCollection::cbegin(), Slic3r::PresetCollection::cend(), and Slic3r::PresetCollection::preset().

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model().

Here is the call graph for this function:

Here is the caller graph for this function:

first_compatible() [1/3]

Preset & Slic3r::PresetCollection::first_compatible ( )

inlineinherited

{ return this->preset(this->first_compatible_idx()); }

References first_compatible_idx(), and preset().

Referenced by Slic3r::PresetBundle::reload_local_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

first_compatible() [2/3]

const Preset & Slic3r::PresetCollection::first_compatible ( ) const

inlineinherited

{ return this->preset(this->first_compatible_idx()); }

References first_compatible_idx(), and preset().

Here is the call graph for this function:

first_compatible() [3/3]

template<typename PreferedCondition>

Preset & Slic3r::PresetCollection::first_compatible ( PreferedCondition prefered_condition )

inlineinherited

{ return this->preset(this->first_compatible_idx(prefered_condition)); }

References first_compatible_idx(), and preset().

Here is the call graph for this function:

first_compatible_idx() [1/2]

size_t Slic3r::PresetCollection::first_compatible_idx ( ) const

inlineinherited

{ return this->first_compatible_idx([](const Preset&) -> int { return 0; }); }

References first_compatible_idx().

Referenced by first_compatible(), first_compatible(), first_compatible(), first_compatible_idx(), and update_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

first_compatible_idx() [2/2]

template<typename PreferedCondition>

size_t Slic3r::PresetCollection::first_compatible_idx ( PreferedCondition prefered_condition ) const

inlineinherited

    {
        size_t i             = m_default_suppressed ? m_num_default_presets : 0;
        size_t n             = this->m_presets.size();
        size_t i_compatible  = n;
        int    match_quality = -1;
        for (; i < n; ++i)
            // Since we use the filament selection from Wizard, it's needed to control the preset visibility too
            if (m_presets[i].is_compatible && m_presets[i].is_visible) {
                int this_match_quality = prefered_condition(m_presets[i]);
                if (this_match_quality > match_quality) {
                    if (match_quality == std::numeric_limits<int>::max())
                        // Better match will not be found.
                        return i;
                    // Store the first compatible profile with highest match quality into i_compatible.
                    i_compatible  = i;
                    match_quality = this_match_quality;
                }
            }
        return (i_compatible == n) ?
                    // No compatible preset found, return the default preset.
                    0 :
                    // Compatible preset found.
                    i_compatible;
}

References m_default_suppressed, m_num_default_presets, and m_presets.

first_visible() [1/2]

Preset & Slic3r::PresetCollection::first_visible ( )

inlineinherited

{ return this->preset(this->first_visible_idx()); }

References first_visible_idx(), and preset().

Referenced by find_preset(), and first_visible_idx().

Here is the call graph for this function:

Here is the caller graph for this function:

first_visible() [2/2]

const Preset & Slic3r::PresetCollection::first_visible ( ) const

inlineinherited

{ return this->preset(this->first_visible_idx()); }

References first_visible_idx(), and preset().

Here is the call graph for this function:

first_visible_idx()

size_t Slic3r::PresetCollection::first_visible_idx ( ) const

inherited

{
    //BBS: set first visible filament to fla
    size_t first_visible = -1;
    size_t idx = m_default_suppressed ? m_num_default_presets : 0;
    for (; idx < m_presets.size(); ++ idx)
        if (m_presets[idx].is_visible && m_presets[idx].get_printer_id() == PresetBundle::ORCA_FILAMENT_LIBRARY) {
            if (first_visible == -1)
                first_visible = idx;
            if (m_type != Preset::TYPE_FILAMENT)
                break;
            else {
                if (m_presets[idx].name.find("PLA") != std::string::npos) {
                    first_visible = idx;
                    break;
                }
            }
        }
    if (first_visible == -1) {
        if (m_presets.size() > 1 && m_default_suppressed)
            first_visible = m_presets.size() == m_num_default_presets ? 0 : m_num_default_presets;
        else
            first_visible = 0;
    }
    return first_visible;
}

References first_visible(), m_default_suppressed, m_num_default_presets, m_presets, m_type, name(), Slic3r::PresetBundle::ORCA_FILAMENT_LIBRARY, and Slic3r::Preset::TYPE_FILAMENT.

Referenced by first_visible(), first_visible(), first_visible_idx_by_type(), get_selected_preset(), Slic3r::PresetBundle::reload_local_bundle(), and select_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

first_visible_idx_by_type()

size_t Slic3r::PresetCollection::first_visible_idx_by_type ( const std::string & filament_type ) const

inherited

{
    size_t start = m_default_suppressed ? m_num_default_presets : 0;
 
    // Find the first visible, compatible, system base preset whose filament_type matches target.
    auto find_by_type = [&](const std::string& target) -> size_t {
        for (size_t i = start; i < m_presets.size(); ++i) {
            const auto& p = m_presets[i];
            if (p.is_visible && p.is_compatible && p.is_system
                && get_preset_base(p) == &p
                && p.config.opt_string("filament_type", 0u) == target)
                return i;
        }
        return size_t(-1);
    };
 
    // 1. Exact filament_type match
    size_t idx = find_by_type(filament_type);
    if (idx != size_t(-1))
        return idx;
 
    // 2. Base type fallback: strip modifier after first space
    //    e.g. "PLA High Speed" -> "PLA"
    //    Dash-separated types like "PA-CF", "PET-CF" are distinct materials, not modifiers.
    auto sep = filament_type.find(' ');
    if (sep != std::string::npos) {
        idx = find_by_type(filament_type.substr(0, sep));
        if (idx != size_t(-1))
            return idx;
    }
 
    // 3. Any visible preset
    return first_visible_idx();
}

References Slic3r::filament_type(), first_visible_idx(), get_preset_base(), m_default_suppressed, m_num_default_presets, and m_presets.

Referenced by filament_id_by_type().

Here is the call graph for this function:

Here is the caller graph for this function:

get_differed_values_to_update()

int Slic3r::PresetCollection::get_differed_values_to_update ( Preset & preset, std::map< std::string, std::string > & key_values )

inherited

{
    if (preset.is_system || preset.is_default || preset.is_project_embedded) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" Error: not a user preset! Should not happen, name %1%") %preset.name;
        ++m_errors;
        return -1;
    }
 
    //BBS: only save difference for user preset
    std::string& inherit_preset = preset.inherits();
    Preset* parent_preset = nullptr;
    if (!inherit_preset.empty()) {
        parent_preset = this->find_preset(inherit_preset, false, true);
    }
    if (parent_preset) {
        DynamicPrintConfig temp_config;
        std::vector<std::string> dirty_options = preset.config.diff(parent_preset->config);
 
        // Send the variant layout even when it matches the parent's, as the local save does: the loader
        // sizes the per-variant values by it and would otherwise keep only the first one.
        std::string extruder_id_name, extruder_variant_name;
        std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
        Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
        if (!extruder_id_name.empty())
            dirty_options.emplace_back(extruder_id_name);
        if (!extruder_variant_name.empty())
            dirty_options.emplace_back(extruder_variant_name);
 
        for (auto option: dirty_options)
        {
            ConfigOption *opt_src = preset.config.option(option);
            if (opt_src)
                key_values[option] = opt_src->serialize();
        }
 
        // Orca: force-emit nullable filament override keys whenever they hold a nil ("off")
        // value, even when the diff dropped them because the parent is nil too. Otherwise the
        // key is absent from the synced profile and the cloud re-materializes it against the
        // option's non-nil default (e.g. filament_retract_before_wipe -> 100%), silently
        // resurrecting an override the user turned off. See GitHub issue on Retract Before Wipe.
        if (m_type == Preset::TYPE_FILAMENT) {
            for (const std::string& opt_key : preset.config.keys()) {
                if (!is_filament_extruder_override_key(opt_key) || key_values.count(opt_key))
                    continue; // not an override, or already carried by the diff
                const ConfigOptionDef *def = print_config_def.get(opt_key);
                if (def == nullptr || !def->default_value || def->default_value->is_nil())
                    continue; // the option's default is nil too, so an absent key cannot come back as a value
                const auto* opt_vec = dynamic_cast<const ConfigOptionVectorBase*>(preset.config.option(opt_key));
                if (opt_vec == nullptr)
                    continue;
                bool has_nil = false;
                for (size_t i = 0; i < opt_vec->size(); ++i)
                    if (opt_vec->is_nil(i)) { has_nil = true; break; }
                if (has_nil)
                    key_values[opt_key] = opt_vec->serialize();
            }
        }
    }
    else {
        for (auto iter = preset.config.cbegin(); iter != preset.config.cend(); ++iter)
        {
            key_values[iter->first] = iter->second->serialize();
        }
    }
 
    //add other values
    key_values[BBL_JSON_KEY_VERSION] = preset.version.to_string();
    if (!preset.base_id.empty()) {
        key_values[BBL_JSON_KEY_BASE_ID] = preset.base_id;
    } else {
        key_values.erase(BBL_JSON_KEY_BASE_ID);
        if (get_preset_base(preset) == &preset && !preset.filament_id.empty()) {
            key_values[BBL_JSON_KEY_FILAMENT_ID] = preset.filament_id;
        }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " uploading user preset name is: " << preset.name << "and create filament_id is: " << preset.filament_id
                            << " and base_id is: " << preset.base_id;
    key_values[ORCA_JSON_KEY_UPDATE_TIME] = std::to_string(preset.updated_time);
    key_values[BBL_JSON_KEY_TYPE] = Preset::get_iot_type_string(preset.type);
    return 0;
}

References BBL_JSON_KEY_BASE_ID, BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_TYPE, BBL_JSON_KEY_VERSION, Slic3r::Preset::config, Slic3r::ConfigOptionDef::default_value, dirty_options(), find_preset(), Slic3r::Preset::get_extruder_names_and_keysets(), Slic3r::Preset::get_iot_type_string(), get_preset_base(), Slic3r::is_filament_extruder_override_key(), m_errors, m_type, ORCA_JSON_KEY_UPDATE_TIME, preset(), Slic3r::print_config_def, Slic3r::ConfigOption::serialize(), and Slic3r::Preset::TYPE_FILAMENT.

Referenced by Slic3r::PresetBundle::get_differed_values_to_update().

Here is the call graph for this function:

Here is the caller graph for this function:

get_edited_preset() [1/2]

Preset & Slic3r::PresetCollection::get_edited_preset ( )

inlineinherited

{ return m_edited_preset; }

References m_edited_preset.

Referenced by Slic3r::GUI::_collect_sorted_machines(), Slic3r::active_capability_config(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::SelectMachineDialog::build_nozzles_info(), Slic3r::GUI::SyncAmsInfoDialog::build_nozzles_info(), Slic3r::GUI::PartPlate::calc_imex_zones(), Slic3r::capabilities_in_use(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), clone_presets(), Slic3r::GUI::collect_imex_warnings(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit(), Slic3r::GUI::DiffPresetDialog::create_buttons(), current_different_from_parent_options(), current_dirty_options(), current_is_dirty(), Slic3r::GUI::PluginsConfigDialog::current_preset(), Slic3r::GUI::delete_filament_preset_by_name(), Slic3r::effective_physical_extruder_map(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::Plater::export_gcode(), Slic3r::GUI::extruder_supports_tpu_high_flow(), get_edited_preset_with_vendor_profile(), Slic3r::GUI::Plater::priv::get_machine_sync_status(), Slic3r::Preset::get_printer_type(), get_selected_preset_parent(), Slic3r::GUI::getExtruderNozzleCount(), Slic3r::GUI::getExtruderNozzleCountTotal(), Slic3r::Preset::has_lidar(), Slic3r::GUI::PartPlate::imex_wipe_tower_hull(), Slic3r::GUI::SyncAmsInfoDialog::is_dirty_filament(), Slic3r::GUI::Plater::is_same_printer_for_connected_and_selected(), Slic3r::GUI::SelectMachineDialog::is_same_printer_model(), Slic3r::GUI::SyncAmsInfoDialog::is_same_printer_model(), Slic3r::GUI::Sidebar::priv::layout_printer(), load_external_preset(), Slic3r::GUI::MainFrame::load_printer_url(), Slic3r::PhysicalPrinterCollection::load_printers_from_presets(), Slic3r::GUI::manuallySetNozzleCount(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::GUI::PartPlate::refresh_imex_icon(), Slic3r::refresh_missing_plugins(), Slic3r::GUI::PartPlate::register_raycasters_for_picking(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::GUI::GUI_App::reload_settings(), Slic3r::GUI::PartPlate::render_icons(), Slic3r::GUI::GCodeViewer::render_markers(), Slic3r::PresetBundle::restore_selection(), Slic3r::GUI::s_get_slicing_extuder_nozzles(), Slic3r::GUI::UnsavedChangesDialog::save(), Slic3r::PresetBundle::save_changes_for_preset(), Slic3r::GUI::CalibrationWizard::save_preset(), Slic3r::GUI::CalibrationWizard::save_preset_with_index(), saved_is_dirty(), Slic3r::GUI::seedExtruderNozzleStats(), Slic3r::GUI::Tab::select_preset(), Slic3r::PresetBundle::selection(), Slic3r::GUI::PartPlate::set_shape(), Slic3r::GUI::setExtruderNozzleCount(), Slic3r::GUI::Sidebar::should_show_SEMM_buttons(), Slic3r::GUI::SelectMachineDialog::show_status(), Slic3r::GUI::SyncAmsInfoDialog::show_status(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::UnsavedChangesDialog::update(), Slic3r::GUI::Sidebar::update_all_preset_comboboxes(), update_dirty(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::GUI::SelectMachineDialog::update_show_status(), Slic3r::GUI::Sidebar::priv::update_sync_status(), and Slic3r::GUI::updateNozzleCountDisplay().

get_edited_preset() [2/2]

const Preset & Slic3r::PresetCollection::get_edited_preset ( ) const

inlineinherited

{ return m_edited_preset; }

References m_edited_preset.

get_edited_preset_with_vendor_profile()

PresetWithVendorProfile Slic3r::PresetCollection::get_edited_preset_with_vendor_profile ( ) const

inlineinherited

{ return this->get_preset_with_vendor_profile(this->get_edited_preset()); }

References get_edited_preset(), and get_preset_with_vendor_profile().

Referenced by Slic3r::GUI::Tab::select_preset(), and anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_presets()

std::map< std::string, std::vector< Preset const * > > Slic3r::PresetCollection::get_filament_presets ( ) const

inherited

{
    std::map<std::string, std::vector<Preset const *>> filament_presets;
    for (auto &preset : m_presets) {
        if (preset.is_user()) {
            if (preset.inherits() == "") { filament_presets[preset.filament_id].push_back(&preset); }
            continue;
        }
        if (get_preset_base(preset) == &preset) { filament_presets[preset.filament_id].push_back(&preset); }
    }
    return filament_presets;
}

References get_preset_base(), m_presets, and preset().

Referenced by Slic3r::GUI::get_filament_id(), and Slic3r::GUI::update_custom_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

get_idx_selected()

size_t Slic3r::PresetCollection::get_idx_selected ( )

inlineinherited

{ return m_idx_selected; }

References m_idx_selected.

Referenced by Slic3r::GUI::delete_filament_preset_by_name().

Here is the caller graph for this function:

get_preset_alias()

std::string Slic3r::PresetCollection::get_preset_alias ( Preset & preset, bool force = false )

inherited

{
    if (!preset.alias.empty())
        return preset.alias;
    else
        set_custom_preset_alias(preset);
 
    if (!preset.alias.empty() || !force)
        return preset.alias;
 
    std::string alias_name;
    std::string preset_name = preset.name;
    size_t      end_pos     = preset_name.find_first_of("@");
    if (end_pos != std::string::npos) {
        alias_name = preset_name.substr(0, end_pos);
        boost::trim_right(alias_name);
    }
    return alias_name;
}

References preset(), and set_custom_preset_alias().

Referenced by Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), and Slic3r::GUI::AMSMaterialsSetting::Popup().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_base()

const Preset * Slic3r::PresetCollection::get_preset_base ( const Preset & child ) const

inherited

{
    if (child.is_system || child.is_default)
        return &child;
    // Handle user preset
    if (child.inherits().empty())
        return &child; // this is user root
    auto inherits = find_preset2(child.inherits(), true);
    return inherits ? get_preset_base(*inherits) : nullptr;
}

References find_preset2(), get_preset_base(), Slic3r::Preset::inherits(), Slic3r::Preset::is_default, and Slic3r::Preset::is_system.

Referenced by Slic3r::GUI::ExportConfigsDialog::data_init(), delete_current_preset(), Slic3r::anonymous_namespace{SnapmakerPrinterAgent.cpp}::find_closest_color_preset_by_vendor_and_type(), first_visible_idx_by_type(), get_differed_values_to_update(), get_filament_presets(), get_preset_base(), get_selected_preset_base(), get_selected_preset_parent(), Slic3r::anonymous_namespace{CrealityPrintAgent.cpp}::has_visible_base_preset(), Slic3r::anonymous_namespace{QidiPrinterAgent.cpp}::has_visible_base_preset(), Slic3r::GUI::ExportPresetBundleDialog::InitExportData(), Slic3r::GUI::ExportPresetBundleDialog::OnRequestPresets(), Slic3r::GUI::ExportConfigsDialog::select_curr_radiobox(), Slic3r::GUI::CreatePrinterPresetDialog::set_current_visible_printer(), set_sync_info_and_save(), and Slic3r::warn_ambiguous_filament_id_match().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_differed_for_save()

Preset * Slic3r::PresetCollection::get_preset_differed_for_save ( Preset & preset )

inherited

{
    if (preset.is_system || preset.is_default)
        return nullptr;
 
    Preset* new_preset = nullptr;
    //BBS: only save difference for user preset
    std::string& inherits = preset.inherits();
    Preset* parent_preset = nullptr;
    if (!inherits.empty()) {
        parent_preset = this->find_preset(inherits, false, true);
    }
    if (parent_preset) {
        new_preset = new Preset();
        *new_preset = preset;
 
        DynamicPrintConfig temp_config;
        std::vector<std::string> dirty_options = preset.config.diff(parent_preset->config);
 
        std::string extruder_id_name, extruder_variant_name;
        std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
        Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
 
        if (!extruder_id_name.empty()) {
            dirty_options.emplace_back(extruder_id_name);
        }
        if (!extruder_variant_name.empty()) {
            dirty_options.emplace_back(extruder_variant_name);
        }
 
        for (auto option: dirty_options)
        {
            ConfigOption *opt_src = preset.config.option(option);
            ConfigOption *opt_dst = temp_config.option(option, true);
            if (opt_dst->is_scalar() || !(opt_dst->nullable()) || is_filament_extruder_override_key(option))
                opt_dst->set(opt_src);
            else {
                ConfigOptionVectorBase* opt_vec_src = static_cast<ConfigOptionVectorBase*>(opt_src);
                ConfigOptionVectorBase* opt_vec_dst = static_cast<ConfigOptionVectorBase*>(opt_dst);
                ConfigOptionVectorBase* opt_vec_inherit = static_cast<ConfigOptionVectorBase*>(parent_preset->config.option(option));
                if (opt_vec_src->size() == 1)
                    opt_dst->set(opt_src);
                else if (key_set1->find(option) != key_set1->end()) {
                    opt_vec_dst->set_with_nil(opt_vec_src, opt_vec_inherit, 1);
                }
                else if (key_set2->find(option) != key_set2->end()) {
                    opt_vec_dst->set_with_nil(opt_vec_src, opt_vec_inherit, 2);
                }
                else
                    opt_dst->set(opt_src);
            }
        }
 
        new_preset->config = temp_config;
    }
 
    return new_preset;
}

References Slic3r::Preset::config, dirty_options(), find_preset(), Slic3r::Preset::get_extruder_names_and_keysets(), Slic3r::is_filament_extruder_override_key(), Slic3r::ConfigOption::is_scalar(), m_type, Slic3r::ConfigOption::nullable(), Slic3r::ConfigBase::option(), Slic3r::Preset, preset(), Slic3r::ConfigOption::set(), Slic3r::ConfigOptionVectorBase::set_with_nil(), and Slic3r::ConfigOptionVectorBase::size().

Referenced by Slic3r::PresetBundle::get_preset_differed_for_save(), and get_project_embedded_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_name_by_alias()

const std::string & Slic3r::PresetCollection::get_preset_name_by_alias ( const std::string & alias ) const

inherited

{
  for (
    // Find the 1st profile name with the alias.
    auto it = Slic3r::lower_bound_by_predicate(m_map_alias_to_profile_name.begin(), m_map_alias_to_profile_name.end(), [&alias](auto &l){ return l.first < alias; });
    // Continue over all profile names with the same alias.
    it != m_map_alias_to_profile_name.end() && it->first == alias; ++ it)
        for (const std::string &preset_name : it->second) {
            if (auto it_preset = this->find_preset_internal(preset_name);
      it_preset != m_presets.end() && it_preset->name == preset_name &&
            it_preset->is_visible && (it_preset->is_compatible || size_t(it_preset - m_presets.begin()) == m_idx_selected))
          return it_preset->name;
        }
    
    return alias;
}

References find_preset_internal(), Slic3r::lower_bound_by_predicate(), m_idx_selected, m_map_alias_to_profile_name, and m_presets.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::PresetBundle::get_preset_name_by_alias(), Slic3r::GUI::CalibrationWizard::save_preset(), and Slic3r::GUI::CalibrationWizard::save_preset_with_index().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_name_renamed()

const std::string * Slic3r::PresetCollection::get_preset_name_renamed ( const std::string & old_name ) const

inherited

{
  auto it_renamed = m_map_system_profile_renamed.find(old_name);
  if (it_renamed != m_map_system_profile_renamed.end())
    return &it_renamed->second;
  return nullptr;
}

References m_map_system_profile_renamed.

Referenced by find_preset().

Here is the caller graph for this function:

get_preset_parent()

const Preset * Slic3r::PresetCollection::get_preset_parent ( const Preset & child ) const

inherited

{
    const std::string &inherits = child.inherits();
    if (inherits.empty())
//    return this->get_selected_preset().is_system ? &this->get_selected_preset() : nullptr;
        return nullptr;
    // find_preset() already resolves "renamed_from" internally.
    const Preset* preset = this->find_preset(inherits, false);
    return
         // not found
        (preset == nullptr/* || preset->is_default */||
         // this should not happen, user profile should not derive from an external profile
         //BBS: add project embedded preset logic and refine is_external
         /*preset->is_external ||*/
         // this should not happen, however people are creative, see GH #4996
         preset == &child) ?
            nullptr :
            preset;
}

References find_preset(), Slic3r::Preset::inherits(), and preset().

Referenced by get_preset_with_vendor_profile(), legacy_user_filament_presets(), and Slic3r::PresetBundle::reload_local_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

get_preset_with_vendor_profile()

PresetWithVendorProfile Slic3r::PresetCollection::get_preset_with_vendor_profile ( const Preset & preset ) const

inherited

{
  const Preset    *p = &preset;
  const VendorProfile *v = nullptr;
  do {
    if (p->vendor != nullptr) {
      v = p->vendor;
      break;
    }
    p = this->get_preset_parent(*p);
  } while (p != nullptr);
  return PresetWithVendorProfile(preset, v);
}

References get_preset_parent(), preset(), and Slic3r::Preset::vendor.

Referenced by generate_custom_presets(), get_edited_preset_with_vendor_profile(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), Slic3r::GUI::ExtrusionCalibration::update_combobox_filaments(), and update_compatible_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

get_presets()

const std::deque< Preset > & Slic3r::PresetCollection::get_presets ( ) const

inlineinherited

{ return m_presets; }

References m_presets.

Referenced by Slic3r::GUI::ExportConfigsDialog::data_init(), Slic3r::GUI::delete_filament_preset_by_name(), Slic3r::anonymous_namespace{SnapmakerPrinterAgent.cpp}::find_closest_color_preset_by_vendor_and_type(), generate_custom_presets(), Slic3r::GUI::CreateFilamentPresetDialog::get_all_filament_presets(), Slic3r::GUI::CreateFilamentPresetDialog::get_all_visible_printer_name(), Slic3r::GUI::get_filament_id(), Slic3r::GUI::EditFilamentPresetDialog::get_same_filament_id_presets(), Slic3r::GUI::GUI_App::get_selected_presets(), Slic3r::anonymous_namespace{CrealityPrintAgent.cpp}::has_visible_base_preset(), Slic3r::anonymous_namespace{QidiPrinterAgent.cpp}::has_visible_base_preset(), Slic3r::GUI::ExportPresetBundleDialog::InitExportData(), Slic3r::CrealityPrintAgent::match_filament_preset(), Slic3r::PrinterPresetCollection::only_default_printers(), Slic3r::anonymous_namespace{PresetBundle.cpp}::printer_kept_bed_paths(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::PresetBundle::resolve_preset_config(), Slic3r::GUI::CreatePrinterPresetDialog::set_current_visible_printer(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), Slic3r::GUI::CreatePrinterPresetDialog::update_presets_list(), and Slic3r::PresetBundle::update_subscribed_presets().

Here is the caller graph for this function:

get_project_embedded_presets()

std::vector< Preset * > Slic3r::PresetCollection::get_project_embedded_presets ( )

inherited

{
    std::vector<Preset*> project_presets;
 
    lock();
    for (Preset &preset : m_presets) {
        //if (preset.type != Preset::get_type_from_string(type)) continue;
        if (!preset.is_project_embedded) continue;
 
        Preset* new_preset = get_preset_differed_for_save(preset);
 
        if (new_preset)
            project_presets.push_back(new_preset);
    }
    unlock();
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, type %1% , total preset counts %2%")%Preset::get_type_string(m_type) %project_presets.size();
    return project_presets;
}

References get_preset_differed_for_save(), Slic3r::Preset::get_type_string(), lock(), m_presets, m_type, preset(), and unlock().

Here is the call graph for this function:

get_selected_idx()

size_t Slic3r::PresetCollection::get_selected_idx ( ) const

inlineinherited

{ return m_idx_selected; }

References m_idx_selected.

Referenced by Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), and get_selected_preset_parent().

Here is the caller graph for this function:

get_selected_preset() [1/2]

Preset & Slic3r::PresetCollection::get_selected_preset ( )

inlineinherited

                                          {
        //BBS fix crash when m_idx_selected == -1, give a default value
        if ((m_idx_selected < 0) || (m_idx_selected >= m_presets.size())) {
            select_preset(first_visible_idx());
        }
        return m_presets[m_idx_selected];
    }

References first_visible_idx(), m_idx_selected, m_presets, and select_preset().

Referenced by Slic3r::GUI::EditFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), current_dirty_options(), current_is_dirty(), delete_current_preset(), Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), get_selected_preset_name(), get_selected_preset_parent(), Slic3r::GUI::Plater::get_selected_printer_name_in_combox(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::GUI::GCodeViewer::init(), load_external_preset(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::GUI::Sidebar::need_auto_sync_extruder_list_after_connect_priner(), Slic3r::GUI::AMSMaterialsSetting::on_select_filament(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::GUI::GUI_App::reload_settings(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_tab(), Slic3r::PresetBundle::save_changes_for_preset(), save_current_preset(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_config(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::UnsavedChangesDialog::update(), Slic3r::GUI::DiffPresetDialog::update_compatibility(), and update_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selected_preset() [2/2]

const Preset & Slic3r::PresetCollection::get_selected_preset ( ) const

inlineinherited

{ return m_presets[m_idx_selected]; }

References m_idx_selected, and m_presets.

get_selected_preset_base()

const Preset & Slic3r::PresetCollection::get_selected_preset_base ( ) const

inlineinherited

    {
        const Preset &selected = m_presets[m_idx_selected];
        const Preset *base     = get_preset_base(selected);
        return base ? *base : selected;
    }

References get_preset_base(), m_idx_selected, and m_presets.

Here is the call graph for this function:

get_selected_preset_name()

std::string Slic3r::PresetCollection::get_selected_preset_name ( ) const

inlineinherited

                                                   {
        if (m_idx_selected == size_t(-1) || m_idx_selected >= m_presets.size())
            return std::string();
        return this->get_selected_preset().name;
    }

References get_selected_preset(), m_idx_selected, m_presets, and Slic3r::Preset::name.

Referenced by Slic3r::GUI::GUI_App::get_selected_presets(), Slic3r::GUI::Plater::priv::on_select_bed_type(), Slic3r::PresetBundle::reload_local_bundle(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets(), Slic3r::PresetBundle::selection(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), update_after_user_presets_loaded(), Slic3r::GUI::Sidebar::update_all_preset_comboboxes(), and Slic3r::GUI::Sidebar::update_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selected_preset_parent()

const Preset * Slic3r::PresetCollection::get_selected_preset_parent ( ) const

inherited

{
    if (this->get_selected_idx() == size_t(-1))
        // This preset collection has no preset activated yet. Only the get_edited_preset() is valid.
        return nullptr;
 
    const Preset    &selected_preset = this->get_selected_preset();
    if (get_preset_base(selected_preset) == &selected_preset)
        return &selected_preset;
 
    const Preset    &edited_preset   = this->get_edited_preset();
    const std::string &inherits        = edited_preset.inherits();
    const Preset      *preset          = nullptr;
    if (inherits.empty()) {
        if (selected_preset.is_external)
            return nullptr;
        preset = &this->default_preset(m_type == Preset::Type::TYPE_PRINTER && edited_preset.printer_technology() == ptSLA ? 1 : 0);
    } else
        // find_preset() already resolves "renamed_from" internally.
        preset = this->find_preset(inherits, false);
    //BBS: add project embedded preset logic and refine is_external
    return (preset == nullptr/* || preset->is_default || preset->is_external*/) ? nullptr : preset;
    //return (preset == nullptr/* || preset->is_default*/ || preset->is_external) ? nullptr : preset;
}

References default_preset(), find_preset(), get_edited_preset(), get_preset_base(), get_selected_idx(), get_selected_preset(), Slic3r::Preset::inherits(), Slic3r::Preset::is_external, m_type, preset(), Slic3r::Preset::printer_technology(), Slic3r::ptSLA, and Slic3r::Preset::TYPE_PRINTER.

Referenced by current_different_from_parent_options().

Here is the call graph for this function:

Here is the caller graph for this function:

get_suffix_modified()

const std::string & Slic3r::PresetCollection::get_suffix_modified ( )

staticinherited

                                                       {
    return g_suffix_modified;
}

References Slic3r::g_suffix_modified.

Referenced by Slic3r::GUI::EditDevNameDialog::on_edit_name(), Slic3r::GUI::AuFile::on_input_enter(), Slic3r::GUI::SelectMachineDialog::on_rename_enter(), Slic3r::GUI::SendMultiMachinePage::on_rename_enter(), Slic3r::GUI::SendToPrinterDialog::on_rename_enter(), Slic3r::GUI::SavePresetDialog::Item::update(), and Slic3r::GUI::PhysicalPrinterDialog::update_preset_input().

Here is the caller graph for this function:

get_user_presets()

int Slic3r::PresetCollection::get_user_presets ( PresetBundle * preset_bundle, std::vector< Preset > & result_presets )

inherited

{
    int count = 0;
    result_presets.clear();
 
    lock();
    for (Preset &preset : m_presets) {
        if (!preset.is_user()) continue;
        if (preset.base_id.empty() && preset.inherits() != "") continue;
        if (!preset.setting_id.empty() && preset.sync_info.empty()) continue;
        //if (!preset.is_bbl_vendor_preset(preset_bundle)) continue;
        if (preset.sync_info == "hold") continue;
 
        result_presets.push_back(preset);
        count++;
    }
    unlock();
 
    return count;
}

References count, lock(), m_presets, preset(), PresetBundle, and unlock().

Here is the call graph for this function:

has_defaults_only()

bool Slic3r::PresetCollection::has_defaults_only ( ) const

inlineinherited

{ return m_presets.size() <= m_num_default_presets; }

References m_num_default_presets, and m_presets.

is_alias_exist()

bool Slic3r::PresetCollection::is_alias_exist ( const std::string & alias, Preset * preset = nullptr )

inherited

{
    auto it = m_map_alias_to_profile_name.find(alias);
    if (m_map_alias_to_profile_name.end() == it) return false;
    if (!preset) return true;
 
    auto compatible_printers = dynamic_cast<ConfigOptionStrings *>(preset->config.option("compatible_printers"));
    if (compatible_printers == nullptr) return true;
 
    for (const std::string &printer_name : compatible_printers->values) {
        auto printer_iter = m_printer_hold_alias.find(printer_name);
        if (m_printer_hold_alias.end() != printer_iter) {
            auto alias_iter = m_printer_hold_alias[printer_name].find(alias);
            if (m_printer_hold_alias[printer_name].end() != alias_iter) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << " The alias already exists: " << alias << " and the preset name: " << preset->name;
                return true;
            }
        }
    }
    return false;
}

References end(), m_map_alias_to_profile_name, m_printer_hold_alias, and preset().

Here is the call graph for this function:

is_base_preset()

bool Slic3r::PresetCollection::is_base_preset ( const Preset & preset ) const

inlineinherited

{ return preset.is_system || (preset.is_user() && preset.inherits().empty()); }

References preset().

Referenced by path_for_preset(), and save_current_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

is_default_suppressed()

bool Slic3r::PresetCollection::is_default_suppressed ( ) const

inlineinherited

{ return m_default_suppressed; }

References m_default_suppressed.

is_dirty()

bool Slic3r::PresetCollection::is_dirty ( const Preset * edited, const Preset * reference )

staticinherited

{
    if (edited != nullptr && reference != nullptr) {
        // Only compares options existing in both configs.
        if (! reference->config.equals(edited->config, &skipped_in_dirty))
            return true;
        // The "compatible_printers" option key is handled differently from the others:
        // It is not mandatory. If the key is missing, it means it is compatible with any printer.
        // If the key exists and it is empty, it means it is compatible with no printer.
        for (auto &opt_key : optional_keys)
            if (reference->config.has(opt_key) != edited->config.has(opt_key))
                return true;
    }
    return false;
}

References Slic3r::Preset::config, Slic3r::DynamicConfig::equals(), Slic3r::ConfigOptionResolver::has(), Slic3r::optional_keys, and Slic3r::skipped_in_dirty.

Referenced by current_is_dirty(), load_external_preset(), saved_is_dirty(), and update_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

lbegin()

Iterator Slic3r::PresetCollection::lbegin ( )

inlineinherited

{ return m_presets.begin(); }

References m_presets.

legacy_user_filament_presets()

std::vector< LegacyUserFilamentPreset > Slic3r::PresetCollection::legacy_user_filament_presets ( const std::map< std::string, std::vector< std::string > > & printers_by_parent )

inherited

{
    auto has_entry = [&printers_by_parent](const std::string &name) { return printers_by_parent.count(name) > 0; };
    std::vector<LegacyUserFilamentPreset> legacy_presets;
    // The preset sync thread can add or delete presets meanwhile.
    lock();
    for (const Preset &preset : m_presets) {
        if (!preset.is_user() || preset.inherits().empty())
            continue;
        const Preset *parent = get_preset_parent(preset);
        if (parent == nullptr || !parent->is_system)
            continue;
        // An empty list already covers every printer.
        const std::vector<std::string> &own = preset.config.option<ConfigOptionStrings>("compatible_printers")->values;
        if (own.empty())
            continue;
        // The parent's name in the older release is its current name or one in its renamed_from, so only the
        // files of presets whose parent has an entry under one of those are read.
        if (!has_entry(parent->name) && std::none_of(parent->renamed_from.begin(), parent->renamed_from.end(), has_entry))
            continue;
        LegacyUserFilamentPreset legacy{preset.name, parent->name, {}, {}, preset.file, own};
        try {
            const json j = read_user_preset_file(preset.file);
            // A preset whose file sets compatible_printers, even to an empty list, was given its printers on
            // purpose and keeps exactly those.
            if (j.contains("compatible_printers"))
                continue;
            legacy.inherits = j.value(BBL_JSON_KEY_INHERITS, std::string());
        } catch (const std::exception &err) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": can not read " << preset.file << ": " << err.what();
            continue;
        }
        auto it = printers_by_parent.find(legacy.inherits);
        if (it == printers_by_parent.end())
            continue;
        for (const std::string &printer : it->second)
            if (std::find(own.begin(), own.end(), printer) == own.end()) {
                legacy.printers.push_back(printer);
                legacy.compatible_printers.push_back(printer);
            }
        if (!legacy.printers.empty())
            legacy_presets.push_back(std::move(legacy));
    }
    unlock();
    return legacy_presets;
}

References BBL_JSON_KEY_INHERITS, Slic3r::LegacyUserFilamentPreset::compatible_printers, get_preset_parent(), Slic3r::LegacyUserFilamentPreset::inherits, Slic3r::Preset::is_system, lock(), m_presets, Slic3r::Preset::name, name(), preset(), Slic3r::LegacyUserFilamentPreset::printers, Slic3r::read_user_preset_file(), Slic3r::Preset::renamed_from, and unlock().

Here is the call graph for this function:

load_external_preset()

std::pair< Preset *, bool > Slic3r::PresetCollection::load_external_preset ( const std::string & path, const std::string & name, const std::string & original_name, const DynamicPrintConfig & config, const std::set< std::string > & different_settings_list, LoadAndSelect select = LoadAndSelect::Always, const Semver file_version = Semver(), const std::string filament_id = std::string() )

inherited

{
    std::deque<Preset>::iterator it       = this->find_preset_internal(original_name);
    bool                         found    = it != m_presets.end() && it->name == original_name;
    if (! found) {
        // Try to match the original_name against the "renamed_from" profile names of loaded system profiles.
        it = this->find_preset_renamed(original_name);
        found = it != m_presets.end();
    }
 
    t_config_option_keys keys;
    DynamicPrintConfig cfg = Preset::load_external_config(m_type, this->default_preset_for(combined_config).config, combined_config, different_settings_list,
        [this, &original_name, &path, found, it](const std::string &inherits) -> DynamicPrintConfig * {
            if (!inherits.empty()) {
                auto iter = this->find_preset_internal(inherits);
                if (iter == m_presets.end() || iter->name != inherits)
                    iter = this->find_preset_renamed(inherits);
                if (iter == m_presets.end())
                    return nullptr;
                BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% inherit %2% 's value to %3% 's values")%original_name %inherits %path;
                return &iter->config;
            }
            if (found && it->is_system) {
                BOOST_LOG_TRIVIAL(info) << "load_external_preset" << boost::format(": change preset %1% 's value to %2% 's values")%original_name %path;
                return &it->config;
            }
            return nullptr;
        }, &keys);
    std::string                 &inherits = Preset::inherits(cfg);
 
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, type %1% , path %2%, name %3%, original_name %4%, inherits %5%")%Preset::get_type_string(m_type) %path %name %original_name %inherits;
    if (select == LoadAndSelect::Never) {
        // Some filament profile has been selected and modified already.
        // Check whether this profile is equal to the modified edited profile.
        const Preset &edited = this->get_edited_preset();
        if ((edited.name == original_name || edited.name == inherits) && profile_print_params_same(edited.config, cfg)) {
            // Just point to that already selected and edited profile.
            //BBS: add config related logs
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" Just point to that already selected and edited profile %1%")%edited.name;
            return std::make_pair(&(*this->find_preset_internal(edited.name)), false);
        }
    }
    // Is there a preset already loaded with the name stored inside the config?
    /*std::deque<Preset>::iterator it       = this->find_preset_internal(original_name);
    bool                         found    = it != m_presets.end() && it->name == original_name;
    if (! found) {
        // Try to match the original_name against the "renamed_from" profile names of loaded system profiles.
        it = this->find_preset_renamed(original_name);
        found = it != m_presets.end();
    }*/
    if (found && profile_print_params_same(it->config, cfg)) {
        // The preset exists and it matches the values stored inside config.
        if (select == LoadAndSelect::Always)
            this->select_preset(it - m_presets.begin());
        //BBS: set the preset to visible
        if ( !it->is_visible ) {
            it->is_visible = true;
            //AppConfig* app_config = get_app_config();
            //if (app_config)
            //    app_config->set(AppConfig::SECTION_FILAMENTS, it->name, "1");
        }
        //BBS: add config related logs
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" The preset exists and it matches the values stored inside config. using original_name %1%")%original_name;
        return std::make_pair(&(*it), false);
    }
    if (! found && select != LoadAndSelect::Never && ! inherits.empty()) {
        // Try to use a system profile as a base to select the system profile
        // and override its settings with the loaded ones.
        assert(it == m_presets.end());
        it    = this->find_preset_internal(inherits);
        if (it == m_presets.end() || it->name != inherits)
            it = this->find_preset_renamed(inherits);
        found = it != m_presets.end();
        if (found && profile_print_params_same(it->config, cfg)) {
            // The system preset exists and it matches the values stored inside config.
            if (select == LoadAndSelect::Always)
                this->select_preset(it - m_presets.begin());
            //BBS: set the preset to visible
            if ( !it->is_visible ) {
                it->is_visible = true;
                //AppConfig* app_config = get_app_config();
                //if (app_config)
                //    app_config->set(AppConfig::SECTION_FILAMENTS, it->name, "1");
            }
            //BBS: add config related logs
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" The preset exists and it matches the values stored inside config. using inherits %1%")%inherits;
            return std::make_pair(&(*it), false);
        }
    }
    if (found) {
        //BBS: only select preset for always
        //if (select != LoadAndSelect::Never) {
        if (select == LoadAndSelect::Always) {
            // Select the existing preset and override it with new values, so that
            // the differences will be shown in the preset editor against the referenced profile.
            this->select_preset(it - m_presets.begin());
            // The source config may contain keys from many possible preset types. Just copy those that relate to this preset.
            //this->get_edited_preset().config.apply_only(combined_config, keys, true);
            this->get_edited_preset().config.apply_only(cfg, keys, true);
            this->update_dirty();
            update_saved_preset_from_current_preset();
            assert(this->get_edited_preset().is_dirty);
            //BBS: set the preset to visible
            if ( !it->is_visible ) {
                it->is_visible = true;
                //AppConfig* app_config = get_app_config();
                //if (app_config)
                //    app_config->set(AppConfig::SECTION_FILAMENTS, it->name, "1");
            }
            //BBS: add config related logs
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" Select the existing preset %1% and override it with new values")%it->name;
            return std::make_pair(&(*it), this->get_edited_preset().is_dirty);
        }
 
        //BBS: for other filaments under AMS
        if (it->is_project_embedded) {
            //update the properties back to the preset
            it->config.apply_only(cfg, keys, true);
            it->is_dirty = false;
 
            return std::make_pair(&(*it), false);
        }
        if (inherits.empty()) {
            // Update the "inherits" field.
            // There is a profile with the same name already loaded. Should we update the "inherits" field?
            inherits = it->vendor ? it->name : it->inherits();
        }
    }
 
    // The external preset does not match an internal preset, load the external preset.
    std::string new_name;
    //BBS: add project embedded preset logic
    //BBS: refine the name logic
    for (size_t idx = 0;; ++ idx) {
        std::string prefix;
        if (original_name.empty()) {
            if (!inherits.empty()) {
                if (idx == 0)
                    prefix = inherits;
                else
                    prefix = inherits + "-" + std::to_string(idx);
            }
            else {
                if (idx > 0)
                    prefix =  std::to_string(idx);
            }
        } else {
            std::string reduced_name = original_name;
            //TODO
            //boost::regex rx("3mf\‍(*\‍)");
            //boost::iterator_range<std::string::iterator> result = boost::algorithm::find_regex(reduced_name, rx);
            //if (!result.empty()) {
            //    reduced_name = std::string(result.begin(), result.end());
            //}
 
            if (idx == 0)
                prefix = reduced_name;
            else
                prefix = reduced_name + "-" + std::to_string(idx) ;
        }
        //new_name = name + suffix;
        new_name = prefix + "(" + name + ")";
        it = this->find_preset_internal(new_name);
        if (it == m_presets.end() || it->name != new_name)
            // Unique profile name. Insert a new profile.
            break;
        if (profile_print_params_same(it->config, cfg)) {
            // The preset exists and it matches the values stored inside config.
            if (select == LoadAndSelect::Always)
                this->select_preset(it - m_presets.begin());
            //BBS: add config related logs
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" The preset %1% exists and it matches the values stored inside config.")%new_name;
            return std::make_pair(&(*it), false);
        }
        // Form another profile name.
    }
    // Insert a new profile.
    //BBS: add project embedded preset logic
    // A G-code's settings are shown like a project's, so a preset made from them lives with the project
    // rather than in the user's library.
    bool from_project = boost::algorithm::iends_with(name, ".3mf") || is_gcode_file(name);
    if (m_type == Preset::TYPE_PRINT)
        cfg.option<ConfigOptionString >("print_settings_id", true)->value  = new_name;
    else if (m_type == Preset::TYPE_FILAMENT)
        cfg.option<ConfigOptionStrings>("filament_settings_id", true)->values[0] = new_name;
    else if (m_type == Preset::TYPE_PRINTER)
        cfg.option<ConfigOptionString>("printer_settings_id", true)->value = new_name;
    Preset &preset = this->load_preset(path, new_name, std::move(cfg), select == LoadAndSelect::Always);
    preset.is_external = true;
    preset.version = file_version;
    if (!filament_id.empty())
        preset.filament_id = filament_id;
    else {
        if (!inherits.empty()) {
            // Orca: resolve via find_preset2 so a renamed/removed-and-matched parent still
            // yields its filament_id (external presets store a full config, so the dangling
            // "inherits" itself is normalized on the next load_presets pass).
            Preset *parent = this->find_preset2(inherits, true);
            if (parent)
                preset.filament_id = parent->filament_id;
        }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << preset.name << " filament_id: " << preset.filament_id << " base_id: " << preset.base_id;
    if (from_project) {
        preset.is_project_embedded = true;
    }
    else {
        //external config
        preset.file = path_for_preset(preset);
        //BBS: save full config here for external
        //we can not reach here
        preset.save(nullptr);
    }
    if (&this->get_selected_preset() == &preset)
        this->get_edited_preset().is_external = true;
 
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", type %1% added a preset, name %2%, path %3%, is_system %4%, is_default %5% is_external %6%")%Preset::get_type_string(m_type) %preset.name %preset.file %preset.is_system %preset.is_default %preset.is_external;
    return std::make_pair(&preset, false);
}

References Always, Slic3r::ConfigBase::apply_only(), Slic3r::Preset::config, default_preset_for(), Slic3r::Preset::filament_id, find_preset2(), find_preset_internal(), find_preset_renamed(), get_edited_preset(), get_selected_preset(), Slic3r::Preset::get_type_string(), Slic3r::Preset::inherits(), is_dirty(), Slic3r::Preset::is_external, Slic3r::is_gcode_file(), Slic3r::Preset::load_external_config(), load_preset(), m_presets, m_type, Slic3r::Preset::name, name(), Never, Slic3r::ConfigBase::option(), path_for_preset(), preset(), Slic3r::profile_print_params_same(), select_preset(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, update_dirty(), and update_saved_preset_from_current_preset().

Here is the call graph for this function:

load_preset() [1/2]

Preset & Slic3r::PresetCollection::load_preset ( const std::string & path, const std::string & name, const DynamicPrintConfig & config, bool select = true, Semver file_version = Semver() )

inherited

{
    DynamicPrintConfig cfg(this->default_preset().config);
    cfg.apply_only(config, cfg.keys(), true);
    return this->load_preset(path, name, std::move(cfg), select, file_version);
}

References Slic3r::ConfigBase::apply_only(), default_preset(), Slic3r::DynamicConfig::keys(), load_preset(), and name().

Referenced by Slic3r::PresetBundle::import_json_presets(), load_external_preset(), and load_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

load_preset() [2/2]

Preset & Slic3r::PresetCollection::load_preset ( const std::string & path, const std::string & name, DynamicPrintConfig && config, bool select = true, Semver file_version = Semver() )

inherited

{
    lock();
    auto it = this->find_preset_internal(name);
    if (it == m_presets.end() || it->name != name) {
        // The preset was not found. Create a new preset.
        if (m_presets.begin() + m_idx_selected >= it)
            ++m_idx_selected;
        it = m_presets.emplace(it, Preset(m_type, name, false));
    }
    Preset &preset = *it;
    preset.file = path;
    preset.config = std::move(config);
    preset.loaded = true;
    preset.is_dirty = false;
 
    //BBS
    if (file_version.valid())
        preset.version = file_version;
    if (select)
        this->select_preset_by_name(name, true);
    unlock();
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", preset type %1%, name %2%, path %3%, is_system %4%, is_default %5% is_visible %6%")%Preset::get_type_string(m_type) %preset.name %preset.file %preset.is_system %preset.is_default %preset.is_visible;
    return preset;
}

References find_preset_internal(), Slic3r::Preset::get_type_string(), lock(), m_idx_selected, m_presets, m_type, name(), Slic3r::Preset, preset(), select_preset_by_name(), unlock(), and Slic3r::Semver::valid().

Here is the call graph for this function:

load_presets()

void Slic3r::PresetCollection::load_presets ( const std::string & dir_path, const std::string & subdir, PresetsConfigSubstitutions & substitutions, ForwardCompatibilitySubstitutionRule rule, std::function< void(Preset &)> preset_loaded_fn = nullptr, const PresetOrigin & load_origin = PresetOrigin(), bool read_only = false )

inherited

{
    // Don't use boost::filesystem::canonical() on Windows, it is broken in regard to reparse points,
    // see https://github.com/prusa3d/PrusaSlicer/issues/732
    boost::filesystem::path dir = boost::filesystem::absolute(boost::filesystem::path(dir_path) / subdir).make_preferred();
    const PresetOrigin resolved_origin = detect_origin_from_path(dir, load_origin);
 
    // Load custom roots first
    if (fs::exists(dir / "base")) {
        load_presets(dir.string(), "base", substitutions, substitution_rule, nullptr, resolved_origin, read_only);
    }
 
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, load presets from %1%, current type %2%")%dir %Preset::get_type_string(m_type);
    //BBS do not parse folder if not exists
    m_dir_path = dir.string();
    if (!fs::exists(dir)) {
        if (!read_only)
            fs::create_directory(dir);
        return;
    }
 
    std::string errors_cummulative;
    // Store the loaded presets into a new vector, otherwise the binary search for already existing presets would be broken.
    // (see the "Preset already present, not loading" message).
    std::deque<Preset> presets_loaded;
 
    //BBS: get the extruder related info for this preset collection
    std::string extruder_id_name, extruder_variant_name;
    std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
    Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
 
    struct UserPresetFile { fs::path path; std::string canonical_name; };
    std::vector<UserPresetFile> files;
    //BBS: change to json format
    for (auto &dir_entry : boost::filesystem::directory_iterator(dir))
    {
        std::string file_name = dir_entry.path().filename().string();
        //if (Slic3r::is_ini_file(dir_entry)) {
        if (Slic3r::is_json_file(file_name)) {
            // Remove the .ini suffix.
            std::string name = file_name.erase(file_name.size() - 5);
            std::string canonical_name = this->canonical_preset_name(name, resolved_origin);
            if (this->find_preset(canonical_name, false)) {
                // This happens when there's is a preset (most likely legacy one) with the same name as a system preset
                // that's already been loaded from a bundle.
                BOOST_LOG_TRIVIAL(warning) << "Preset already present, not loading: " << canonical_name;
                continue;
            }
            files.push_back({ dir_entry.path(), std::move(canonical_name) });
        }
    }
 
    resolve_then_commit<CNumericLocalesSetter>(files.size(),
        [&](size_t i) {
            return this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
                                             extruder_id_name, extruder_variant_name, key_set1, key_set2, read_only);
        },
        [&](size_t i, UserPresetLoad &&loaded) {
            // Resolve read the files without the lock, so another instance may have saved
            // over them since. A file that changed is resolved again under the lock before
            // commit removes or rewrites it, which also keeps its .json and .info from two
            // different saves apart. Without the lock nothing is checked, so commit leaves
            // the files alone.
            const std::string lock_path = user_presets_lock_path(read_only);
            InstanceLock      instance_lock(lock_path);
            if (instance_lock.locked()) {
                const PresetFilesOnDisk   on_disk = PresetFilesOnDisk::read(files[i].path);
                boost::system::error_code ec;
                // The link itself, and a stat error counts as present, so a file that is
                // there but cannot be read is still counted and removed by commit.
                if (! on_disk.json && fs::symlink_status(files[i].path, ec).type() == fs::file_not_found)
                    return; // removed by another instance since it was read
                if (! (on_disk == loaded.on_disk)) {
                    CNumericLocalesSetter locales_setter;
                    loaded = this->resolve_user_preset(files[i].path, files[i].canonical_name, resolved_origin, substitution_rule,
                                                       extruder_id_name, extruder_variant_name, key_set1, key_set2, read_only);
                }
            }
            const bool leave_files = read_only || (! lock_path.empty() && ! instance_lock.locked());
            // Committing can remove an unreadable preset's file, and a filesystem error
            // there is reported without stopping the rest of the directory.
            try {
                this->commit_user_preset(std::move(loaded), presets_loaded, substitutions, preset_loaded_fn, leave_files);
            } catch (const std::runtime_error &err) {
                errors_cummulative += err.what();
                errors_cummulative += "\n";
            }
        });
 
    if (presets_loaded.size() > 0)
        m_presets.insert(m_presets.end(), std::make_move_iterator(presets_loaded.begin()), std::make_move_iterator(presets_loaded.end()));
    sort_presets();
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": loaded %1% presets from %2%, type %3%")%presets_loaded.size() %dir %Preset::get_type_string(m_type);
    //this->select_preset(first_visible_idx());
    if (! errors_cummulative.empty())
        throw Slic3r::RuntimeError(errors_cummulative);
}

References canonical_preset_name(), Slic3r::detect_origin_from_path(), find_preset(), Slic3r::Preset::get_extruder_names_and_keysets(), Slic3r::Preset::get_type_string(), Slic3r::is_json_file(), load_presets(), m_dir_path, m_type, name(), and Slic3r::resolve_then_commit().

Referenced by load_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

load_project_embedded_presets()

void Slic3r::PresetCollection::load_project_embedded_presets ( std::vector< Preset * > & project_presets, const std::string & type, PresetsConfigSubstitutions & substitutions, ForwardCompatibilitySubstitutionRule rule )

inherited

{
    std::string errors_cummulative;
    // Store the loaded presets into a new vector, otherwise the binary search for already existing presets would be broken.
    // (see the "Preset already present, not loading" message).
    std::deque<Preset> presets_loaded;
    std::vector<Preset*>::iterator it;
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" enter, type %1% , total preset counts %2%")%Preset::get_type_string(m_type) %project_presets.size();
    std::string extruder_id_name, extruder_variant_name;
    std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
    Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
 
    lock();
    for (it = project_presets.begin(); it != project_presets.end(); it++) {
        Preset* preset = *it;
        if (preset->type != Preset::get_type_from_string(type)) continue;
        if (!preset->is_project_embedded) continue;
        std::string name = preset->name;
        if (this->find_preset(name, false)) {
            BOOST_LOG_TRIVIAL(warning) << "Preset already present, not loading: " << name;
            continue;
        }
        try {
            DynamicPrintConfig config = preset->config;
            if (preset->loading_substitutions && ! preset->loading_substitutions->empty()) {
                substitutions.push_back({ preset->name, m_type, PresetConfigSubstitutions::Source::ProjectFile, preset->name, std::move(*(preset->loading_substitutions))});
                free(preset->loading_substitutions);
                preset->loading_substitutions = NULL;
            }
            //BBS: use inherit config as the base
            Preset* inherit_preset = nullptr;
            ConfigOption* inherits_config = config.option(BBL_JSON_KEY_INHERITS);
            if (inherits_config) {
                ConfigOptionString * option_str = dynamic_cast<ConfigOptionString *> (inherits_config);
                std::string inherits_value = option_str->value;
                /*size_t pos = inherits_value.find_first_of('*');
                if (pos != std::string::npos) {
                    inherits_value.replace(pos, 1, 1, '~');
                    option_str->value = inherits_value;
                }*/
                inherit_preset = this->find_preset2(inherits_value, true);
                Preset::normalize_inherits(config, inherit_preset);
            }
            const Preset& default_preset = this->default_preset_for(config);
            if (inherit_preset) {
                preset->config = inherit_preset->config;
                preset->filament_id = inherit_preset->filament_id;
            }
            else {
                // Find a default preset for the config. The PrintPresetCollection provides different default preset based on the "printer_technology" field.
                //BBS 202407: don't load project embedded preset when can not find inherit
                //preset->config = default_preset.config;
                BOOST_LOG_TRIVIAL(error) << boost::format("can not find parent for config %1%!")%preset->file;
                continue;
            }
            extend_default_config_length(config, false, {});
            preset->config.update_diff_values_to_child_config(config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
            //preset->config.apply(std::move(config));
            Preset::normalize(preset->config);
            // Report configuration fields, which are misplaced into a wrong group.
            std::string incorrect_keys = Preset::remove_invalid_keys(preset->config, default_preset.config);
            if (!incorrect_keys.empty()) {
                ++m_errors;
                BOOST_LOG_TRIVIAL(error) << "Error in a preset file: The preset \"" << preset->name
                                         << "\" contains the following incorrect keys: " << incorrect_keys << ", which were removed";
            }
            preset->loaded = true;
            presets_loaded.emplace_back(*preset);
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", %1% got preset, name %2%, path %3%, is_system %4%, is_default %5% is_visible %6%")%Preset::get_type_string(m_type) %preset->name %preset->file %preset->is_system %preset->is_default %preset->is_visible;
        } catch (const std::runtime_error &err) {
            errors_cummulative += err.what();
            errors_cummulative += "\n";
        }
    }
 
    m_presets.insert(m_presets.end(), std::make_move_iterator(presets_loaded.begin()), std::make_move_iterator(presets_loaded.end()));
    sort_presets();
    //don't select it here
    //this->select_preset(first_visible_idx());
    unlock();
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" finished, %1% got %2% presets, errors_cummulative %3%")%Preset::get_type_string(m_type) %presets_loaded.size() %errors_cummulative;
    if (! errors_cummulative.empty())
        throw Slic3r::RuntimeError(errors_cummulative);
}

References BBL_JSON_KEY_INHERITS, Slic3r::Preset::config, default_preset(), default_preset_for(), Slic3r::extend_default_config_length(), Slic3r::Preset::filament_id, find_preset(), find_preset2(), Slic3r::Preset::get_extruder_names_and_keysets(), Slic3r::Preset::get_type_from_string(), Slic3r::Preset::get_type_string(), lock(), m_errors, m_presets, m_type, name(), Slic3r::Preset::normalize(), Slic3r::Preset::normalize_inherits(), Slic3r::ConfigBase::option(), preset(), Slic3r::PresetConfigSubstitutions::ProjectFile, Slic3r::Preset::remove_invalid_keys(), sort_presets(), type(), unlock(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

load_user_preset()

bool Slic3r::PresetCollection::load_user_preset ( std::string name, std::map< std::string, std::string > preset_values, PresetsConfigSubstitutions & substitutions, ForwardCompatibilitySubstitutionRule rule, const PresetOrigin & load_origin = PresetOrigin(PresetOrigin::Kind::User) )

inherited

{
    std::string errors_cummulative;
    // Store the loaded presets into a new vector, otherwise the binary search for already existing presets would be broken.
    // (see the "Preset already present, not loading" message).
    //std::deque<Preset> presets_loaded;
    int count = 0;
    const std::string canonical_name = this->canonical_preset_name(name, load_origin);
    auto update_alias = [this](Preset &preset) {
        if (! preset.alias.empty())
            return;
        set_custom_preset_alias(preset);
    };
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(" enter, name %1% , total value counts %2%")%canonical_name %preset_values.size();
 
    //if the version is not matching, skip it
    if (preset_values.find(BBL_JSON_KEY_VERSION) == preset_values.end()) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("can not find version, not loading for user preset %1%")%canonical_name;
        return false;
    }
    std::string version_str = preset_values[BBL_JSON_KEY_VERSION];
    boost::optional<Semver> cloud_version = Semver::parse(version_str);
    if (!cloud_version) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("invalid version %1%, not loading for user preset %2%")%version_str %canonical_name;
        return false;
    }
 
    //setting_id
    if (preset_values.find(BBL_JSON_KEY_SETTING_ID) == preset_values.end()) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("can not find setting_id, not loading for user preset %1%")%canonical_name;
        return false;
    }
    std::string cloud_setting_id = preset_values[BBL_JSON_KEY_SETTING_ID];
 
    //update_time
    long long cloud_update_time = 0;
    if (preset_values.find(ORCA_JSON_KEY_UPDATE_TIME) != preset_values.end()) {
        cloud_update_time = std::atoll(preset_values[ORCA_JSON_KEY_UPDATE_TIME].c_str());
    }
 
    //user_id
    if (preset_values.find(BBL_JSON_KEY_USER_ID) == preset_values.end()) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format("can not find user_id, not loading for user preset %1%")%canonical_name;
        return false;
    }
    std::string cloud_user_id = preset_values[BBL_JSON_KEY_USER_ID];
 
    lock();
    //std::string name = preset->name;
    auto iter = this->find_preset_internal(canonical_name);
    bool need_update = false;
    if ((iter != m_presets.end()) && (iter->name == canonical_name)) {
        BOOST_LOG_TRIVIAL(info) << "Found the Preset locally: " << canonical_name;
        //BBS: we should compare the time between cloud and local
        if ((cloud_update_time == 0) || (cloud_update_time <= iter->updated_time)) {
            if (cloud_update_time < iter->updated_time)
                iter->sync_info = "update";
            else
                iter->sync_info.clear();
            // Fixup possible data lost
            iter->setting_id = cloud_setting_id;
            fs::path idx_file(iter->file);
            idx_file.replace_extension(".info");
            iter->save_info(idx_file.string());
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format("preset %1%'s update_time is eqaul or newer, cloud  update_time %2%, local update_time %3%")%canonical_name %cloud_update_time %iter->updated_time;
            unlock();
            return false;
        }
        else {
            //update the one from cloud which is newer
            need_update = true;
        }
    }
 
    // base_id is only required for presets inheriting from a parent. Root presets
    // with an empty "inherits" field intentionally have no base_id.
    std::string based_id;
    const auto base_id = preset_values.find(BBL_JSON_KEY_BASE_ID);
    if (base_id != preset_values.end()) {
        based_id = base_id->second;
    } else {
        const auto inherits_iter               = preset_values.find(BBL_JSON_KEY_INHERITS);
        const bool preset_inherits_from_parent = inherits_iter != preset_values.end() && !inherits_iter->second.empty();
        if (preset_inherits_from_parent) {
            // No base_id stored although the preset inherits from a parent. Rather than
            // dropping the preset, derive base_id on the fly from the resolved parent's
            // setting_id below (the parent is found by its "inherits" name). Only the
            // genuinely unresolvable-parent case is skipped, further down.
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format("no base_id for user preset %1%, will derive it from the parent") % canonical_name;
        }
    }
 
    //filament_id
    std::string cloud_filament_id;
    if ((m_type == Preset::TYPE_FILAMENT) && preset_values.find(BBL_JSON_KEY_FILAMENT_ID) != preset_values.end()) {
        cloud_filament_id = preset_values[BBL_JSON_KEY_FILAMENT_ID];
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << canonical_name << " filament_id: " << cloud_filament_id << " base_id: " << based_id;
    }
 
    DynamicPrintConfig new_config, cloud_config;
    try {
        ConfigSubstitutions config_substitutions = cloud_config.load_string_map(preset_values, rule);
        if (! config_substitutions.empty())
            substitutions.push_back({ canonical_name, m_type, PresetConfigSubstitutions::Source::UserCloud, canonical_name, std::move(config_substitutions) });
 
        //BBS: use inherit config as the base
        Preset* inherit_preset = nullptr;
        ConfigOption* inherits_config = cloud_config.option(BBL_JSON_KEY_INHERITS);
        if (inherits_config) {
            ConfigOptionString * option_str = dynamic_cast<ConfigOptionString *> (inherits_config);
            std::string inherits_value = option_str->value;
            inherit_preset = this->find_preset2(inherits_value, true);
            Preset::normalize_inherits(cloud_config, inherit_preset);
        }
        const Preset& default_preset = this->default_preset_for(cloud_config);
        if (inherit_preset) {
            new_config = inherit_preset->config;
            // Derive base_id from the resolved parent when it was not supplied. The
            // parent's setting_id is itself computed deterministically at load time, so
            // this stays stable. Does not affect the preset's own (cloud) setting_id.
            if (based_id.empty())
                based_id = inherit_preset->setting_id;
            if (cloud_filament_id == "null") {
                cloud_filament_id = inherit_preset->filament_id;
            }
        }
        else {
            // We support custom root preset now
            auto inherits_config2 = dynamic_cast<ConfigOptionString *>(inherits_config);
            if (inherits_config2 && !inherits_config2->value.empty()) {
                //we should skip this preset here
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", can not find inherit preset for user preset %1%, just skip")%canonical_name;
                unlock();
                return false;
            }
            // Find a default preset for the config. The PrintPresetCollection provides different default preset based on the "printer_technology" field.
            new_config = default_preset.config;
        }
 
        std::string extruder_id_name, extruder_variant_name;
        std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
        Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
 
        // Older uploads left out a variant layout equal to the parent's but still sent one value per
        // parent variant. Read those values against the parent's layout instead of cutting them to one.
        if (inherit_preset && !cloud_config.has(extruder_variant_name)) {
            const auto  *parent_variants = inherit_preset->config.option<ConfigOptionStrings>(extruder_variant_name);
            const size_t variant_count   = parent_variants ? parent_variants->size() : 0;
            bool         values_per_variant = false;
            for (const std::string &key : cloud_config.keys()) {
                const size_t stride = key_set2->count(key) ? 2 : key_set1->count(key) ? 1 : 0;
                const auto  *values = dynamic_cast<const ConfigOptionVectorBase *>(cloud_config.option(key));
                if (stride > 0 && key != extruder_id_name && values && variant_count > 1 && values->size() == variant_count * stride) {
                    values_per_variant = true;
                    break;
                }
            }
            if (values_per_variant)
                for (const std::string &key : {extruder_id_name, extruder_variant_name})
                    if (!key.empty() && !cloud_config.has(key) && inherit_preset->config.has(key))
                        cloud_config.set_key_value(key, inherit_preset->config.option(key)->clone());
        }
 
        extend_default_config_length(cloud_config, false, {});
 
        if (inherit_preset)
            new_config.update_diff_values_to_child_config(cloud_config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
        else{
            new_config.apply(std::move(cloud_config));
            extend_default_config_length(new_config, true, default_preset.config);
        }
        Preset::normalize(new_config);
        // Report configuration fields, which are misplaced into a wrong group.
        std::string incorrect_keys = Preset::remove_invalid_keys(new_config, default_preset.config);
        if (!incorrect_keys.empty()) {
            ++m_errors;
            BOOST_LOG_TRIVIAL(error) << "Error in a preset file: The preset \"" << canonical_name
                                     << "\" contains the following incorrect keys: " << incorrect_keys << ", which were removed";
        }
        if (need_update) {
            if (iter->name == m_edited_preset.name && iter->is_dirty) {
                // Keep modifies when update from remote
                new_config.apply_only(m_edited_preset.config, m_edited_preset.config.diff(iter->config));
            } else if (iter->name == m_edited_preset.name) {
                // Preset is not dirty (no local unsaved changes) — also update the edited preset
                // to prevent a false "dirty" indication (orange highlight) after a silent cloud sync
                m_edited_preset.config = new_config;
            }
            iter->config = new_config;
            iter->updated_time = cloud_update_time;
            iter->sync_info    = "save";
            iter->version      = cloud_version.value();
            iter->user_id = cloud_user_id;
            iter->setting_id = cloud_setting_id;
            iter->base_id = based_id;
            iter->filament_id = cloud_filament_id;
            update_alias(*iter);
            // Persist the cloud-assigned identity to disk, mirroring the equal/newer branch
            // above; otherwise the id stays only in memory and the next launch rewrites it.
            iter->save_info();
            //presets_loaded.emplace_back(*it->second);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", update the user preset %1% from cloud, type %2%, setting_id %3%, base_id %4%, sync_info %5% inherits %6%, filament_id %7%")
               % iter->name %Preset::get_type_string(m_type) %iter->setting_id %iter->base_id %iter->sync_info %iter->inherits() % iter->filament_id;
        }
        else {
            //create a new one
            Preset preset(m_type, canonical_name, false);
            preset.is_system = false;
            preset.loaded = true;
            preset.bundle_id = load_origin.bundle_id;
            preset.config = new_config;
            preset.updated_time = cloud_update_time;
            preset.sync_info   = "save";
            preset.version      = cloud_version.value();
            preset.user_id = cloud_user_id;
            preset.setting_id = cloud_setting_id;
            preset.base_id = based_id;
            preset.filament_id = cloud_filament_id;
            update_alias(preset);
 
            size_t cur_index = iter - m_presets.begin();
            m_presets.insert(iter, preset);
            //m_presets.emplace_back (preset);
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", insert a new user preset %1%, type %2%, setting_id %3%, base_id %4%, sync_info %5% inherits %6%, filament_id %7%")
               %preset.name %Preset::get_type_string(m_type) %preset.setting_id %preset.base_id %preset.sync_info %preset.inherits() %preset.filament_id;
            if (cur_index <= m_idx_selected) {
                m_idx_selected ++;
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(", increase m_idx_selected to %1%, due to user preset inserted")%m_idx_selected;
            }
        }
    } catch (const std::runtime_error &err) {
        errors_cummulative += err.what();
        errors_cummulative += "\n";
    }
 
    unlock();
 
    if (! errors_cummulative.empty())
        throw Slic3r::RuntimeError(errors_cummulative);
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" finished, load user preset %1% , type %2%, errors_cummulative %3%")%canonical_name %Preset::get_type_string(m_type) %errors_cummulative;
    return (need_update)?false:true;
}

References Slic3r::ConfigBase::apply(), Slic3r::ConfigBase::apply_only(), BBL_JSON_KEY_BASE_ID, BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_USER_ID, BBL_JSON_KEY_VERSION, Slic3r::PresetOrigin::bundle_id, canonical_preset_name(), Slic3r::ConfigOption::clone(), Slic3r::Preset::config, count, default_preset(), default_preset_for(), Slic3r::extend_default_config_length(), Slic3r::Preset::filament_id, find_preset2(), find_preset_internal(), Slic3r::Preset::get_extruder_names_and_keysets(), Slic3r::Preset::get_type_string(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::keys(), Slic3r::ConfigBase::load_string_map(), lock(), m_edited_preset, m_errors, m_idx_selected, m_presets, m_type, name(), Slic3r::Preset::normalize(), Slic3r::Preset::normalize_inherits(), Slic3r::ConfigBase::option(), ORCA_JSON_KEY_UPDATE_TIME, Slic3r::Semver::parse(), preset(), Slic3r::Preset::remove_invalid_keys(), set_custom_preset_alias(), Slic3r::DynamicConfig::set_key_value(), Slic3r::Preset::setting_id, Slic3r::ConfigOptionVector< T >::size(), Slic3r::Preset::TYPE_FILAMENT, unlock(), Slic3r::DynamicPrintConfig::update_diff_values_to_child_config(), Slic3r::PresetConfigSubstitutions::UserCloud, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::PresetBundle::load_user_presets(), and Slic3r::PresetBundle::update_subscribed_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

lock()

void Slic3r::PresetCollection::lock ( )

inlineinherited

{ m_mutex.lock(); }

References m_mutex.

Referenced by add_detached_preset(), append_preset(), apply_legacy_user_filament_presets(), clone_presets(), delete_current_preset(), delete_preset(), get_project_embedded_presets(), get_user_presets(), legacy_user_filament_presets(), load_preset(), load_project_embedded_presets(), load_user_preset(), need_sync(), reset(), reset_project_embedded_presets(), save_current_preset(), set_sync_info_and_save(), and update_after_user_presets_loaded().

Here is the caller graph for this function:

merge_presets()

std::vector< std::vector< std::string > > Slic3r::PresetCollection::merge_presets ( const std::vector< PresetCollection * > & others, const VendorMap & new_vendors )

protectedinherited

{
    auto less = [this](const Preset &a, const Preset &b) {
        return m_type == Preset::TYPE_FILAMENT ? filament_preset_less(a, b) : a < b;
    };
    struct Incoming { Preset *preset; size_t source; };
    auto incoming_less = [&less](const Incoming &a, const Incoming &b) { return less(*a.preset, *b.preset); };
    // Each of `others` is sorted, so its presets form one sorted run.
    std::vector<Incoming> incoming;
    std::vector<size_t>   run_ends { 0 };
    for (size_t source = 0; source < others.size(); ++ source) {
        for (Preset &preset : others[source]->m_presets)
            if (! preset.is_default && ! preset.is_external)
                incoming.push_back({ &preset, source });
        assert(std::is_sorted(incoming.begin() + run_ends.back(), incoming.end(), incoming_less));
        run_ends.push_back(incoming.size());
    }
    // Merged pairwise and stably, so equal names stay in the order of `others`.
    const size_t runs = others.size();
    for (size_t width = 1; width < runs; width *= 2)
        for (size_t i = 0; i + width < runs; i += 2 * width)
            std::inplace_merge(incoming.begin() + run_ends[i], incoming.begin() + run_ends[i + width],
                               incoming.begin() + run_ends[std::min(i + 2 * width, runs)], incoming_less);
 
    std::vector<std::vector<std::string>> duplicates(others.size());
    std::deque<Preset> merged;
    auto own = m_presets.begin() + m_num_default_presets;
    std::move(m_presets.begin(), own, std::back_inserter(merged));
    // On equal names this collection's preset is kept, else the earliest of `others`,
    // and each repeat is listed under the collection it came from.
    for (auto next = incoming.begin(); own != m_presets.end() || next != incoming.end();) {
        if (next == incoming.end() || (own != m_presets.end() && ! less(*next->preset, *own)))
            merged.emplace_back(std::move(*own ++));
        else {
            Preset &preset = *(next ++)->preset;
            if (preset.vendor != nullptr) {
                // Re-assign a pointer to the vendor structure in the new PresetBundle.
                auto it = new_vendors.find(preset.vendor->id);
                assert(it != new_vendors.end());
                preset.vendor = &it->second;
            }
            merged.emplace_back(std::move(preset));
        }
        for (; next != incoming.end() && next->preset->name == merged.back().name; ++ next)
            duplicates[next->source].emplace_back(next->preset->name);
    }
    m_presets = std::move(merged);
    return duplicates;
}

References filament_preset_less(), m_num_default_presets, m_presets, m_type, preset(), and Slic3r::Preset::TYPE_FILAMENT.

Here is the call graph for this function:

name()

std::string Slic3r::PresetCollection::name ( ) const

inherited

{
    switch (this->type()) {
    case Preset::TYPE_PRINT:        return L(PRESET_PRINT_NAME);
    case Preset::TYPE_FILAMENT:     return L(PRESET_FILAMENT_NAME);
    //case Preset::TYPE_SLA_PRINT:    return L("SLA print");
    //case Preset::TYPE_SLA_MATERIAL: return L("SLA material");
    case Preset::TYPE_PRINTER:      return L(PRESET_PRINTER_NAME);
    default:                        return "invalid";
    }
}

References L, PRESET_FILAMENT_NAME, PRESET_PRINT_NAME, PRESET_PRINTER_NAME, type(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by PresetCollection(), append_preset(), canonical_preset_name(), delete_preset(), find_preset(), find_preset(), find_preset2(), find_preset2(), find_preset_internal(), find_preset_internal(), find_preset_renamed(), find_preset_renamed(), first_visible_idx(), legacy_user_filament_presets(), load_external_preset(), load_preset(), load_preset(), load_presets(), load_project_embedded_presets(), load_user_preset(), need_sync(), select_preset_by_name(), select_preset_by_name_strict(), and set_sync_info_and_save().

Here is the call graph for this function:

Here is the caller graph for this function:

need_sync()

bool Slic3r::PresetCollection::need_sync ( std::string name, std::string setting_id, long long update_time )

inherited

{
    lock();
    auto preset = find_preset(name, false, true);
    bool need   = preset == nullptr || preset->setting_id != setting_id || preset->updated_time < update_time;
    unlock();
    return need;
}

References find_preset(), lock(), name(), preset(), and unlock().

Here is the call graph for this function:

num_default_presets()

size_t Slic3r::PresetCollection::num_default_presets ( )

inlineinherited

{ return m_num_default_presets; }

References m_num_default_presets.

num_visible()

size_t Slic3r::PresetCollection::num_visible ( ) const

inlineinherited

{ return std::count_if(m_presets.begin(), m_presets.end(), [](const Preset &preset){return preset.is_visible;}); }

References m_presets, and preset().

Here is the call graph for this function:

only_default_printers()

bool Slic3r::PrinterPresetCollection::only_default_printers

(

)

const

{
    for (const auto& printer : get_presets()) {
        if (!boost::starts_with(printer.name,"Default") && printer.is_visible)
            return false;
    }
    return true;
}

References Slic3r::PresetCollection::get_presets().

Referenced by Slic3r::GUI::GuideFrame::run().

Here is the call graph for this function:

Here is the caller graph for this function:

operator()()

const std::deque< Preset > & Slic3r::PresetCollection::operator() ( ) const

inlineinherited

{ return m_presets; }

References m_presets.

operator=()

PrinterPresetCollection & Slic3r::PrinterPresetCollection::operator= ( const PrinterPresetCollection & other )

privatedefault

References PrinterPresetCollection().

Here is the call graph for this function:

path_for_preset()

std::string Slic3r::PresetCollection::path_for_preset ( const Preset & preset ) const

inherited

{
    return path_from_name(get_preset_bare_name(preset.name), is_base_preset(preset));
}

References Slic3r::get_preset_bare_name(), is_base_preset(), path_from_name(), and preset().

Referenced by add_detached_preset(), clone_presets(), load_external_preset(), save_current_preset(), and save_user_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

path_from_name()

std::string Slic3r::PresetCollection::path_from_name ( const std::string & new_name, bool detach = false ) const

inherited

{
     //BBS: change to json format
    //std::string file_name = boost::iends_with(new_name, ".ini") ? new_name : (new_name + ".ini");
    std::string file_name = boost::iends_with(new_name, ".json") ? new_name : (new_name + ".json");
    if (detach)
        return (boost::filesystem::path(m_dir_path) / "base" / file_name).make_preferred().string();
    else
        return (boost::filesystem::path(m_dir_path) / file_name).make_preferred().string();
}

References m_dir_path.

Referenced by Slic3r::PresetBundle::import_json_presets(), and path_for_preset().

Here is the caller graph for this function:

preset() [1/2]

const Preset & Slic3r::PresetCollection::preset ( size_t idx ) const

inlineinherited

{ return const_cast<PresetCollection*>(this)->preset(idx); }

References PresetCollection(), and preset().

Referenced by preset().

Here is the call graph for this function:

Here is the caller graph for this function:

preset() [2/2]

Preset & Slic3r::PresetCollection::preset ( size_t idx, bool real = false )

inlineinherited

                                                          {
        if (real) return m_presets[idx];
        return (idx == m_idx_selected) ? m_edited_preset : m_presets[idx];
    }

References m_edited_preset, m_idx_selected, and m_presets.

Referenced by PresetCollection(), add_detached_preset(), append_preset(), check_and_fix_syncinfo(), clone_presets(), clone_presets_for_filament(), clone_presets_for_printer(), commit_user_preset(), Slic3r::GUI::Tab::compatible_widget_create(), delete_preset(), diameters_of_selected_printer(), filament_id_by_type(), Slic3r::PrinterPresetCollection::find_custom_preset_by_model_and_variant(), find_preset(), find_preset2(), Slic3r::PrinterPresetCollection::find_system_preset_by_model_and_variant(), first_compatible(), first_compatible(), first_compatible(), first_visible(), first_visible(), Slic3r::GUI::SyncAmsInfoDialog::generate_override_fix_ams_list(), get_differed_values_to_update(), get_filament_presets(), get_preset_alias(), get_preset_differed_for_save(), get_preset_parent(), get_preset_with_vendor_profile(), get_project_embedded_presets(), get_selected_preset_parent(), get_user_presets(), is_alias_exist(), is_base_preset(), legacy_user_filament_presets(), load_external_preset(), load_preset(), load_project_embedded_presets(), load_user_preset(), merge_presets(), need_sync(), num_visible(), path_for_preset(), reset(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), resolve_user_preset(), save_current_preset(), save_user_presets(), select_preset(), set_custom_preset_alias(), set_printer_hold_alias(), set_sync_info_and_save(), Slic3r::GUI::SendMultiMachinePage::sync_ams_list(), system_preset_names(), update_library_profile_excluded_from(), update_map_alias_to_profile_name(), update_map_system_profile_renamed(), and update_vendor_ptrs_after_copy().

reset()

void Slic3r::PresetCollection::reset ( bool delete_files )

inherited

{
    //BBS: add lock logic for sync preset in background
    lock();
    if (m_presets.size() > m_num_default_presets) {
        if (delete_files) {
            // Erase the preset files.
            for (Preset &preset : m_presets)
                if (! preset.is_default && ! preset.is_external && ! preset.is_system) {
                    //BBS remove idx and ini files
                    preset.remove_files();
                }
        }
        // Don't use m_presets.resize() here as it requires a default constructor for Preset.
        m_presets.erase(m_presets.begin() + m_num_default_presets, m_presets.end());
        this->select_preset(0);
    }
    //BBS: add lock logic for sync preset in background
    unlock();
    m_map_alias_to_profile_name.clear();
    m_map_system_profile_renamed.clear();
}

References lock(), m_map_alias_to_profile_name, m_map_system_profile_renamed, m_num_default_presets, m_presets, preset(), select_preset(), and unlock().

Here is the call graph for this function:

reset_project_embedded_presets()

bool Slic3r::PresetCollection::reset_project_embedded_presets ( )

inherited

{
    std::deque<Preset>::iterator it = m_presets.begin();
    bool re_select = false;
    int count = -1;
 
    lock();
    while ( it!=m_presets.end() )
    {
        count++;
        //if (preset.type != Preset::get_type_from_string(type)) continue;
        if (it->is_project_embedded) {
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" type %1% , delete preset %2%")%Preset::get_type_string(m_type) % it->name;
            if ((!re_select) && (m_idx_selected == count))
                re_select = true;
            if (m_idx_selected > count) {
                m_idx_selected--;
                count--;
            }
            it = m_presets.erase(it);
        }
        else
            it++;
    }
 
    if (re_select)
        m_idx_selected = -1;
 
    unlock();
 
    return re_select;
}

References count, Slic3r::Preset::get_type_string(), lock(), m_idx_selected, m_presets, m_type, and unlock().

Referenced by Slic3r::PresetBundle::restore_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_user_preset()

PresetCollection::UserPresetLoad Slic3r::PresetCollection::resolve_user_preset ( const boost::filesystem::path & file, const std::string & canonical_name, const PresetOrigin & load_origin, ForwardCompatibilitySubstitutionRule substitution_rule, const std::string & extruder_id_name, const std::string & extruder_variant_name, std::set< std::string > * key_set1, std::set< std::string > * key_set2, bool read_only ) const

privateinherited

{
    UserPresetLoad out;
    out.preset = Preset(m_type, canonical_name, false);
    Preset &preset = out.preset;
    preset.bundle_id = load_origin.bundle_id;
    preset.file = file.string();
    // Before either file is parsed, so a save that lands during the parse still shows
    // up as a difference when commit compares.
    out.on_disk = PresetFilesOnDisk::read(file);
    // Load the preset file, apply preset values on top of defaults.
    try {
        fs::path idx_path(preset.file);
        idx_path.replace_extension(".info");
        if (fs::exists(idx_path)) {
            out.info_file = idx_path.string();
            preset.load_info(out.info_file);
        }
        DynamicPrintConfig config;
        //BBS: change to json format
        //ConfigSubstitutions config_substitutions = config.load_from_ini(preset.file, substitution_rule);
        std::map<std::string, std::string> key_values;
        std::string reason;
        ConfigSubstitutions config_substitutions = config.load_from_json(preset.file, substitution_rule, key_values, reason);
        if (! config_substitutions.empty())
            out.substitutions.push_back({ preset.name, m_type, PresetConfigSubstitutions::Source::UserFile, preset.file, std::move(config_substitutions) });
        if (!reason.empty()) {
            out.discard_file = true;
            out.errors.push_back((boost::format("parse config %1% failed") % preset.file).str());
            return out;
        }
 
        std::string version_str = key_values[BBL_JSON_KEY_VERSION];
        boost::optional<Semver> version = Semver::parse(version_str);
        if (!version) {
            out.errors.push_back((boost::format("invalid version %1% in config %2%") % version_str % preset.file).str());
            return out;
        }
        preset.version = *version;
 
        if (key_values.find(BBL_JSON_KEY_FILAMENT_ID) != key_values.end())
            preset.filament_id = key_values[BBL_JSON_KEY_FILAMENT_ID];
        if (key_values.find(BBL_JSON_KEY_DESCRIPTION) != key_values.end())
            preset.description = key_values[BBL_JSON_KEY_DESCRIPTION];
        if (key_values.find(BBL_JSON_KEY_INSTANTIATION) != key_values.end())
            preset.is_visible = key_values[BBL_JSON_KEY_INSTANTIATION] != "false";
 
        //Orca: find and use the inherit config as the base
        const Preset* inherit_preset = nullptr;
        ConfigOption* inherits_config = config.option(BBL_JSON_KEY_INHERITS);
 
        // check inherits_config
        if (inherits_config) {
            ConfigOptionString * option_str = dynamic_cast<ConfigOptionString *> (inherits_config);
            std::string inherits_value = option_str->value;
            // Orca: try to find if the parent preset has been renamed
            inherit_preset = this->find_preset2(inherits_value);
            Preset::normalize_inherits(config, inherit_preset);
        }
        // Local hot reload only supports FFF; no SLA default printer is installed.
        if (read_only && load_origin.kind == PresetOrigin::Kind::LocalBundle && m_type == Preset::TYPE_PRINTER &&
            Preset::printer_technology(config) != ptFFF) {
            out.errors.push_back((boost::format("local bundle printer %1% is not FFF") % preset.file).str());
            return out;
        }
        const Preset& default_preset = this->default_preset_for(config);
        if (inherit_preset) {
            preset.config = inherit_preset->config;
            preset.filament_id = inherit_preset->filament_id;
            extend_default_config_length(config, false, {});
            preset.config.update_diff_values_to_child_config(config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
        }
        else {
            auto inherits_config2 = dynamic_cast<ConfigOptionString *>(inherits_config);
            if ((inherits_config2 && !inherits_config2->value.empty())) {
                out.errors.push_back((boost::format("can not find parent %1% for config %2%!") % inherits_config2->value % preset.file).str());
                return out;
            }
            // We support custom root preset now
            // Find a default preset for the config. The PrintPresetCollection provides different default preset based on the "printer_technology" field.
            preset.config = default_preset.config;
            preset.config.apply(std::move(config));
            extend_default_config_length(preset.config, true, default_preset.config);
        }
 
        Preset::normalize(preset.config);
        // Report configuration fields, which are misplaced into a wrong group.
        std::string incorrect_keys = Preset::remove_invalid_keys(preset.config, default_preset.config);
        if (!incorrect_keys.empty())
            out.errors.push_back("Error in a preset file: The preset \"" + preset.file +
                                 "\" contains the following incorrect keys: " + incorrect_keys + ", which were removed");
 
        if (preset.type == Preset::TYPE_FILAMENT && preset.is_user() && preset.inherits().empty()) {
            auto compatible_printers = dynamic_cast<ConfigOptionStrings *>(preset.config.option("compatible_printers", true));
            if (compatible_printers && compatible_printers->values.empty()) {
                size_t at_pos = canonical_name.find('@');
                if (at_pos != std::string::npos && at_pos + 1 < canonical_name.length()) {
                    compatible_printers->values.push_back(canonical_name.substr(at_pos + 1));
                    out.save_compatible_printers = true;
                }
            }
        }
 
        preset.loaded = true;
        out.complete = true;
    } catch (const std::ifstream::failure &err) {
        out.discard_file = true;
        out.errors.push_back((boost::format("The user-config cannot be loaded: %1%. Reason: %2%") % preset.file % err.what()).str());
        //throw Slic3r::RuntimeError(std::string("The selected preset cannot be loaded: ") + preset.file + "\n\tReason: " + err.what());
    } catch (const std::runtime_error &err) {
        out.discard_file = true;
        out.errors.push_back((boost::format("Failed loading the user-config file: %1%. Reason: %2%") % preset.file % err.what()).str());
        //throw Slic3r::RuntimeError(std::string("Failed loading the preset file: ") + preset.file + "\n\tReason: " + err.what());
    }
    out.install = true;
    return out;
}

References BBL_JSON_KEY_DESCRIPTION, BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_INSTANTIATION, BBL_JSON_KEY_VERSION, Slic3r::PresetOrigin::bundle_id, Slic3r::PresetCollection::UserPresetLoad::complete, Slic3r::Preset::config, default_preset(), default_preset_for(), Slic3r::PresetCollection::UserPresetLoad::discard_file, Slic3r::PresetCollection::UserPresetLoad::errors, Slic3r::extend_default_config_length(), Slic3r::Preset::filament_id, find_preset2(), Slic3r::PresetCollection::UserPresetLoad::info_file, Slic3r::PresetCollection::UserPresetLoad::install, Slic3r::PresetOrigin::kind, Slic3r::ConfigBase::load_from_json(), Slic3r::PresetOrigin::LocalBundle, m_type, Slic3r::Preset::normalize(), Slic3r::Preset::normalize_inherits(), Slic3r::PresetCollection::UserPresetLoad::on_disk, Slic3r::ConfigBase::option(), Slic3r::Semver::parse(), Slic3r::Preset, preset(), Slic3r::PresetCollection::UserPresetLoad::preset, Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::PresetCollection::PresetFilesOnDisk::read(), Slic3r::Preset::remove_invalid_keys(), Slic3r::PresetCollection::UserPresetLoad::save_compatible_printers, Slic3r::PresetCollection::UserPresetLoad::substitutions, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, Slic3r::PresetConfigSubstitutions::UserFile, and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

save_current_preset()

void Slic3r::PresetCollection::save_current_preset ( const std::string & new_name, bool detach = false, bool save_to_project = false, Preset * _curr_preset = nullptr )

inherited

{
    Preset curr_preset = _curr_preset ? *_curr_preset : m_edited_preset;
    //BBS: add lock logic for sync preset in background
    std::string final_inherits;
    lock();
    // 1) Find the preset with a new_name or create a new one,
    // initialize it with the edited config.
    auto it = this->find_preset_internal(new_name);
    const bool preset_existed = (it != m_presets.end() && it->name == new_name);
    if (it != m_presets.end() && it->name == new_name) {
        // Preset with the same name found.
        Preset &preset = *it;
        //BBS: add project embedded preset logic
        if (!preset.can_overwrite()) {
        //if (preset.is_default || preset.is_external || preset.is_system)
            // Cannot overwrite the default preset.
            //BBS: add lock logic for sync preset in background
            unlock();
            return;
        }
        // Overwriting an existing preset.
        preset.config = std::move(curr_preset.config);
        // The newly saved preset will be activated -> make it visible.
        preset.is_visible = true;
        //TODO: remove the detach logic
        if (detach) {
            // Clear the link to the parent profile.
            preset.vendor = nullptr;
      preset.inherits().clear();
      preset.alias.clear();
      preset.renamed_from.clear();
            preset.m_excluded_from.clear();
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": save preset %1% , with detach")%new_name;
        }
        //BBS: add lock logic for sync preset in background
 
        if (m_type == Preset::TYPE_PRINT)
            preset.config.option<ConfigOptionString>("print_settings_id", true)->value = new_name;
        else if (m_type == Preset::TYPE_FILAMENT)
            preset.config.option<ConfigOptionStrings>("filament_settings_id", true)->values[0] = new_name;
        else if (m_type == Preset::TYPE_PRINTER)
            preset.config.option<ConfigOptionString>("printer_settings_id", true)->value = new_name;
        final_inherits = preset.inherits();
        unlock();
        // TODO: apply change from custom root to devided presets.
        if (preset.inherits().empty()) {
            for (auto &preset2 : m_presets)
                if (preset2.inherits() == preset.name)
                    preset2.reload(preset);
        }
    } else {
        // Creating a new preset.
        Preset       &preset   = *m_presets.insert(it, curr_preset);
        std::string  &inherits = preset.inherits();
        std::string   old_name = preset.name;
        preset.name = new_name;
        preset.vendor = nullptr;
    preset.alias.clear();
        preset.renamed_from.clear();
        preset.m_excluded_from.clear();
        preset.setting_id.clear();
        if (detach) {
          // Clear the link to the parent profile.
          inherits.clear();
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": save preset %1% , with detach")%new_name;
        } else if (is_base_preset(preset)) {
            inherits = old_name;
        }
 
        preset.is_default  = false;
        preset.is_system   = false;
        preset.is_external = false;
 
        preset.bundle_id.clear();
 
        preset.file        = this->path_for_preset(preset);
        // The newly saved preset will be activated -> make it visible.
        preset.is_visible  = true;
        // Just system presets have aliases
        preset.alias.clear();
        //BBS: add project embedded preset logic
        if (save_to_project) {
            preset.is_project_embedded = true;
        }
        else
            preset.is_project_embedded = false;
        if (m_type == Preset::TYPE_PRINT)
            preset.config.option<ConfigOptionString>("print_settings_id", true)->value = new_name;
        else if (m_type == Preset::TYPE_FILAMENT)
            preset.config.option<ConfigOptionStrings>("filament_settings_id", true)->values[0] = new_name;
        else if (m_type == Preset::TYPE_PRINTER)
            preset.config.option<ConfigOptionString>("printer_settings_id", true)->value = new_name;
        //BBS: add lock logic for sync preset in background
        final_inherits = inherits;
        unlock();
    }
    // 2) Activate the saved preset.
    this->select_preset_by_name(new_name, true);
    // 2) Store the active preset to disk.
    //BBS: only save difference for user preset
    Preset* parent_preset = nullptr;
    if (!final_inherits.empty()) {
        parent_preset = this->find_preset2(final_inherits, true);
        if (parent_preset) {
            // Orca: take the saved diff against the resolved parent (renamed / library-matched).
            Preset::normalize_inherits(this->get_selected_preset().config, parent_preset);
            if (this->get_selected_preset().base_id.empty()) {
                this->get_selected_preset().base_id = parent_preset->setting_id;
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " base_id: " << parent_preset->setting_id;
            }
        }
    }
    if (parent_preset)
        this->get_selected_preset().save(&(parent_preset->config));
    else
        this->get_selected_preset().save(nullptr);
 
    {
        LifecycleEventContext ctx;
        ctx.name  = new_name;
        ctx.msg = preset_existed ? "overwrite" : "new";
        ctx.code = LifecycleEvtCode::Ok;
        fire_lifecycle_event(LifecycleEvent::PresetSaved, ctx);
    }
}

References Slic3r::Preset::base_id, Slic3r::LifecycleEventContext::code, Slic3r::Preset::config, find_preset2(), find_preset_internal(), Slic3r::fire_lifecycle_event(), get_selected_preset(), is_base_preset(), lock(), m_edited_preset, m_presets, m_type, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Preset::normalize_inherits(), Slic3r::Ok, path_for_preset(), preset(), Slic3r::PresetSaved, Slic3r::Preset::save(), select_preset_by_name(), Slic3r::Preset::setting_id, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, and unlock().

Referenced by Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), generate_custom_presets(), Slic3r::PresetBundle::save_changes_for_preset(), Slic3r::GUI::CalibrationWizard::save_preset(), and Slic3r::GUI::CalibrationWizard::save_preset_with_index().

Here is the call graph for this function:

Here is the caller graph for this function:

save_user_presets()

void Slic3r::PresetCollection::save_user_presets ( const std::string & dir_path, const std::string & type, std::map< std::string, std::string > & need_to_delete_list )

inherited

{
    boost::filesystem::path dir = boost::filesystem::absolute(boost::filesystem::path(dir_path) / type).make_preferred();
 
    if (!fs::exists(dir))
        fs::create_directory(dir);
 
    m_dir_path = dir.string();
 
    std::vector<std::string> delete_name_list;
    //std::map<std::string, Preset*>::iterator it;
    //for (it = my_presets.begin(); it != my_presets.end(); it++) {
    for (auto it = m_presets.begin(); it != m_presets.end(); it++) {
        Preset* preset = &m_presets[it - m_presets.begin()];
        if (!preset->is_user()) continue;
        if (preset->sync_info != "save") continue;
        preset->sync_info.clear();
        preset->file = path_for_preset(*preset);
 
        //BBS: only save difference for user preset
        std::string inherits = Preset::inherits(preset->config);
        if (inherits.empty()) {
            // We support custom root preset now
            //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" can not find inherits for %1% , should not happen")%preset->name;
            //preset->sync_info = "delete";
            //need_to_delete_list.push_back(preset->setting_id);
            //delete_name_list.push_back(preset->name);
            preset->save(nullptr);
            continue;
        }
        Preset* parent_preset = this->find_preset(inherits, false, true);
        if (!parent_preset) {
            ++m_errors;
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" can not find parent preset for %1% , inherits %2%")%preset->name %inherits;
            continue;
        }
 
        if (preset->base_id.empty())
            preset->base_id = parent_preset->setting_id;
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << preset->name << " filament_id: " << preset->filament_id << " base_id: " << preset->base_id;
        preset->save(&(parent_preset->config));
    }
 
    for (auto delete_name: delete_name_list)
    {
        this->delete_preset(delete_name);
    }
    delete_name_list.clear();
 
    return;
}

References Slic3r::Preset::config, delete_preset(), find_preset(), Slic3r::Preset::inherits(), m_dir_path, m_errors, m_presets, path_for_preset(), preset(), Slic3r::Preset::setting_id, and type().

Referenced by generate_custom_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

saved_is_dirty()

bool Slic3r::PresetCollection::saved_is_dirty ( ) const

inlineinherited

        { return is_dirty(&this->get_edited_preset(), &m_saved_preset); }

References get_edited_preset(), is_dirty(), and m_saved_preset.

Here is the call graph for this function:

section_name()

std::string Slic3r::PresetCollection::section_name ( ) const

inherited

{
    switch (this->type()) {
    case Preset::TYPE_PRINT:        return PRESET_PRINT_NAME;
    case Preset::TYPE_FILAMENT:     return PRESET_FILAMENT_NAME;
    //case Preset::TYPE_SLA_PRINT:    return PRESET_SLA_PRINT_NAME;
    //case Preset::TYPE_SLA_MATERIAL: return PRESET_SLA_MATERIALS_NAME;
    case Preset::TYPE_PRINTER:      return PRESET_PRINTER_NAME;
    default:                        return "invalid";
    }
}

References PRESET_FILAMENT_NAME, PRESET_PRINT_NAME, PRESET_PRINTER_NAME, type(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Here is the call graph for this function:

select_preset()

Preset & Slic3r::PresetCollection::select_preset ( size_t idx )

inherited

{
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% try to select preset %2%")%Preset::get_type_string(m_type) %idx;
    for (Preset &preset : m_presets)
        preset.is_dirty = false;
    if (idx >= m_presets.size())
        idx = first_visible_idx();
    m_idx_selected = idx;
    m_edited_preset = m_presets[idx];
    update_saved_preset_from_current_preset();
    bool default_visible = ! m_default_suppressed || m_idx_selected < m_num_default_presets;
    for (size_t i = 0; i < m_num_default_presets; ++i)
        m_presets[i].is_visible = default_visible;
 
    //set this preset to true
    if (!m_presets[idx].is_visible) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% set %2%, idx %3% to visible") % Preset::get_type_string(m_type) % m_presets[idx].name % idx;
        m_presets[idx].is_visible = true;
    }
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% select success, m_idx_selected %2%, name %3%, is_system %4%, is_default %5%")%Preset::get_type_string(m_type) % m_idx_selected % m_edited_preset.name % m_edited_preset.is_system % m_edited_preset.is_default;
    return m_presets[idx];
}

References first_visible_idx(), Slic3r::Preset::get_type_string(), m_default_suppressed, m_edited_preset, m_idx_selected, m_num_default_presets, m_presets, m_type, preset(), and update_saved_preset_from_current_preset().

Referenced by delete_current_preset(), get_selected_preset(), load_external_preset(), Slic3r::PresetBundle::reload_local_bundle(), reset(), select_preset_by_name(), select_preset_by_name_strict(), and update_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

select_preset_by_name()

bool Slic3r::PresetCollection::select_preset_by_name ( const std::string & name, bool force )

inherited

{
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, try to select by name %2%, force %3%")%Preset::get_type_string(m_type) %name_w_suffix %force;
    std::string name = Preset::remove_suffix_modified(name_w_suffix);
    const std::string normalized_name = this->canonical_preset_name(name);
    // 1) Try to find the preset by its name.
    auto it = this->find_preset_internal(normalized_name);
    size_t idx = 0;
    if (it != m_presets.end() && it->name == normalized_name && it->is_visible)
        // Preset found by its name and it is visible.
        idx = it - m_presets.begin();
    else {
        // Find the first visible preset.
        for (size_t i = m_default_suppressed ? m_num_default_presets : 0; i < m_presets.size(); ++ i)
            if (m_presets[i].is_visible) {
                idx = i;
                break;
            }
        // If the first visible preset was not found, return the 0th element, which is the default preset.
    }
 
    // 2) Select the new preset.
    if (m_idx_selected != idx || force) {
        this->select_preset(idx);
        //BBS: add config related logs
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, select %2%, success")%Preset::get_type_string(m_type) %name_w_suffix;
        return true;
    }
 
    //BBS: add config related logs
    if (m_idx_selected == idx)
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, already selected before") % Preset::get_type_string(m_type);
    else
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, select %2%, failed")%Preset::get_type_string(m_type) %name_w_suffix;
    return false;
}

References canonical_preset_name(), find_preset_internal(), Slic3r::Preset::get_type_string(), m_default_suppressed, m_idx_selected, m_num_default_presets, m_presets, m_type, name(), Slic3r::Preset::remove_suffix_modified(), and select_preset().

Referenced by clone_presets(), Slic3r::GUI::ExportConfigsDialog::data_init(), Slic3r::GUI::ExportPresetBundleDialog::InitExportData(), load_preset(), Slic3r::GUI::CreatePrinterPresetDialog::load_system_and_user_presets_with_curr_model(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::GUI::GUI_App::reload_settings(), Slic3r::PresetBundle::restore_selection(), save_current_preset(), Slic3r::GUI::Tab::select_preset(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), update_after_user_presets_loaded(), and Slic3r::GUI::DiffPresetDialog::update_compatibility().

Here is the call graph for this function:

Here is the caller graph for this function:

select_preset_by_name_strict()

bool Slic3r::PresetCollection::select_preset_by_name_strict ( const std::string & name )

protectedinherited

{
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, try to select by name %2%")%Preset::get_type_string(m_type) %name;
    const std::string canonical_name = this->canonical_preset_name(name);
    // 1) Try to find the preset by its name.
    auto it = this->find_preset_internal(canonical_name);
 
    size_t idx = (size_t)-1;
    if (it != m_presets.end() && it->name == canonical_name && it->is_visible)
        // Preset found by its name.
        idx = it - m_presets.begin();
    // 2) Select the new preset.
    if (idx != (size_t)-1) {
        this->select_preset(idx);
        //BBS: add config related logs
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, select %2%, success")%Preset::get_type_string(m_type) %name;
        return true;
    }
    m_idx_selected = idx;
    //BBS: add config related logs
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1%, select %2%, failed")%Preset::get_type_string(m_type) %name;
    return false;
}

References canonical_preset_name(), find_preset_internal(), Slic3r::Preset::get_type_string(), m_idx_selected, m_presets, m_type, name(), and select_preset().

Here is the call graph for this function:

set_custom_preset_alias()

void Slic3r::PresetCollection::set_custom_preset_alias ( Preset & preset )

protectedinherited

{
    // For filaments, remove the postfix
    // For printers, there is nothing to remove
    // For prints AKA processes, the postfix should be kept
    // Alias should be set here, as the preset name may be augmented further later (i.e., prefixing relative path for bundles)
    std::string bare_preset_name = get_preset_bare_name(preset.name);
    std::string alias_name = bare_preset_name;
 
    const bool is_root_filament_preset =
        m_type == Preset::Type::TYPE_FILAMENT &&
        preset.config.has(BBL_JSON_KEY_INHERITS) &&
        preset.config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS)->value.empty();
    if (is_root_filament_preset) {
        const size_t suffix_separator_pos = bare_preset_name.find_first_of("@");
        if (suffix_separator_pos != std::string::npos) {
            alias_name = bare_preset_name.substr(0, suffix_separator_pos);
            boost::trim_right(alias_name);
            if (alias_name.empty())
                alias_name = bare_preset_name;
        }
    }
 
    preset.alias = std::move(alias_name);
    m_map_alias_to_profile_name[preset.alias].push_back(preset.name);
    set_printer_hold_alias(preset.alias, preset);
}

References BBL_JSON_KEY_INHERITS, Slic3r::ConfigOptionString::empty(), Slic3r::get_preset_bare_name(), m_map_alias_to_profile_name, m_type, preset(), set_printer_hold_alias(), and Slic3r::Preset::TYPE_FILAMENT.

Referenced by clone_presets(), commit_user_preset(), get_preset_alias(), Slic3r::PresetBundle::import_json_presets(), and load_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

set_default_suppressed()

void Slic3r::PresetCollection::set_default_suppressed ( bool default_suppressed )

inherited

{
    if (m_default_suppressed != default_suppressed) {
        m_default_suppressed = default_suppressed;
        bool default_visible = ! default_suppressed || m_idx_selected < m_num_default_presets;
        for (size_t i = 0; i < m_num_default_presets; ++ i)
            m_presets[i].is_visible = default_visible;
    }
}

References m_default_suppressed, m_idx_selected, m_num_default_presets, and m_presets.

set_printer_hold_alias()

void Slic3r::PresetCollection::set_printer_hold_alias ( const std::string & alias, Preset & preset, bool remove = false )

inherited

{
    auto compatible_printers = dynamic_cast<ConfigOptionStrings *>(preset.config.option("compatible_printers"));
    if (compatible_printers == nullptr) return;
    for (const std::string &printer_name : compatible_printers->values) {
        auto printer_iter = m_printer_hold_alias.find(printer_name);
        bool insert_success = false, remove_success = false;
        if (m_printer_hold_alias.end() == printer_iter) {
            if (!remove) {
                insert_success = true;
                m_printer_hold_alias[printer_name].insert(alias);
            }
        } else {
            auto &printer_filament_alias = m_printer_hold_alias[printer_name];
            auto  alias_iter             = printer_filament_alias.find(alias);
            if (printer_filament_alias.end() == alias_iter) {
                if (!remove) {
                    insert_success = true;
                    printer_filament_alias.insert(alias);
                }
            } else {
                if (remove) {
                    if (preset.inherits() == "") {
                        remove_success = true;
                        printer_filament_alias.erase(alias);
                    }
                    if (auto alias_iter = m_map_alias_to_profile_name.find(alias); alias_iter != m_map_alias_to_profile_name.end()) {
                        auto& presets = alias_iter->second;
                        auto  new_end = std::remove(presets.begin(), presets.end(), preset.name);
                        presets.erase(new_end, presets.end());
                        if (presets.empty()) { m_map_alias_to_profile_name.erase(alias); }
                    }
                }
            }
        }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << " preset name : " << preset.name << " remove action: " << remove << " insert success: "
                                << insert_success << " remove success: " << remove_success << " alias: " << alias;
    }
}

References m_map_alias_to_profile_name, m_printer_hold_alias, and preset().

Referenced by delete_preset(), and set_custom_preset_alias().

Here is the call graph for this function:

Here is the caller graph for this function:

set_sync_func()

void Slic3r::PresetCollection::set_sync_func ( SyncFunc func )

inlineinherited

{ sync_func = func; }

References sync_func.

set_sync_info_and_save()

void Slic3r::PresetCollection::set_sync_info_and_save ( std::string name, std::string setting_id, std::string syncinfo, long long update_time, const std::string & user_id )

inherited

{
    lock();
    const std::string canonical_name = this->canonical_preset_name(name);
    for (auto it = m_presets.begin(); it != m_presets.end(); it++) {
        Preset* preset = &m_presets[it - m_presets.begin()];
        if (preset->name == canonical_name) {
            if (syncinfo.empty())
                preset->sync_info.clear();
            else
                preset->sync_info = syncinfo;
            if (get_preset_base(*preset) == preset) {
                for (auto & preset2 : m_presets)
                    if (preset2.inherits() == preset->name) {
                        preset2.base_id = setting_id;
                        preset2.save_info();
                    }
            }
            if (!setting_id.empty())
                preset->setting_id = setting_id;
            if (!user_id.empty())
                preset->user_id = user_id;
            if (update_time > 0)
                preset->updated_time = update_time;
            if (preset->sync_info == "update")
                preset->save(nullptr);
            else
                preset->save_info();
            break;
        }
    }
    unlock();
}

References canonical_preset_name(), get_preset_base(), lock(), m_presets, name(), preset(), and unlock().

Here is the call graph for this function:

size()

size_t Slic3r::PresetCollection::size ( ) const

inlineinherited

{ return m_presets.size(); }

References m_presets.

Referenced by Slic3r::GUI::Tab::compatible_widget_create(), generate_custom_presets(), Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::PresetBundle::reload_local_bundle(), and Slic3r::GUI::ExtrusionCalibration::update_combobox_filaments().

Here is the caller graph for this function:

sort_presets()

void Slic3r::PresetCollection::sort_presets ( )

inlineprivateinherited

                        {
        if (m_type == Preset::TYPE_FILAMENT)
            std::sort(m_presets.begin() + m_num_default_presets, m_presets.end(), filament_preset_less);
        else
            std::sort(m_presets.begin() + m_num_default_presets, m_presets.end());
    }

References filament_preset_less(), m_num_default_presets, m_presets, m_type, and Slic3r::Preset::TYPE_FILAMENT.

Referenced by load_project_embedded_presets(), Slic3r::PresetBundle::reload_local_bundle(), and update_after_user_presets_loaded().

Here is the call graph for this function:

Here is the caller graph for this function:

system_preset_names()

std::vector< std::string > Slic3r::PresetCollection::system_preset_names ( ) const

inherited

{
    size_t num = 0;
    for (const Preset &preset : m_presets)
        if (preset.is_system)
            ++ num;
    std::vector<std::string> out;
    out.reserve(num);
    for (const Preset &preset : m_presets)
        if (preset.is_system) {
            out.emplace_back(preset.name);
            out.insert(out.end(), preset.renamed_from.begin(), preset.renamed_from.end());
        }
    std::sort(out.begin(), out.end());
    return out;
}

References m_presets, and preset().

Here is the call graph for this function:

type()

Preset::Type Slic3r::PresetCollection::type ( ) const

inlineinherited

{ return m_type; }

References m_type.

Referenced by PresetCollection(), Slic3r::PrinterPresetCollection::PrinterPresetCollection(), add_default_preset(), Slic3r::GUI::UnsavedChangesDialog::build(), clone_presets_for_filament(), clone_presets_for_printer(), Slic3r::PresetBundle::commit_vendor_preset(), Slic3r::GUI::GUI_App::get_selected_presets(), Slic3r::PresetBundle::import_json_presets(), load_project_embedded_presets(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), name(), Slic3r::PresetBundle::resolve_vendor_preset(), save_user_presets(), section_name(), Slic3r::GUI::UnsavedChangesDialog::update(), and update_user_presets_directory().

Here is the caller graph for this function:

unlock()

void Slic3r::PresetCollection::unlock ( )

inlineinherited

{ m_mutex.unlock(); }

References m_mutex.

Referenced by add_detached_preset(), append_preset(), apply_legacy_user_filament_presets(), clone_presets(), delete_current_preset(), delete_preset(), get_project_embedded_presets(), get_user_presets(), legacy_user_filament_presets(), load_preset(), load_project_embedded_presets(), load_user_preset(), need_sync(), reset(), reset_project_embedded_presets(), save_current_preset(), set_sync_info_and_save(), and update_after_user_presets_loaded().

Here is the caller graph for this function:

update_after_user_presets_loaded()

void Slic3r::PresetCollection::update_after_user_presets_loaded ( )

inherited

{
    lock();
    std::string     selected_name = get_selected_preset_name();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", before sort, type %1%, selected_idx %2%, selected_name %3%") %m_type %m_idx_selected %selected_name;
    sort_presets();
    this->select_preset_by_name(selected_name, false);
    unlock();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", after sort, type %1%, selected_idx %2%") %m_type %m_idx_selected;
 
    return;
}

References get_selected_preset_name(), lock(), m_idx_selected, m_type, select_preset_by_name(), sort_presets(), and unlock().

Here is the call graph for this function:

update_compatible() [1/2]

void Slic3r::PresetCollection::update_compatible ( const PresetWithVendorProfile & active_printer, const PresetWithVendorProfile * active_print, PresetSelectCompatibleType select_other_if_incompatible )

inlineinherited

        { this->update_compatible(active_printer, active_print, select_other_if_incompatible, [](const Preset&) -> int { return 0; }); }

References update_compatible().

Here is the call graph for this function:

update_compatible() [2/2]

template<typename PreferedCondition>

void Slic3r::PresetCollection::update_compatible ( const PresetWithVendorProfile & active_printer, const PresetWithVendorProfile * active_print, PresetSelectCompatibleType select_other_if_incompatible, PreferedCondition prefered_condition )

inlineinherited

    {
        if (this->update_compatible_internal(active_printer, active_print, select_other_if_incompatible) == (size_t)-1) {
            // Find some other compatible preset, or the "-- default --" preset.
            size_t index = this->first_compatible_idx(prefered_condition);
            this->select_preset(index);
        }
    }

References first_compatible_idx(), select_preset(), and update_compatible_internal().

Referenced by update_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

update_compatible_internal()

size_t Slic3r::PresetCollection::update_compatible_internal ( const PresetWithVendorProfile & active_printer, const PresetWithVendorProfile * active_print, PresetSelectCompatibleType unselect_if_incompatible )

privateinherited

{
    DynamicPrintConfig config;
    config.set_key_value("printer_preset", new ConfigOptionString(active_printer.preset.name));
    const ConfigOption *opt = active_printer.preset.config.option("nozzle_diameter");
    if (opt)
        config.set_key_value("num_extruders", new ConfigOptionInt((int)static_cast<const ConfigOptionFloats*>(opt)->values.size()));
    int some_compatible = 0;
 
    if (active_print)
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": active printer %1%, print %2%, unselect_if_incompatible %3%")%active_printer.preset.name %active_print->preset.name % (int)unselect_if_incompatible;
    else
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": active printer %1%, unselect_if_incompatible %2%")%active_printer.preset.name % (int)unselect_if_incompatible;
    for (size_t idx_preset = m_num_default_presets; idx_preset < m_presets.size(); ++ idx_preset) {
        bool    selected        = idx_preset == m_idx_selected;
        Preset &preset_selected = m_presets[idx_preset];
        Preset &preset_edited   = selected ? m_edited_preset : preset_selected;
 
        const PresetWithVendorProfile this_preset_with_vendor_profile = this->get_preset_with_vendor_profile(preset_edited);
        bool    was_compatible  = preset_edited.is_compatible;
        preset_edited.is_compatible = is_compatible_with_printer(this_preset_with_vendor_profile, active_printer, &config);
        if (preset_edited.is_compatible)
            some_compatible++;
      if (active_print != nullptr)
          preset_edited.is_compatible &= is_compatible_with_print(this_preset_with_vendor_profile, *active_print, active_printer);
        if (! preset_edited.is_compatible && selected &&
            (unselect_if_incompatible == PresetSelectCompatibleType::Always || (unselect_if_incompatible == PresetSelectCompatibleType::OnlyIfWasCompatible && was_compatible)))
        {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  type %1% , previous selected %2% becomes uncompatible, will select later")%Preset::get_type_string(m_type) %m_idx_selected;
            m_idx_selected = size_t(-1);
        }
        if (selected)
            preset_selected.is_compatible = preset_edited.is_compatible;
    }
    // Update visibility of the default profiles here if the defaults are suppressed, the current profile is not compatible and we don't want to select another compatible profile.
    if (m_idx_selected >= m_num_default_presets && m_default_suppressed)
    {
        for (size_t i = 0; i < m_num_default_presets; ++ i)
        {
            m_presets[i].is_visible = (some_compatible == 0);
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": type %1% returned m_idx_selected %2%, some_compatible %3%")%Preset::get_type_string(m_type) %m_idx_selected %some_compatible;
    return m_idx_selected;
}

References Slic3r::Always, Slic3r::Preset::config, Slic3r::ConfigOptionString, get_preset_with_vendor_profile(), Slic3r::Preset::get_type_string(), Slic3r::Preset::is_compatible, Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), m_default_suppressed, m_edited_preset, m_idx_selected, m_num_default_presets, m_presets, m_type, Slic3r::Preset::name, Slic3r::OnlyIfWasCompatible, Slic3r::ConfigBase::option(), Slic3r::PresetWithVendorProfile::preset, and Slic3r::DynamicConfig::set_key_value().

Referenced by update_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

update_dirty()

bool Slic3r::PresetCollection::update_dirty ( )

inherited

{
    bool was_dirty = this->get_selected_preset().is_dirty;
    bool is_dirty  = current_is_dirty();
    this->get_selected_preset().is_dirty = is_dirty;
    this->get_edited_preset().is_dirty = is_dirty;
 
    return was_dirty != is_dirty;
}

References current_is_dirty(), get_edited_preset(), get_selected_preset(), Slic3r::Preset::is_dirty, and is_dirty().

Referenced by load_external_preset(), Slic3r::PresetBundle::reload_local_bundle(), and Slic3r::PresetBundle::restore_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

update_library_profile_excluded_from()

void Slic3r::PresetCollection::update_library_profile_excluded_from ( )

protectedinherited

{
    // Orca: Collect all filament presets that has empty compatible_printers and belongs to the Orca Filament Library.
    std::map<std::string, std::set<std::string>*> excluded_froms;
    for (Preset& preset : m_presets) {
        if (preset.vendor != nullptr && preset.vendor->name == PresetBundle::ORCA_FILAMENT_LIBRARY) {
            // check if the preset has empty compatible_printers
            const auto* compatible_printers = dynamic_cast<const ConfigOptionStrings*>(preset.config.option("compatible_printers"));
            if (compatible_printers == nullptr || compatible_printers->values.empty())
                excluded_froms[preset.alias] = &preset.m_excluded_from;
        }
    }
 
    // Check all presets that has the same alias as the filament presets with empty compatible_printers in Orca Filament Library.
    // A printer specific profile supersedes the generic one, no matter whether it lives in a vendor bundle or in the
    // library itself.
    for (const Preset& preset : m_presets) {
        if (preset.vendor == nullptr)
            continue;
 
        const auto* compatible_printers = dynamic_cast<const ConfigOptionStrings*>(preset.config.option("compatible_printers"));
        // Profiles with empty compatible_printers are the generic ones, they never supersede anything.
        if (compatible_printers == nullptr || compatible_printers->values.empty())
            continue;
        auto itr = excluded_froms.find(preset.alias);
        if (itr != excluded_froms.end()) {
            // Add the printer models to the excluded_from list.
            for (const std::string& printer_name : compatible_printers->values) {
                itr->second->insert(printer_name);
            }
        }
    }
}

References m_presets, Slic3r::PresetBundle::ORCA_FILAMENT_LIBRARY, and preset().

Here is the call graph for this function:

update_map_alias_to_profile_name()

void Slic3r::PresetCollection::update_map_alias_to_profile_name ( )

protectedinherited

{
  m_map_alias_to_profile_name.clear();
    for (const Preset &preset : m_presets) {
        m_map_alias_to_profile_name[preset.alias].push_back(preset.name);
    }
  // now m_map_alias_to_profile_name is map, not need sort
  //std::sort(m_map_alias_to_profile_name.begin(), m_map_alias_to_profile_name.end(), [](auto &l, auto &r) { return l.first < r.first; });
}

References m_map_alias_to_profile_name, m_presets, and preset().

Referenced by Slic3r::PresetBundle::reload_local_bundle().

Here is the call graph for this function:

Here is the caller graph for this function:

update_map_system_profile_renamed()

void Slic3r::PresetCollection::update_map_system_profile_renamed ( )

protectedinherited

{
  m_map_system_profile_renamed.clear();
  for (Preset &preset : m_presets)
    for (const std::string &renamed_from : preset.renamed_from) {
            const auto [it, success] = m_map_system_profile_renamed.insert(std::pair<std::string, std::string>(renamed_from, preset.name));
            if (!success) {
                ++m_errors;
                BOOST_LOG_TRIVIAL(error) << boost::format("Preset name \"%1%\" was marked as renamed from \"%2%\", though preset name "
                                                          "\"%3%\" was marked as renamed from \"%2%\" as well.") %
                                                preset.name % renamed_from % it->second;
            }
        }
}

References m_errors, m_map_system_profile_renamed, m_presets, and preset().

Here is the call graph for this function:

update_saved_preset_from_current_preset()

void Slic3r::PresetCollection::update_saved_preset_from_current_preset ( )

inlineinherited

{ m_saved_preset = m_edited_preset; }

References m_edited_preset, and m_saved_preset.

Referenced by PresetCollection(), load_external_preset(), and select_preset().

Here is the caller graph for this function:

update_user_presets_directory()

void Slic3r::PresetCollection::update_user_presets_directory ( const std::string & dir_path, const std::string & type )

inherited

{
    boost::filesystem::path dir = boost::filesystem::absolute(boost::filesystem::path(dir_path) / type).make_preferred();
 
    if (!fs::exists(dir))
        fs::create_directory(dir);
 
    m_dir_path = dir.string();
}

References m_dir_path, and type().

Here is the call graph for this function:

update_vendor_ptrs_after_copy()

void Slic3r::PresetCollection::update_vendor_ptrs_after_copy ( const VendorMap & vendors )

protectedinherited

{
    for (Preset &preset : m_presets)
        if (preset.vendor != nullptr) {
            assert(! preset.is_default && ! preset.is_external);
            // Re-assign a pointer to the vendor structure in the new PresetBundle.
            auto it = new_vendors.find(preset.vendor->id);
            assert(it != new_vendors.end());
            preset.vendor = &it->second;
        }
}

References m_presets, and preset().

Here is the call graph for this function:

validate_preset()

bool Slic3r::PresetCollection::validate_preset ( const std::string & name, std::string & inherit )

inherited

{
    // Presets that came from system vendors, the built-in defaults, or any loaded bundle (local or
    // subscribed) are trusted — their g-code isn't user-authored, so the 3MF importer should not
    // warn about them.
    auto is_trusted = [](const Preset &p) { return p.is_system || p.is_default || p.is_from_bundle(); };
 
    const std::string canonical_name = this->canonical_preset_name(preset_name);
    std::deque<Preset>::iterator it       = this->find_preset_internal(canonical_name);
    bool                         found    = (it != m_presets.end()) && (it->name == canonical_name) && is_trusted(*it);
    if (!found) {
        it = this->find_preset_renamed(canonical_name);
        found = it != m_presets.end() && is_trusted(*it);
    }
    if (!found) {
        if (!inherit_name.empty()) {
            const std::string canonical_inherit_name = this->canonical_preset_name(inherit_name);
            it    = this->find_preset_internal(canonical_inherit_name);
            found = it != m_presets.end() && it->name == canonical_inherit_name && is_trusted(*it);
            if (!found) {
                it    = this->find_preset_renamed(canonical_inherit_name);
                found = it != m_presets.end() && is_trusted(*it);
            }
            if (found)
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": preset_name %1%, inherit_name %2%, found inherit in list")%preset_name %inherit_name;
            else
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": preset_name %1%, inherit_name %2%, can not found preset and inherit in list")%preset_name %inherit_name;
        }
        else {
            //inherit is null , should not happen , just consider it as valid
            found = false;
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": preset_name %1%, no inherit, set to not found")%preset_name;
        }
    }
    else {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": preset_name %1%, found in list")%preset_name;
    }
 
    return found;
}

References canonical_preset_name(), find_preset_internal(), find_preset_renamed(), and m_presets.

Here is the call graph for this function:

write_legacy_user_filament_preset()

bool Slic3r::PresetCollection::write_legacy_user_filament_preset ( const LegacyUserFilamentPreset & legacy )

staticinherited

{
    // Only compatible_printers changes in the file. Saving the whole preset would also rewrite an inherits that
    // names a renamed parent by its old name, the only name older releases know it by.
    try {
        json j = read_user_preset_file(legacy.file);
        // Changed by hand or by another instance since the preset was found: a list of its own stands, and
        // another parent would need other printers.
        if (j.contains("compatible_printers") || j.value(BBL_JSON_KEY_INHERITS, std::string()) != legacy.inherits)
            return false;
        j["compatible_printers"] = legacy.compatible_printers;
        if (const std::error_code ec = write_file_atomically(legacy.file, j.dump(1, '\t') + "\n")) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": failed to save " << legacy.file << ": " << ec.message();
            return false;
        }
    } catch (const std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": can not migrate " << legacy.file << ": " << err.what();
        return false;
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": user preset " << legacy.preset << " gets " << legacy.printers.size()
                            << " printer(s) its parent listed in an older release";
    return true;
}

References BBL_JSON_KEY_INHERITS, Slic3r::LegacyUserFilamentPreset::compatible_printers, Slic3r::LegacyUserFilamentPreset::file, Slic3r::LegacyUserFilamentPreset::inherits, Slic3r::LegacyUserFilamentPreset::preset, Slic3r::LegacyUserFilamentPreset::printers, Slic3r::read_user_preset_file(), and Slic3r::write_file_atomically().

Referenced by Slic3r::PresetBundle::migrate_legacy_user_filament_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

PresetBundle

friend class PresetBundle

friend

References PresetBundle.

Referenced by PresetBundle.

Member Data Documentation

m_default_suppressed

bool Slic3r::PresetCollection::m_default_suppressed = true

privateinherited

Referenced by first_compatible_idx(), first_visible_idx(), first_visible_idx_by_type(), is_default_suppressed(), operator=(), select_preset(), select_preset_by_name(), set_default_suppressed(), and update_compatible_internal().

m_dir_path

std::string Slic3r::PresetCollection::m_dir_path

privateinherited

Referenced by Slic3r::PresetBundle::import_json_presets(), load_presets(), operator=(), path_from_name(), Slic3r::PresetBundle::save_preset_to_bundle_dir(), save_user_presets(), and update_user_presets_directory().

m_edited_preset

Preset Slic3r::PresetCollection::m_edited_preset

privateinherited

Referenced by PresetCollection(), apply_legacy_user_filament_presets(), diameters_of_selected_printer(), discard_current_changes(), get_edited_preset(), get_edited_preset(), load_user_preset(), operator=(), preset(), Slic3r::PresetBundle::reload_local_bundle(), save_current_preset(), select_preset(), update_compatible_internal(), and update_saved_preset_from_current_preset().

m_errors

int Slic3r::PresetCollection::m_errors = 0

privateinherited

Referenced by commit_user_preset(), error_count(), get_differed_values_to_update(), load_project_embedded_presets(), load_user_preset(), save_user_presets(), and update_map_system_profile_renamed().

m_idx_selected

size_t Slic3r::PresetCollection::m_idx_selected

privateinherited

Referenced by PresetCollection(), add_detached_preset(), apply_legacy_user_filament_presets(), delete_current_preset(), discard_current_changes(), get_idx_selected(), get_preset_name_by_alias(), get_selected_idx(), get_selected_preset(), get_selected_preset(), get_selected_preset_base(), get_selected_preset_name(), load_preset(), load_user_preset(), operator=(), preset(), Slic3r::PresetBundle::reload_local_bundle(), reset_project_embedded_presets(), select_preset(), select_preset_by_name(), select_preset_by_name_strict(), set_default_suppressed(), update_after_user_presets_loaded(), and update_compatible_internal().

m_map_alias_to_profile_name

std::map<std::string, std::vector<std::string> > Slic3r::PresetCollection::m_map_alias_to_profile_name

privateinherited

Referenced by get_preset_name_by_alias(), is_alias_exist(), operator=(), Slic3r::PresetBundle::reload_local_bundle(), reset(), set_custom_preset_alias(), set_printer_hold_alias(), and update_map_alias_to_profile_name().

m_map_system_profile_renamed

std::map<std::string, std::string> Slic3r::PresetCollection::m_map_system_profile_renamed

privateinherited

Referenced by find_preset_renamed(), get_preset_name_renamed(), operator=(), reset(), and update_map_system_profile_renamed().

m_mutex

std::recursive_mutex Slic3r::PresetCollection::m_mutex

privateinherited

Referenced by lock(), and unlock().

m_num_default_presets

size_t Slic3r::PresetCollection::m_num_default_presets = 0

privateinherited

Referenced by add_default_preset(), begin(), begin(), cbegin(), default_preset(), default_preset(), find_preset_internal(), first_compatible_idx(), first_visible_idx(), first_visible_idx_by_type(), has_defaults_only(), merge_presets(), num_default_presets(), operator=(), Slic3r::PresetBundle::reload_local_bundle(), reset(), select_preset(), select_preset_by_name(), set_default_suppressed(), sort_presets(), and update_compatible_internal().

m_presets

std::deque<Preset> Slic3r::PresetCollection::m_presets

privateinherited

Referenced by PresetCollection(), add_default_preset(), add_detached_preset(), append_preset(), apply_legacy_user_filament_presets(), begin(), begin(), cbegin(), cend(), clone_presets(), default_preset(), default_preset(), delete_current_preset(), delete_preset(), diameters_of_selected_printer(), discard_current_changes(), end(), end(), erase(), find_preset(), find_preset_internal(), find_preset_renamed(), first_compatible_idx(), first_visible_idx(), first_visible_idx_by_type(), get_filament_presets(), get_preset_name_by_alias(), get_presets(), get_project_embedded_presets(), get_selected_preset(), get_selected_preset(), get_selected_preset_base(), get_selected_preset_name(), get_user_presets(), has_defaults_only(), lbegin(), legacy_user_filament_presets(), load_external_preset(), load_preset(), load_project_embedded_presets(), load_user_preset(), merge_presets(), num_visible(), operator()(), operator=(), preset(), Slic3r::PresetBundle::reload_local_bundle(), reset(), reset_project_embedded_presets(), Slic3r::PresetBundle::restore_selection(), save_current_preset(), save_user_presets(), select_preset(), select_preset_by_name(), select_preset_by_name_strict(), Slic3r::PresetBundle::selection(), set_default_suppressed(), set_sync_info_and_save(), size(), sort_presets(), system_preset_names(), update_compatible_internal(), update_library_profile_excluded_from(), update_map_alias_to_profile_name(), update_map_system_profile_renamed(), update_vendor_ptrs_after_copy(), and validate_preset().

m_printer_hold_alias

std::unordered_map<std::string, std::unordered_set<std::string> > Slic3r::PresetCollection::m_printer_hold_alias

privateinherited

Referenced by is_alias_exist(), and set_printer_hold_alias().

m_saved_preset

Preset Slic3r::PresetCollection::m_saved_preset

privateinherited

Referenced by PresetCollection(), apply_legacy_user_filament_presets(), operator=(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::PresetBundle::restore_selection(), saved_is_dirty(), Slic3r::PresetBundle::selection(), and update_saved_preset_from_current_preset().

m_type

Preset::Type Slic3r::PresetCollection::m_type

privateinherited

Referenced by PresetCollection(), add_detached_preset(), append_preset(), clone_presets(), commit_user_preset(), first_visible_idx(), get_differed_values_to_update(), get_preset_differed_for_save(), get_project_embedded_presets(), get_selected_preset_parent(), load_external_preset(), load_preset(), load_presets(), load_project_embedded_presets(), load_user_preset(), merge_presets(), operator=(), reset_project_embedded_presets(), resolve_user_preset(), save_current_preset(), select_preset(), select_preset_by_name(), select_preset_by_name_strict(), set_custom_preset_alias(), sort_presets(), type(), update_after_user_presets_loaded(), and update_compatible_internal().

sync_func

SyncFunc Slic3r::PresetCollection::sync_func { nullptr }

inherited

{ nullptr };

Referenced by set_sync_func().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Preset.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Preset.cpp