#include <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

Public Member Functions
	PrinterPresetCollection (Preset::Type type, const std::vector< std::string > &keys, const Slic3r::StaticPrintConfig &defaults, const std::string &default_name="- default -")

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

bool	only_default_printers () const

Iterator	begin ()

ConstIterator	begin () const

ConstIterator	cbegin () const

Iterator	end ()

ConstIterator	end () const

ConstIterator	cend () const

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)

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

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

std::pair< Preset *, bool >	load_external_preset (const std::string &path, const std::string &name, const std::string &original_name, const DynamicPrintConfig &config, LoadAndSelect select=LoadAndSelect::Always)

bool	save_current_preset (const std::string &new_name, bool detach=false)

Preset &	get_preset_with_name (const std::string &new_name, const Preset *initial_preset)

bool	delete_current_preset ()

bool	delete_preset (const std::string &name)

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

Preset &	get_edited_preset ()

const Preset &	get_edited_preset () 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

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 respect_active_preset=true)

const Preset &	preset (size_t idx, bool respect_active_preset=true) const

void	discard_current_changes ()

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

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

size_t	first_visible_idx () const

template<typename PreferedCondition >
size_t	first_compatible_idx (PreferedCondition prefered_condition) const

size_t	first_compatible_idx () const

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

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)

std::string	path_from_name (const std::string &new_name) const

size_t	num_default_presets () const

const std::vector< std::pair< std::string, std::string > > &	map_alias_to_profile_name ()

Static Public Member Functions
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 bool	is_independent_from_extruder_number_option (const std::string &opt_key)

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::string >	merge_presets (PresetCollection &&other, const VendorMap &new_vendors)

void	update_map_alias_to_profile_name ()

void	update_map_system_profile_renamed ()

Private Member Functions
	PrinterPresetCollection ()=default

	PrinterPresetCollection (const PrinterPresetCollection &other)=default

PrinterPresetCollection &	operator= (const PrinterPresetCollection &other)=default

std::deque< Preset >::iterator	find_preset_internal (const std::string &name)

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)

Private Attributes
Preset::Type	m_type

std::deque< Preset >	m_presets

std::vector< std::pair< std::string, std::string > >	m_map_alias_to_profile_name

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

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

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 -"`
	)

inline

606 :

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

Slic3r::PresetCollection::type

Preset::Type type() const

Definition Preset.hpp:300

Slic3r::PresetCollection::PresetCollection

PresetCollection()=default

◆ PrinterPresetCollection() [2/3]

Slic3r::PrinterPresetCollection::PrinterPresetCollection ( )

privatedefault

◆ PrinterPresetCollection() [3/3]

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

privatedefault

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(), Slic3r::PresetCollection::m_num_default_presets, Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::type().

Referenced by Slic3r::PresetBundle::PresetBundle(), and Slic3r::PresetCollection::PresetCollection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ begin() [1/2]

Iterator Slic3r::PresetCollection::begin ( )

inlineinherited

291{ return m_presets.begin() + m_num_default_presets; }

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

◆ begin() [2/2]

ConstIterator Slic3r::PresetCollection::begin ( ) const

inlineinherited

292{ return m_presets.cbegin() + m_num_default_presets; }

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

◆ cbegin()

ConstIterator Slic3r::PresetCollection::cbegin ( ) const

inlineinherited

293{ return m_presets.cbegin() + m_num_default_presets; }

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

Referenced by find_system_preset_by_model_and_variant().

Here is the caller graph for this function:

◆ cend()

ConstIterator Slic3r::PresetCollection::cend ( ) const

inlineinherited

296{ return m_presets.cend(); }

References Slic3r::PresetCollection::m_presets.

Referenced by find_system_preset_by_model_and_variant().

Here is the caller 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

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

Slic3r::PresetCollection::dirty_options

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

Definition Preset.cpp:1349

Slic3r::PresetCollection::get_edited_preset

Preset & get_edited_preset()

Definition Preset.hpp:379

Slic3r::PresetCollection::get_selected_preset_parent

const Preset * get_selected_preset_parent() const

Definition Preset.cpp:1069

References Slic3r::PresetCollection::dirty_options(), Slic3r::PresetCollection::get_edited_preset(), and Slic3r::PresetCollection::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

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

Slic3r::PresetCollection::get_selected_preset

Preset & get_selected_preset()

Definition Preset.hpp:365

References Slic3r::PresetCollection::dirty_options(), Slic3r::PresetCollection::get_edited_preset(), and Slic3r::PresetCollection::get_selected_preset().

Here is the call graph for this function:

◆ current_is_dirty()

bool Slic3r::PresetCollection::current_is_dirty ( ) const

inlineinherited

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

Slic3r::PresetCollection::is_dirty

static bool is_dirty(const Preset *edited, const Preset *reference)

Definition Preset.cpp:1333

References Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_selected_preset(), and Slic3r::PresetCollection::is_dirty().

Referenced by Slic3r::GUI::PresetComboBox::OnSelect(), Slic3r::GUI::PlaterPresetComboBox::OnSelect(), Slic3r::GUI::TabPresetComboBox::OnSelect(), Slic3r::GUI::Tab::select_preset(), and Slic3r::PresetCollection::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

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

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

Referenced by Slic3r::PresetBundle::PresetBundle(), Slic3r::PresetCollection::default_preset_for(), default_preset_for(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetCollection::get_selected_preset_parent(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::PresetBundle::load_configbundle(), Slic3r::PresetCollection::load_preset(), and Slic3r::PresetCollection::load_presets().

Here is the caller graph for this function:

◆ default_preset() [2/2]

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

inlineinherited

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

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::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::ConfigBase::opt(), Slic3r::ptFFF, and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

◆ delete_current_preset()

bool Slic3r::PresetCollection::delete_current_preset ( )

inherited

{
    const Preset &selected = this->get_selected_preset();
    if (selected.is_default)
        return false;
    if (! selected.is_external && ! selected.is_system) {
        // Erase the preset file.
        boost::nowide::remove(selected.file.c_str());
    }
    // Remove the preset from the list.
    m_presets.erase(m_presets.begin() + m_idx_selected);
    // 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::file, Slic3r::PresetCollection::get_selected_preset(), Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::Preset::is_system, Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::select_preset().

Referenced by Slic3r::PresetCollection::delete_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_preset()

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

inherited

{
    if (name == this->get_selected_preset().name)
        return delete_current_preset();
 
    const std::string selected_preset_name = this->get_selected_preset_name();
 
    auto it = this->find_preset_internal(name);
 
    const Preset& preset = *it;
    if (preset.is_default)
        return false;
    if (!preset.is_external && !preset.is_system) {
        // Erase the preset file.
        boost::nowide::remove(preset.file.c_str());
    }
    m_presets.erase(it);
 
    // update selected preset
    this->select_preset_by_name(selected_preset_name, true);
 
    return true;
}

References Slic3r::PresetCollection::delete_current_preset(), Slic3r::Preset::file, Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::PresetCollection::get_selected_preset_name(), Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::Preset::is_system, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::name(), Slic3r::PresetCollection::preset(), and Slic3r::PresetCollection::select_preset_by_name().

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 Slic3r::PresetCollection::current_different_from_parent_options(), Slic3r::PresetCollection::current_dirty_options(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

Here is the caller 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];
        // Don't save the resetted preset state as a "saved into project" state.
//        update_saved_preset_from_current_preset();
    }

References Slic3r::PresetCollection::m_edited_preset, Slic3r::PresetCollection::m_idx_selected, and Slic3r::PresetCollection::m_presets.

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

Here is the caller graph for this function:

◆ end() [1/2]

Iterator Slic3r::PresetCollection::end ( )

inlineinherited

294{ return m_presets.end(); }

References Slic3r::PresetCollection::m_presets.

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

Here is the caller graph for this function:

◆ end() [2/2]

ConstIterator Slic3r::PresetCollection::end ( ) const

inlineinherited

295{ return m_presets.cend(); }

References Slic3r::PresetCollection::m_presets.

◆ find_preset() [1/2]

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

inherited

{
    Preset key(m_type, name, false);
    auto it = this->find_preset_internal(name);
    // Ensure that a temporary copy is returned if the preset found is currently selected.
    return (it != m_presets.end() && it->name == key.name) ? &this->preset(it - m_presets.begin(), respect_active_preset) :
        first_visible_if_not_found ? &this->first_visible() : nullptr;
}

References Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::first_visible(), Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::m_type, Slic3r::Preset::name, Slic3r::PresetCollection::name(), and Slic3r::PresetCollection::preset().

Referenced by Slic3r::GUI::UnsavedChangesDialog::UnsavedChangesDialog(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::GUI::ConfigWizard::priv::check_and_install_missing_materials(), Slic3r::GUI::Plater::check_selected_presets_visibility(), Slic3r::PresetCollection::find_preset(), Slic3r::GUI::SavePresetDialog::Item::get_existing_preset(), Slic3r::PresetCollection::get_preset_parent(), Slic3r::PresetCollection::get_selected_preset_parent(), Slic3r::PresetBundle::load_configbundle(), Slic3r::PresetCollection::load_presets(), Slic3r::PresetBundle::load_selections(), Slic3r::GUI::ConfigWizard::priv::load_vendors(), Slic3r::PresetBundle::transfer_and_save(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::TabPresetComboBox::update(), Slic3r::GUI::DiffPresetDialog::update_compatibility(), Slic3r::GUI::TabPresetComboBox::update_dirty(), Slic3r::GUI::Plater::update_filament_colors_in_full_config(), and Slic3r::GUI::DiffPresetDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_preset() [2/2]

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

inlineinherited

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

Slic3r::PresetCollection::find_preset

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

Definition Preset.cpp:1164

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

Here is the call graph for this function:

◆ find_preset_internal() [1/2]

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

inlineprivateinherited

    {
        auto it = Slic3r::lower_bound_by_predicate(m_presets.begin() + m_num_default_presets, m_presets.end(), [&name](const auto& l) { 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) {
                    it = m_presets.begin() + i;
                    break;
                }
        }
        return it;
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_preset_internal() [2/2]

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

inlineprivateinherited

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

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

Here is the call 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 Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::m_map_system_profile_renamed, Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::name().

Referenced by Slic3r::PresetCollection::find_preset_renamed(), Slic3r::PresetCollection::get_preset_parent(), Slic3r::PresetCollection::get_selected_preset_parent(), and Slic3r::PresetCollection::load_external_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

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

Slic3r::PresetCollection::find_preset_renamed

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

Definition Preset.hpp:556

References Slic3r::PresetCollection::find_preset_renamed(), and Slic3r::PresetCollection::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(), Slic3r::Preset::config, Slic3r::Preset::is_system, Slic3r::ConfigBase::opt_string(), and Slic3r::PresetCollection::preset().

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

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

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

Slic3r::PresetCollection::first_compatible_idx

size_t first_compatible_idx() const

Definition Preset.hpp:447

References Slic3r::PresetCollection::first_compatible_idx(), and Slic3r::PresetCollection::preset().

Here is the call graph for this function:

◆ first_compatible() [2/3]

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

inlineinherited

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

References Slic3r::PresetCollection::first_compatible_idx(), and Slic3r::PresetCollection::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

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

References Slic3r::PresetCollection::first_compatible_idx(), and Slic3r::PresetCollection::preset().

Here is the call graph for this function:

◆ first_compatible_idx() [1/2]

size_t Slic3r::PresetCollection::first_compatible_idx ( ) const

inlineinherited

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

References Slic3r::PresetCollection::first_compatible_idx().

Referenced by Slic3r::PresetCollection::first_compatible(), Slic3r::PresetCollection::first_compatible(), Slic3r::PresetCollection::first_compatible(), Slic3r::PresetCollection::first_compatible_idx(), and Slic3r::PresetCollection::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 = 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 Slic3r::PresetCollection::m_default_suppressed, Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

◆ first_visible() [1/2]

Preset & Slic3r::PresetCollection::first_visible ( )

inlineinherited

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

Slic3r::PresetCollection::first_visible_idx

size_t first_visible_idx() const

Definition Preset.cpp:1174

References Slic3r::PresetCollection::first_visible_idx(), and Slic3r::PresetCollection::preset().

Referenced by Slic3r::PresetCollection::find_preset().

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

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

References Slic3r::PresetCollection::first_visible_idx(), and Slic3r::PresetCollection::preset().

Here is the call graph for this function:

◆ first_visible_idx()

size_t Slic3r::PresetCollection::first_visible_idx ( ) const

inherited

{
    size_t idx = m_default_suppressed ? m_num_default_presets : 0;
    for (; idx < m_presets.size(); ++ idx)
        if (m_presets[idx].is_visible)
            break;
    if (idx == m_presets.size())
        idx = 0;
    return idx;
}

References Slic3r::PresetCollection::m_default_suppressed, Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

Referenced by Slic3r::PresetCollection::first_visible(), Slic3r::PresetCollection::first_visible(), Slic3r::PresetCollection::load_presets(), and Slic3r::PresetCollection::select_preset().

Here is the caller graph for this function:

◆ get_edited_preset() [1/2]

Preset & Slic3r::PresetCollection::get_edited_preset ( )

inlineinherited

379{ return m_edited_preset; }

References Slic3r::PresetCollection::m_edited_preset.

Here is the caller graph for this function:

◆ get_edited_preset() [2/2]

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

inlineinherited

380{ return m_edited_preset; }

References Slic3r::PresetCollection::m_edited_preset.

◆ get_edited_preset_with_vendor_profile()

PresetWithVendorProfile Slic3r::PresetCollection::get_edited_preset_with_vendor_profile ( ) const

inlineinherited

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

Slic3r::PresetCollection::get_preset_with_vendor_profile

PresetWithVendorProfile get_preset_with_vendor_profile(const Preset &preset) const

Definition Preset.cpp:1122

References Slic3r::PresetCollection::get_edited_preset(), and Slic3r::PresetCollection::get_preset_with_vendor_profile().

Referenced by Slic3r::GUI::Tab::select_preset().

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

394{ return m_idx_selected; }

References Slic3r::PresetCollection::m_idx_selected.

◆ 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)
    if (auto it_preset = this->find_preset_internal(it->second);
      it_preset != m_presets.end() && it_preset->name == it->second &&
            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 Slic3r::PresetCollection::find_preset_internal(), Slic3r::lower_bound_by_predicate(), Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_map_alias_to_profile_name, and Slic3r::PresetCollection::m_presets.

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

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 Slic3r::PresetCollection::m_map_system_profile_renamed.

Referenced by Slic3r::GUI::ConfigWizard::priv::load_vendors().

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;
    const Preset* preset = this->find_preset(inherits, false);
    if (preset == nullptr) {
      auto it = this->find_preset_renamed(inherits);
    if (it != m_presets.end())
      preset = &(*it);
    }
    return
         // not found
        (preset == nullptr/* || preset->is_default */||
         // this should not happen, user profile should not derive from an external profile
         preset->is_external ||
         // this should not happen, however people are creative, see GH #4996
         preset == &child) ?
            nullptr :
            preset;
}

References Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::find_preset_renamed(), Slic3r::Preset::inherits(), Slic3r::Preset::is_external, Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::preset().

Referenced by Slic3r::PresetCollection::get_preset_with_vendor_profile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_preset_with_name()

Preset & Slic3r::PresetCollection::get_preset_with_name	(	const std::string &	new_name,
		const Preset *	initial_preset
	)

inherited

{
    // 1) Find the preset with a new_name or create a new one,
    // initialize it with the preset_to config.
    auto it = this->find_preset_internal(new_name);
    if (it != m_presets.end() && it->name == new_name) {
        // Preset with the same name found.
        Preset& preset = *it;
        if (!preset.is_default && !preset.is_external && !preset.is_system && initial_preset->name != new_name) {
            // Overwriting an existing preset if it isn't default/external/system or isn't an initial_preset
            preset.config = initial_preset->config;
            // The newly saved preset can be activated -> make it visible.
            preset.is_visible = true;
        }
        return preset;
    }
 
    const std::string selected_preset_name = this->get_selected_preset_name();
 
    // Creating a new preset.
    Preset& preset = *m_presets.insert(it, *initial_preset);
    std::string& inherits = preset.inherits();
    std::string old_name = preset.name;
    preset.name = new_name;
    preset.file = this->path_from_name(new_name);
    preset.vendor = nullptr;
    preset.alias.clear();
    preset.renamed_from.clear();
    if (preset.is_system) {
        // Inheriting from a system preset.
        inherits = old_name;
    }
    else if (inherits.empty()) {
        // Inheriting from a user preset. Link the new preset to the old preset.
        // inherits = old_name;
    }
    else {
        // Inherited from a user preset. Just maintain the "inherited" flag,
        // meaning it will inherit from either the system preset, or the inherited user preset.
    }
    preset.is_default = false;
    preset.is_system = false;
    preset.is_external = false;
    // The newly saved preset can be activated -> make it visible.
    preset.is_visible = true;
    // Just system presets have aliases
    preset.alias.clear();
 
    // sort printers and get new it
    std::sort(m_presets.begin(), m_presets.end());
 
    // set initial preset selection
    this->select_preset_by_name(selected_preset_name, true);
 
    it = this->find_preset_internal(new_name);
    assert(it != m_presets.end());
 
    return *it;
}

References Slic3r::Preset::alias, Slic3r::Preset::config, Slic3r::Preset::file, Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::get_selected_preset_name(), Slic3r::Preset::inherits(), Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::Preset::is_system, Slic3r::Preset::is_visible, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, Slic3r::PresetCollection::path_from_name(), Slic3r::PresetCollection::preset(), Slic3r::Preset::renamed_from, Slic3r::PresetCollection::select_preset_by_name(), and Slic3r::Preset::vendor.

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

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 Slic3r::PresetCollection::get_preset_parent(), Slic3r::PresetCollection::preset(), and Slic3r::Preset::vendor.

Referenced by Slic3r::PresetCollection::get_edited_preset_with_vendor_profile(), Slic3r::PresetBundle::load_installed_filaments(), Slic3r::PresetBundle::load_installed_sla_materials(), Slic3r::PresetCollection::update_compatible_internal(), and Slic3r::ExtruderFilaments::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

393{ return m_presets; }

References Slic3r::PresetCollection::m_presets.

Referenced by Slic3r::ExtruderFilaments::ExtruderFilaments(), Slic3r::GUI::SavePresetDialog::Item::get_existing_preset(), only_default_printers(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::TabPresetComboBox::update(), and Slic3r::GUI::PresetComboBox::update().

Here is the caller graph for this function:

◆ get_selected_idx()

size_t Slic3r::PresetCollection::get_selected_idx ( ) const

inlineinherited

367{ return m_idx_selected; }

References Slic3r::PresetCollection::m_idx_selected.

Referenced by Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), Slic3r::PresetCollection::get_selected_preset_parent(), Slic3r::GUI::PlaterPresetComboBox::update(), and Slic3r::GUI::TabPresetComboBox::update().

Here is the caller graph for this function:

◆ get_selected_preset() [1/2]

Preset & Slic3r::PresetCollection::get_selected_preset ( )

inlineinherited

365{ return m_presets[m_idx_selected]; }

References Slic3r::PresetCollection::m_idx_selected, and Slic3r::PresetCollection::m_presets.

Here is the caller graph for this function:

◆ get_selected_preset() [2/2]

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

inlineinherited

366{ return m_presets[m_idx_selected]; }

References Slic3r::PresetCollection::m_idx_selected, and Slic3r::PresetCollection::m_presets.

◆ get_selected_preset_name()

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

inlineinherited

369{ return (m_idx_selected == size_t(-1)) ? std::string() : this->get_selected_preset().name; }

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

Referenced by Slic3r::ExtruderFilaments::ExtruderFilaments(), Slic3r::PresetCollection::delete_preset(), Slic3r::PresetBundle::export_selections(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::PresetCollection::get_preset_with_name(), Slic3r::PresetBundle::load_config_file_config_bundle(), Slic3r::PresetBundle::load_selections(), Slic3r::PresetHints::maximum_volumetric_flow_description(), Slic3r::PresetBundle::save_changes_for_preset(), and Slic3r::PresetBundle::transfer_and_save().

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 (selected_preset.is_system || selected_preset.is_default)
        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
        preset = this->find_preset(inherits, false);
    if (preset == nullptr) {
      // Resolve the "renamed_from" field.
      assert(! inherits.empty());
      auto it = this->find_preset_renamed(inherits);
    if (it != m_presets.end())
      preset = &(*it);
    }
    return (preset == nullptr/* || preset->is_default*/ || preset->is_external) ? nullptr : preset;
}

Referenced by Slic3r::PresetCollection::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::SavePresetDialog::Item::update().

Here is the caller graph for this function:

◆ has_defaults_only()

bool Slic3r::PresetCollection::has_defaults_only ( ) const

inlineinherited

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

References Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

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

Here is the caller graph for this function:

◆ is_default_suppressed()

bool Slic3r::PresetCollection::is_default_suppressed ( ) const

inlineinherited

360{ return m_default_suppressed; }

References Slic3r::PresetCollection::m_default_suppressed.

Referenced by Slic3r::ExtruderFilaments::first_compatible_idx().

Here is the caller graph for this function:

◆ 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))
            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(), and Slic3r::optional_keys.

Referenced by Slic3r::PresetCollection::current_is_dirty(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::saved_is_dirty(), and Slic3r::PresetCollection::update_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_independent_from_extruder_number_option()

bool Slic3r::PresetCollection::is_independent_from_extruder_number_option ( const std::string & opt_key )

staticinherited

{
    return independent_from_extruder_number_options.find(opt_key) != independent_from_extruder_number_options.end();
}

References Slic3r::independent_from_extruder_number_options.

Referenced by Slic3r::Search::OptionsSearcher::append_options(), Slic3r::deep_diff(), and Slic3r::GUI::Tab::init_options_list().

Here is the caller 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,
		LoadAndSelect	select = `LoadAndSelect::Always`
	)

inherited

{
    // Load the preset over a default preset, so that the missing fields are filled in from the default preset.
    DynamicPrintConfig cfg(this->default_preset_for(combined_config).config);
    t_config_option_keys keys = cfg.keys();
    cfg.apply_only(combined_config, keys, true);
    std::string                 &inherits = Preset::inherits(cfg);
    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.
            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());
        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);
        found = it != m_presets.end() && it->name == inherits;
        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());
            return std::make_pair(&(*it), false);
        }
    }
    if (found) {
        if (select != LoadAndSelect::Never) {
            // 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.
 
            // Following keys are not used neither by the UI nor by the slicing core, therefore they are not important 
            // Erase them from config appl to avoid redundant "dirty" parameter in loaded preset.
            for (const char* key : { "print_settings_id", "filament_settings_id", "sla_print_settings_id", "sla_material_settings_id", "printer_settings_id",
                                     "printer_model", "printer_variant", "default_print_profile", "default_filament_profile", "default_sla_print_profile", "default_sla_material_profile" })
                keys.erase(std::remove(keys.begin(), keys.end(), key), keys.end());
 
            this->get_edited_preset().config.apply_only(combined_config, keys, true);
            this->update_dirty();
            // Don't save the newly loaded project as a "saved into project" state.
            //update_saved_preset_from_current_preset();
            assert(this->get_edited_preset().is_dirty);
            return std::make_pair(&(*it), this->get_edited_preset().is_dirty);
        }
        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;
    for (size_t idx = 0;; ++ idx) {
        std::string suffix;
        if (original_name.empty()) {
            if (idx > 0)
                suffix = " (" + std::to_string(idx) + ")";
        } else {
            if (idx == 0)
                suffix = " (" + original_name + ")";
            else
                suffix = " (" + original_name + "-" + std::to_string(idx) + ")";
        }
        new_name = name + suffix;
        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());
            return std::make_pair(&(*it), false);
        }
        // Form another profile name.
    }
    // Insert a new profile.
    Preset &preset = this->load_preset(path, new_name, std::move(cfg), select == LoadAndSelect::Always);
    preset.is_external = true;
    if (this->m_idx_selected != size_t(-1) && &this->get_selected_preset() == &preset)
        this->get_edited_preset().is_external = true;
 
    return std::make_pair(&preset, false);
}

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

Here is the call graph for this function:

Here is the caller 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`
	)

inherited

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

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

Referenced by Slic3r::PresetBundle::load_config_file_config(), Slic3r::PresetBundle::load_configbundle(), Slic3r::PresetCollection::load_external_preset(), and Slic3r::PresetCollection::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`
	)

inherited

{
    auto it = this->find_preset_internal(name);
    if (it == m_presets.end() || it->name != name) {
        // The preset was not found. Create a new preset.
        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;
    if (select)
        this->select_preset_by_name(name, true);
    return preset;
}

References Slic3r::Preset::config, Slic3r::Preset::file, Slic3r::PresetCollection::find_preset_internal(), Slic3r::Preset::is_dirty, Slic3r::Preset::loaded, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::m_type, Slic3r::PresetCollection::name(), Slic3r::PresetCollection::preset(), and Slic3r::PresetCollection::select_preset_by_name().

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
	)

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();
    m_dir_path = dir.string();
    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;
    for (auto &dir_entry : boost::filesystem::directory_iterator(dir))
        if (Slic3r::is_ini_file(dir_entry)) {
            std::string name = dir_entry.path().filename().string();
            // Remove the .ini suffix.
            name.erase(name.size() - 4);
            if (this->find_preset(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: " << name;
                continue;
            }
            try {
                Preset preset(m_type, name, false);
                preset.file = dir_entry.path().string();
                // Load the preset file, apply preset values on top of defaults.
                try {
                    DynamicPrintConfig config;
                    ConfigSubstitutions config_substitutions = config.load_from_ini(preset.file, substitution_rule);
                    if (! config_substitutions.empty())
                        substitutions.push_back({ preset.name, m_type, PresetConfigSubstitutions::Source::UserFile, preset.file, std::move(config_substitutions) });
                    // Find a default preset for the config. The PrintPresetCollection provides different default preset based on the "printer_technology" field.
                    const Preset &default_preset = this->default_preset_for(config);
                    preset.config = default_preset.config;
                    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(config, default_preset.config);
                    if (! incorrect_keys.empty())
                        BOOST_LOG_TRIVIAL(error) << "Error in a preset file: The preset \"" <<
                            preset.file << "\" contains the following incorrect keys: " << incorrect_keys << ", which were removed";
                    preset.loaded = true;
                } catch (const std::ifstream::failure &err) {
                    throw Slic3r::RuntimeError(std::string("The selected preset cannot be loaded: ") + preset.file + "\n\tReason: " + err.what());
                } catch (const std::runtime_error &err) {
                    throw Slic3r::RuntimeError(std::string("Failed loading the preset file: ") + preset.file + "\n\tReason: " + err.what());
                }
                presets_loaded.emplace_back(preset);
            } 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()));
    std::sort(m_presets.begin() + m_num_default_presets, m_presets.end());
    this->select_preset(first_visible_idx());
    if (! errors_cummulative.empty())
        throw Slic3r::RuntimeError(errors_cummulative);
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ map_alias_to_profile_name()

const std::vector< std::pair< std::string, std::string > > & Slic3r::PresetCollection::map_alias_to_profile_name ( )

inlineinherited

571{ return m_map_alias_to_profile_name; }

References Slic3r::PresetCollection::m_map_alias_to_profile_name.

Referenced by Slic3r::ExtruderFilaments::get_preset_name_by_alias().

Here is the caller graph for this function:

◆ merge_presets()

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

protectedinherited

{
    std::vector<std::string> duplicates;
    for (Preset &preset : other.m_presets) {
        if (preset.is_default || preset.is_external)
            continue;
        Preset key(m_type, preset.name);
        auto it = std::lower_bound(m_presets.begin() + m_num_default_presets, m_presets.end(), key);
        if (it == m_presets.end() || it->name != preset.name) {
            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;
            }
            m_presets.emplace(it, std::move(preset));
        } else
            duplicates.emplace_back(std::move(preset.name));
    }
    return duplicates;
}

References Slic3r::VendorProfile::id, Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::PresetCollection::m_num_default_presets, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::m_type, Slic3r::Preset::name, Slic3r::PresetCollection::preset(), and Slic3r::Preset::vendor.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ name()

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

inherited

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

References L, Slic3r::PresetCollection::type(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::Preset::TYPE_SLA_PRINT.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ num_default_presets()

size_t Slic3r::PresetCollection::num_default_presets ( ) const

inlineinherited

511{ return m_num_default_presets; }

References Slic3r::PresetCollection::m_num_default_presets.

Referenced by Slic3r::ExtruderFilaments::first_compatible_idx(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::TabPresetComboBox::update(), Slic3r::GUI::PresetComboBox::update(), and Slic3r::ExtruderFilaments::update_compatible_internal().

Here is the caller graph for this function:

◆ num_visible()

size_t Slic3r::PresetCollection::num_visible ( ) const

inlineinherited

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

References Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::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 (! printer.is_default)
            return false;
    }
    return true;
}

References Slic3r::PresetCollection::get_presets().

Referenced by Slic3r::GUI::GUI_App::config_wizard_startup().

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

305{ return m_presets; }

References Slic3r::PresetCollection::m_presets.

◆ operator=()

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

privatedefault

◆ path_from_name()

std::string Slic3r::PresetCollection::path_from_name ( const std::string & new_name ) const

inherited

{
    std::string file_name = boost::iends_with(new_name, ".ini") ? new_name : (new_name + ".ini");
    return (boost::filesystem::path(m_dir_path) / file_name).make_preferred().string();
}

References Slic3r::PresetCollection::m_dir_path.

Referenced by Slic3r::PresetCollection::get_preset_with_name(), Slic3r::PresetBundle::load_config_file_config(), and Slic3r::PresetCollection::save_current_preset().

Here is the caller graph for this function:

◆ preset() [1/2]

Preset & Slic3r::PresetCollection::preset	(	size_t	idx,
		bool	respect_active_preset = `true`
	)

inlineinherited

402{ return (idx == m_idx_selected && respect_active_preset) ? m_edited_preset : m_presets[idx]; }

References Slic3r::PresetCollection::m_edited_preset, Slic3r::PresetCollection::m_idx_selected, and Slic3r::PresetCollection::m_presets.

Here is the caller graph for this function:

◆ preset() [2/2]

const Preset & Slic3r::PresetCollection::preset	(	size_t	idx,
		bool	respect_active_preset = `true`
	)		const

inlineinherited

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

References Slic3r::PresetCollection::preset().

Referenced by Slic3r::PresetCollection::preset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

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

inherited

{
    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)
                    boost::nowide::remove(preset.file.c_str());
        }
        // 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);
    }
    m_map_alias_to_profile_name.clear();
    m_map_system_profile_renamed.clear();
}

References Slic3r::Preset::file, Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::Preset::is_system, Slic3r::PresetCollection::m_map_alias_to_profile_name, Slic3r::PresetCollection::m_map_system_profile_renamed, Slic3r::PresetCollection::m_num_default_presets, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::preset(), and Slic3r::PresetCollection::select_preset().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_current_preset()

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

inherited

{
    bool is_saved_as_new{ false };
    // 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);
    if (it != m_presets.end() && it->name == new_name) {
        // Preset with the same name found.
        Preset &preset = *it;
        if (preset.is_default || preset.is_external || preset.is_system)
            // Cannot overwrite the default preset.
            return false;
        // Overwriting an existing preset.
        preset.config = std::move(m_edited_preset.config);
        // The newly saved preset will be activated -> make it visible.
        preset.is_visible = true;
        if (detach) {
            // Clear the link to the parent profile.
            preset.vendor = nullptr;
      preset.inherits().clear();
      preset.alias.clear();
      preset.renamed_from.clear();
        }
    } else {
        is_saved_as_new = true;
        // Creating a new preset.
        Preset       &preset   = *m_presets.insert(it, m_edited_preset);
        std::string  &inherits = preset.inherits();
        std::string   old_name = preset.name;
        preset.name = new_name;
        preset.file = this->path_from_name(new_name);
        preset.vendor = nullptr;
    preset.alias.clear();
        preset.renamed_from.clear();
        if (detach) {
          // Clear the link to the parent profile.
          inherits.clear();
        } else if (preset.is_system) {
            // Inheriting from a system preset.
            inherits = /* preset.vendor->name + "/" + */ old_name;
        } else if (inherits.empty()) {
            // Inheriting from a user preset. Link the new preset to the old preset.
            // inherits = old_name;
        } else {
            // Inherited from a user preset. Just maintain the "inherited" flag,
            // meaning it will inherit from either the system preset, or the inherited user preset.
        }
        preset.is_default  = false;
        preset.is_system   = false;
        preset.is_external = false;
        // The newly saved preset will be activated -> make it visible.
        preset.is_visible  = true;
        // Just system presets have aliases
        preset.alias.clear();
    }
    // 2) Activate the saved preset.
    this->select_preset_by_name(new_name, true);
    // 2) Store the active preset to disk.
    this->get_selected_preset().save();
 
    return is_saved_as_new;
}

References Slic3r::Preset::alias, Slic3r::Preset::config, Slic3r::Preset::file, Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::Preset::inherits(), Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::Preset::is_system, Slic3r::Preset::is_visible, Slic3r::PresetCollection::m_edited_preset, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, Slic3r::PresetCollection::path_from_name(), Slic3r::PresetCollection::preset(), Slic3r::Preset::renamed_from, Slic3r::Preset::save(), Slic3r::PresetCollection::select_preset_by_name(), and Slic3r::Preset::vendor.

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

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

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

Slic3r::PresetCollection::m_saved_preset

Preset m_saved_preset

Definition Preset.hpp:586

References Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::is_dirty(), and Slic3r::PresetCollection::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 "print";
    case Preset::TYPE_FILAMENT:     return "filament";
    case Preset::TYPE_SLA_PRINT:    return "sla_print";
    case Preset::TYPE_SLA_MATERIAL: return "sla_material";
    case Preset::TYPE_PRINTER:      return "printer";
    default:                        return "invalid";
    }
}

References Slic3r::PresetCollection::type(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::Preset::TYPE_SLA_PRINT.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_preset()

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

inherited

{
    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];
    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;
    return m_presets[idx];
}

References Slic3r::PresetCollection::first_visible_idx(), Slic3r::Preset::is_dirty, Slic3r::PresetCollection::m_default_suppressed, Slic3r::PresetCollection::m_edited_preset, Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_num_default_presets, Slic3r::PresetCollection::m_presets, and Slic3r::PresetCollection::preset().

Referenced by Slic3r::PresetBundle::PresetBundle(), Slic3r::PresetCollection::delete_current_preset(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::load_presets(), Slic3r::PresetCollection::reset(), Slic3r::PresetCollection::select_preset_by_name(), Slic3r::PresetCollection::select_preset_by_name_strict(), and Slic3r::PresetCollection::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

{
    std::string name = Preset::remove_suffix_modified(name_w_suffix);
    // 1) Try to find the preset by its name.
    auto it = this->find_preset_internal(name);
    size_t idx = 0;
    if (it != m_presets.end() && it->name == 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);
        return true;
    }
 
    return false;
}

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

Referenced by Slic3r::PresetCollection::delete_preset(), Slic3r::PresetCollection::get_preset_with_name(), Slic3r::PresetCollection::load_preset(), Slic3r::PresetBundle::load_selections(), Slic3r::PresetCollection::save_current_preset(), 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

{
    // 1) Try to find the preset by its name.
    auto it = this->find_preset_internal(name);
    size_t idx = (size_t)-1;
    if (it != m_presets.end() && it->name == 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);
        return true;
    }
    m_idx_selected = idx;
    return false;
}

References Slic3r::PresetCollection::find_preset_internal(), Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::name(), and Slic3r::PresetCollection::select_preset().

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

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 Slic3r::PresetCollection::m_default_suppressed, Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_num_default_presets, and Slic3r::PresetCollection::m_presets.

◆ size()

size_t Slic3r::PresetCollection::size ( ) const

inlineinherited

459{ return m_presets.size(); }

References Slic3r::PresetCollection::m_presets.

Referenced by Slic3r::GUI::Tab::compatible_widget_create(), Slic3r::PresetUpdater::priv::perform_updates(), and Slic3r::GUI::TabPresetComboBox::update().

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 Slic3r::Preset::is_system, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, Slic3r::PresetCollection::preset(), and Slic3r::Preset::renamed_from.

Referenced by Slic3r::flatten_configbundle_hierarchy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ type()

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

inlineinherited

300{ return m_type; }

References Slic3r::PresetCollection::m_type.

Referenced by Slic3r::GUI::UnsavedChangesDialog::UnsavedChangesDialog(), Slic3r::PresetCollection::add_default_preset(), Slic3r::GUI::UnsavedChangesDialog::build(), Slic3r::PresetBundle::load_configbundle(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::PresetCollection::name(), Slic3r::PresetCollection::section_name(), and Slic3r::GUI::UnsavedChangesDialog::update().

Here is the caller 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

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

Slic3r::PresetCollection::update_compatible

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

Definition Preset.hpp:464

References Slic3r::PresetCollection::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.
            this->select_preset(this->first_compatible_idx(prefered_condition));        
    }

References Slic3r::PresetCollection::first_compatible_idx(), Slic3r::PresetCollection::select_preset(), and Slic3r::PresetCollection::update_compatible_internal().

Referenced by Slic3r::PresetCollection::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()));
    bool some_compatible = false;
    std::vector<size_t> indices_of_template_presets;
    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);
        some_compatible |= preset_edited.is_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)))
            m_idx_selected = size_t(-1);
        if (selected)
            preset_selected.is_compatible = preset_edited.is_compatible;
        if (preset_edited.vendor && preset_edited.vendor->templates_profile) {
            if (preset_selected.is_visible)
                indices_of_template_presets.push_back(idx_preset);
            else {
                preset_selected.is_compatible = false;
                if (selected)
                    m_idx_selected = size_t(-1);
            }
        }
    }
    // filter out template profiles where profile with same alias and compability exists
    if (!indices_of_template_presets.empty()) {
        for (size_t idx_preset = m_num_default_presets; idx_preset < m_presets.size(); ++idx_preset) {
            if (m_presets[idx_preset].vendor && !m_presets[idx_preset].vendor->templates_profile && m_presets[idx_preset].is_compatible) {
                std::string preset_alias = m_presets[idx_preset].alias;
                for (size_t idx_of_template_in_presets : indices_of_template_presets) {
                    if (m_presets[idx_of_template_in_presets].alias == preset_alias) {
                        // unselect selected template filament if there is non-template alias compatible
                        if (idx_of_template_in_presets == m_idx_selected && (unselect_if_incompatible == PresetSelectCompatibleType::Always || unselect_if_incompatible == PresetSelectCompatibleType::OnlyIfWasCompatible)) {
                            m_idx_selected = size_t(-1);
                        }
                        m_presets[idx_of_template_in_presets].is_compatible = false;
                        break;
                    }
                }
            }
        }
    }
    
    // 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;
    return m_idx_selected;
}

References Slic3r::Always, Slic3r::Preset::config, Slic3r::PresetCollection::get_preset_with_vendor_profile(), Slic3r::Preset::is_compatible, Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::Preset::is_visible, Slic3r::PresetCollection::m_default_suppressed, Slic3r::PresetCollection::m_edited_preset, Slic3r::PresetCollection::m_idx_selected, Slic3r::PresetCollection::m_num_default_presets, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, Slic3r::OnlyIfWasCompatible, Slic3r::ConfigBase::option(), Slic3r::PresetWithVendorProfile::preset, Slic3r::DynamicConfig::set_key_value(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::VendorProfile::templates_profile, and Slic3r::Preset::vendor.

Referenced by Slic3r::PresetCollection::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 Slic3r::PresetCollection::current_is_dirty(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::Preset::is_dirty, and Slic3r::PresetCollection::is_dirty().

Referenced by Slic3r::PresetCollection::load_external_preset(), and Slic3r::GUI::TabPresetComboBox::update_dirty().

Here is the call graph for this function:

Here is the caller 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.emplace_back(preset.alias, preset.name);
  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 Slic3r::Preset::alias, Slic3r::PresetCollection::m_map_alias_to_profile_name, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, and Slic3r::PresetCollection::preset().

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

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)
                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 error, Slic3r::PresetCollection::m_map_system_profile_renamed, Slic3r::PresetCollection::m_presets, Slic3r::Preset::name, Slic3r::PresetCollection::preset(), and Slic3r::Preset::renamed_from.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_saved_preset_from_current_preset()

void Slic3r::PresetCollection::update_saved_preset_from_current_preset ( )

inlineinherited

492{ m_saved_preset = m_edited_preset; }

References Slic3r::PresetCollection::m_edited_preset, and Slic3r::PresetCollection::m_saved_preset.

Referenced by Slic3r::PresetCollection::PresetCollection().

Here is the caller 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 Slic3r::VendorProfile::id, Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::PresetCollection::m_presets, Slic3r::PresetCollection::preset(), and Slic3r::Preset::vendor.

Referenced by Slic3r::PresetBundle::operator=().

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

Member Data Documentation

◆ m_default_suppressed

bool Slic3r::PresetCollection::m_default_suppressed = true

privateinherited

Referenced by Slic3r::PresetCollection::first_compatible_idx(), Slic3r::PresetCollection::first_visible_idx(), Slic3r::PresetCollection::is_default_suppressed(), Slic3r::PresetCollection::select_preset(), Slic3r::PresetCollection::select_preset_by_name(), Slic3r::PresetCollection::set_default_suppressed(), and Slic3r::PresetCollection::update_compatible_internal().

◆ m_dir_path

std::string Slic3r::PresetCollection::m_dir_path

privateinherited

Referenced by Slic3r::PresetCollection::load_presets(), and Slic3r::PresetCollection::path_from_name().

◆ m_edited_preset

Preset Slic3r::PresetCollection::m_edited_preset

privateinherited

Referenced by Slic3r::PresetCollection::PresetCollection(), Slic3r::PresetCollection::discard_current_changes(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::preset(), Slic3r::PresetCollection::save_current_preset(), Slic3r::PresetCollection::select_preset(), Slic3r::PresetCollection::update_compatible_internal(), and Slic3r::PresetCollection::update_saved_preset_from_current_preset().

◆ m_idx_selected

size_t Slic3r::PresetCollection::m_idx_selected

privateinherited

◆ m_map_alias_to_profile_name

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

privateinherited

Referenced by Slic3r::PresetCollection::get_preset_name_by_alias(), Slic3r::PresetCollection::map_alias_to_profile_name(), Slic3r::PresetCollection::reset(), and Slic3r::PresetCollection::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 Slic3r::PresetCollection::find_preset_renamed(), Slic3r::PresetCollection::get_preset_name_renamed(), Slic3r::PresetCollection::reset(), and Slic3r::PresetCollection::update_map_system_profile_renamed().

◆ m_num_default_presets

size_t Slic3r::PresetCollection::m_num_default_presets = 0

privateinherited

◆ m_presets

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

privateinherited

◆ m_saved_preset

Preset Slic3r::PresetCollection::m_saved_preset

privateinherited

Referenced by Slic3r::PresetCollection::saved_is_dirty(), and Slic3r::PresetCollection::update_saved_preset_from_current_preset().

◆ m_type

Preset::Type Slic3r::PresetCollection::m_type

privateinherited

Referenced by Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_selected_preset_parent(), Slic3r::PresetCollection::load_preset(), Slic3r::PresetCollection::load_presets(), Slic3r::PresetCollection::merge_presets(), and Slic3r::PresetCollection::type().

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

src/libslic3r/Preset.hpp
src/libslic3r/Preset.cpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ConstIterator

◆ Iterator

Member Enumeration Documentation

◆ LoadAndSelect

Constructor & Destructor Documentation

◆ PrinterPresetCollection() [1/3]

◆ PrinterPresetCollection() [2/3]

◆ PrinterPresetCollection() [3/3]

Member Function Documentation

◆ add_default_preset()

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ current_different_from_parent_options()

◆ current_dirty_options()

◆ current_is_dirty()

◆ default_preset() [1/2]

◆ default_preset() [2/2]

◆ default_preset_for()

◆ delete_current_preset()

◆ delete_preset()

◆ dirty_options()

◆ discard_current_changes()

◆ end() [1/2]

◆ end() [2/2]

◆ find_preset() [1/2]

◆ find_preset() [2/2]

◆ find_preset_internal() [1/2]

◆ find_preset_internal() [2/2]

◆ find_preset_renamed() [1/2]

◆ find_preset_renamed() [2/2]

◆ find_system_preset_by_model_and_variant()

◆ first_compatible() [1/3]

◆ first_compatible() [2/3]

◆ first_compatible() [3/3]

◆ first_compatible_idx() [1/2]

◆ first_compatible_idx() [2/2]

◆ first_visible() [1/2]

◆ first_visible() [2/2]

◆ first_visible_idx()

◆ get_edited_preset() [1/2]

◆ get_edited_preset() [2/2]

◆ get_edited_preset_with_vendor_profile()

◆ get_idx_selected()

◆ get_preset_name_by_alias()

◆ get_preset_name_renamed()

◆ get_preset_parent()

◆ get_preset_with_name()

◆ get_preset_with_vendor_profile()

◆ get_presets()

◆ get_selected_idx()

◆ get_selected_preset() [1/2]

◆ get_selected_preset() [2/2]

◆ get_selected_preset_name()

◆ get_selected_preset_parent()

◆ get_suffix_modified()

◆ has_defaults_only()

◆ is_default_suppressed()

◆ is_dirty()

◆ is_independent_from_extruder_number_option()

◆ load_external_preset()

◆ load_preset() [1/2]

◆ load_preset() [2/2]

◆ load_presets()

◆ map_alias_to_profile_name()

◆ merge_presets()

◆ name()

◆ num_default_presets()

◆ num_visible()

◆ only_default_printers()