Slic3r::DynamicPrintConfig Class Reference

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

Inheritance diagram for Slic3r::DynamicPrintConfig:

Collaboration diagram for Slic3r::DynamicPrintConfig:

Public Member Functions
	DynamicPrintConfig ()
	DynamicPrintConfig (const DynamicPrintConfig &rhs)
	DynamicPrintConfig (DynamicPrintConfig &&rhs) noexcept
	DynamicPrintConfig (const StaticPrintConfig &rhs)
	DynamicPrintConfig (const ConfigBase &rhs)
DynamicPrintConfig &	operator= (const DynamicPrintConfig &rhs)
DynamicPrintConfig &	operator= (DynamicPrintConfig &&rhs) noexcept
const ConfigDef *	def () const override
void	normalize_fdm (int used_filaments=0)
void	normalize_fdm_1 ()
t_config_option_keys	normalize_fdm_2 (int num_objects, int used_filaments=0)
size_t	get_parameter_size (const std::string &param_name, size_t extruder_nums)
void	set_num_extruders (unsigned int num_extruders)
void	set_num_filaments (unsigned int num_filaments)
std::map< std::string, std::string >	validate (bool under_cli=false)
void	handle_legacy (t_config_option_key &opt_key, std::string &value) const override
void	handle_legacy_composite () override
std::string	get_filament_type (std::string &displayed_filament_type, int id=0)
bool	is_using_different_extruders ()
bool	support_different_extruders (int &extruder_count) const
bool	has_multi_variant_filament () const
int	get_extruder_nozzle_volume_count (int extruder_count, std::vector< std::vector< NozzleVolumeType > > &nozzle_volume_types) const
int	get_index_for_extruder (int extruder_or_filament_id, std::string id_name, ExtruderType extruder_type, NozzleVolumeType nozzle_volume_type, std::string variant_name, unsigned int stride=1) const
std::vector< int >	update_values_to_printer_extruders (DynamicPrintConfig &printer_config, int extruder_count, int extruder_nozzle_volume_count, std::vector< std::vector< NozzleVolumeType > > &nv_types, std::set< std::string > &key_set, std::string id_name, std::string variant_name, unsigned int stride=1, unsigned int extruder_id=0, NozzleVolumeType filament_nvt=nvtStandard)
void	update_values_to_printer_extruders_for_multiple_filaments (DynamicPrintConfig &printer_config, int extruder_count, int extruder_nozzle_volume_count, std::set< std::string > &key_set, std::string id_name, std::string variant_name)
void	update_filament_config_values_for_multiple_extruders (DynamicPrintConfig &printer_config, const std::unordered_map< int, std::vector< FilamentVariantUse > > &filament_variant_uses, int extruder_count, int extruder_nozzle_volume_count, std::set< std::string > &key_set, std::string id_name, std::string variant_name, std::vector< int > *slot_machine_indices=nullptr)
void	update_non_diff_values_to_base_config (DynamicPrintConfig &new_config, const t_config_option_keys &keys, const std::set< std::string > &different_keys, std::string extruder_id_name, std::string extruder_variant_name, std::set< std::string > &key_set1, std::set< std::string > &key_set2)
void	update_diff_values_to_child_config (DynamicPrintConfig &new_config, std::string extruder_id_name, std::string extruder_variant_name, std::set< std::string > &key_set1, std::set< std::string > &key_set2)
int	update_values_from_single_to_multi (DynamicPrintConfig &multi_config, std::set< std::string > &key_set, std::string id_name, std::string variant_name)
int	update_values_from_multi_to_multi (DynamicPrintConfig &new_config, std::set< std::string > &key_set, std::string id_name, std::string variant_name, std::vector< std::string > &extruder_variants)
int	update_values_from_multi_to_multi_2 (const std::vector< std::string > &src_extruder_variants, const std::vector< std::string > &dst_extruder_variants, const DynamicPrintConfig &dst_config, const std::set< std::string > &key_sets)
std::string	get_filament_vendor () const
std::string	get_filament_type () const
DynamicConfig &	operator+= (const DynamicConfig &rhs)
DynamicConfig &	operator+= (DynamicConfig &&rhs)
bool	operator== (const DynamicConfig &rhs) const
bool	operator!= (const DynamicConfig &rhs) const
void	swap (DynamicConfig &other)
void	clear ()
bool	erase (const t_config_option_key &opt_key)
size_t	remove_nil_options ()
template<class T>
T *	opt (const t_config_option_key &opt_key, bool create=false)
template<class T>
const T *	opt (const t_config_option_key &opt_key) const
const ConfigOption *	optptr (const t_config_option_key &opt_key) const override
ConfigOption *	optptr (const t_config_option_key &opt_key, bool create=false) override
t_config_option_keys	keys () const override
bool	empty () const
bool	set_key_value (const std::string &opt_key, ConfigOption *opt)
bool	equals (const DynamicConfig &other, const std::set< std::string > *skipped_keys=nullptr) const
t_config_option_keys	diff (const DynamicConfig &other) const
t_config_option_keys	equal (const DynamicConfig &other) const
std::string &	opt_string (const t_config_option_key &opt_key, bool create=false)
const std::string &	opt_string (const t_config_option_key &opt_key) const
std::string &	opt_string (const t_config_option_key &opt_key, unsigned int idx)
const std::string &	opt_string (const t_config_option_key &opt_key, unsigned int idx) const
double &	opt_float (const t_config_option_key &opt_key)
const double &	opt_float (const t_config_option_key &opt_key) const
double &	opt_float (const t_config_option_key &opt_key, unsigned int idx)
const double &	opt_float (const t_config_option_key &opt_key, unsigned int idx) const
double &	opt_float_nullable (const t_config_option_key &opt_key, unsigned int idx)
const double &	opt_float_nullable (const t_config_option_key &opt_key, unsigned int idx) const
FloatOrPercent &	opt_float_or_percent_nullable (const t_config_option_key &opt_key, unsigned int idx)
const FloatOrPercent &	opt_float_or_percent_nullable (const t_config_option_key &opt_key, unsigned int idx) const
int &	opt_int (const t_config_option_key &opt_key)
int	opt_int (const t_config_option_key &opt_key) const
int &	opt_int (const t_config_option_key &opt_key, unsigned int idx)
int	opt_int (const t_config_option_key &opt_key, unsigned int idx) const
int &	opt_int_nullable (const t_config_option_key &opt_key, unsigned int idx)
const int &	opt_int_nullable (const t_config_option_key &opt_key, unsigned int idx) const
template<typename ENUM>
ENUM	opt_enum (const t_config_option_key &opt_key) const
int	opt_enum (const t_config_option_key &opt_key, unsigned int idx) const
int	opt_enum_nullable (const t_config_option_key &opt_key, unsigned int idx) const
bool	opt_bool (const t_config_option_key &opt_key) const
bool	opt_bool (const t_config_option_key &opt_key, unsigned int idx) const
bool	opt_bool_nullable (const t_config_option_key &opt_key, unsigned int idx) const
bool	read_cli (int argc, const char *const argv[], t_config_option_keys *extra, t_config_option_keys *keys=nullptr)
std::map< t_config_option_key, std::unique_ptr< ConfigOption > >::const_iterator	cbegin () const
std::map< t_config_option_key, std::unique_ptr< ConfigOption > >::const_iterator	cend () const
size_t	size () const
DynamicConfigDifference	diff_report (const DynamicConfig &rhs) const
	Computes the symmetric difference between this DynamicConfig (left) and another DynamicConfig (rhs).
bool	equals (const ConfigBase &other, const std::set< std::string > *skipped_keys=nullptr) const
t_config_option_keys	diff (const ConfigBase &other) const
t_config_option_keys	equal (const ConfigBase &other) const
virtual bool	apply_to (ConfigBase &) const
ConfigOption *	option (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option (const t_config_option_key &opt_key) const
ConfigOption *	option_throw (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option_throw (const t_config_option_key &opt_key) const
void	apply (const ConfigBase &other, bool ignore_nonexistent=false)
void	apply_only (const ConfigBase &other, const t_config_option_keys &keys, bool ignore_nonexistent=false)
std::string	opt_serialize (const t_config_option_key &opt_key) const
void	set (const std::string &opt_key, bool value, bool create=false)
void	set (const std::string &opt_key, int value, bool create=false)
void	set (const std::string &opt_key, double value, bool create=false)
void	set (const std::string &opt_key, const char *value, bool create=false)
void	set (const std::string &opt_key, const std::string &value, bool create=false)
bool	set_deserialize_nothrow (const t_config_option_key &opt_key_src, const std::string &value_src, ConfigSubstitutionContext &substitutions, bool append=false)
void	set_deserialize (const t_config_option_key &opt_key, const std::string &str, ConfigSubstitutionContext &config_substitutions, bool append=false)
void	set_deserialize (std::initializer_list< SetDeserializeItem > items, ConfigSubstitutionContext &substitutions)
void	set_deserialize_strict (const t_config_option_key &opt_key, const std::string &str, bool append=false)
void	set_deserialize_strict (std::initializer_list< SetDeserializeItem > items)
double	get_abs_value_at (const t_config_option_key &opt_key, size_t index) const
double	get_abs_value (const t_config_option_key &opt_key) const
double	get_abs_value (const t_config_option_key &opt_key, double ratio_over) const
void	setenv_ () const
ConfigSubstitutions	load (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load (const boost::property_tree::ptree &tree, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_string_map (std::map< std::string, std::string > &key_values, ForwardCompatibilitySubstitutionRule compatibility_rule)
int	load_from_json (const std::string &file, ConfigSubstitutionContext &substitutions, bool load_inherits_in_config, std::map< std::string, std::string > &key_values, std::string &reason)
ConfigSubstitutions	load_from_json (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule, std::map< std::string, std::string > &key_values, std::string &reason)
ConfigSubstitutions	load_from_ini (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_ini_string (const std::string &data, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_ini_string_commented (std::string &&data, ForwardCompatibilitySubstitutionRule compatibility_rule)
ConfigSubstitutions	load_from_gcode_file (const std::string &file, ForwardCompatibilitySubstitutionRule compatibility_rule)
void	save (const std::string &file) const
void	save_to_json (const std::string &file, const std::string &name, const std::string &from, const std::string &version) const
void	save_to_json (std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8=false) const
void	update_plugin_manifest ()
void	null_nullables ()
bool	has (const t_config_option_key &opt_key) const

Static Public Member Functions
static DynamicPrintConfig	full_print_config ()
static DynamicPrintConfig *	new_from_defaults_keys (const std::vector< std::string > &keys)
static size_t	load_from_gcode_string_legacy (ConfigBase &config, const char *str, ConfigSubstitutionContext &substitutions)
static void	set_resolve_capability_fn (std::function< std::string(std::string, std::string)> fn)

Private Member Functions
template<class Archive>
void	serialize (Archive &ar)

Private Attributes
std::map< t_config_option_key, std::unique_ptr< ConfigOption > >	options

Detailed Description

Constructor & Destructor Documentation

DynamicPrintConfig() [1/5]

Slic3r::DynamicPrintConfig::DynamicPrintConfig ( )

inline

{}

Referenced by Slic3r::DynamicPrintAndCLIConfig::DynamicPrintAndCLIConfig(), DynamicPrintConfig(), DynamicPrintConfig(), full_print_config(), new_from_defaults_keys(), operator=(), operator=(), update_diff_values_to_child_config(), update_filament_config_values_for_multiple_extruders(), update_non_diff_values_to_base_config(), update_values_from_multi_to_multi(), update_values_from_multi_to_multi_2(), update_values_from_single_to_multi(), update_values_to_printer_extruders(), and update_values_to_printer_extruders_for_multiple_filaments().

Here is the caller graph for this function:

DynamicPrintConfig() [2/5]

Slic3r::DynamicPrintConfig::DynamicPrintConfig ( const DynamicPrintConfig & rhs )

inline

: DynamicConfig(rhs) {}

References Slic3r::DynamicConfig::DynamicConfig(), and DynamicPrintConfig().

Here is the call graph for this function:

DynamicPrintConfig() [3/5]

Slic3r::DynamicPrintConfig::DynamicPrintConfig ( DynamicPrintConfig && rhs )

inlinenoexcept

: DynamicConfig(std::move(rhs)) {}

References DynamicPrintConfig().

Here is the call graph for this function:

DynamicPrintConfig() [4/5]

Slic3r::DynamicPrintConfig::DynamicPrintConfig ( const StaticPrintConfig & rhs )

explicit

                                                                   : DynamicConfig(rhs, rhs.keys_ref())
{
}

References Slic3r::DynamicConfig::DynamicConfig().

Here is the call graph for this function:

DynamicPrintConfig() [5/5]

Slic3r::DynamicPrintConfig::DynamicPrintConfig ( const ConfigBase & rhs )

inlineexplicit

: DynamicConfig(rhs) {}

References Slic3r::DynamicConfig::DynamicConfig().

Here is the call graph for this function:

Member Function Documentation

apply()

void Slic3r::ConfigBase::apply ( const ConfigBase & other, bool ignore_nonexistent = false )

inlineinherited

        { if (! other.apply_to(*this)) this->apply_only(other, other.keys(), ignore_nonexistent); }

References ConfigBase(), apply_only(), apply_to(), and keys().

Referenced by Slic3r::BackgroundSlicingProcess::apply(), Slic3r::GCodeProcessor::apply_config_superslicer(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::CalibUtils::calib_temptue(), Slic3r::GUI::CalibUtils::calib_VFA(), Slic3r::PresetBundle::config_from_gcode(), Slic3r::PresetBundle::construct_full_config(), Slic3r::GUI::SLAImportJob::finalize(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::PresetBundle::import_json_presets(), Slic3r::GUI::PartPlate::load_gcode_from_file(), Slic3r::PresetCollection::load_user_preset(), Slic3r::GCodeProcessor::process_file(), Slic3r::Preset::reload(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::CLI::run(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), Slic3r::GUI::PartPlateList::store_to_3mf_structure(), Slic3r::GUI::PlaterPresetComboBox::sync_colour_config(), Slic3r::GUI::PresetComboBox::update_ams_color(), Slic3r::GUI::ObjectSettings::update_config_values(), and Slic3r::update_static_print_config_from_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_only()

void Slic3r::ConfigBase::apply_only ( const ConfigBase & other, const t_config_option_keys & keys, bool ignore_nonexistent = false )

inherited

{
    // loop through options and apply them
    for (const t_config_option_key &opt_key : keys) {
        // Create a new option with default value for the key.
        // If the key is not in the parameter definition, or this ConfigBase is a static type and it does not support the parameter,
        // an exception is thrown if not ignore_nonexistent.
        ConfigOption *my_opt = this->option(opt_key, true);
        if (my_opt == nullptr) {
            // opt_key does not exist in this ConfigBase and it cannot be created, because it is not defined by this->def().
            // This is only possible if other is of DynamicConfig type.
            if (auto n = opt_key.find('#'); n != std::string::npos) {
                auto opt_key2 = opt_key.substr(0, n);
                auto my_opt2 = dynamic_cast<ConfigOptionVectorBase*>(this->option(opt_key2));
                auto other_opt = other.option(opt_key2);
                if (my_opt2 == nullptr && other_opt) {
                    my_opt2 = dynamic_cast<ConfigOptionVectorBase *>(this->option(opt_key2, true));
                    if (my_opt2->empty()) {
                        my_opt2->resize(1, other_opt);
                    }
                }   
                if (my_opt2) {
                    int index = std::atoi(opt_key.c_str() + n + 1);
                    if (other_opt)
                        my_opt2->set_at(other_opt, index, index);
                    continue;
                }
            }
            if (ignore_nonexistent)
                continue;
            throw UnknownOptionException(opt_key);
        }
    const ConfigOption *other_opt = other.option(opt_key);
    if (other_opt == nullptr) {
            // The key was not found in the source config, therefore it will not be initialized!
//      printf("Not found, therefore not initialized: %s\n", opt_key.c_str());
    } else
            my_opt->set(other_opt);
    }
}

References ConfigBase(), keys(), option(), and Slic3r::ConfigOption::set().

Referenced by apply(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::Preset::load_external_config(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::load_preset(), Slic3r::PresetCollection::load_user_preset(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::CLI::run(), Slic3r::PresetBundle::save_changes_for_preset(), Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_to()

virtual bool Slic3r::ConfigBase::apply_to ( ConfigBase & ) const

inlinevirtualinherited

{ return false; }

References ConfigBase().

Referenced by apply().

Here is the call graph for this function:

Here is the caller graph for this function:

cbegin()

std::map< t_config_option_key, std::unique_ptr< ConfigOption > >::const_iterator Slic3r::DynamicConfig::cbegin ( ) const

inlineinherited

{ return options.cbegin(); }

References options.

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::CacheDictionary::collect(), Slic3r::dynamic_config_iterate(), cereal::save(), and Slic3r::save_config().

Here is the caller graph for this function:

cend()

std::map< t_config_option_key, std::unique_ptr< ConfigOption > >::const_iterator Slic3r::DynamicConfig::cend ( ) const

inlineinherited

{ return options.cend(); }

References options.

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::CacheDictionary::collect(), Slic3r::dynamic_config_iterate(), cereal::save(), and Slic3r::save_config().

Here is the caller graph for this function:

clear()

void Slic3r::DynamicConfig::clear ( )

inlineinherited

    {
        this->options.clear();
    }

Referenced by cereal::load(), operator=(), operator=(), and Slic3r::read_config().

Here is the caller graph for this function:

def()

const ConfigDef * Slic3r::DynamicPrintConfig::def ( ) const

inlineoverridevirtual

Reimplemented from Slic3r::DynamicConfig.

{ return &print_config_def; }

References Slic3r::print_config_def.

Referenced by Slic3r::Search::SettingsIndex::append_options(), Slic3r::GUI::change_opt_value(), Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::get_full_label(), Slic3r::GUI::get_full_settings_hierarchy(), Slic3r::GUI::get_string_from_enum(), Slic3r::GUI::get_string_value(), Slic3r::PrintConfigDef::handle_legacy_composite(), update_filament_config_values_for_multiple_extruders(), Slic3r::GUI::Sidebar::update_presets(), update_values_from_multi_to_multi(), update_values_from_multi_to_multi_2(), update_values_from_single_to_multi(), update_values_to_printer_extruders(), and update_values_to_printer_extruders_for_multiple_filaments().

Here is the caller graph for this function:

diff() [1/2]

t_config_option_keys Slic3r::ConfigBase::diff ( const ConfigBase & other ) const

inherited

{
    t_config_option_keys diff;
    for (const t_config_option_key &opt_key : this->keys()) {
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt != *other_opt)
            diff.emplace_back(opt_key);
    }
    return diff;
}

References ConfigBase(), diff(), keys(), and option().

Referenced by diff().

Here is the call graph for this function:

Here is the caller graph for this function:

diff() [2/2]

t_config_option_keys Slic3r::DynamicConfig::diff ( const DynamicConfig & other ) const

inherited

{
    t_config_option_keys diff;
    dynamic_config_iterate(*this, other,
        [&diff](const t_config_option_key &key, const ConfigOption *l, const ConfigOption *r) {
            if (*l != *r)
                diff.emplace_back(key);
            // Continue iterating.
            return false;
        });
    return diff;
}

References DynamicConfig(), diff(), and Slic3r::dynamic_config_iterate().

Referenced by Slic3r::GUI::ObjectSettings::add_missed_options(), Slic3r::GUI::ConfigManipulation::apply(), diff(), Slic3r::PresetCollection::dirty_options(), Slic3r::PresetCollection::dirty_options_without_option_list(), Slic3r::PresetBundle::full_fff_config(), Slic3r::profile_print_params_same(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::CLI::run(), Slic3r::Preset::set_dirty(), and Slic3r::GUI::PartPlate::set_vase_mode_related_object_config().

Here is the call graph for this function:

Here is the caller graph for this function:

diff_report()

DynamicConfig::DynamicConfigDifference Slic3r::DynamicConfig::diff_report ( const DynamicConfig & rhs ) const

inherited

Computes the symmetric difference between this DynamicConfig (left) and another DynamicConfig (rhs).

Parameters

rhs	The right-hand side config to compare against.

Returns

DynamicConfigDifference report.

                                                                                              {
    DynamicConfig::DynamicConfigDifference result;
 
    std::set<t_config_option_key> all_keys;
 
    for (const auto& kvp : this->options) {
  all_keys.insert(kvp.first);
    }
    for (const auto& kvp : rhs.options) {
  all_keys.insert(kvp.first);
    }
 
    for (const auto& key : all_keys) {
  auto left_it = this->options.find(key);
  auto right_it = rhs.options.find(key);
 
  bool left_has = (left_it != this->options.end());
  bool right_has = (right_it != rhs.options.end());
 
  if (left_has && right_has) {
      if (*left_it->second != *right_it->second) {
    result.differences[key] = {
        left_it->second->serialize(),
        right_it->second->serialize()
    };
      }
  } else if (left_has) {
      result.differences[key] = {
    left_it->second->serialize(),
    std::nullopt
      };
  } else if (right_has) {
      result.differences[key] = {
    std::nullopt,
    right_it->second->serialize()
      };
  }
    }
    return result;
}

References DynamicConfig(), Slic3r::DynamicConfig::DynamicConfigDifference::differences, and options.

Here is the call graph for this function:

empty()

bool Slic3r::DynamicConfig::empty ( ) const

inlineinherited

{ return options.empty(); }

References options.

Referenced by Slic3r::extract_profile(), Slic3r::import_sla_archive(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::paste_settings_into_list(), Slic3r::CLI::run(), and Slic3r::GUI::Tab::sync_excluder().

Here is the caller graph for this function:

equal() [1/2]

t_config_option_keys Slic3r::ConfigBase::equal ( const ConfigBase & other ) const

inherited

{
    t_config_option_keys equal;
    for (const t_config_option_key &opt_key : this->keys()) {
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt == *other_opt)
            equal.emplace_back(opt_key);
    }
    return equal;
}

References ConfigBase(), equal(), keys(), and option().

Referenced by equal().

Here is the call graph for this function:

Here is the caller graph for this function:

equal() [2/2]

t_config_option_keys Slic3r::DynamicConfig::equal ( const DynamicConfig & other ) const

inherited

{
    t_config_option_keys equal;
    dynamic_config_iterate(*this, other,
        [&equal](const t_config_option_key &key, const ConfigOption *l, const ConfigOption *r) {
            if (*l == *r)
                equal.emplace_back(key);
            // Continue iterating.
            return false;
        });
    return equal;
}

References DynamicConfig(), Slic3r::dynamic_config_iterate(), and equal().

Referenced by equal().

Here is the call graph for this function:

Here is the caller graph for this function:

equals() [1/2]

bool Slic3r::ConfigBase::equals ( const ConfigBase & other, const std::set< std::string > * skipped_keys = nullptr ) const

inherited

{
    for (const t_config_option_key &opt_key : this->keys()) {
        if (skipped_keys && (skipped_keys->count(opt_key) != 0))
            continue;
        const ConfigOption *this_opt  = this->option(opt_key);
        const ConfigOption *other_opt = other.option(opt_key);
        if (this_opt != nullptr && other_opt != nullptr && *this_opt != *other_opt)
            return false;
    }
    return true;
}

References ConfigBase(), keys(), and option().

Here is the call graph for this function:

equals() [2/2]

bool Slic3r::DynamicConfig::equals ( const DynamicConfig & other, const std::set< std::string > * skipped_keys = nullptr ) const

inherited

{
    return ! dynamic_config_iterate(*this, other,
        [](const t_config_option_key & /* key */, const ConfigOption *l, const ConfigOption *r) { return *l != *r; },
        skipped_keys);
}

References DynamicConfig(), and Slic3r::dynamic_config_iterate().

Referenced by Slic3r::PresetCollection::is_dirty(), and Slic3r::GUI::GUI_App::reload_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

erase()

bool Slic3r::DynamicConfig::erase ( const t_config_option_key & opt_key )

inlineinherited

    {
        auto it = this->options.find(opt_key);
        if (it == this->options.end())
            return false;
        this->options.erase(it);
        return true;
    }

Referenced by Slic3r::PresetBundle::construct_full_config(), Slic3r::GUI::ExportConfigsDialog::earse_preset_fields_for_safe(), Slic3r::PresetBundle::full_config_secure(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::GUI::ExportPresetBundleDialog::InitExportData(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicPrintConfig::normalize_fdm_1(), Slic3r::PresetBundle::reload_local_bundle(), and Slic3r::CLI::run().

Here is the caller graph for this function:

full_print_config()

DynamicPrintConfig Slic3r::DynamicPrintConfig::full_print_config ( )

static

{
  return DynamicPrintConfig((const PrintRegionConfig&)FullPrintConfig::defaults());
}

References DynamicPrintConfig(), and Slic3r::PrintRegionConfig.

Here is the call graph for this function:

get_abs_value() [1/2]

double Slic3r::ConfigBase::get_abs_value ( const t_config_option_key & opt_key ) const

inherited

{
    // Get stored option value.
    const ConfigOption *raw_opt = this->option(opt_key);
    if (raw_opt == nullptr) {
      std::stringstream ss;
      ss << "You can't define an option that need " << opt_key << " without defining it!";
      throw std::runtime_error(ss.str());
    }
    assert(raw_opt != nullptr);
 
    if (raw_opt->type() == coFloat)
        return static_cast<const ConfigOptionFloat*>(raw_opt)->value;
    if (raw_opt->type() == coInt)
      return static_cast<const ConfigOptionInt *>(raw_opt)->value;
    if (raw_opt->type() == coBool)
      return static_cast<const ConfigOptionBool *>(raw_opt)->value ? 1 : 0;
 
    const ConfigOptionPercent *cast_opt = nullptr;
    if (raw_opt->type() == coFloatOrPercent) {
        auto cofop = static_cast<const ConfigOptionFloatOrPercent*>(raw_opt);
            if (cofop->value == 0 && boost::ends_with(opt_key, "_line_width")) {
                return this->get_abs_value("line_width");
            }
            if (!cofop->percent)
                return cofop->value;
            cast_opt = cofop;
    }
 
    if (raw_opt->type() == coPercent) {
      cast_opt = static_cast<const ConfigOptionPercent *>(raw_opt);
    }
 
    // Get option definition.
    const ConfigDef *def = this->def();
    if (def == nullptr)
        throw NoDefinitionException(opt_key);
    const ConfigOptionDef *opt_def = def->get(opt_key);
 
 
    assert(opt_def != nullptr);
    if (opt_def->ratio_over == "")
        return cast_opt->get_abs_value(1);
    // Compute absolute value over the absolute value of the base option.
    //FIXME there are some ratio_over chains, which end with empty ratio_with.
    // For example, XXX_extrusion_width parameters are not handled by get_abs_value correctly.
    return opt_def->ratio_over.empty() ? 0. :
        static_cast<const ConfigOptionFloatOrPercent*>(raw_opt)->get_abs_value(this->get_abs_value(opt_def->ratio_over));
    
 
    throw ConfigurationError("ConfigBase::get_abs_value(): Not a valid option type for get_abs_value()");
}

References Slic3r::coBool, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coPercent, def(), get_abs_value(), Slic3r::ConfigOptionPercent::get_abs_value(), option(), Slic3r::ConfigOptionDef::ratio_over, Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), get_abs_value(), get_abs_value(), Slic3r::GUI::GLGizmoBrimEars::get_brim_default_radius(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

get_abs_value() [2/2]

double Slic3r::ConfigBase::get_abs_value ( const t_config_option_key & opt_key, double ratio_over ) const

inherited

{
    // Get stored option value.
    const ConfigOption *raw_opt = this->option(opt_key);
    // Mirror the single-arg overload — assert() is a no-op under NDEBUG.
    if (raw_opt == nullptr)
        throw ConfigurationError("ConfigBase::get_abs_value(): \"" + opt_key + "\" is not defined");
    if (raw_opt->type() != coFloatOrPercent)
        throw ConfigurationError("ConfigBase::get_abs_value(): opt_key is not of coFloatOrPercent");
    // Compute absolute value.
    return static_cast<const ConfigOptionFloatOrPercent*>(raw_opt)->get_abs_value(ratio_over);
}

References Slic3r::coFloatOrPercent, get_abs_value(), option(), and Slic3r::ConfigOption::type().

Here is the call graph for this function:

get_abs_value_at()

double Slic3r::ConfigBase::get_abs_value_at ( const t_config_option_key & opt_key, size_t index ) const

inherited

{
    const ConfigOption *raw_opt = this->option(opt_key);
    assert(raw_opt != nullptr);
    if (raw_opt->type() == coFloats) {
        return static_cast<const ConfigOptionFloats*>(raw_opt)->get_at(index);
    }
    if (raw_opt->type() == coFloatsOrPercents) {
        const ConfigDef *def = this->def();
        if (def == nullptr) throw NoDefinitionException(opt_key);
        const ConfigOptionDef *opt_def = def->get(opt_key);
        assert(opt_def != nullptr);
 
        if (opt_def->ratio_over.empty()) {
            return 0;
        } else {
            const ConfigOption *ratio_opt = this->option(opt_def->ratio_over);
            assert(ratio_opt->type() == coFloats);
            const ConfigOptionFloats *ratio_values = static_cast<const ConfigOptionFloats *>(ratio_opt);
            return static_cast<const ConfigOptionFloatsOrPercents *>(raw_opt)->get_at(index).get_abs_value(ratio_values->get_at(index));
        }
    }
 
    throw ConfigurationError("ConfigBase::get_abs_value_at(): Not a valid option type for get_abs_value_at()");
}

References Slic3r::coFloats, Slic3r::coFloatsOrPercents, def(), Slic3r::ConfigOptionVector< double >::get_at(), option(), Slic3r::ConfigOptionDef::ratio_over, and Slic3r::ConfigOption::type().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_nozzle_volume_count()

int Slic3r::DynamicPrintConfig::get_extruder_nozzle_volume_count	(	int	extruder_count,
		std::vector< std::vector< NozzleVolumeType > > &	nozzle_volume_types ) const

{
    int count = extruder_count;
    auto opt_extruder_nozzle_stats = dynamic_cast<const ConfigOptionStrings*>(this->option("extruder_nozzle_stats"));
    nozzle_volume_types.resize(extruder_count, std::vector<NozzleVolumeType>{});
    if (opt_extruder_nozzle_stats && (int(opt_extruder_nozzle_stats->values.size()) == extruder_count)) {
        std::vector<std::map<NozzleVolumeType, int>> extruder_nozzle_counts = get_extruder_nozzle_stats(opt_extruder_nozzle_stats->values);
        count = 0;
        for (int i = 0; i < extruder_count; i++)
        {
            count += extruder_nozzle_counts[i].size();
            // std::map iteration order gives the canonical slot order: ascending NozzleVolumeType
            for (auto& iter : extruder_nozzle_counts[i])
                nozzle_volume_types[i].push_back(iter.first);
        }
    }
    return count;
}

References count, Slic3r::get_extruder_nozzle_stats(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionVector< T >::resize().

Referenced by Slic3r::PresetBundle::construct_full_config(), and Slic3r::PresetBundle::full_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_type() [1/2]

std::string Slic3r::DynamicPrintConfig::get_filament_type

(

)

const

{
    const ConfigOptionStrings* opt = dynamic_cast<const ConfigOptionStrings*> (option("filament_type"));
    if (opt && !opt->values.empty())
    {
        return opt->values[0];
    }
 
    return std::string();
}

References Slic3r::DynamicConfig::opt(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

get_filament_type() [2/2]

std::string Slic3r::DynamicPrintConfig::get_filament_type	(	std::string &	displayed_filament_type,
		int	id = 0 )

{
    auto* filament_id = dynamic_cast<const ConfigOptionStrings*>(this->option("filament_id"));
    auto* filament_type = dynamic_cast<const ConfigOptionStrings*>(this->option("filament_type"));
    auto* filament_is_support = dynamic_cast<const ConfigOptionBools*>(this->option("filament_is_support"));
 
    // get_at() on an empty vector option is undefined behavior (.front() of an empty vector),
    // and e.g. filament_id is never populated on a CLI from-scratch slice - treat an empty
    // option the same as a missing one.
    if (filament_id && filament_id->values.empty())
        filament_id = nullptr;
    if (filament_is_support && filament_is_support->values.empty())
        filament_is_support = nullptr;
 
    if (!filament_type || filament_type->values.empty())
        return "";
 
    if (!filament_is_support) {
        if (filament_type) {
            displayed_filament_type = filament_type->get_at(id);
            return filament_type->get_at(id);
        }
        else {
            displayed_filament_type = "";
            return "";
        }
    }
    else {
        bool is_support = filament_is_support ? filament_is_support->get_at(id) : false;
        if (is_support) {
            if (filament_id) {
                if (filament_id->get_at(id) == "GFS00") {
                    displayed_filament_type = "Sup.PLA";
                    return "PLA-S";
                }
                else if (filament_id->get_at(id) == "GFS01") {
                    displayed_filament_type = "Sup.PA";
                    return "PA-S";
                }
                else {
                    if (filament_type->get_at(id) == "PLA") {
                        displayed_filament_type = "Sup.PLA";
                        return "PLA-S";
                    }
                    else if (filament_type->get_at(id) == "PA") {
                        displayed_filament_type = "Sup.PA";
                        return "PA-S";
                    }
                    else {
                        displayed_filament_type = filament_type->get_at(id);
                        return filament_type->get_at(id);
                    }
                }
            }
            else {
                if (filament_type->get_at(id) == "PLA") {
                    displayed_filament_type = "Sup.PLA";
                    return "PLA-S";
                } else if (filament_type->get_at(id) == "PA") {
                    displayed_filament_type = "Sup.PA";
                    return "PA-S";
                } else {
                    displayed_filament_type = filament_type->get_at(id);
                    return filament_type->get_at(id);
                }
            }
        }
        else {
            displayed_filament_type = filament_type->get_at(id);
            return filament_type->get_at(id);
        }
    }
    return "PLA";
}

References Slic3r::filament_type(), Slic3r::is_support(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::_collect_filament_info(), Slic3r::GUI::Sidebar::collect_physical_filament_info(), Slic3r::GUI::Plater::export_3mf(), Slic3r::GUI::filament_type_for_color_decompose(), Slic3r::GUI::SyncAmsInfoDialog::generate_override_fix_ams_list(), Slic3r::PresetBundle::get_used_tpu_filaments(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::Plater::send_gcode_legacy(), and Slic3r::GUI::SendMultiMachinePage::sync_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

get_filament_vendor()

std::string Slic3r::DynamicPrintConfig::get_filament_vendor

(

)

const

{
    const ConfigOptionStrings* opt = dynamic_cast<const ConfigOptionStrings*> (option("filament_vendor"));
    if (opt && !opt->values.empty())
    {
        return opt->values[0];
    }
 
    return std::string();
}

References Slic3r::DynamicConfig::opt(), and Slic3r::ConfigBase::option().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_index_for_extruder()

int Slic3r::DynamicPrintConfig::get_index_for_extruder	(	int	extruder_or_filament_id,
		std::string	id_name,
		ExtruderType	extruder_type,
		NozzleVolumeType	nozzle_volume_type,
		std::string	variant_name,
		unsigned int	stride = 1 ) const

{
    int ret = -1;
 
    auto variant_opt = dynamic_cast<const ConfigOptionStrings*>(this->option(variant_name));
    const ConfigOptionInts* id_opt = id_name.empty()?nullptr: dynamic_cast<const ConfigOptionInts*>(this->option(id_name));
    const ConfigOptionStrings* extruder_variant_list_opt = dynamic_cast<const ConfigOptionStrings*>(this->option("extruder_variant_list"));
    auto generated_extruder_id = [extruder_variant_list_opt](int target_index) {
        if (!extruder_variant_list_opt)
            return 0;
 
        int variant_index = 0;
        for (int extruder_index = 0; extruder_index < int(extruder_variant_list_opt->values.size()); ++extruder_index) {
            std::vector<std::string> variants_list;
            boost::split(variants_list, extruder_variant_list_opt->get_at(extruder_index), boost::is_any_of(","), boost::token_compress_on);
            for (std::string variant : variants_list) {
                boost::trim(variant);
                if (variant.empty())
                    continue;
                if (variant_index == target_index)
                    return extruder_index + 1;
                ++variant_index;
            }
        }
        return 0;
    };
 
    if (variant_opt != nullptr) {
        int v_size = variant_opt->values.size();
        const bool has_complete_id_map = id_opt && int(id_opt->values.size()) >= v_size;
        // nvtHybrid not supported in presets, switch to nvtStandard to match the preset values
        if (nozzle_volume_type == nvtHybrid)
            nozzle_volume_type = nvtStandard;
        std::string extruder_variant = get_extruder_variant_string(extruder_type, nozzle_volume_type);
        for (int index = 0; index < v_size; index++)
        {
            const std::string variant = variant_opt->get_at(index);
            if (extruder_variant == variant) {
                if (id_opt) {
                    const int id = has_complete_id_map ? id_opt->get_at(index) : generated_extruder_id(index);
                    if (id == extruder_or_filament_id) {
                        ret = index * stride;
                        break;
                    }
                }
                else {
                    ret = index * stride;
                    break;
                }
 
            }
        }
    }
    return ret;
}

References Slic3r::ConfigOptionVector< T >::get_at(), Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_extruder_variant_string(), Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::ConfigBase::option(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::PresetBundle::get_filament_variant_index(), Slic3r::get_index_for_extruder_parameter(), update_filament_config_values_for_multiple_extruders(), update_values_to_printer_extruders(), and update_values_to_printer_extruders_for_multiple_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

get_parameter_size()

size_t Slic3r::DynamicPrintConfig::get_parameter_size	(	const std::string &	param_name,
		size_t	extruder_nums )

{
    constexpr size_t default_param_length = 1;
    size_t filament_variant_length = default_param_length;
    size_t process_variant_length = default_param_length;
    size_t machine_variant_length = default_param_length;
 
    if (this->has("filament_extruder_variant"))
        filament_variant_length = this->option<ConfigOptionStrings>("filament_extruder_variant")->size();
    if (this->has("print_extruder_variant"))
        process_variant_length = this->option<ConfigOptionStrings>("print_extruder_variant")->size();
    if (this->has("printer_extruder_variant"))
        machine_variant_length = this->option<ConfigOptionStrings>("printer_extruder_variant")->size();
 
    if (printer_options_with_variant_1.count(param_name) > 0) {
        return machine_variant_length;
    }
    else if (printer_options_with_variant_2.count(param_name) > 0) {
        return machine_variant_length * 2;
    }
    else if (filament_options_with_variant.count(param_name) > 0) {
        return filament_variant_length;
    }
    else if (print_options_with_variant.count(param_name) > 0) {
        return process_variant_length;
    }
    return extruder_nums;
}

References Slic3r::filament_options_with_variant, Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigBase::option(), Slic3r::print_options_with_variant, and Slic3r::printer_options_with_variant_2.

Referenced by Slic3r::extend_extruder_variant(), and set_num_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_legacy()

void Slic3r::DynamicPrintConfig::handle_legacy ( t_config_option_key & opt_key, std::string & value ) const

inlineoverridevirtual

Reimplemented from Slic3r::ConfigBase.

        { PrintConfigDef::handle_legacy(opt_key, value); }

References Slic3r::PrintConfigDef::handle_legacy().

Here is the call graph for this function:

handle_legacy_composite()

void Slic3r::DynamicPrintConfig::handle_legacy_composite ( )

inlineoverridevirtual

Reimplemented from Slic3r::ConfigBase.

        { PrintConfigDef::handle_legacy_composite(*this); }

References Slic3r::PrintConfigDef::handle_legacy_composite().

Here is the call graph for this function:

has()

bool Slic3r::ConfigOptionResolver::has ( const t_config_option_key & opt_key ) const

inlineinherited

{ return this->optptr(opt_key) != nullptr; }

References optptr().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::active_bed_exclude_volume_mode(), Slic3r::append_bed_exclude_volumes(), Slic3r::append_printer_bed_assets(), Slic3r::GUI::change_opt_value(), Slic3r::GUI::ConfigManipulation::check_adaptive_pressure_advance_model(), Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type(), Slic3r::GUI::ConfigManipulation::check_chamber_minimal_temperature(), Slic3r::GUI::ConfigManipulation::check_chamber_temperature(), Slic3r::GUI::ConfigManipulation::check_filament_max_volumetric_speed(), Slic3r::GUI::ConfigManipulation::check_nozzle_recommended_temperature_range(), Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_initial_layer_range(), Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_range(), Slic3r::config_value_or_none(), Slic3r::GUI::Bed3D::detect_type(), Slic3r::PresetCollection::dirty_options(), Slic3r::PresetCollection::dirty_options_without_option_list(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::extend_default_config_length(), Slic3r::extend_extruder_variant(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_formatted_tooltip_text(), Slic3r::get_instance_arrange_poly(), Slic3r::GUI::PartPlate::get_object_filament_extruders(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::DynamicPrintConfig::get_parameter_size(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::GUI::PartPlate::get_spiral_vase_mode(), Slic3r::GUI::ConfigManipulation::get_temperature_range(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::handle_legacy_project_loaded(), Slic3r::handle_legacy_sla(), Slic3r::has_bed_exclude_volumes(), Slic3r::PresetBundle::import_json_presets(), Slic3r::PresetCollection::is_dirty(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::GUI::ObjectList::load_shape_object(), Slic3r::PresetCollection::load_user_preset(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicPrintConfig::normalize_fdm_1(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::DynamicConfig::read_cli(), Slic3r::Preset::remove_invalid_keys(), Slic3r::GUI::PartPlate::render_logo(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::CLI::run(), Slic3r::GUI::PartPlate::set_bed_type(), Slic3r::set_filament_dev_options(), Slic3r::Model::setExtruderParams(), Slic3r::Model::setPrintSpeedTable(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::TabPrintPlate::update_custom_dirty(), Slic3r::GUI::TabPrintModel::update_model_config(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::Tab::validate_filament_temperature_pairs().

Here is the call graph for this function:

has_multi_variant_filament()

bool Slic3r::DynamicPrintConfig::has_multi_variant_filament

(

)

const

{
    auto variants  = dynamic_cast<const ConfigOptionStrings*>(this->option("filament_extruder_variant"));
    auto diameters = dynamic_cast<const ConfigOptionFloats*>(this->option("filament_diameter"));
    return variants && diameters && variants->size() > diameters->size();
}

References Slic3r::ConfigBase::option().

Referenced by Slic3r::PresetBundle::construct_full_config(), and Slic3r::PresetBundle::full_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

is_using_different_extruders()

bool Slic3r::DynamicPrintConfig::is_using_different_extruders

(

)

{
    bool ret = false;
 
    auto nozzle_diameters_opt = dynamic_cast<const ConfigOptionFloats*>(this->option("nozzle_diameter"));
    if (nozzle_diameters_opt != nullptr) {
        int size = nozzle_diameters_opt->size();
        if (size > 1) {
            auto extruder_type_opt = dynamic_cast<const ConfigOptionEnumsGeneric*>(this->option("extruder_type"));
            auto nozzle_volume_type_opt = dynamic_cast<const ConfigOptionEnumsGeneric*>(this->option("nozzle_volume_type"));
            if (extruder_type_opt && nozzle_volume_type_opt) {
                ExtruderType extruder_type = (ExtruderType)(extruder_type_opt->get_at(0));
                NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(nozzle_volume_type_opt->get_at(0));
                for (int index = 1; index < size; index++)
                {
                    ExtruderType extruder_type_1 = (ExtruderType)(extruder_type_opt->get_at(index));
                    NozzleVolumeType nozzle_volume_type_1 = (NozzleVolumeType)(nozzle_volume_type_opt->get_at(index));
                    if ((extruder_type_1 != extruder_type) || (nozzle_volume_type_1 != nozzle_volume_type)) {
                        ret = true;
                        break;
                    }
                }
            }
        }
    }
 
    return ret;
}

References Slic3r::nozzle_volume_type(), Slic3r::ConfigBase::option(), and Slic3r::DynamicConfig::size().

Here is the call graph for this function:

keys()

t_config_option_keys Slic3r::DynamicConfig::keys ( ) const

overridevirtualinherited

Implements Slic3r::ConfigBase.

{
    t_config_option_keys keys;
    keys.reserve(this->options.size());
    for (const auto &opt : this->options)
        keys.emplace_back(opt.first);
    return keys;
}

References keys(), opt(), and options.

Referenced by DynamicConfig(), DynamicConfig(), Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::GCode::append_full_config(), Slic3r::Search::SettingsIndex::append_options(), Slic3r::PlaceholderParser::apply_config(), Slic3r::PlaceholderParser::config_diff(), Slic3r::PresetBundle::config_from_gcode(), Slic3r::GUI::Plater::export_published_3mf(), Slic3r::extend_default_config_length(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::full_print_config_diffs(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::GUI::get_config_json(), keys(), Slic3r::Preset::load_external_config(), Slic3r::PresetCollection::load_preset(), Slic3r::PresetCollection::load_user_preset(), Slic3r::DynamicPrintConfig::new_from_defaults_keys(), Slic3r::GUI::ObjectList::paste_settings_into_list(), Slic3r::GCode::placeholder_parser_process(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::preset_templates(), Slic3r::prune_stale_plugin_overrides(), read_cli(), Slic3r::CLI::run(), Slic3r::GUI::Tab::sync_excluder(), Slic3r::GUI::ObjectTableSettings::update_config_values(), Slic3r::DynamicPrintConfig::update_diff_values_to_child_config(), Slic3r::DynamicPrintConfig::update_non_diff_values_to_base_config(), Slic3r::update_static_print_config_from_dynamic(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), and Slic3r::GUI::variant_keys().

Here is the call graph for this function:

Here is the caller graph for this function:

load() [1/2]

ConfigSubstitutions Slic3r::ConfigBase::load ( const boost::property_tree::ptree & tree, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    for (const boost::property_tree::ptree::value_type &v : tree) {
        try {
            t_config_option_key opt_key = v.first;
            this->set_deserialize(opt_key, v.second.get_value<std::string>(), substitutions_ctxt);
        } catch (UnknownOptionException & /* e */) {
            // ignore
        }
    }
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    this->handle_legacy_composite();
    return std::move(substitutions_ctxt.substitutions);
}

References handle_legacy_composite(), set_deserialize(), and Slic3r::ConfigSubstitutionContext::substitutions.

Here is the call graph for this function:

load() [2/2]

ConfigSubstitutions Slic3r::ConfigBase::load ( const std::string & file, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    std::map<std::string, std::string> key_values;
    if (is_gcode_file(file))
        return this->load_from_gcode_file(file, compatibility_rule);
    else if (is_json_file(file)) {
        std::string reason;
        return this->load_from_json(file, compatibility_rule, key_values, reason);
    }
    else {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "unsupported format for config file" << file;
        return ConfigSubstitutions();
        //return this->load_from_ini(file, compatibility_rule);
    }
}

References Slic3r::is_gcode_file(), Slic3r::is_json_file(), load_from_gcode_file(), and load_from_json().

Referenced by Slic3r::extract_profile(), Slic3r::import_sla_archive(), Slic3r::import_sla_archive(), load_from_ini(), and load_from_ini_string().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_gcode_file()

ConfigSubstitutions Slic3r::ConfigBase::load_from_gcode_file ( const std::string & file, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    // Read a 64k block from the end of the G-code.
  boost::nowide::ifstream ifs(file);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  before parse_file %1%") % file.c_str();
    // Look for Slic3r or OrcaSlicer header.
    // Look for the header across the whole file as the G-code may have been extended at the start by a post-processing script or the user.
    //BBS
    bool has_delimiters = true;
    {
        //BBS
        std::string bambuslicer_gcode_header = "; OrcaSlicer";
 
        std::string orcaslicer_gcode_header = std::string("; generated by ");
        orcaslicer_gcode_header += SLIC3R_APP_NAME;
 
        std::string header;
        bool        header_found = false;
        while (std::getline(ifs, header)) {
            // BBS
            const char* line_c = skip_whitespaces(header.c_str());
            if (std::toupper(*line_c) == 'N')
                line_c = skip_word(line_c);
            line_c = skip_whitespaces(line_c);
            // BBS
            if (strncmp(bambuslicer_gcode_header.c_str(), line_c, strlen(bambuslicer_gcode_header.c_str())) == 0 ||
                strncmp(orcaslicer_gcode_header.c_str(), line_c, strlen(orcaslicer_gcode_header.c_str())) == 0) {
                header_found = true;
                break;
            }
        }
        if (!header_found) {
            // TRN %1% is the application name.
            std::string error_message = format(_u8L("Not a G-code file generated by %1%."), SLIC3R_APP_FULL_NAME);
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << error_message;
            throw Slic3r::RuntimeError(error_message.c_str());
        }
    }
 
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    size_t                    key_value_pairs = 0;
 
    if (has_delimiters)
    {
        //BBS
        // PrusaSlicer starting with 2.4.0-alpha0 delimits the config section stored into G-code with
        // ; CONFIG_BLOCK_START
        // ...
        // ; CONFIG_BLOCK_END
        bool begin_found = false;
        bool end_found   = false;
        std::string line;
        while (std::getline(ifs, line))
            if (line.rfind("; CONFIG_BLOCK_START",0)==0) {
                begin_found = true;
                break;
            }
        if (!begin_found) {
            //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block closing tag \"; CONFIG_BLOCK_START\" not found when reading %1%", file);
            // TRN %1% is a tag in the G-code file that must not be translated.
            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_START"));
        }
        std::string key, value;
        while (std::getline(ifs, line)) {
            if (line.rfind("; CONFIG_BLOCK_END",0)==0) {
                end_found = true;
                break;
            }
            // line should be a valid key = value pair.
            auto pos = line.find('=');
            if (pos != std::string::npos && pos > 1 && line.front() == ';') {
                key   = line.substr(1, pos - 1);
                value = line.substr(pos + 1);
                boost::trim(key);
                boost::trim(value);
                try {
                    this->set_deserialize(key, value, substitutions_ctxt);
                    ++ key_value_pairs;
                } catch (UnknownOptionException & /* e */) {
                    // ignore
                }
            }
        }
        if (!end_found) {
            //BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Configuration block opening tag \"; CONFIG_BLOCK_END\" not found when reading %1%", file);
            throw Slic3r::RuntimeError(format(_u8L("Config tag \"%1%\" not found"), "; CONFIG_BLOCK_END"));
        }
    }
    else
    {
        auto                      header_end_pos = ifs.tellg();
        // Slicer older than 2.4.0-alpha0 do not emit any delimiter.
        // Try a heuristics reading the G-code from back.
        ifs.seekg(0, ifs.end);
        auto file_length = ifs.tellg();
      auto data_length = std::min<std::fstream::pos_type>(65535, file_length - header_end_pos);
      ifs.seekg(file_length - data_length, ifs.beg);
        std::vector<char> data(size_t(data_length) + 1, 0);
        ifs.read(data.data(), data_length);
        ifs.close();
        key_value_pairs = load_from_gcode_string_legacy(*this, data.data(), substitutions_ctxt);
    }
 
    if (key_value_pairs < 80) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << format("Suspiciously low number of configuration values extracted from %1%: %2%", file, key_value_pairs);
        throw Slic3r::RuntimeError(format(_u8L("Suspiciously low number of configuration values extracted from %1%: %2%"), file, key_value_pairs));
    }
 
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    this->handle_legacy_composite();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  finished to parse_file %1%") % file.c_str();
    return std::move(substitutions_ctxt.substitutions);
}

References _u8L, Slic3r::format(), handle_legacy_composite(), load_from_gcode_string_legacy(), set_deserialize(), Slic3r::skip_whitespaces(), Slic3r::skip_word(), SLIC3R_APP_FULL_NAME, and Slic3r::ConfigSubstitutionContext::substitutions.

Referenced by Slic3r::PresetBundle::config_from_gcode(), load(), and Slic3r::GCodeProcessor::process_file().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_gcode_string_legacy()

size_t Slic3r::ConfigBase::load_from_gcode_string_legacy ( ConfigBase & config, const char * str, ConfigSubstitutionContext & substitutions )

staticinherited

{
    if (str == nullptr)
        return 0;
 
    // BBS. Remove line numbers.
    std::regex match_pattern("\nN[0-9]* *");
    std::string replace_pattern = "\n";
    char* result = (char*)calloc(strlen(str) + 1, 1);
    std::regex_replace(result, str, str + strlen(str), match_pattern, replace_pattern);
 
    // Walk line by line in reverse until a non-configuration key appears.
    const char *data_start = result;
    data_start = skip_whitespaces(data_start);
    if (std::toupper(*data_start) == 'N')
        data_start = skip_word(data_start);
 
    // boost::nowide::ifstream seems to cook the text data somehow, so less then the 64k of characters may be retrieved.
    const char *end = data_start + strlen(data_start);
    size_t num_key_value_pairs = 0;
    for (;;) {
        // Extract next line.
        for (--end; end > data_start && (*end == '\r' || *end == '\n'); --end);
        if (end == data_start)
            break;
        const char *start = end ++;
        for (; start > data_start && *start != '\r' && *start != '\n'; --start);
        if (start == data_start)
            break;
        // Extracted a line from start to end. Extract the key = value pair.
        if (end - (++ start) < 10 || start[0] != ';' || start[1] != ' ')
            break;
        const char *key = start + 2;
        if (!((*key >= 'a' && *key <= 'z') || (*key >= 'A' && *key <= 'Z')))
            // A key must start with a letter.
            break;
        const char *sep = key;
        for (; sep != end && *sep != '='; ++ sep) ;
        if (sep == end || sep[-1] != ' ' || sep[1] != ' ')
            break;
        const char *value = sep + 2;
        if (value > end)
            break;
        const char *key_end = sep - 1;
        if (key_end - key < 3)
            break;
        // The key may contain letters, digits and underscores.
        for (const char *c = key; c != key_end; ++ c)
            if (!((*c >= 'a' && *c <= 'z') || (*c >= 'A' && *c <= 'Z') || (*c >= '0' && *c <= '9') || *c == '_')) {
                key = nullptr;
                break;
            }
        if (key == nullptr)
            break;
        try {
            config.set_deserialize(std::string(key, key_end), std::string(value, end), substitutions);
            ++num_key_value_pairs;
        }
        catch (UnknownOptionException & /* e */) {
            // ignore
        }
        end = start;
    }
 
    // Do legacy conversion on a completely loaded dictionary.
    // Perform composite conversions, for example merging multiple keys into one key.
    config.handle_legacy_composite();
 
    free(result);
    return num_key_value_pairs;
}

References ConfigBase(), handle_legacy_composite(), set_deserialize(), Slic3r::skip_whitespaces(), and Slic3r::skip_word().

Referenced by Slic3r::_3MF_Importer::_extract_print_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_print_config_from_archive(), load_from_gcode_file(), and Slic3r::load_from_superslicer_gcode_file().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_ini()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini ( const std::string & file, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    try {
        boost::property_tree::ptree tree;
        boost::nowide::ifstream ifs(file);
        boost::property_tree::read_ini(ifs, tree);
        return this->load(tree, compatibility_rule);
    } catch (const ConfigurationError &e) {
        throw ConfigurationError(format(_u8L("Failed loading configuration file \"%1%\": %2%"), file, e.what()));
    }
}

References _u8L, Slic3r::format(), and load().

Referenced by Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_ini_string()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini_string ( const std::string & data, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    boost::property_tree::ptree tree;
    std::istringstream iss(data);
    boost::property_tree::read_ini(iss, tree);
    return this->load(tree, compatibility_rule);
}

References load().

Referenced by Slic3r::GUI::Plater::priv::load_files(), and load_from_ini_string_commented().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_ini_string_commented()

ConfigSubstitutions Slic3r::ConfigBase::load_from_ini_string_commented ( std::string && data, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    // Convert the "data" string into INI format by removing the semi-colons at the start of a line.
    // Also the "; generated by PrusaSlicer ..." comment line will be removed.
    size_t j = 0;
    for (size_t i = 0; i < data.size();)
        if (i == 0 || data[i] == '\n') {
            // Start of a line.
            if (data[i] == '\n') {
                // Consume LF, don't keep empty lines.
                if (j > 0 && data[j - 1] != '\n')
                    data[j ++] = data[i];
                ++ i;
            }
            // Skip all leading spaces;
            for (; i < data.size() && (data[i] == ' ' || data[i] == '\t'); ++ i) ;
            // Skip the semicolon (comment indicator).
            if (i < data.size() && data[i] == ';')
                ++ i;
            // Skip all leading spaces after semicolon.
            for (; i < data.size() && (data[i] == ' ' || data[i] == '\t'); ++ i) ;
            if (strncmp(data.data() + i, "generated by ", 13) == 0) {
                // Skip the "; generated by ..." line.
                for (; i < data.size() && data[i] != '\n'; ++ i);
            }
        } else if (data[i] == '\r' && i + 1 < data.size() && data[i + 1] == '\n') {
            // Skip CR.
            ++ i;
        } else {
            // Consume the rest of the data.
            data[j ++] = data[i ++];
        }
    data.erase(data.begin() + j, data.end());
 
    return this->load_from_ini_string(data, compatibility_rule);
}

References load_from_ini_string().

Here is the call graph for this function:

load_from_json() [1/2]

int Slic3r::ConfigBase::load_from_json ( const std::string & file, ConfigSubstitutionContext & substitutions, bool load_inherits_in_config, std::map< std::string, std::string > & key_values, std::string & reason )

inherited

{
    json j;
    std::list<std::string> different_settings_append;
    std::string new_support_style;
    std::string is_infill_first;
    std::string get_wall_sequence;
    bool is_project_settings = false;
 
    CNumericLocalesSetter locales_setter;
 
    std::function<bool(const json::const_iterator&, const char,const char,const bool,std::string&)> parse_str_arr = [&parse_str_arr](const json::const_iterator& it, const char single_sep,const char array_sep,const bool escape_string_style,std::string& value_str)->bool {
        // must have consistent type name
        std::string consistent_type;
        for (auto iter = it.value().begin(); iter != it.value().end(); ++iter) {
            if (consistent_type.empty())
                consistent_type = iter.value().type_name();
            else {
                if (consistent_type != iter.value().type_name())
                    return false;
            }
        }
 
        bool first = true;
        for (auto iter = it.value().begin(); iter != it.value().end(); iter++) {
            if (iter.value().is_array()) {
                if (!first)
                    value_str += array_sep;
                else
                    first = false;
                bool success = parse_str_arr(iter, single_sep, array_sep,escape_string_style, value_str);
                if (!success)
                    return false;
            }
            else if (iter.value().is_string()) {
                if (!first)
                    value_str += single_sep;
                else
                    first = false;
                if (!escape_string_style)
                    value_str += iter.value();
                else {
                    value_str += "\"";
                    value_str += escape_string_cstyle(iter.value());
                    value_str += "\"";
                }
            }
            else {
                //should not happen
                return false;
            }
        }
        return true;
        };
 
    try {
        boost::nowide::ifstream ifs(file);
        ifs >> j;
        ifs.close();
 
        const ConfigDef* config_def = this->def();
        if (config_def == nullptr) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": no config defs!";
            return -1;
        }
        //parse the json elements
        for (auto it = j.begin(); it != j.end(); it++) {
            if (ascii_iequals(it.key(), BBL_JSON_KEY_VERSION)) {
                key_values.emplace(BBL_JSON_KEY_VERSION, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_IS_CUSTOM)) {
                //skip it
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_NAME)) {
                key_values.emplace(BBL_JSON_KEY_NAME, it.value());
                if (it.value() == "project_settings")
                    is_project_settings = true;
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_URL)) {
                key_values.emplace(BBL_JSON_KEY_URL, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_TYPE)) {
                key_values.emplace(BBL_JSON_KEY_TYPE, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_SETTING_ID)) {
                key_values.emplace(BBL_JSON_KEY_SETTING_ID, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_FILAMENT_ID)) {
                key_values.emplace(BBL_JSON_KEY_FILAMENT_ID, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_FROM)) {
                key_values.emplace(BBL_JSON_KEY_FROM, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_DESCRIPTION)) {
                key_values.emplace(BBL_JSON_KEY_DESCRIPTION, it.value());
            }
            else if (ascii_iequals(it.key(), BBL_JSON_KEY_INSTANTIATION)) {
                key_values.emplace(BBL_JSON_KEY_INSTANTIATION, it.value());
            }
            else if (!load_inherits_to_config && ascii_iequals(it.key(), BBL_JSON_KEY_INHERITS)) {
                key_values.emplace(BBL_JSON_KEY_INHERITS, it.value());
            }
            else if (!load_inherits_to_config && ascii_iequals(it.key(), BBL_JSON_KEY_INCLUDES)) {
                key_values.emplace(BBL_JSON_KEY_INCLUDES, it.value().dump());
            } else if (ascii_iequals(it.key(), ORCA_JSON_KEY_RENAMED_FROM)) {
                key_values.emplace(ORCA_JSON_KEY_RENAMED_FROM, it.value());
            } else {
                t_config_option_key opt_key = it.key();
                std::string value_str;
 
                if (it.value().is_string()) {
                    //bool test1 = (it.key() == std::string("end_gcode"));
                    this->set_deserialize(opt_key, it.value(), substitution_context);
                    //some logic for special values
                    if (opt_key == "support_type") {
                        //std::string new_value = dynamic_cast<ConfigOptionString*>(this->option(opt_key))->value;
                        if (it.value() == "hybrid(auto)") {
                            different_settings_append.push_back(opt_key);
                            different_settings_append.push_back("support_style");
                            new_support_style = "tree_hybrid";
                        }
                    } else if (opt_key == "wall_infill_order") {
                        //BBS: check wall_infill order to decide if it be different and append to diff_setting_append
                        if (it.value() == "outer wall/inner wall/infill" || it.value() == "infill/outer wall/inner wall" || it.value() == "inner-outer-inner wall/infill") {
                            get_wall_sequence = "wall_seq_diff_to_system";
                        }
 
                        if (it.value() == "infill/outer wall/inner wall" || it.value() == "infill/inner wall/outer wall") {
                            different_settings_append.push_back("is_infill_first");
                            is_infill_first = "true";
                        }
                    }
                }
                else if (it.value().is_array()) {
                    t_config_option_key opt_key_src = opt_key;
                    this->handle_legacy(opt_key, value_str);
                    if (opt_key.empty()) {
                        //BBS: record these options
                        substitution_context.unrecogized_keys.push_back(opt_key_src);
                        continue;
                    }
                    bool valid = true, first = true;
                    const ConfigOptionDef* optdef = config_def->get(opt_key);
                    if (optdef == nullptr) {
                        // If we didn't find an option, look for any other option having this as an alias.
                        for (const auto& opt : config_def->options) {
                            for (const t_config_option_key& opt_key2 : opt.second.aliases) {
                                if (opt_key2 == opt_key) {
                                    opt_key = opt.first;
                                    optdef = &opt.second;
                                    break;
                                }
                            }
                            if (optdef != nullptr)
                                break;
                        }
                    }
 
                    char single_sep = ',';
                    char array_sep = '#';  // currenty not used
                    bool escape_string_type = false;
                    if (optdef) {
                        switch (optdef->type)
                        {
                        case coStrings:
                            escape_string_type = true;
                            single_sep = ';';
                            break;
                        case coPointsGroups:
                            single_sep = '#';
                            break;
                        default:
                            break;
                        }
                    }
 
                    // BBS: we only support 2 depth array
                    valid = parse_str_arr(it, single_sep, array_sep,escape_string_type, value_str);
                    if (!valid) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": parse " << file << " error, invalid json array for " << it.key();
                        break;
                    }
                    if (valid)
                        this->set_deserialize(opt_key, value_str, substitution_context);
                }
                else {
                    //should not happen
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" error, invalid json type for " << it.key();
                }
            }
        }
        if (!different_settings_append.empty()) {
            if (!new_support_style.empty()) {
                ConfigOptionEnum<SupportMaterialStyle>* opt = this->option<ConfigOptionEnum<SupportMaterialStyle>>("support_style", true);
                opt->value = smsTreeHybrid;
            }
 
            if (!is_infill_first.empty()) {
                ConfigOptionBool *opt = this->option<ConfigOptionBool>("is_infill_first", true);
                opt->value = true;
            }
 
            if (is_project_settings) {
                std::vector<std::string>& different_settings = this->option<ConfigOptionStrings>("different_settings_to_system", true)->values;
                size_t size = different_settings.size();
                if (size == 0) {
                    const auto *filament_ids = this->option<ConfigOptionStrings>("filament_settings_id");
                    size = (filament_ids ? filament_ids->values.size() : 0) + 2;
                    different_settings.resize(size);
                }
 
                std::vector<bool> is_first(size, false);
                std::vector<std::vector<std::string>> original_diffs(size);
                for (int index = 0; index < size; index++)
                {
                    if (different_settings[index].empty()) {
                        is_first[index] = true;
                    }
                    else {
                        // remove unneeded key
                        if (get_wall_sequence.empty()) {
                            std::string wall_sqe_string = "wall_sequence";
                            int pos=different_settings[index].find(wall_sqe_string);
 
                            if (pos != different_settings[index].npos) {
                                int erase_len = wall_sqe_string.size();
                                if (pos + erase_len < different_settings[index].size() && different_settings[index][pos + erase_len] == ';')
                                    erase_len++;
                                different_settings[index].erase(pos, erase_len);
                            }
 
                        }
 
                        if (different_settings[index].empty()) {
                            is_first[index] = true;
                            continue;
                        }
 
                        Slic3r::unescape_strings_cstyle(different_settings[index], original_diffs[index]);
                    }
                }
 
                for (auto diff_key : different_settings_append)
                {
                    //get the index in the group
                    int index = 0;
                    bool need_insert = true;
                    if (diff_key == "support_type")
                        index = 0;
                    else if (diff_key == "support_style")
                        index = 0;
                    else if (diff_key == "is_infill_first")
                        index = 0;
 
                    //check whether exist firstly
                    if (!original_diffs[index].empty()) {
                        for (int j = 0; j < original_diffs[index].size(); j++) {
                            if (original_diffs[index][j] == diff_key) {
                                need_insert = false;
                                break;
                            }
                        }
                    }
                    if (!need_insert)
                        continue;
 
                    //insert this key
                    if (!is_first[index])
                        different_settings[index] += ";";
                    else
                        is_first[index] = false;
                    different_settings[index] += diff_key;
                }
            }
        }
        
        // Do legacy conversion on a completely loaded dictionary.
        // Perform composite conversions, for example merging multiple keys into one key.
        this->handle_legacy_composite();
        return 0;
    }
    catch (const std::ifstream::failure &err)  {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a ifstream error, reason = " << err.what();
        reason = std::string("ifstreamError: ") + err.what();
        //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file, e.what()));
    }
    catch(nlohmann::detail::parse_error &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a nlohmann::detail::parse_error, reason = " << err.what();
        reason = std::string("JsonParseError: ") + err.what();
        //throw ConfigurationError(format("Failed loading configuration file \"%1%\": %2%", file, err.what()));
    }
    catch(std::exception &err) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< ": parse "<<file<<" got a generic exception, reason = " << err.what();
        reason = std::string("std::exception: ") + err.what();
    }
    return -1;
}

References Slic3r::ascii_iequals(), BBL_JSON_KEY_DESCRIPTION, BBL_JSON_KEY_FILAMENT_ID, BBL_JSON_KEY_FROM, BBL_JSON_KEY_INCLUDES, BBL_JSON_KEY_INHERITS, BBL_JSON_KEY_INSTANTIATION, BBL_JSON_KEY_IS_CUSTOM, BBL_JSON_KEY_NAME, BBL_JSON_KEY_SETTING_ID, BBL_JSON_KEY_TYPE, BBL_JSON_KEY_URL, BBL_JSON_KEY_VERSION, Slic3r::coPointsGroups, Slic3r::coStrings, def(), Slic3r::empty(), Slic3r::escape_string_cstyle(), Slic3r::filament_ids(), Slic3r::ConfigDef::get(), handle_legacy(), handle_legacy_composite(), Slic3r::is_infill_first(), option(), Slic3r::ConfigDef::options, ORCA_JSON_KEY_RENAMED_FROM, set_deserialize(), Slic3r::smsTreeHybrid, Slic3r::ConfigOptionDef::type, Slic3r::unescape_strings_cstyle(), Slic3r::ConfigSubstitutionContext::unrecogized_keys, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive(), Slic3r::PresetBundle::import_json_presets(), load(), load_from_json(), Slic3r::PhysicalPrinterCollection::load_printers(), and Slic3r::PresetCollection::resolve_user_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

load_from_json() [2/2]

ConfigSubstitutions Slic3r::ConfigBase::load_from_json ( const std::string & file, ForwardCompatibilitySubstitutionRule compatibility_rule, std::map< std::string, std::string > & key_values, std::string & reason )

inherited

{
    int ret = 0;
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
 
    ret = load_from_json(file, substitutions_ctxt, true, key_values, reason);
    return std::move(substitutions_ctxt.substitutions);
}

References load_from_json(), and Slic3r::ConfigSubstitutionContext::substitutions.

Here is the call graph for this function:

load_string_map()

ConfigSubstitutions Slic3r::ConfigBase::load_string_map ( std::map< std::string, std::string > & key_values, ForwardCompatibilitySubstitutionRule compatibility_rule )

inherited

{
    CNumericLocalesSetter locales_setter;
 
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    std::map<std::string, std::string>::iterator it;
    for (it = key_values.begin(); it != key_values.end(); it++) {
        try {
            t_config_option_key opt_key = it->first;
            this->set_deserialize(opt_key, it->second, substitutions_ctxt);
        }
        catch (UnknownOptionException& /* e */) {
            // ignore
        }
    }
    return std::move(substitutions_ctxt.substitutions);
}

References set_deserialize(), and Slic3r::ConfigSubstitutionContext::substitutions.

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

Here is the call graph for this function:

Here is the caller graph for this function:

new_from_defaults_keys()

DynamicPrintConfig * Slic3r::DynamicPrintConfig::new_from_defaults_keys ( const std::vector< std::string > & keys )

static

{
    auto *out = new DynamicPrintConfig();
    out->apply_only(FullPrintConfig::defaults(), keys);
    return out;
}

References DynamicPrintConfig(), and Slic3r::DynamicConfig::keys().

Referenced by Slic3r::GUI::ConfigWizard::ConfigWizard(), Slic3r::GUI::ObjectList::add_category_to_settings_from_frequent(), Slic3r::GUI::ObjectList::add_category_to_settings_from_selection(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), and Slic3r::GUI::ObjectList::merge().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_fdm()

void Slic3r::DynamicPrintConfig::normalize_fdm

(

int

used_filaments = 0

)

{
    if (this->has("extruder")) {
        int extruder = this->option("extruder")->getInt();
        this->erase("extruder");
        if (extruder != 0) {
            if (!this->has("sparse_infill_filament_id") || this->option("sparse_infill_filament_id")->getInt() == 0)
                this->option("sparse_infill_filament_id", true)->setInt(extruder);
            if (!this->has("outer_wall_filament_id") || this->option("outer_wall_filament_id")->getInt() == 0)
                this->option("outer_wall_filament_id", true)->setInt(extruder);
            if (!this->has("inner_wall_filament_id") || this->option("inner_wall_filament_id")->getInt() == 0)
                this->option("inner_wall_filament_id", true)->setInt(extruder);
            if (!this->has("internal_solid_filament_id") || this->option("internal_solid_filament_id")->getInt() == 0)
                this->option("internal_solid_filament_id", true)->setInt(extruder);
            if (!this->has("top_surface_filament_id") || this->option("top_surface_filament_id")->getInt() == 0)
                this->option("top_surface_filament_id", true)->setInt(extruder);
            if (!this->has("bottom_surface_filament_id") || this->option("bottom_surface_filament_id")->getInt() == 0)
                this->option("bottom_surface_filament_id", true)->setInt(extruder);
            // Don't propagate the current extruder to support.
            // For non-soluble supports, the default "0" extruder means to use the active extruder,
            // for soluble supports one certainly does not want to set the extruder to non-soluble.
            // if (!this->has("support_filament"))
            //     this->option("support_filament", true)->setInt(extruder);
            // if (!this->has("support_interface_filament"))
            //     this->option("support_interface_filament", true)->setInt(extruder);
        }
    }
 
    if (this->has("sparse_infill_filament_id")) {
        int sparse_infill_filament_id = this->option("sparse_infill_filament_id")->getInt();
        if (sparse_infill_filament_id > 0 && (!this->has("internal_solid_filament_id") || this->option("internal_solid_filament_id")->getInt() == 0))
            this->option("internal_solid_filament_id", true)->setInt(sparse_infill_filament_id);
    }
 
    const int internal_solid = this->has("internal_solid_filament_id") ? this->option("internal_solid_filament_id")->getInt() : 0;
    const int top_surface    = this->has("top_surface_filament_id") ? this->option("top_surface_filament_id")->getInt() : 0;
    const int bottom_surface = this->has("bottom_surface_filament_id") ? this->option("bottom_surface_filament_id")->getInt() : 0;
 
    if (internal_solid == 0 && top_surface > 0)
        this->option("internal_solid_filament_id", true)->setInt(top_surface);
    if (internal_solid == 0 && bottom_surface > 0)
        this->option("internal_solid_filament_id", true)->setInt(bottom_surface);
    if (top_surface == 0 && internal_solid > 0)
        this->option("top_surface_filament_id", true)->setInt(internal_solid);
    if (bottom_surface == 0 && internal_solid > 0)
        this->option("bottom_surface_filament_id", true)->setInt(internal_solid);
 
    if (this->has("spiral_mode") && this->opt<ConfigOptionBool>("spiral_mode", true)->value) {
        {
            // this should be actually done only on the spiral layers instead of all
            auto* opt = this->opt<ConfigOptionBools>("retract_when_changing_layer", true);
            opt->values.assign(opt->values.size(), false);  // set all values to false
            // Disable retract on layer change also for filament overrides.
            auto* opt_n = this->opt<ConfigOptionBoolsNullable>("filament_retract_when_changing_layer", true);
            opt_n->values.assign(opt_n->values.size(), false);  // Set all values to false.
        }
        {
            this->opt<ConfigOptionInt>("wall_loops", true)->value       = 1;
            this->opt<ConfigOptionBool>("alternate_extra_wall", true)->value = false;
            this->opt<ConfigOptionInt>("top_shell_layers", true)->value = 0;
            this->opt<ConfigOptionPercent>("sparse_infill_density", true)->value = 0;
        }
    }
 
    if (auto *opt_gcode_resolution = this->opt<ConfigOptionFloat>("resolution", false); opt_gcode_resolution)
        // Resolution will be above 1um.
        opt_gcode_resolution->value = std::max(opt_gcode_resolution->value, 0.001);
 
    // BBS
    ConfigOptionBool* ept_opt = this->option<ConfigOptionBool>("enable_prime_tower");
    if (used_filaments > 0 && ept_opt != nullptr) {
        ConfigOptionBool* islh_opt = this->option<ConfigOptionBool>("independent_support_layer_height", true);
        //ConfigOptionBool* alh_opt = this->option<ConfigOptionBool>("adaptive_layer_height");
        ConfigOptionEnum<PrintSequence>* ps_opt = this->option<ConfigOptionEnum<PrintSequence>>("print_sequence");
 
        ConfigOptionEnum<TimelapseType>* timelapse_opt = this->option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
        bool is_smooth_timelapse = timelapse_opt != nullptr && timelapse_opt->value == TimelapseType::tlSmooth;
        if (!is_smooth_timelapse && (used_filaments == 1 || ps_opt->value == PrintSequence::ByObject)) {
            ept_opt->value = false;
        }
 
        if (ept_opt->value) {
            if (islh_opt)
                islh_opt->value = false;
            //if (alh_opt)
            //    alh_opt->value = false;
        }
        /* BBS: MusangKing - not sure if this is still valid, just comment it out cause "Independent support layer height" is re-opened.
        else {
            if (islh_opt)
                islh_opt->value = true;
        }
        */
    }
}

References Slic3r::ByObject, Slic3r::DynamicConfig::erase(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOption::setInt(), Slic3r::sparse_infill_filament_id(), Slic3r::tlSmooth, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::PrintObject::object_config_from_model_object().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_fdm_1()

void Slic3r::DynamicPrintConfig::normalize_fdm_1

(

)

{
    if (this->has("extruder")) {
        int extruder = this->option("extruder")->getInt();
        this->erase("extruder");
        if (extruder != 0) {
            if (!this->has("sparse_infill_filament_id") || this->option("sparse_infill_filament_id")->getInt() == 0)
                this->option("sparse_infill_filament_id", true)->setInt(extruder);
            if (!this->has("outer_wall_filament_id") || this->option("outer_wall_filament_id")->getInt() == 0)
                this->option("outer_wall_filament_id", true)->setInt(extruder);
            if (!this->has("inner_wall_filament_id") || this->option("inner_wall_filament_id")->getInt() == 0)
                this->option("inner_wall_filament_id", true)->setInt(extruder);
            if (!this->has("internal_solid_filament_id") || this->option("internal_solid_filament_id")->getInt() == 0)
                this->option("internal_solid_filament_id", true)->setInt(extruder);
            if (!this->has("top_surface_filament_id") || this->option("top_surface_filament_id")->getInt() == 0)
                this->option("top_surface_filament_id", true)->setInt(extruder);
            if (!this->has("bottom_surface_filament_id") || this->option("bottom_surface_filament_id")->getInt() == 0)
                this->option("bottom_surface_filament_id", true)->setInt(extruder);
            // Don't propagate the current extruder to support.
            // For non-soluble supports, the default "0" extruder means to use the active extruder,
            // for soluble supports one certainly does not want to set the extruder to non-soluble.
            // if (!this->has("support_filament"))
            //     this->option("support_filament", true)->setInt(extruder);
            // if (!this->has("support_interface_filament"))
            //     this->option("support_interface_filament", true)->setInt(extruder);
        }
    }
 
    if (this->has("sparse_infill_filament_id")) {
        int sparse_infill_filament_id = this->option("sparse_infill_filament_id")->getInt();
        if (sparse_infill_filament_id > 0 && (!this->has("internal_solid_filament_id") || this->option("internal_solid_filament_id")->getInt() == 0))
            this->option("internal_solid_filament_id", true)->setInt(sparse_infill_filament_id);
    }
 
    const int internal_solid = this->has("internal_solid_filament_id") ? this->option("internal_solid_filament_id")->getInt() : 0;
    const int top_surface    = this->has("top_surface_filament_id") ? this->option("top_surface_filament_id")->getInt() : 0;
    const int bottom_surface = this->has("bottom_surface_filament_id") ? this->option("bottom_surface_filament_id")->getInt() : 0;
 
    if (internal_solid == 0 && top_surface > 0)
        this->option("internal_solid_filament_id", true)->setInt(top_surface);
    if (internal_solid == 0 && bottom_surface > 0)
        this->option("internal_solid_filament_id", true)->setInt(bottom_surface);
    if (top_surface == 0 && internal_solid > 0)
        this->option("top_surface_filament_id", true)->setInt(internal_solid);
    if (bottom_surface == 0 && internal_solid > 0)
        this->option("bottom_surface_filament_id", true)->setInt(internal_solid);
 
    if (this->has("spiral_mode") && this->opt<ConfigOptionBool>("spiral_mode", true)->value) {
        {
            // this should be actually done only on the spiral layers instead of all
            auto* opt = this->opt<ConfigOptionBools>("retract_when_changing_layer", true);
            opt->values.assign(opt->values.size(), false);  // set all values to false
            // Disable retract on layer change also for filament overrides.
            auto* opt_n = this->opt<ConfigOptionBoolsNullable>("filament_retract_when_changing_layer", true);
            opt_n->values.assign(opt_n->values.size(), false);  // Set all values to false.
        }
        {
            this->opt<ConfigOptionInt>("wall_loops", true)->value       = 1;
            this->opt<ConfigOptionBool>("alternate_extra_wall", true)->value = false;
            this->opt<ConfigOptionInt>("top_shell_layers", true)->value = 0;
            this->opt<ConfigOptionPercent>("sparse_infill_density", true)->value = 0;
        }
    }
 
    if (auto *opt_gcode_resolution = this->opt<ConfigOptionFloat>("resolution", false); opt_gcode_resolution)
        // Resolution will be above 1um.
        opt_gcode_resolution->value = std::max(opt_gcode_resolution->value, 0.001);
 
    return;
}

References Slic3r::DynamicConfig::erase(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionResolver::has(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOption::setInt(), and Slic3r::sparse_infill_filament_id().

Referenced by Slic3r::Print::apply().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_fdm_2()

t_config_option_keys Slic3r::DynamicPrintConfig::normalize_fdm_2	(	int	num_objects,
		int	used_filaments = 0 )

{
    t_config_option_keys changed_keys;
    ConfigOptionBool* ept_opt = this->option<ConfigOptionBool>("enable_prime_tower");
    if (used_filaments > 0 && ept_opt != nullptr) {
        ConfigOptionBool* islh_opt = this->option<ConfigOptionBool>("independent_support_layer_height", true);
        //ConfigOptionBool* alh_opt = this->option<ConfigOptionBool>("adaptive_layer_height");
        ConfigOptionEnum<PrintSequence>* ps_opt = this->option<ConfigOptionEnum<PrintSequence>>("print_sequence");
 
        ConfigOptionEnum<TimelapseType>* timelapse_opt = this->option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
        bool is_smooth_timelapse = timelapse_opt != nullptr && timelapse_opt->value == TimelapseType::tlSmooth;
 
        ConfigOptionBool *enable_wrapping_opt = this->option<ConfigOptionBool>("enable_wrapping_detection");
        bool enable_wrapping = enable_wrapping_opt != nullptr && enable_wrapping_opt->value;
 
        bool has_mixed_filament = false;
        {
            auto *mixed_opt = this->option<ConfigOptionBools>("filament_is_mixed");
            if (mixed_opt)
                has_mixed_filament = has_any_mixed_filament(mixed_opt->values);
        }
        if (!is_smooth_timelapse && !enable_wrapping
            && (  (used_filaments == 1 && !has_mixed_filament)
                || (ps_opt->value == PrintSequence::ByObject && num_objects > 1))) {
            if (ept_opt->value) {
                ept_opt->value = false;
                changed_keys.push_back("enable_prime_tower");
            }
            //ept_opt->value = false;
        }
 
        if (ept_opt->value) {
            if (islh_opt) {
                if (islh_opt->value) {
                    islh_opt->value = false;
                    changed_keys.push_back("independent_support_layer_height");
                }
                //islh_opt->value = false;
            }
            //if (alh_opt) {
            //    if (alh_opt->value) {
            //        alh_opt->value = false;
            //        changed_keys.push_back("adaptive_layer_height");
            //    }
            //    //alh_opt->value = false;
            //}
        }
        /* BBS：MusangKing - use "global->support->Independent support layer height" widget to replace previous assignment
        else {
            if (islh_opt) {
                if (!islh_opt->value) {
                    islh_opt->value = true;
                    changed_keys.push_back("independent_support_layer_height");
                }
                //islh_opt->value = true;
            }
        }
        */
    }
 
    return changed_keys;
}

References Slic3r::ByObject, Slic3r::has_any_mixed_filament(), Slic3r::ConfigBase::option(), Slic3r::tlSmooth, and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::Print::apply().

Here is the call graph for this function:

Here is the caller graph for this function:

null_nullables()

void Slic3r::ConfigBase::null_nullables ( )

inherited

{
    for (const std::string &opt_key : this->keys()) {
        ConfigOption *opt = this->optptr(opt_key, false);
        assert(opt != nullptr);
        if (opt->nullable())
          opt->deserialize("nil", ForwardCompatibilitySubstitutionRule::Disable);
    }
}

References Slic3r::Disable, keys(), and optptr().

Here is the call graph for this function:

operator!=()

bool Slic3r::DynamicConfig::operator!= ( const DynamicConfig & rhs ) const

inlineinherited

{ return ! (*this == rhs); }

References DynamicConfig().

Here is the call graph for this function:

operator+=() [1/2]

DynamicConfig & Slic3r::DynamicConfig::operator+= ( const DynamicConfig & rhs )

inlineinherited

    {
        assert(this->def() == nullptr || this->def() == rhs.def());
        for (const auto &kvp : rhs.options) {
            auto it = this->options.find(kvp.first);
            if (it == this->options.end())
                this->options[kvp.first].reset(kvp.second->clone());
            else {
                assert(it->second->type() == kvp.second->type());
                if (it->second->type() == kvp.second->type())
                    *it->second = *kvp.second;
                else
                    it->second.reset(kvp.second->clone());
            }
        }
        return *this;
    }

References DynamicConfig(), def(), and options.

Here is the call graph for this function:

operator+=() [2/2]

DynamicConfig & Slic3r::DynamicConfig::operator+= ( DynamicConfig && rhs )

inlineinherited

    {
        assert(this->def() == nullptr || this->def() == rhs.def());
        for (auto &kvp : rhs.options) {
            auto it = this->options.find(kvp.first);
            if (it == this->options.end()) {
                this->options.insert(std::make_pair(kvp.first, std::move(kvp.second)));
            } else {
                assert(it->second->type() == kvp.second->type());
                it->second = std::move(kvp.second);
            }
        }
        rhs.options.clear();
        return *this;
    }

References DynamicConfig(), and def().

Here is the call graph for this function:

operator=() [1/2]

DynamicPrintConfig & Slic3r::DynamicPrintConfig::operator= ( const DynamicPrintConfig & rhs )

inline

{ DynamicConfig::operator=(rhs); return *this; }

References DynamicPrintConfig(), and Slic3r::DynamicConfig::operator=().

Here is the call graph for this function:

operator=() [2/2]

DynamicPrintConfig & Slic3r::DynamicPrintConfig::operator= ( DynamicPrintConfig && rhs )

inlinenoexcept

{ DynamicConfig::operator=(std::move(rhs)); return *this; }

References DynamicPrintConfig(), and Slic3r::DynamicConfig::operator=().

Here is the call graph for this function:

operator==()

bool Slic3r::DynamicConfig::operator== ( const DynamicConfig & rhs ) const

inherited

{
    auto it1     = this->options.begin();
    auto it1_end = this->options.end();
    auto it2     = rhs.options.begin();
    auto it2_end = rhs.options.end();
    for (; it1 != it1_end && it2 != it2_end; ++ it1, ++ it2)
    if (it1->first != it2->first || *it1->second != *it2->second)
      // key or value differ
      return false;
    return it1 == it1_end && it2 == it2_end;
}

References DynamicConfig(), and options.

Here is the call graph for this function:

opt() [1/2]

template<class T>

const T * Slic3r::DynamicConfig::opt ( const t_config_option_key & opt_key ) const

inlineinherited

        { return dynamic_cast<const T*>(this->option(opt_key)); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt() [2/2]

template<class T>

T * Slic3r::DynamicConfig::opt ( const t_config_option_key & opt_key, bool create = false )

inlineinherited

        { return dynamic_cast<T*>(this->option(opt_key, create)); }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::GUI::Sidebar::build_filament_ams_list(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::PrinterPresetCollection::default_preset_for(), Slic3r::GUI::PartPlateList::delete_plate(), Slic3r::GUI::Bed3D::detect_type(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::filament_color_hex(), Slic3r::GUI::filament_color_picker_value(), Slic3r::gcode_add_line_number(), Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::get_bed_shape(), Slic3r::DynamicPrintConfig::get_filament_type(), Slic3r::GUI::Materials::get_filament_type(), Slic3r::DynamicPrintConfig::get_filament_vendor(), Slic3r::GUI::Materials::get_filament_vendor(), Slic3r::GUI::Materials::get_material_type(), Slic3r::GUI::Materials::get_material_vendor(), Slic3r::get_real_skirt_dist(), Slic3r::GUI::get_string_value(), Slic3r::GUI::GLCanvas3D::get_wipe_tower_info(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::handle_legacy_sla(), Slic3r::has_bed_exclude_volumes(), Slic3r::GUI::GCodeViewer::init(), Slic3r::is_XL_printer(), keys(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::PublishSettingsDialog::make_mixed_visual_spec(), Slic3r::make_publish_universal(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_identity(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_blend_color(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_chip_bitmap(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_label(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_tab_bitmap(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_slot_components(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicPrintConfig::normalize_fdm_1(), optptr(), Slic3r::GUI::ArrangeJob::prepare_belt_regions(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::GCodeProcessor::process_file(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::ImexArrangeInput::read_config(), Slic3r::GUI::DesignCanvas::refresh_bed(), Slic3r::GUI::GCodeViewer::render_markers(), Slic3r::run_post_process_scripts(), Slic3r::GUI::set_arrange_polygon_bed_exclusion_extruders(), Slic3r::GUI::Plater::set_bed_shape(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), set_key_value(), Slic3r::DynamicPrintConfig::set_num_extruders(), Slic3r::DynamicPrintConfig::set_num_filaments(), Slic3r::GUI::sync_loaded_project_filament_config(), Slic3r::PresetUtils::system_printer_model(), Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_material(), Slic3r::DynamicPrintConfig::update_diff_values_to_child_config(), Slic3r::DynamicPrintConfig::update_non_diff_values_to_base_config(), Slic3r::GUI::DiffPresetDialog::update_tree(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), Slic3r::DynamicPrintConfig::update_values_from_single_to_multi(), Slic3r::DynamicPrintConfig::update_values_to_printer_extruders(), and Slic3r::DynamicPrintConfig::validate().

Here is the call graph for this function:

opt_bool() [1/2]

bool Slic3r::DynamicConfig::opt_bool ( const t_config_option_key & opt_key ) const

inlineinherited

{ return this->option<ConfigOptionBool>(opt_key)->value != 0; }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::GUI::PartPlate::get_spiral_vase_mode(), Slic3r::GUI::get_string_value(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::GUI::MenuFactory::load_handy_model(), Slic3r::GUI::CalibrateFilamentComboBox::load_tray(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::pad_combo_value_for_config(), Slic3r::GUI::ArrangeJob::prepare_belt_regions(), Slic3r::GUI::ArrangeJob::process(), Slic3r::GUI::FillBedJob::process(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::GUI::Sidebar::should_show_SEMM_buttons(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::GUI::support_combo_value_for_config(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::ConfigManipulation::toggle_print_sla_options(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_bool() [2/2]

bool Slic3r::DynamicConfig::opt_bool ( const t_config_option_key & opt_key, unsigned int idx ) const

inherited

                                                                                       {
    if (const ConfigOptionBools *opts = dynamic_cast<const ConfigOptionBools *>(this->option(opt_key))) {
        return opts->get_at(idx) != 0;
    }
    else {
        const ConfigOptionBoolsNullable *opt_s = dynamic_cast<const ConfigOptionBoolsNullable *>(this->option(opt_key));
        assert(opt_s != nullptr);
        return opt_s->get_at(idx) != 0;
    }
}

References Slic3r::ConfigOptionBoolsTempl< NULLABLE >::get_at(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_bool_nullable()

bool Slic3r::DynamicConfig::opt_bool_nullable ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionBoolsNullable*>(this->option(opt_key))->get_at(idx);}

References Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::ConfigManipulation::toggle_print_fff_options().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_enum() [1/2]

template<typename ENUM>

ENUM Slic3r::DynamicConfig::opt_enum ( const t_config_option_key & opt_key ) const

inlineinherited

{ return static_cast<ENUM>(this->option(opt_key)->getInt()); }

References Slic3r::ConfigOption::getInt(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::active_bed_exclude_volume_mode(), Slic3r::append_bed_exclude_volumes(), Slic3r::BackgroundSlicingProcess::apply(), Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type(), Slic3r::GUI::collect_imex_warnings(), Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::get_instance_arrange_poly(), Slic3r::GLVolumeCollection::get_selection_support_normal_z(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::has_bed_exclude_volumes(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::Plater::on_config_change(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::Plater::priv::on_select_bed_type(), Slic3r::GUI::ArrangeJob::prepare_belt_regions(), Slic3r::GUI::PartPlate::render_logo(), Slic3r::GUI::PartPlate::set_bed_type(), Slic3r::Model::setExtruderParams(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::TabPrintPlate::update_custom_dirty(), Slic3r::GUI::TabPrintModel::update_model_config(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_enum() [2/2]

int Slic3r::DynamicConfig::opt_enum ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionEnumsGeneric*>(this->option(opt_key))->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_enum_nullable()

int Slic3r::DynamicConfig::opt_enum_nullable ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionEnumsGenericNullable*>(this->option(opt_key))->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float() [1/4]

double & Slic3r::DynamicConfig::opt_float ( const t_config_option_key & opt_key )

inlineinherited

{ return this->option<ConfigOptionFloat>(opt_key)->value; }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::change_opt_value(), Slic3r::GUI::ConfigManipulation::check_filament_max_volumetric_speed(), Slic3r::GUI::ConfigManipulation::check_layer_height(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::get_max_layer_height(), Slic3r::GUI::get_min_layer_height(), Slic3r::get_real_skirt_dist(), Slic3r::GUI::get_string_value(), Slic3r::Slicing::max_layer_height_from_nozzle(), Slic3r::Slicing::min_layer_height_from_nozzle(), Slic3r::GUI::GLCanvas3D::CenterOfMass::model_markers(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower(), Slic3r::GUI::ArrangeJob::prepare_belt_regions(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::ImexArrangeInput::read_config(), Slic3r::CLI::run(), Slic3r::GUI::Selection::scale_to_fit_print_volume(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::ConfigManipulation::update_print_sla_config().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_float() [2/4]

const double & Slic3r::DynamicConfig::opt_float ( const t_config_option_key & opt_key ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionFloat*>(this->option(opt_key))->value; }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float() [3/4]

double & Slic3r::DynamicConfig::opt_float ( const t_config_option_key & opt_key, unsigned int idx )

inherited

{
    if (ConfigOptionFloats *opt_floats = dynamic_cast<ConfigOptionFloats *>(this->option(opt_key))) {
        return opt_floats->get_at(idx);
    } else {
        ConfigOptionFloatsNullable *opt_floats_nullable = dynamic_cast<ConfigOptionFloatsNullable *>(this->option(opt_key));
        assert(opt_floats_nullable != nullptr);
        return opt_floats_nullable->get_at(idx);
    }
}

References Slic3r::ConfigOptionVector< double >::get_at(), and Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float() [4/4]

const double & Slic3r::DynamicConfig::opt_float ( const t_config_option_key & opt_key, unsigned int idx ) const

inherited

{
    if (const ConfigOptionFloats *opt_floats = dynamic_cast<const ConfigOptionFloats *>(this->option(opt_key))) {
        return opt_floats->get_at(idx);
    } else if (const ConfigOptionFloatsNullable *opt_floats_nullable = dynamic_cast<const ConfigOptionFloatsNullable *>(this->option(opt_key))) {
        return opt_floats_nullable->get_at(idx);
    } else {
        assert(false);
        static const double zero = 0.0;
        return zero;
    }
}

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float_nullable() [1/2]

double & Slic3r::DynamicConfig::opt_float_nullable ( const t_config_option_key & opt_key, unsigned int idx )

inlineinherited

{ return this->option<ConfigOptionFloatsNullable>(opt_key)->get_at(idx); }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::Model::setPrintSpeedTable(), and Slic3r::GUI::ConfigManipulation::toggle_print_fff_options().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_float_nullable() [2/2]

const double & Slic3r::DynamicConfig::opt_float_nullable ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionFloatsNullable *>(this->option(opt_key))->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float_or_percent_nullable() [1/2]

FloatOrPercent & Slic3r::DynamicConfig::opt_float_or_percent_nullable ( const t_config_option_key & opt_key, unsigned int idx )

inlineinherited

{ return this->option<ConfigOptionFloatsOrPercentsNullable>(opt_key)->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_float_or_percent_nullable() [2/2]

const FloatOrPercent & Slic3r::DynamicConfig::opt_float_or_percent_nullable ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionFloatsOrPercentsNullable *>(this->option(opt_key))->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_int() [1/4]

int & Slic3r::DynamicConfig::opt_int ( const t_config_option_key & opt_key )

inlineinherited

{ return this->option<ConfigOptionInt>(opt_key)->value; }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_initial_layer_range(), Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_range(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::get_instance_arrange_poly(), Slic3r::GUI::PartPlate::get_object_filament_extruders(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::get_real_skirt_dist(), Slic3r::GLVolumeCollection::get_selection_support_normal_z(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::GUI::get_string_value(), Slic3r::GUI::ConfigManipulation::get_temperature_range(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots(), Slic3r::Model::setExtruderParams(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_int() [2/4]

int Slic3r::DynamicConfig::opt_int ( const t_config_option_key & opt_key ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionInt*>(this->option(opt_key))->value; }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_int() [3/4]

int & Slic3r::DynamicConfig::opt_int ( const t_config_option_key & opt_key, unsigned int idx )

inlineinherited

{ return this->option<ConfigOptionInts>(opt_key)->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_int() [4/4]

int Slic3r::DynamicConfig::opt_int ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionInts*>(this->option(opt_key))->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_int_nullable() [1/2]

int & Slic3r::DynamicConfig::opt_int_nullable ( const t_config_option_key & opt_key, unsigned int idx )

inlineinherited

{ return this->option<ConfigOptionIntsNullable>(opt_key)->get_at(idx);}

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_int_nullable() [2/2]

const int & Slic3r::DynamicConfig::opt_int_nullable ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return dynamic_cast<const ConfigOptionIntsNullable*>(this->option(opt_key))->get_at(idx);}

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_serialize()

std::string Slic3r::ConfigBase::opt_serialize ( const t_config_option_key & opt_key ) const

inherited

{
    const ConfigOption* opt = this->option(opt_key);
    assert(opt != nullptr);
    return opt->serialize();
}

References option().

Referenced by Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::GCode::_do_export(), Slic3r::GCode::append_full_config(), Slic3r::config_value_or_none(), Slic3r::GUI::Plater::export_published_3mf(), and save().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_string() [1/4]

const std::string & Slic3r::DynamicConfig::opt_string ( const t_config_option_key & opt_key ) const

inlineinherited

{ return const_cast<DynamicConfig*>(this)->opt_string(opt_key); }

References DynamicConfig(), and opt_string().

Referenced by opt_string().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_string() [2/4]

std::string & Slic3r::DynamicConfig::opt_string ( const t_config_option_key & opt_key, bool create = false )

inlineinherited

{ return this->option<ConfigOptionString>(opt_key, create)->value; }

References Slic3r::ConfigBase::option().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive(), Slic3r::GUI::PresetComboBox::add_connected_printers(), Slic3r::append_printer_bed_assets(), Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), Slic3r::anonymous_namespace{SnapmakerPrinterAgent.cpp}::find_closest_color_preset_by_vendor_and_type(), Slic3r::GUI::Plater::force_filament_colors_update(), Slic3r::GUI::gcode(), Slic3r::GUI::PresetComboBox::get_bmp(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::PresetBundle::get_custom_vendor_models(), Slic3r::ElegooLink::get_print_host_webui(), Slic3r::PrintHost::get_print_host_webui(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::PresetBundle::get_similar_printer_preset(), Slic3r::GUI::get_string_value(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::GUI::ObjectTablePanel::init_filaments_and_colors(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::PhysicalPrinterCollection::load_printers_from_presets(), Slic3r::PresetBundle::load_selections(), Slic3r::GUI::CalibrateFilamentComboBox::load_tray(), Slic3r::anonymous_namespace{ElegooLink.cpp}::lookup_cc2_serial(), Slic3r::PrintBase::output_filename(), Slic3r::anonymous_namespace{PresetBundle.cpp}::printer_kept_bed_paths(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::CLI::run(), Slic3r::GUI::GUI_App::select_machine(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets(), Slic3r::Model::setExtruderParams(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_all_printers(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::GUI::Sidebar::priv::switch_diameter_to(), Slic3r::GUI::GUI_App::switch_printer_agent(), Slic3r::GUI::TabSLAMaterial::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::Tab::update_preset_description_line(), Slic3r::GUI::Sidebar::update_presets(), and Slic3r::GUI::Sidebar::update_printer_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_string() [3/4]

std::string & Slic3r::DynamicConfig::opt_string ( const t_config_option_key & opt_key, unsigned int idx )

inlineinherited

{ return this->option<ConfigOptionStrings>(opt_key)->get_at(idx); }

References Slic3r::ConfigBase::option().

Here is the call graph for this function:

opt_string() [4/4]

const std::string & Slic3r::DynamicConfig::opt_string ( const t_config_option_key & opt_key, unsigned int idx ) const

inlineinherited

{ return const_cast<DynamicConfig*>(this)->opt_string(opt_key, idx); }

References DynamicConfig(), and opt_string().

Referenced by opt_string().

Here is the call graph for this function:

Here is the caller graph for this function:

option() [1/2]

const ConfigOption * Slic3r::ConfigOptionResolver::option ( const t_config_option_key & opt_key ) const

inlineinherited

{ return this->optptr(opt_key); }

option() [2/2]

ConfigOption * Slic3r::ConfigBase::option ( const t_config_option_key & opt_key, bool create = false )

inlineinherited

        { return this->optptr(opt_key, create); }

References optptr().

Referenced by Slic3r::DynamicConfig::DynamicConfig(), Slic3r::Flashforge::Flashforge(), Slic3r::_BBS_3MF_Exporter::_add_model_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_config_from_archive(), Slic3r::_BBS_3MF_Importer::_extract_project_embedded_presets_from_archive(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), Slic3r::active_capability_config(), Slic3r::GUI::PresetComboBox::add_ams_filaments(), Slic3r::GUI::ObjectList::add_category_to_settings_from_frequent(), Slic3r::GUI::ObjectList::add_category_to_settings_from_selection(), Slic3r::add_correct_opts_to_diff(), Slic3r::GUI::ObjectSettings::add_missed_options(), Slic3r::GUI::ObjectTableSettings::add_missed_options(), Slic3r::append_bed_exclude_volumes(), Slic3r::GCode::append_full_config(), Slic3r::GUI::MenuFactory::append_menu_items_flush_options(), Slic3r::Search::SettingsIndex::append_options(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GUI::ConfigManipulation::apply(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GCodeProcessor::apply_config(), Slic3r::GUI::ConfigWizard::priv::apply_config(), Slic3r::PlaceholderParser::apply_config(), Slic3r::apply_first_layer_order(), Slic3r::GUI::ConfigManipulation::apply_null_fff_config(), apply_only(), Slic3r::PlaceholderParser::apply_only(), Slic3r::GUI::GLCanvas3D::WipeTowerInfo::apply_wipe_tower(), Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), Slic3r::GUI::PartPlate::belt_open_y(), Slic3r::GUI::PartPlate::build_imex_cache_key(), Slic3r::GUI::SelectMachineDialog::build_nozzles_info(), Slic3r::GUI::SyncAmsInfoDialog::build_nozzles_info(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), Slic3r::GUI::build_plate_tilt_up_direction(), Slic3r::GUI::TabPrinter::cache_extruder_cnt(), Slic3r::GUI::PartPlate::calc_imex_zones(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::cfg_bool(), Slic3r::cfg_float(), Slic3r::Search::change_opt_key(), Slic3r::GUI::change_opt_value(), Slic3r::GUI::ConfigManipulation::check_adaptive_pressure_advance_model(), Slic3r::GUI::Plater::priv::check_ams_status_impl(), Slic3r::GUI::ConfigManipulation::check_chamber_minimal_temperature(), Slic3r::GUI::ConfigManipulation::check_chamber_temperature(), Slic3r::GUI::ConfigManipulation::check_filament_ironing_spacing(), Slic3r::check_filaments_printable(), Slic3r::GUI::ConfigManipulation::check_nozzle_recommended_temperature_range(), Slic3r::PresetBundle::check_preset_references(), Slic3r::GUI::collect_imex_warnings(), collect_plugin_manifest(), Slic3r::Preset::compatible_printers_condition(), Slic3r::Preset::compatible_prints_condition(), Slic3r::compute_filament_override_value(), Slic3r::compute_imex_zone_layout(), Slic3r::PresetBundle::config_from_gcode(), Slic3r::GUI::construct_extruder_unprintable_error(), Slic3r::PresetBundle::construct_full_config(), Slic3r::GUI::ObjectGridTable::construct_object_configs(), Slic3r::GUI::CreateFilamentPresetDialog::create_filament_preset_item(), Slic3r::GUI::GLGizmoRotate3D::data_changed(), Slic3r::deep_diff(), Slic3r::GUI::Bed3D::detect_type(), diff(), Slic3r::GUI::GLCanvas3D::do_move(), Slic3r::effective_physical_extruder_map(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::ensure_process_variant_columns(), equal(), equals(), Slic3r::GUI::Plater::export_3mf(), Slic3r::extend_default_config_length(), Slic3r::extend_extruder_variant(), Slic3r::WipeTower2::extract_wipe_volumes(), Slic3r::GUI::extruder_supports_tpu_high_flow(), Slic3r::GUI::GUI_App::extruders_cnt(), Slic3r::GUI::GUI_App::extruders_edited_cnt(), Slic3r::filter_published_config(), Slic3r::find_fixed_mixed_filament(), Slic3r::find_imex_mode(), Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::PresetBundle::full_fff_config(), Slic3r::full_print_config_diffs(), Slic3r::PresetBundle::full_sla_config(), Slic3r::GUI::SyncAmsInfoDialog::generate_override_fix_ams_list(), Slic3r::GUI::CreatePrinterPresetDialog::generate_process_presets_data(), get_abs_value(), get_abs_value(), get_abs_value_at(), Slic3r::GUI::NewCalibrationHistoryDialog::get_all_filaments(), Slic3r::GUI::ExtrusionCalibration::get_bed_temp(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::GUI::get_config_json(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::ModelObject::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::Plater::get_enable_wrapping_detection(), Slic3r::DynamicPrintConfig::get_extruder_nozzle_volume_count(), Slic3r::get_extruder_supported_nozzle_volume_types(), Slic3r::GUI::Tab::get_extruder_sync_enable_state(), Slic3r::GUI::PartPlate::get_extruders(), Slic3r::GUI::PartPlate::get_extruders_under_cli(), Slic3r::GUI::get_filament_compatible_printer(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_preset_choices(), Slic3r::GUI::CreateFilamentPresetDialog::get_filament_presets_by_machine(), Slic3r::PresetBundle::get_filament_presets_for_machine(), Slic3r::DynamicPrintConfig::get_filament_type(), Slic3r::DynamicPrintConfig::get_filament_type(), Slic3r::PresetBundle::get_filament_variant_index(), Slic3r::DynamicPrintConfig::get_filament_vendor(), Slic3r::GUI::get_flow_ratio(), Slic3r::GUI::get_formatted_tooltip_text(), Slic3r::GUI::get_full_label(), Slic3r::DynamicPrintConfig::get_index_for_extruder(), Slic3r::get_instance_arrange_poly(), Slic3r::GUI::get_min_flush_volumes(), Slic3r::GUI::PartPlate::get_object_filament_extruders(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::DynamicPrintConfig::get_parameter_size(), Slic3r::GUI::PartPlate::get_physical_extruder_by_filament_id(), Slic3r::GUI::PartPlate::get_plate_wrapping_detection_area(), Slic3r::PresetCollection::get_preset_differed_for_save(), Slic3r::GUI::get_preset_info(), Slic3r::PrintHost::get_print_host(), Slic3r::PrintHost::get_print_host_webui(), Slic3r::PresetBundle::get_printer_extruder_count(), get_printer_technology(), Slic3r::anonymous_namespace{SL1.cpp}::get_raster_params(), Slic3r::GUI::PartPlate::get_real_filament_map_mode(), Slic3r::GUI::PartPlate::get_real_filament_maps(), Slic3r::GUI::PartPlate::get_real_filament_volume_maps(), Slic3r::get_real_skirt_dist(), Slic3r::GUI::Plater::get_selected_printer_name_in_combox(), Slic3r::GUI::GLGizmoFdmSupports::get_selection_support_threshold_angle(), Slic3r::anonymous_namespace{SL1.cpp}::get_slice_params(), Slic3r::GUI::get_string_from_enum(), Slic3r::GUI::get_string_value(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::GUI::CreatePresetForPrinterDialog::get_visible_printer_and_compatible_filament_presets(), Slic3r::GUI::ObjectGridTable::get_volume_config_value(), Slic3r::GUI::getExtruderNozzleCount(), Slic3r::GUI::getExtruderNozzleCountTotal(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::handle_legacy_project_loaded(), Slic3r::PresetBundle::has_errors(), Slic3r::GUI::PartPlate::has_imex_multimaterial_conflict(), Slic3r::DynamicPrintConfig::has_multi_variant_filament(), Slic3r::has_skirt(), Slic3r::imex_cfg_bool(), Slic3r::imex_cfg_enum(), Slic3r::imex_cfg_float(), Slic3r::imex_cfg_int(), Slic3r::imex_mode_table(), Slic3r::GUI::PartPlate::imex_wipe_tower_hull(), Slic3r::PresetBundle::import_json_presets(), Slic3r::Preset::inherits(), Slic3r::GUI::ObjectTablePanel::init_filaments_and_colors(), Slic3r::GUI::init_multi_extruder_params_for_cali(), Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook(), Slic3r::is_compatible_with_parent_printer(), Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::is_compatible_with_printer(), Slic3r::GUI::CalibrationPresetPage::is_filament_in_blacklist(), Slic3r::is_printable_filament_changed(), Slic3r::GUI::is_soluble_filament(), Slic3r::GUI::is_support_filament(), Slic3r::DynamicPrintConfig::is_using_different_extruders(), Slic3r::StaticConfig::keys(), legacy_bed_exclude_area_points(), Slic3r::GUI::MainFrame::load_config(), Slic3r::GUI::Tab::load_config(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::GUI::Tab::load_current_preset(), load_default_gcodes_to_config(), Slic3r::PresetCollection::load_external_preset(), Slic3r::GUI::Plater::priv::load_files(), load_from_json(), Slic3r::GUI::MenuFactory::load_handy_model(), Slic3r::load_mixed_filament_settings(), Slic3r::PresetCollection::load_project_embedded_presets(), Slic3r::PresetBundle::load_selections(), Slic3r::GUI::ObjectList::load_shape_object(), Slic3r::PresetCollection::load_user_preset(), Slic3r::GCodeThumbnails::make_and_check_thumbnail_list(), Slic3r::GUI::manuallySetNozzleCount(), Slic3r::GUI::IMEXModesCtrl::matches_config(), Slic3r::min_object_distance(), Slic3r::GUI::mixed_gradient_curve(), Slic3r::GUI::mixed_gradient_ramp(), Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::mixed_slot_signature(), Slic3r::normalize_compatible_field(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicPrintConfig::normalize_fdm_1(), Slic3r::DynamicPrintConfig::normalize_fdm_2(), Slic3r::normalize_filament_values_to_variants(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::Plater::on_filament_change(), Slic3r::GUI::TabPrinter::on_preset_loaded(), Slic3r::GUI::CalibrationPresetPage::on_recommend_input_value(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::AMSMaterialsSetting::on_select_filament(), Slic3r::GUI::Plater::priv::on_select_preset(), Slic3r::GUI::Tab::on_value_change(), Slic3r::GUI::Plater::open_filament_map_setting_dialog(), Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_bool_nullable(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_enum_nullable(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_float_nullable(), Slic3r::DynamicConfig::opt_float_nullable(), Slic3r::DynamicConfig::opt_float_or_percent_nullable(), Slic3r::DynamicConfig::opt_float_or_percent_nullable(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_int_nullable(), Slic3r::DynamicConfig::opt_int_nullable(), opt_serialize(), Slic3r::DynamicConfig::opt_string(), Slic3r::DynamicConfig::opt_string(), Slic3r::option_of(), Slic3r::opts_equal(), Slic3r::GUI::anonymous_namespace{Plater.cpp}::parse_mixed_gradient_slots(), Slic3r::GUI::ObjectList::paste_settings_into_list(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::place_wipe_tower(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::GUI::FillBedJob::prepare(), Slic3r::GUI::ArrangeJob::prepare_all(), Slic3r::GUI::ArrangeJob::prepare_partplate(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::GUI::ArrangeJob::prepare_wipe_tower(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::preset_templates(), Slic3r::prime_tower_is_printed(), Slic3r::print_config_diffs(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::printable_area_center(), Slic3r::PhysicalPrinter::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::Preset::printer_technology_ref(), Slic3r::GUI::ArrangeJob::process(), Slic3r::GUI::CalibUtils::process_and_store_3mf(), Slic3r::BackgroundSlicingProcess::process_sla(), Slic3r::anonymous_namespace{PrintConfig.cpp}::project_bed_material_keepouts(), Slic3r::prune_stale_plugin_overrides(), Slic3r::DynamicConfig::read_cli(), Slic3r::ImexArrangeInput::read_config(), Slic3r::GUI::recompute_mixed_slot_colors(), Slic3r::referenced_capabilities(), Slic3r::GUI::PartPlate::refresh_imex_icon(), Slic3r::refresh_missing_plugins(), Slic3r::GUI::PartPlate::register_raycasters_for_picking(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::GUI::ObjectGridTable::reload_object_data(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::GUI::PartPlate::render_icons(), Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::PresetBundle::reset_default_nozzle_volume_type(), Slic3r::PresetBundle::reset_project_embedded_presets(), Slic3r::GUI::IMEXModesCtrl::reset_row_to_parent(), Slic3r::resize_mixed_filament_metadata(), Slic3r::GUI::PartPlate::resolve_active_mode_tools(), Slic3r::PresetCollection::resolve_user_preset(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::resolve_wipe_tower_type(), Slic3r::GUI::IMEXModesCtrl::row_differs_from_parent(), Slic3r::GUI::IMEXModesCtrl::row_has_parent_counterpart(), Slic3r::CLI::run(), Slic3r::GUI::s_get_slicing_extuder_nozzles(), Slic3r::anonymous_namespace{Flashforge.cpp}::safe_config_string(), Slic3r::Preset::save(), Slic3r::GUI::CalibrationWizard::save_preset_with_index(), save_to_json(), Slic3r::GUI::Selection::scale_to_fit_print_volume(), Slic3r::GUI::sCheckFilamentInfo(), Slic3r::GUI::seedExtruderNozzleStats(), Slic3r::GUI::Tab::select_preset(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::select_printer_default_presets(), Slic3r::GUI::Plater::send_gcode_legacy(), Slic3r::PresetBundle::set_calibrate_printer(), Slic3r::GUI::set_config_values(), Slic3r::GUI::PartPlateList::set_default_wipe_tower_pos_for_plate(), Slic3r::StaticConfig::set_defaults(), set_deserialize_raw(), Slic3r::set_filament_dev_options(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), Slic3r::DynamicPrintConfig::set_num_extruders(), Slic3r::DynamicPrintConfig::set_num_filaments(), Slic3r::GUI::PartPlate::set_shape(), Slic3r::GUI::PartPlate::set_vase_mode_related_object_config(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_config(), Slic3r::DynamicPrintConfig::support_different_extruders(), Slic3r::GUI::support_nozzle_volume(), Slic3r::GUI::Sidebar::priv::switch_diameter(), Slic3r::GUI::Sidebar::priv::switch_diameter_to(), Slic3r::GUI::Tab::switch_excluder(), Slic3r::GUI::SendMultiMachinePage::sync_ams_list(), Slic3r::GUI::Sidebar::sync_ams_list(), Slic3r::GUI::PlaterPresetComboBox::sync_colour_config(), Slic3r::GUI::Tab::sync_excluder(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), Slic3r::GUI::Plater::priv::take_snapshot(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::Plater::priv::undo_redo_to(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GUI::PresetComboBox::update_ams_color(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::GUI::CalibrationPresetPage::update_combobox_filaments(), Slic3r::PresetBundle::update_compatible(), Slic3r::PresetCollection::update_compatible_internal(), Slic3r::GUI::ObjectTableSettings::update_config_values(), Slic3r::GUI::update_custom_filaments(), Slic3r::DynamicPrintConfig::update_diff_values_to_child_config(), Slic3r::GUI::Plater::update_filament_colors_in_full_config(), Slic3r::DynamicPrintConfig::update_filament_config_values_for_multiple_extruders(), Slic3r::GUI::TabFilament::update_filament_overrides_page(), Slic3r::GUI::Plater::update_flush_volume_matrix(), Slic3r::GUI::TabPrintModel::update_model_config(), Slic3r::DynamicPrintConfig::update_non_diff_values_to_base_config(), update_plugin_manifest(), Slic3r::GUI::Tab::update_preset_description_line(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), Slic3r::update_static_print_config_from_dynamic(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), Slic3r::DynamicPrintConfig::update_values_from_single_to_multi(), Slic3r::DynamicPrintConfig::update_values_to_printer_extruders(), Slic3r::DynamicPrintConfig::update_values_to_printer_extruders_for_multiple_filaments(), Slic3r::GUI::updateNozzleCountDisplay(), Slic3r::DynamicPrintConfig::validate(), Slic3r::GUI::Tab::validate_filament_temperature_pairs(), Slic3r::PresetBundle::validate_presets(), Slic3r::GUI::variant_keys(), and Slic3r::GUI::zero_pressure_advance_where_disabled().

Here is the call graph for this function:

option_throw() [1/2]

const ConfigOption * Slic3r::ConfigOptionResolver::option_throw ( const t_config_option_key & opt_key ) const

inlineinherited

    {
        const ConfigOption* opt = this->optptr(opt_key);
        if (opt == nullptr)
            throw UnknownOptionException(opt_key);
        return opt;
    }

option_throw() [2/2]

ConfigOption * Slic3r::ConfigBase::option_throw ( const t_config_option_key & opt_key, bool create = false )

inlineinherited

    {
        ConfigOption *opt = this->optptr(opt_key, create);
        if (opt == nullptr)
            throw UnknownOptionException(opt_key);
        return opt;
    }

References optptr().

Referenced by option_throw(), set(), set(), set(), set(), and set().

Here is the call graph for this function:

Here is the caller graph for this function:

optptr() [1/2]

const ConfigOption * Slic3r::DynamicConfig::optptr ( const t_config_option_key & opt_key ) const

overridevirtualinherited

Reimplemented from Slic3r::ConfigBase.

{
    auto it = options.find(opt_key);
    return (it == options.end()) ? nullptr : it->second.get();
}

References options.

Referenced by Slic3r::apply_mixed_config_relocations(), Slic3r::apply_receiver_mix_relocations(), Slic3r::GUI::get_string_value(), Slic3r::client::MyContext::new_old_variable(), and Slic3r::client::MyContext::resolve_output_symbol().

Here is the caller graph for this function:

optptr() [2/2]

ConfigOption * Slic3r::DynamicConfig::optptr ( const t_config_option_key & opt_key, bool create = false )

overridevirtualinherited

Implements Slic3r::ConfigBase.

{
    auto it = options.find(opt_key);
    if (it != options.end())
        // Option was found.
        return it->second.get();
    if (! create)
        // Option was not found and a new option shall not be created.
        return nullptr;
    // Try to create a new ConfigOption.
    const ConfigDef       *def    = this->def();
    if (def == nullptr)
        throw NoDefinitionException(opt_key);
    const ConfigOptionDef *optdef = def->get(opt_key);
    if (optdef == nullptr)
//        throw ConfigurationError(std::string("Invalid option name: ") + opt_key);
        // Let the parent decide what to do if the opt_key is not defined by this->def().
        return nullptr;
    ConfigOption *opt = optdef->create_default_option();
    this->options.emplace_hint(it, opt_key, std::unique_ptr<ConfigOption>(opt));
    return opt;
}

References Slic3r::ConfigOptionDef::create_default_option(), def(), opt(), and options.

Here is the call graph for this function:

read_cli()

bool Slic3r::DynamicConfig::read_cli ( int argc, const char *const argv[], t_config_option_keys * extra, t_config_option_keys * keys = nullptr )

inherited

{
    // cache the CLI option => opt_key mapping
    std::map<std::string,std::string> opts;
    for (const auto &oit : this->def()->options)
        for (const std::string &t : oit.second.cli_args(oit.first))
            opts[t] = oit.first;
 
    bool parse_options = true;
    for (int i = 1; i < argc; ++ i) {
        std::string token = argv[i];
        // Store non-option arguments in the provided vector.
        if (! parse_options || ! boost::starts_with(token, "-")) {
            extra->push_back(token);
            continue;
        }
#ifdef __APPLE__
        if (boost::starts_with(token, "-psn_"))
            // OSX launcher may add a "process serial number", for example "-psn_0_989382" to the command line.
            // While it is supposed to be dropped since OSX 10.9, we will rather ignore it.
            continue;
#endif /* __APPLE__ */
        // Stop parsing tokens as options when -- is supplied.
        if (token == "--") {
            parse_options = false;
            continue;
        }
        // Remove leading dashes (one or two).
        token.erase(token.begin(), token.begin() + (boost::starts_with(token, "--") ? 2 : 1));
        // Read value when supplied in the --key=value form.
        std::string value;
        {
            size_t equals_pos = token.find("=");
            if (equals_pos != std::string::npos) {
                value = token.substr(equals_pos+1);
                token.erase(equals_pos);
            }
        }
        // Look for the cli -> option mapping.
        auto it = opts.find(token);
        bool no = false;
        if (it == opts.end()) {
            //BBS: don't use 'no-' for boolean options
            boost::nowide::cerr << "Invalid option --" << token.c_str() << std::endl;
            return false;
            /* Remove the "no-" prefix used to negate boolean options.
            std::string yes_token;
            if (boost::starts_with(token, "no-")) {
                yes_token = token.substr(3);
                it = opts.find(yes_token);
                no = true;
            }
            if (it == opts.end()) {
                boost::nowide::cerr << "Invalid option --" << token.c_str() << std::endl;
                return false;
            }
            if (no)
                token = yes_token;*/
        }
 
        const t_config_option_key &opt_key = it->second;
        const ConfigOptionDef     &optdef  = this->def()->options.at(opt_key);
 
        // If the option type expects a value and it was not already provided,
        // look for it in the next token.
        if (value.empty() && optdef.type != coBool && optdef.type != coBools) {
            if (i == argc-1) {
                boost::nowide::cerr << "Need values for option --" << token.c_str() << std::endl;
                return false;
            }
            value = argv[++ i];
        }
 
        /*if (no) {
            assert(optdef.type == coBool || optdef.type == coBools);
            if (! value.empty()) {
                boost::nowide::cerr << "Boolean options negated by the --no- prefix cannot have a value." << std::endl;
                return false;
            }
        }*/
 
        // Store the option value.
        const bool               existing   = this->has(opt_key);
        if (keys != nullptr && ! existing) {
            // Save the order of detected keys.
            keys->push_back(opt_key);
        }
        ConfigOption            *opt_base   = this->option(opt_key, true);
        ConfigOptionVectorBase  *opt_vector = opt_base->is_vector() ? static_cast<ConfigOptionVectorBase*>(opt_base) : nullptr;
        if (opt_vector) {
      if (! existing)
        // remove the default values
        opt_vector->clear();
            // Vector values will be chained. Repeated use of a parameter will append the parameter or parameters
            // to the end of the value.
            if (opt_base->type() == coBools && value.empty())
                static_cast<ConfigOptionBools*>(opt_base)->values.push_back(!no);
            else {
                // Deserialize any other vector value (ConfigOptionInts, Floats, Percents, Points) the same way
                // they get deserialized from an .ini file. For ConfigOptionStrings, that means that the C-style unescape
                // will be applied for values enclosed in quotes, while values non-enclosed in quotes are left to be
                // unescaped by the calling shell.
                const std::string vector_value = opt_base->type() == coBools ? normalize_cli_bool_value(value) : value;
                bool deserialized = false;
                try {
                    deserialized = opt_vector->deserialize(vector_value, true);
                } catch (const std::exception &ex) {
                    // e.g. "nil" deserialized into a non-nullable vector option throws instead of
                    // returning false - treat that the same as any other invalid value here.
                    deserialized = false;
                }
                if (! deserialized) {
                    boost::nowide::cerr << "Invalid value for option --" << token.c_str() << std::endl;
                    return false;
                }
            }
        } else if (opt_base->type() == coBool) {
            if (value.empty())
                static_cast<ConfigOptionBool*>(opt_base)->value = !no;
            else if (! opt_base->deserialize(normalize_cli_bool_value(value))) {
                boost::nowide::cerr << "Invalid value for option --" << token.c_str() << std::endl;
                return false;
            }
        } else if (opt_base->type() == coString) {
            // Do not unescape single string values, the unescaping is left to the calling shell.
            static_cast<ConfigOptionString*>(opt_base)->value = value;
        } else {
            // Just bail out if the configuration value is not understood.
            ConfigSubstitutionContext context(ForwardCompatibilitySubstitutionRule::Disable);
            // Any scalar value of a type different from Bool and String.
            if (! this->set_deserialize_nothrow(opt_key, value, context, false)) {
        boost::nowide::cerr << "Invalid value for option --" << token.c_str() << std::endl;
        return false;
      }
        }
    }
    return true;
}

References Slic3r::ConfigOptionVectorBase::clear(), Slic3r::coBool, Slic3r::coBools, Slic3r::coString, def(), Slic3r::ConfigOption::deserialize(), Slic3r::Disable, Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigOption::is_vector(), keys(), Slic3r::normalize_cli_bool_value(), Slic3r::ConfigBase::option(), Slic3r::ConfigDef::options, options, Slic3r::ConfigBase::set_deserialize_nothrow(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionDef::type.

Here is the call graph for this function:

remove_nil_options()

size_t Slic3r::DynamicConfig::remove_nil_options ( )

inherited

{
  size_t cnt_removed = 0;
  for (auto it = options.begin(); it != options.end();)
    if (it->second->is_nil()) {
      it = options.erase(it);
      ++ cnt_removed;
    } else
      ++ it;
  return cnt_removed;
}

References options.

save()

void Slic3r::ConfigBase::save ( const std::string & file ) const

inherited

{
    boost::nowide::ofstream c;
    c.open(file, std::ios::out | std::ios::trunc);
    c << "# " << Slic3r::header_slic3r_generated() << std::endl;
    for (const std::string &opt_key : this->keys())
        c << opt_key << " = " << this->opt_serialize(opt_key) << std::endl;
    c.close();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
}

References Slic3r::header_slic3r_generated(), keys(), and opt_serialize().

Here is the call graph for this function:

save_to_json() [1/2]

void Slic3r::ConfigBase::save_to_json ( const std::string & file, const std::string & name, const std::string & from, const std::string & version ) const

inherited

{
    // Serialize first: if that throws (invalid UTF-8), the existing file stays untouched.
    std::ostringstream ss;
    this->save_to_json(ss, name, from, version);
    if (const std::error_code ec = write_file_atomically(file, ss.str()))
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(": failed to save config to %1%: %2%") % file % ec.message();
    else
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
}

References save_to_json(), and Slic3r::write_file_atomically().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_project_config_file_to_archive(), Slic3r::_BBS_3MF_Exporter::_add_project_embedded_presets_to_archive(), Slic3r::PresetBundle::export_current_configs(), Slic3r::Preset::save(), and save_to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

save_to_json() [2/2]

void Slic3r::ConfigBase::save_to_json ( std::ostream & os, const std::string & name, const std::string & from, const std::string & version, bool replace_invalid_utf8 = false ) const

inherited

{
    json j;
    //record the headers
    j[BBL_JSON_KEY_VERSION] = version;
    j[BBL_JSON_KEY_NAME] = name;
    j[BBL_JSON_KEY_FROM] = from;
 
    //record all the key-values
    for (const std::string &opt_key : this->keys())
    {
        const ConfigOption* opt = this->option(opt_key);
        if ( opt->is_scalar() ) {
            if (opt->type() == coString && (opt_key != "bed_custom_texture" && opt_key != "bed_custom_model"))
                //keep \n, \r, \t
                j[opt_key] = (dynamic_cast<const ConfigOptionString *>(opt))->value;
            else
                j[opt_key] = opt->serialize();
        }
        else {
            const ConfigOptionVectorBase* vec = static_cast<const ConfigOptionVectorBase*>(opt);
            //if (!vec->empty())
            std::vector<std::string> string_values = vec->vserialize();
 
            /*for (int i = 0; i < string_values.size(); i++)
            {
            std::string string_value = escape_string_cstyle(string_values[i]);
            j[opt_key][i] = string_value;
            }*/
 
            json j_array(string_values);
            j[opt_key] = j_array;
        }
    }
 
    // Serialize the top-level "plugins" manifest: the individual plugin-backed options keep bare
    // capability names; the full "name;uuid;capability" references are derived here (same helper as
    // update_plugin_manifest). Only with a resolver (GUI); without one (CLI/headless) leave whatever
    // the "plugins" option already serialized above, so a round-trip never drops the manifest.
    if (resolve_capability_fn) {
        std::vector<std::string> unique_refs = this->collect_plugin_manifest();
        if (unique_refs.empty())
            j.erase("plugins");
        else
            j["plugins"] = unique_refs;
    }
 
    os << j.dump(1, '\t', false, replace_invalid_utf8 ? json::error_handler_t::replace : json::error_handler_t::strict) << std::endl;
}

References BBL_JSON_KEY_FROM, BBL_JSON_KEY_NAME, BBL_JSON_KEY_VERSION, collect_plugin_manifest(), Slic3r::coString, keys(), option(), resolve_capability_fn, and Slic3r::ConfigOptionVectorBase::vserialize().

Here is the call graph for this function:

serialize()

template<class Archive>

void Slic3r::DynamicConfig::serialize ( Archive & ar )

inlineprivateinherited

{ ar(options); }

References options.

set() [1/5]

void Slic3r::ConfigBase::set ( const std::string & opt_key, bool value, bool create = false )

inlineinherited

      { this->option_throw<ConfigOptionBool>(opt_key, create)->value = value; }

References option_throw().

Referenced by Slic3r::Print::apply(), Slic3r::extract_profile(), Slic3r::import_sla_archive(), Slic3r::CLI::run(), and Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config().

Here is the call graph for this function:

Here is the caller graph for this function:

set() [2/5]

void Slic3r::ConfigBase::set ( const std::string & opt_key, const char * value, bool create = false )

inlineinherited

      { this->option_throw<ConfigOptionString>(opt_key, create)->value = value; }

References option_throw().

Here is the call graph for this function:

set() [3/5]

void Slic3r::ConfigBase::set ( const std::string & opt_key, const std::string & value, bool create = false )

inlineinherited

      { this->option_throw<ConfigOptionString>(opt_key, create)->value = value; }

References option_throw().

Here is the call graph for this function:

set() [4/5]

void Slic3r::ConfigBase::set ( const std::string & opt_key, double value, bool create = false )

inherited

{
    ConfigOption *opt = this->option_throw(opt_key, create);
    switch (opt->type()) {
      case coFloat:       static_cast<ConfigOptionFloat*>(opt)->value = value; break;
      case coFloatOrPercent:  static_cast<ConfigOptionFloatOrPercent*>(opt)->value = value; static_cast<ConfigOptionFloatOrPercent*>(opt)->percent = false; break;
        case coString:      static_cast<ConfigOptionString*>(opt)->value = float_to_string_decimal_point(value); break;
      default: throw BadOptionTypeException("Configbase::set() - conversion from float not possible");
    }
}

References Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coString, Slic3r::float_to_string_decimal_point(), and option_throw().

Here is the call graph for this function:

set() [5/5]

void Slic3r::ConfigBase::set ( const std::string & opt_key, int value, bool create = false )

inherited

{
    ConfigOption *opt = this->option_throw(opt_key, create);
    switch (opt->type()) {
      case coInt:    static_cast<ConfigOptionInt*>(opt)->value = value; break;
      case coFloat:  static_cast<ConfigOptionFloat*>(opt)->value = value; break;
    case coFloatOrPercent:  static_cast<ConfigOptionFloatOrPercent*>(opt)->value = value; static_cast<ConfigOptionFloatOrPercent*>(opt)->percent = false; break;
    case coString: static_cast<ConfigOptionString*>(opt)->value = std::to_string(value); break;
      default: throw BadOptionTypeException("Configbase::set() - conversion from int not possible");
    }
}

References Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coString, and option_throw().

Here is the call graph for this function:

set_deserialize() [1/2]

void Slic3r::ConfigBase::set_deserialize ( const t_config_option_key & opt_key, const std::string & str, ConfigSubstitutionContext & config_substitutions, bool append = false )

inherited

{
  if (! this->set_deserialize_nothrow(opt_key_src, value_src, substitutions_ctxt, append))
    throw BadOptionValueException(format(_u8L("Invalid value provided for parameter %1%: %2%"), opt_key_src,  value_src));
}

References _u8L, Slic3r::append(), Slic3r::format(), and set_deserialize_nothrow().

Referenced by construct_assemble_list(), load(), load_from_gcode_file(), load_from_gcode_string_legacy(), load_from_json(), load_string_map(), set_deserialize(), set_deserialize_strict(), and set_deserialize_strict().

Here is the call graph for this function:

Here is the caller graph for this function:

set_deserialize() [2/2]

void Slic3r::ConfigBase::set_deserialize ( std::initializer_list< SetDeserializeItem > items, ConfigSubstitutionContext & substitutions )

inherited

{
  for (const SetDeserializeItem &item : items)
    this->set_deserialize(item.opt_key, item.opt_value, substitutions_ctxt, item.append);
}

References set_deserialize().

Here is the call graph for this function:

set_deserialize_nothrow()

bool Slic3r::ConfigBase::set_deserialize_nothrow ( const t_config_option_key & opt_key_src, const std::string & value_src, ConfigSubstitutionContext & substitutions, bool append = false )

inherited

{
    t_config_option_key opt_key = opt_key_src;
    std::string         value   = value_src;
    // Both opt_key and value may be modified by handle_legacy().
    // If the opt_key is no more valid in this version of Slic3r, opt_key is cleared by handle_legacy().
    this->handle_legacy(opt_key, value);
    if (opt_key.empty()) {
        // Ignore the option.
        //BBS: record these options, keep only one repeated opt_key
        auto iter = std::find(substitutions_ctxt.unrecogized_keys.begin(), substitutions_ctxt.unrecogized_keys.end(), opt_key_src);
        if (iter == substitutions_ctxt.unrecogized_keys.end())
            substitutions_ctxt.unrecogized_keys.push_back(opt_key_src);
        return true;
    }
    return this->set_deserialize_raw(opt_key, value, substitutions_ctxt, append);
}

References Slic3r::append(), handle_legacy(), set_deserialize_raw(), and Slic3r::ConfigSubstitutionContext::unrecogized_keys.

Referenced by Slic3r::DynamicConfig::read_cli(), and set_deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

set_deserialize_strict() [1/2]

void Slic3r::ConfigBase::set_deserialize_strict ( const t_config_option_key & opt_key, const std::string & str, bool append = false )

inlineinherited

        { ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Disable }; this->set_deserialize(opt_key, str, ctxt, append); }

References Slic3r::append(), Slic3r::Disable, and set_deserialize().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_deserialize_strict() [2/2]

void Slic3r::ConfigBase::set_deserialize_strict ( std::initializer_list< SetDeserializeItem > items )

inlineinherited

        { ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Disable }; this->set_deserialize(items, ctxt); }

References Slic3r::Disable, and set_deserialize().

Here is the call graph for this function:

set_key_value()

bool Slic3r::DynamicConfig::set_key_value ( const std::string & opt_key, ConfigOption * opt )

inlineinherited

    {
        auto it = this->options.find(opt_key);
        if (it == this->options.end()) {
            this->options[opt_key].reset(opt);
            return true;
        } else {
            it->second.reset(opt);
            return false;
        }
    }

References opt().

Referenced by Slic3r::GUI::Plater::_calib_pa_pattern(), Slic3r::append_bed_exclude_volumes(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::WipeTowerIntegration::append_tcr2(), Slic3r::GUI::ConfigManipulation::apply(), Slic3r::Print::apply(), Slic3r::GUI::PageBedShape::apply_custom_config(), Slic3r::GUI::PageDiameters::apply_custom_config(), Slic3r::GUI::PageFirmware::apply_custom_config(), Slic3r::GUI::ConfigManipulation::apply_null_fff_config(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::Sidebar::build_filament_ams_list(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_max_vol_speed(), Slic3r::GUI::CalibUtils::calib_pa_pattern(), Slic3r::GUI::CalibUtils::calib_retraction(), Slic3r::GUI::CalibUtils::calib_temptue(), Slic3r::GUI::CalibUtils::calib_VFA(), Slic3r::GUI::change_opt_value(), Slic3r::GUI::ConfigManipulation::check_chamber_minimal_temperature(), Slic3r::GUI::ConfigManipulation::check_filament_ironing_spacing(), Slic3r::GUI::ConfigManipulation::check_filament_max_volumetric_speed(), Slic3r::GUI::ConfigManipulation::check_layer_height(), Slic3r::compute_filament_override_value(), Slic3r::PresetBundle::config_from_gcode(), Slic3r::PresetBundle::construct_full_config(), Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::CreatePresetForPrinterDialog::create_dialog_buttons(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::GUI::empty_tray_config(), Slic3r::GCodeProcessor::export_config_for_render(), Slic3r::extend_extruder_variant(), Slic3r::CrealityPrintAgent::fetch_filament_info(), Slic3r::filter_published_config(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::PresetBundle::get_filament_presets_for_machine(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::is_compatible_with_printer(), Slic3r::GUI::ConfigManipulation::layer_height_out_of_range_dialog(), cereal::load(), Slic3r::load_enum_option(), Slic3r::GUI::Plater::load_gcode(), Slic3r::GUI::MenuFactory::load_handy_model(), Slic3r::PresetCollection::load_user_preset(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::GLGizmoBrimEars::on_render_input_window(), Slic3r::GUI::GLGizmoFuzzySkin::on_render_input_window(), Slic3r::GUI::Plater::priv::on_select_bed_type(), Slic3r::GUI::Tab::on_value_change(), Slic3r::PrintBase::output_filename(), Slic3r::GCode::process_layer(), Slic3r::prune_stale_plugin_overrides(), Slic3r::read_config(), Slic3r::PresetBundle::reload_local_bundle(), Slic3r::CLI::run(), Slic3r::Preset::save(), Slic3r::GUI::CalibrationWizard::save_preset(), Slic3r::GUI::CreatePrinterPresetDialog::save_printable_area_config(), Slic3r::PresetBundle::set_calibrate_printer(), Slic3r::GUI::Tab::set_custom_gcode(), Slic3r::GUI::TabFilament::set_custom_gcode(), Slic3r::GCode::set_extruder(), Slic3r::GUI::CalibUtils::set_for_auto_pa_model_and_config(), Slic3r::GUI::PartPlate::set_vase_mode_related_object_config(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_config(), anonymous_namespace{OrcaSlicer_profile_validator.cpp}::slice_two_color_cube_and_export(), Slic3r::client::MyContext::store_new_variable(), Slic3r::GUI::PlaterPresetComboBox::sync_colour_config(), Slic3r::GUI::Tab::sync_excluder(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::PresetComboBox::update_ams_color(), Slic3r::PresetCollection::update_compatible_internal(), Slic3r::GUI::CalibrationPresetPage::update_filament_combobox(), Slic3r::GUI::TabPrinter::update_input_shaper_menu(), Slic3r::PrintBase::update_object_placeholders(), Slic3r::update_preset_name_option(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::ConfigManipulation::update_print_sla_config().

Here is the call graph for this function:

set_num_extruders()

void Slic3r::DynamicPrintConfig::set_num_extruders

(

unsigned int

num_extruders

)

{
    extend_extruder_variant(*this, num_extruders);
 
    const auto &defaults = FullPrintConfig::defaults();
    for (const std::string &key : print_config_def.extruder_option_keys()) {
        if (key == "default_filament_profile")
            // Don't resize this field, as it is presented to the user at the "Dependencies" page of the Printer profile and we don't want to present
            // empty fields there, if not defined by the system profile.
            continue;
        auto *opt = this->option(key, false);
        assert(opt != nullptr);
        assert(opt->is_vector());
        if (opt != nullptr && opt->is_vector()) {
            static_cast<ConfigOptionVectorBase*>(opt)->resize(get_parameter_size(key, num_extruders), defaults.option(key));
        }
    }
}

References Slic3r::extend_extruder_variant(), get_parameter_size(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), and Slic3r::print_config_def.

Referenced by Slic3r::Preset::set_num_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

set_num_filaments()

void Slic3r::DynamicPrintConfig::set_num_filaments

(

unsigned int

num_filaments

)

{
    const auto& defaults = FullPrintConfig::defaults();
    for (const std::string& key : print_config_def.filament_option_keys()) {
        if (key == "default_filament_profile")
            // Don't resize this field, as it is presented to the user at the "Dependencies" page of the Printer profile and we don't want to present
            // empty fields there, if not defined by the system profile.
            continue;
        auto* opt = this->option(key, false);
        assert(opt != nullptr);
        assert(opt->is_vector());
        if (opt != nullptr && opt->is_vector())
            static_cast<ConfigOptionVectorBase*>(opt)->resize(num_filaments, defaults.option(key));
    }
}

References Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), and Slic3r::print_config_def.

Here is the call graph for this function:

set_resolve_capability_fn()

void Slic3r::ConfigBase::set_resolve_capability_fn ( std::function< std::string(std::string, std::string)> fn )

inlinestaticinherited

{ resolve_capability_fn = fn; }

References resolve_capability_fn.

Referenced by Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_capability_resolver(), and Slic3r::plugin_hooks::uninstall().

Here is the caller graph for this function:

setenv_()

void Slic3r::ConfigBase::setenv_ ( ) const

inherited

{
    t_config_option_keys opt_keys = this->keys();
    for (t_config_option_keys::const_iterator it = opt_keys.begin(); it != opt_keys.end(); ++it) {
        // prepend the SLIC3R_ prefix
        std::ostringstream ss;
        ss << "SLIC3R_";
        ss << *it;
        std::string envname = ss.str();
 
        // capitalize environment variable name
        for (size_t i = 0; i < envname.size(); ++i)
            envname[i] = (envname[i] <= 'z' && envname[i] >= 'a') ? envname[i]-('a'-'A') : envname[i];
 
        boost::nowide::setenv(envname.c_str(), this->opt_serialize(*it).c_str(), 1);
    }
}

References keys().

Referenced by Slic3r::run_post_process_scripts().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

size_t Slic3r::DynamicConfig::size ( ) const

inlineinherited

{ return options.size(); }

References options.

Referenced by Slic3r::GUI::has_filaments(), Slic3r::DynamicPrintConfig::is_using_different_extruders(), load_default_gcodes_to_config(), Slic3r::GUI::ArrangeJob::prepare(), cereal::save(), Slic3r::save_config(), Slic3r::DynamicPrintConfig::support_different_extruders(), Slic3r::DynamicPrintConfig::update_non_diff_values_to_base_config(), and Slic3r::DynamicPrintConfig::update_values_to_printer_extruders().

Here is the caller graph for this function:

support_different_extruders()

bool Slic3r::DynamicPrintConfig::support_different_extruders

(

int &

extruder_count

)

const

{
    std::set<std::string> variant_set;
 
    auto nozzle_diameters_opt = dynamic_cast<const ConfigOptionFloats*>(this->option("nozzle_diameter"));
    if (nozzle_diameters_opt != nullptr) {
        int size = nozzle_diameters_opt->size();
        extruder_count = size;
        auto extruder_variant_opt = dynamic_cast<const ConfigOptionStrings*>(this->option("extruder_variant_list"));
        if (extruder_variant_opt != nullptr) {
            for (int index = 0; index < size; index++) {
                std::string variant = extruder_variant_opt->get_at(index);
                std::vector<std::string> variants_list;
                boost::split(variants_list, variant, boost::is_any_of(","), boost::token_compress_on);
                if (!variants_list.empty())
                    variant_set.insert(variants_list.begin(), variants_list.end());
            }
        }
    }
 
    return (variant_set.size() > 1);
}

References Slic3r::ConfigBase::option(), and Slic3r::DynamicConfig::size().

Referenced by Slic3r::PresetBundle::construct_full_config(), Slic3r::PresetBundle::full_fff_config(), and Slic3r::PresetBundle::support_different_extruders().

Here is the call graph for this function:

Here is the caller graph for this function:

swap()

void Slic3r::DynamicConfig::swap ( DynamicConfig & other )

inlineinherited

    {
        std::swap(this->options, other.options);
    }

References DynamicConfig(), and options.

Here is the call graph for this function:

update_diff_values_to_child_config()

void Slic3r::DynamicPrintConfig::update_diff_values_to_child_config	(	DynamicPrintConfig &	new_config,
		std::string	extruder_id_name,
		std::string	extruder_variant_name,
		std::set< std::string > &	key_set1,
		std::set< std::string > &	key_set2 )

{
    std::vector<int> cur_extruder_ids, target_extruder_ids, variant_index;
    std::vector<std::string> cur_extruder_variants, target_extruder_variants;
 
    if (!extruder_id_name.empty()) {
        if (this->option(extruder_id_name))
            cur_extruder_ids = this->option<ConfigOptionInts>(extruder_id_name)->values;
        if (new_config.option(extruder_id_name))
            target_extruder_ids = new_config.option<ConfigOptionInts>(extruder_id_name)->values;
    }
    if (this->option(extruder_variant_name))
        cur_extruder_variants = this->option<ConfigOptionStrings>(extruder_variant_name, true)->values;
    if (new_config.option(extruder_variant_name))
        target_extruder_variants = new_config.option<ConfigOptionStrings>(extruder_variant_name, true)->values;
 
    int cur_variant_count = cur_extruder_variants.size();
    int target_variant_count = target_extruder_variants.size();
 
    if (cur_variant_count > 0)
        variant_index.resize(cur_variant_count, -1);
    else
        variant_index.resize(1, 0);
 
    // A parent variant the child does not list (the parent gained it after the child was saved, or the
    // child lists none) takes the child's first variant of the same extruder, as slicing does.
    // Left unmatched, the parent's value would silently replace the user's.
    if (target_variant_count == 0) {
        // The child's one value belongs to the extruder of the parent's first variant.
        if (cur_variant_count > 0)
            variant_index = map_variant_indices(cur_extruder_variants, cur_extruder_ids, {},
                                                cur_extruder_ids.empty() ? std::vector<int>() : std::vector<int>{cur_extruder_ids[0]});
    }
    else if ((cur_extruder_ids.size() > 0) && cur_variant_count != cur_extruder_ids.size()){
        //should not happen
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" size of %1% = %2%, not equal to size of %3% = %4%")
             %extruder_variant_name %cur_variant_count %extruder_id_name %cur_extruder_ids.size();
    }
    else if ((target_extruder_ids.size() > 0) && target_variant_count != target_extruder_ids.size()){
        //should not happen
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" size of %1% = %2%, not equal to size of %3% = %4%")
             %extruder_variant_name %target_variant_count %extruder_id_name %target_extruder_ids.size();
    }
    else if (cur_variant_count > 0) {
        variant_index = map_variant_indices(cur_extruder_variants, cur_extruder_ids, target_extruder_variants, target_extruder_ids);
    }
 
    const t_config_option_keys &keys = new_config.keys();
    for (auto& opt : keys) {
        if ((opt == extruder_id_name) || (opt == extruder_variant_name))
            continue;
        ConfigOption *opt_src = this->option(opt);
        const ConfigOption *opt_target = new_config.option(opt);
        if (opt_src && opt_target && (*opt_src != *opt_target)) {
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" change key %1% from base_value %2% to child's value %3%")
                    %opt %(opt_src->serialize()) %(opt_target->serialize());
            if (opt_target->is_scalar()
                || ((key_set1.find(opt) == key_set1.end()) && (key_set2.empty() || (key_set2.find(opt) == key_set2.end())))) {
                //nothing to do, keep the original one
                opt_src->set(opt_target);
            }
            else {
                ConfigOptionVectorBase* opt_vec_src = static_cast<ConfigOptionVectorBase*>(opt_src);
                const ConfigOptionVectorBase* opt_vec_dest = static_cast<const ConfigOptionVectorBase*>(opt_target);
                int stride = 1;
                if (key_set2.find(opt) != key_set2.end())
                    stride = 2;
                // set_only_diff() requires the base vector length to equal variant_index.size()*stride, where
                // variant_index is sized from the parent's printer_extruder_variant list (or 1 when it has none).
                // Legacy / multi-extruder / multi-variant presets can violate this in either direction when a key's
                // stored length and the variant-list length were sized inconsistently - e.g. a Snapmaker U1 base
                // (4 nozzles) whose stride-2 machine limits were length-extended to nozzles*2 while its
                // printer_extruder_variant list is empty (variant_index == 1), so base length != variant_index*stride.
                // Rather than throw (which is caught upstream and DELETES the user preset file), fall back to the
                // child's explicit value, which is authoritative for its own extruder/variant layout.
                if (opt_vec_src->size() != variant_index.size() * size_t(stride)) {
                    opt_src->set(opt_target);
                }
                else
                    // An override's nil means "disabled" and is the child's value; every other nil column inherits.
                    opt_vec_src->set_only_diff(opt_vec_dest, variant_index, stride, is_filament_extruder_override_key(opt));
            }
        }
    }
    return;
}

References DynamicPrintConfig(), Slic3r::is_filament_extruder_override_key(), Slic3r::ConfigOption::is_scalar(), Slic3r::DynamicConfig::keys(), Slic3r::map_variant_indices(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOption::serialize(), Slic3r::ConfigOption::set(), Slic3r::ConfigOptionVectorBase::set_only_diff(), and Slic3r::ConfigOptionVectorBase::size().

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_config_values_for_multiple_extruders()

void Slic3r::DynamicPrintConfig::update_filament_config_values_for_multiple_extruders	(	DynamicPrintConfig &	printer_config,
		const std::unordered_map< int, std::vector< FilamentVariantUse > > &	filament_variant_uses,
		int	extruder_count,
		int	extruder_nozzle_volume_count,
		std::set< std::string > &	key_set,
		std::string	id_name,
		std::string	variant_name,
		std::vector< int > *	slot_machine_indices = nullptr )

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: extruder_count %2%, extruder_nozzle_volume_count %3%")%__LINE__ %extruder_count %extruder_nozzle_volume_count;
 
    auto opt_filament_map = printer_config.option<ConfigOptionInts>("filament_map");
    if (!opt_filament_map) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: filament_map option not found, skipping")%__LINE__;
        return;
    }
    std::vector<int> filament_maps = opt_filament_map->values;
    size_t filament_count = filament_maps.size();
    auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("extruder_type"));
    auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("nozzle_volume_type"));
    if (!opt_extruder_type || !opt_nozzle_volume_type) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: extruder_type or nozzle_volume_type option not found, skipping")%__LINE__;
        return;
    }
 
    auto opt_filament_volume_maps = dynamic_cast<const ConfigOptionInts*>(printer_config.option("filament_volume_map"));
    std::vector<int> filament_volume_maps;
    // Orca: same sizing guard as the single-slot rebuild above — honour the per-filament volume
    // map only when a producer sized it to the filament count.
    if (opt_filament_volume_maps && opt_filament_volume_maps->values.size() == filament_count)
        filament_volume_maps = opt_filament_volume_maps->values;
    auto opt_ids = id_name.empty() ? nullptr : dynamic_cast<const ConfigOptionInts*>(this->option(id_name));
 
    std::vector<int> slot_param_indices;
    slot_param_indices.reserve(filament_count * 2);
    if (slot_machine_indices) {
        slot_machine_indices->clear();
        slot_machine_indices->reserve(filament_count * 2);
    }
 
    auto resolve_slot = [&](int f_index, ExtruderType extruder_type, NozzleVolumeType nozzle_volume_type, int extruder_id_1based) {
        int param_index = get_index_for_extruder(f_index + 1, id_name, extruder_type, nozzle_volume_type, variant_name);
        if (param_index < 0) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: could not found extruder_type %2%, nozzle_volume_type %3%, filament_index %4%, extruder index %5%")
                %__LINE__ %s_keys_names_ExtruderType[extruder_type] % s_keys_names_NozzleVolumeType[nozzle_volume_type] % (f_index+1) %extruder_id_1based;
            assert(false);
            //for some updates happens in a invalid state(caused by popup window)
            //we need to avoid crash
            param_index = 0;
            if (opt_ids) {
                for (int i = 0; i < opt_ids->values.size(); i++)
                    if (opt_ids->values[i] == (f_index + 1)) {
                        param_index = i;
                        break;
                    }
            }
        }
        slot_param_indices.push_back(param_index);
        if (slot_machine_indices) {
            // Orca: key each output slot to the machine slot of its own variant (the same
            // derivation the per-filament slot map uses), so the retract-override nil fallback
            // stays aligned when a filament occupies more than one slot.
            int machine_index = printer_config.get_index_for_extruder(extruder_id_1based, "print_extruder_id", extruder_type, nozzle_volume_type, "print_extruder_variant");
            slot_machine_indices->push_back(std::max(machine_index, 0));
        }
    };
 
    for (int f_index = 0; f_index < static_cast<int>(filament_count); f_index++) {
        auto uses_it = filament_variant_uses.find(f_index);
        if (uses_it != filament_variant_uses.end() && !uses_it->second.empty()) {
            for (const FilamentVariantUse &use : uses_it->second)
                resolve_slot(f_index, use.extruder_type, use.nozzle_volume_type, use.extruder_id + 1);
        }
        else {
            ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(filament_maps[f_index] - 1));
            NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(filament_maps[f_index] - 1));
            if ((extruder_nozzle_volume_count > extruder_count || nozzle_volume_type == nvtHybrid) && !filament_volume_maps.empty())
                nozzle_volume_type = (NozzleVolumeType)(filament_volume_maps[f_index]);
            resolve_slot(f_index, extruder_type, nozzle_volume_type, filament_maps[f_index]);
        }
    }
 
    const ConfigDef *config_def = this->def();
    if (!config_def) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
        return;
    }
    bool has_id_key = !id_name.empty() && key_set.count(id_name) > 0;
    for (auto &key : key_set) {
        if (has_id_key && key == id_name)
            continue;
        const ConfigOptionDef *optdef = config_def->get(key);
        if (!optdef) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
            continue;
        }
        switch (optdef->type) {
            case coStrings:          gather_option_values<ConfigOptionStrings, std::string>(__FUNCTION__, key, this->option<ConfigOptionStrings>(key), slot_param_indices); break;
            case coInts:             gather_option_values<ConfigOptionInts, int>(__FUNCTION__, key, this->option<ConfigOptionInts>(key), slot_param_indices); break;
            case coFloats:           gather_option_values<ConfigOptionFloats, double>(__FUNCTION__, key, this->option<ConfigOptionFloats>(key), slot_param_indices); break;
            case coPercents:         gather_option_values<ConfigOptionPercents, double>(__FUNCTION__, key, this->option<ConfigOptionPercents>(key), slot_param_indices); break;
            case coFloatsOrPercents: gather_option_values<ConfigOptionFloatsOrPercents, FloatOrPercent>(__FUNCTION__, key, this->option<ConfigOptionFloatsOrPercents>(key), slot_param_indices); break;
            case coBools:            gather_option_values<ConfigOptionBools, unsigned char>(__FUNCTION__, key, this->option<ConfigOptionBools>(key), slot_param_indices); break;
            case coEnums:            gather_option_values<ConfigOptionEnumsGeneric, int>(__FUNCTION__, key, this->option<ConfigOptionEnumsGeneric>(key), slot_param_indices); break;
            default:
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
                break;
        }
    }
    // Orca: also require a non-empty id list; get_at on an empty vector is undefined.
    if (has_id_key && opt_ids && !opt_ids->values.empty()) {
        // remap the id list itself last: the slot resolution above still needs the original ids
        std::vector<int> new_values;
        new_values.reserve(slot_param_indices.size());
        for (int idx : slot_param_indices)
            new_values.push_back(opt_ids->get_at(idx));
        const_cast<ConfigOptionInts*>(opt_ids)->values = std::move(new_values);
    }
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coEnums, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coStrings, def(), Slic3r::FilamentVariantUse::extruder_id, Slic3r::FilamentVariantUse::extruder_type, Slic3r::gather_option_values(), Slic3r::ConfigDef::get(), get_index_for_extruder(), Slic3r::FilamentVariantUse::nozzle_volume_type, Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionDef::type.

Here is the call graph for this function:

update_non_diff_values_to_base_config()

void Slic3r::DynamicPrintConfig::update_non_diff_values_to_base_config	(	DynamicPrintConfig &	new_config,
		const t_config_option_keys &	keys,
		const std::set< std::string > &	different_keys,
		std::string	extruder_id_name,
		std::string	extruder_variant_name,
		std::set< std::string > &	key_set1,
		std::set< std::string > &	key_set2 )

{
    std::vector<int> cur_extruder_ids, target_extruder_ids, variant_index;
    std::vector<std::string> cur_extruder_variants, target_extruder_variants;
 
    if (!extruder_id_name.empty()) {
        if (this->option(extruder_id_name))
            cur_extruder_ids = this->option<ConfigOptionInts>(extruder_id_name)->values;
        if (new_config.option(extruder_id_name))
            target_extruder_ids = new_config.option<ConfigOptionInts>(extruder_id_name)->values;
    }
    if (this->option(extruder_variant_name))
        cur_extruder_variants = this->option<ConfigOptionStrings>(extruder_variant_name, true)->values;
    if (new_config.option(extruder_variant_name))
        target_extruder_variants = new_config.option<ConfigOptionStrings>(extruder_variant_name, true)->values;
 
    int cur_variant_count = cur_extruder_variants.size();
    int target_variant_count = target_extruder_variants.size();
 
    // A base variant this config does not list (the base gained it after the config was saved, or the
    // config lists none) takes this config's first variant of the same extruder, as a user preset's
    // values do in update_diff_values_to_child_config. Left unmatched, the base's value would silently
    // replace the user's.
    variant_index.resize(target_variant_count, -1);
    if (cur_variant_count == 0) {
        // Defensive: target_variant_count may be 0 if the preset doesn't carry extruder_variant_name.
        // In that case keep variant_index empty and let the downstream size checks produce a useful error.
        if (!variant_index.empty())
            // This config's one value belongs to the extruder of the base's first variant.
            variant_index = map_variant_indices(target_extruder_variants, target_extruder_ids, {},
                                                target_extruder_ids.empty() ? std::vector<int>() : std::vector<int>{target_extruder_ids[0]});
    }
    else if ((cur_extruder_ids.size() > 0) && cur_variant_count != cur_extruder_ids.size()){
        //should not happen
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" size of %1% = %2%, not equal to size of %3% = %4%")
             %extruder_variant_name %cur_variant_count %extruder_id_name %cur_extruder_ids.size();
    }
    else if ((target_extruder_ids.size() > 0) && target_variant_count != target_extruder_ids.size()){
        //should not happen
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(" size of %1% = %2%, not equal to size of %3% = %4%")
             %extruder_variant_name %target_variant_count %extruder_id_name %target_extruder_ids.size();
    }
    else {
        variant_index = map_variant_indices(target_extruder_variants, target_extruder_ids, cur_extruder_variants, cur_extruder_ids);
    }
 
    for (auto& opt : keys) {
        ConfigOption *opt_src = this->option(opt);
        const ConfigOption *opt_target = new_config.option(opt);
        if (opt_src && opt_target && (*opt_src != *opt_target)) {
            BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(" change key %1% from old_value %2% to inherit's value %3%")
                    %opt %(opt_src->serialize()) %(opt_target->serialize());
            if (different_keys.find(opt) == different_keys.end()) {
                opt_src->set(opt_target);
            }
            else {
                if (opt_target->is_scalar()
                    || ((key_set1.find(opt) == key_set1.end()) && (key_set2.empty() || (key_set2.find(opt) == key_set2.end())))) {
                    //nothing to do, keep the original one
                }
                else {
                    // Guard: set_with_restore is parent-shaped and would truncate the child's
                    // vector when the child has more extruders than the parent (e.g. an IDEX
                    // preset inheriting from a single-nozzle base). The child's saved value is
                    // authoritative for its own extruder count, so skip the merge for this key.
                    if (cur_variant_count > target_variant_count)
                        continue;
 
                    // The variant lists are the base's layout itself, which every other value is
                    // carried onto: a variant this config lacks keeps its own name and id.
                    if (opt == extruder_id_name || opt == extruder_variant_name) {
                        opt_src->set(opt_target);
                        continue;
                    }
 
                    int stride = 1;
                    if (key_set2.find(opt) != key_set2.end())
                        stride = 2;
 
                    const size_t restore_n     = variant_index.size();
                    const size_t expected_size = restore_n * size_t(stride);
 
                    if (stride == 2) {
                        // Options in key_set2 are machine limits stored as (normal,silent) pairs per printer variant.
                        if (opt_src->type() != coFloats || opt_target->type() != coFloats)
                            throw ConfigurationError((boost::format("%1%: key '%2%' is expected to be ConfigOptionFloats for stride=2.") % __FUNCTION__ % opt).str());
 
                        auto *src_f = static_cast<ConfigOptionFloats*>(opt_src);
                        ConfigOptionFloats rhs_tmp(*static_cast<const ConfigOptionFloats*>(opt_target));
 
                        const size_t src_size  = src_f->values.size();
                        const size_t dest_size = rhs_tmp.values.size();
                        if (src_size != expected_size || dest_size != expected_size)
                            log_normalize_legacy_vector_size(__FUNCTION__, opt, stride, src_size, dest_size, expected_size, restore_n, cur_variant_count,
                                                             target_variant_count, cur_extruder_ids.size(), target_extruder_ids.size(), opt_src, opt_target);
 
                        // Normalize src in-place so backup_values indexing is safe, normalize rhs via a temporary copy.
                        normalize_stride2_floats(*src_f, expected_size);
                        normalize_stride2_floats(rhs_tmp, expected_size);
                        src_f->set_with_restore(&rhs_tmp, variant_index, stride);
                    } else {
                        ConfigOptionVectorBase* opt_vec_src = static_cast<ConfigOptionVectorBase*>(opt_src);
 
                        const size_t src_size  = opt_vec_src->size();
                        const size_t dest_size = static_cast<const ConfigOptionVectorBase*>(opt_target)->size();
                        if (src_size != expected_size || dest_size != expected_size)
                            log_normalize_legacy_vector_size(__FUNCTION__, opt, stride, src_size, dest_size, expected_size, restore_n, cur_variant_count,
                                                             target_variant_count, cur_extruder_ids.size(), target_extruder_ids.size(), opt_src, opt_target);
 
                        if (opt_vec_src->size() != expected_size)
                            opt_vec_src->resize(expected_size, opt_target);
 
                        // Normalize rhs via a cloned temporary (rhs itself is const).
                        ConfigOptionUniquePtr rhs_owner(opt_target->clone());
                        ConfigOptionVectorBase *rhs_vec = dynamic_cast<ConfigOptionVectorBase*>(rhs_owner.get());
                        if (rhs_vec == nullptr)
                            throw ConfigurationError((boost::format("%1%: key '%2%' is expected to be a vector option.") % __FUNCTION__ % opt).str());
                        if (rhs_vec->size() != expected_size)
                            rhs_vec->resize(expected_size, opt_target);
 
                        opt_vec_src->set_with_restore(rhs_vec, variant_index, stride);
                    }
                }
            }
        }
    }
    return;
}

References DynamicPrintConfig(), Slic3r::ConfigOption::clone(), Slic3r::coFloats, Slic3r::ConfigOption::is_scalar(), Slic3r::DynamicConfig::keys(), Slic3r::map_variant_indices(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionVectorBase::resize(), Slic3r::ConfigOption::serialize(), Slic3r::ConfigOption::set(), Slic3r::ConfigOptionVectorBase::set_with_restore(), Slic3r::ConfigOptionVectorBase::size(), Slic3r::DynamicConfig::size(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionVector< double >::values.

Referenced by Slic3r::Preset::load_external_config().

Here is the call graph for this function:

Here is the caller graph for this function:

update_plugin_manifest()

void Slic3r::ConfigBase::update_plugin_manifest ( )

inherited

{
    // Writes the derived manifest back into this config's "plugins" option (save_to_json writes the
    // same manifest into a JSON document instead), so an in-memory backend config carries a resolved
    // manifest even when the source preset was never serialized (picked-but-unsaved). Without a
    // resolver (CLI/headless) leave whatever manifest was loaded from disk untouched.
    if (!resolve_capability_fn)
        return;
    if (auto* manifest = this->option<ConfigOptionStrings>("plugins", true))
        manifest->values = this->collect_plugin_manifest();
}

References collect_plugin_manifest(), option(), and resolve_capability_fn.

Here is the call graph for this function:

update_values_from_multi_to_multi()

int Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi	(	DynamicPrintConfig &	new_config,
		std::set< std::string > &	key_set,
		std::string	id_name,
		std::string	variant_name,
		std::vector< std::string > &	extruder_variants )

{
    int new_extruder_count = new_extruder_variants.size();
    std::vector<int> new_variant_indices(new_extruder_count, -1);
 
    auto print_variant_opt = dynamic_cast<const ConfigOptionStrings*>(this->option(variant_name));
    auto new_variant_opt = dynamic_cast<const ConfigOptionStrings*>(new_config.option(variant_name));
    auto new_print_id_opt = dynamic_cast<const ConfigOptionInts*>(new_config.option(id_name));
    if (!print_variant_opt || !new_variant_opt || !new_print_id_opt) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get variant %3%, id %4% from config")%__FUNCTION__ %__LINE__ % variant_name  % id_name;
        return -1;
    }
    int variant_count = print_variant_opt->size(), new_variant_count = new_variant_opt->size();
 
    std::vector<std::vector<int>> extruder_variant_indices;
    for (int i = 0; i < new_extruder_count; i++)
    {
        std::vector<int> variant_indices;
        for (int j = 0; j < variant_count; j++)
        {
            if (new_extruder_variants[i] == print_variant_opt->values[j]) {
                variant_indices.push_back(j);
            }
        }
 
        if (variant_indices.empty())
        {
            //can not find any
            variant_indices.resize(variant_count, 0);
            for (int j = 0; j < variant_count; j++)
                variant_indices[j] = j;
        }
        extruder_variant_indices.emplace_back(variant_indices);
    }
 
    for (int i = 0; i < new_extruder_count; i++)
    {
        for (int j = 0; j < new_variant_count; j++)
        {
            if ((i+1 == new_print_id_opt->values[j]) && (new_extruder_variants[i] == new_variant_opt->values[j])) {
                new_variant_indices[i] = j;
                break;
            }
        }
    }
 
    const ConfigDef* config_def = this->def();
    if (!config_def) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define") % __LINE__;
        return -1;
    }
    for (auto& key : key_set)
    {
        const ConfigOptionDef* optdef = config_def->get(key);
        if (!optdef) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%") % __LINE__ % key;
            continue;
        }
        switch (optdef->type) {
        case coStrings:
        {
            ConfigOptionStrings* src_opt = new_config.option<ConfigOptionStrings>(key);
            if (src_opt) {
                ConfigOptionStrings* opt = this->option<ConfigOptionStrings>(key, true);
 
                //assert(variant_count == opt->size());
                opt->values = src_opt->values;
            }
            break;
        }
        case coInts:
        {
            ConfigOptionInts* src_opt = new_config.option<ConfigOptionInts>(key);
            if (src_opt) {
                ConfigOptionInts* opt = this->option<ConfigOptionInts>(key, true);
 
                //assert(variant_count == opt->size());
                opt->values = src_opt->values;
            }
            break;
        }
        case coFloats:
        {
            ConfigOptionFloats* src_opt = new_config.option<ConfigOptionFloats>(key);
            if (src_opt) {
                ConfigOptionFloats* opt = this->option<ConfigOptionFloats>(key, true);
 
                std::vector<double> old_values = opt->values;
                int old_count = old_values.size();
                int new_count = src_opt->values.size();
 
                assert(variant_count == old_count);
                assert(new_variant_count == new_count);
                opt->values = src_opt->values;
 
                for (int i = 0; i < new_extruder_count; i++)
                {
                    std::vector<int>& variant_indices = extruder_variant_indices[i];
                    int new_variant_index = new_variant_indices[i];
                    if ((new_variant_index == -1) || variant_indices.empty())
                        continue;
 
                    for(auto idx : variant_indices){
                        assert(idx < old_count);
                        //the counts come from the variant columns, the arrays from the options;
                        //they disagree when a config was authored at a different variant width
                        if (idx >= old_count || new_variant_index >= (int)opt->values.size())
                            continue;
                        if (old_values[idx] < opt->values[new_variant_index])
                            opt->values[new_variant_index] = old_values[idx];
                    }
                }
            }
            break;
        }
        case coFloatsOrPercents:
        {
            ConfigOptionFloatsOrPercents* src_opt = new_config.option<ConfigOptionFloatsOrPercents>(key);
            if (src_opt) {
                ConfigOptionFloatsOrPercents* opt = this->option<ConfigOptionFloatsOrPercents>(key, true);
 
                std::vector<FloatOrPercent> old_values = opt->values;
                int old_count = old_values.size();
                int new_count = src_opt->values.size();
 
                assert(variant_count == old_count);
                assert(new_variant_count == new_count);
                opt->values = src_opt->values;
 
                for (int i = 0; i < new_extruder_count; i++)
                {
                    std::vector<int>& variant_indices = extruder_variant_indices[i];
                    int new_variant_index = new_variant_indices[i];
                    if ((new_variant_index == -1) || variant_indices.empty())
                        continue;
 
                    for(auto idx : variant_indices){
                        assert(idx < old_count);
                        //the counts come from the variant columns, the arrays from the options;
                        //they disagree when a config was authored at a different variant width
                        if (idx >= old_count || new_variant_index >= (int)opt->values.size())
                            continue;
                        if (old_values[idx] < opt->values[new_variant_index])
                            opt->values[new_variant_index] = old_values[idx];
                    }
                }
            }
            break;
        }
        case coBools:
        {
            ConfigOptionBools* src_opt = new_config.option<ConfigOptionBools>(key);
            if (src_opt) {
                ConfigOptionBools* opt = this->option<ConfigOptionBools>(key, true);
 
                std::vector<unsigned char> old_values = opt->values;
                int old_count = old_values.size();
                int new_count = src_opt->values.size();
 
                assert(variant_count == old_count);
                assert(new_variant_count == new_count);
                opt->values = src_opt->values;
 
                for (int i = 0; i < new_extruder_count; i++)
                {
                    std::vector<int>& variant_indices = extruder_variant_indices[i];
                    int new_variant_index = new_variant_indices[i];
                    if ((new_variant_index == -1) || variant_indices.empty())
                        continue;
 
                    for(auto idx : variant_indices){
                        assert(idx < old_count);
                        if (idx >= old_count || new_variant_index >= (int)opt->values.size())
                            continue;
                        if (old_values[idx]) //enabled
                            opt->values[new_variant_index] = old_values[idx];
                    }
                }
            }
 
            break;
        }
        default:
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%") % __LINE__ % key;
            break;
        }
    }
 
    return 0;
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coStrings, def(), Slic3r::ConfigDef::get(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionDef::type, Slic3r::ConfigOptionVector< T >::values, Slic3r::ConfigOptionVector< double >::values, Slic3r::ConfigOptionVector< FloatOrPercent >::values, Slic3r::ConfigOptionVector< int >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Here is the call graph for this function:

update_values_from_multi_to_multi_2()

int Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2	(	const std::vector< std::string > &	src_extruder_variants,
		const std::vector< std::string > &	dst_extruder_variants,
		const DynamicPrintConfig &	dst_config,
		const std::set< std::string > &	key_sets )

{
    const ConfigDef  *config_def     = this->def();
    if (!config_def) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
        return -1;
    }
 
    auto get_same_variant_indices = [](const std::vector<std::string>& extruder_variants, const std::string& variant){
        std::vector<int> indices;
        for(int i=0;i<extruder_variants.size();++i)
            if(extruder_variants[i] == variant)
                indices.push_back(i);
        return indices;
    };
 
    std::vector<std::vector<int>> same_variant_indices;
    for(size_t dst_idx =0 ;dst_idx < dst_extruder_variants.size(); ++dst_idx){
        auto& dst_variant = dst_extruder_variants[dst_idx];
        auto indices =get_same_variant_indices(src_extruder_variants, dst_variant);
        same_variant_indices.emplace_back(indices);
    }
 
    //dst_values below is the destination PRINT preset's per-variant row, sized to its own
    //print_extruder_variant; dst_extruder_variants is the PRINTER's list. They disagree until
    //the print preset is re-selected, so size the row to the variant count before indexing it.
    const size_t dst_variant_count = dst_extruder_variants.size();
    if (dst_variant_count == 0) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: empty destination variant list")%__LINE__;
        return -1;
    }
 
    t_config_option_keys keys = this->keys();
    for(auto& key : keys){
        if(key_sets.find(key) == key_sets.end())
            continue;
        const ConfigOptionDef* optdef = config_def->get(key);
        if(!optdef){
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
            continue;
        }
 
        switch (optdef->type){
            case coFloats:
            {
                ConfigOptionFloatsNullable* opt = this->option<ConfigOptionFloatsNullable>(key);
                auto src_values = opt->values;
                const auto* dst_opt = dst_config.option<ConfigOptionFloatsNullable>(key);
                if(!dst_opt){
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: %2% missing from destination config")%__LINE__%key;
                    break;
                }
                auto dst_values = dst_opt->values;
                dst_values.resize(dst_variant_count, ConfigOptionFloatsNullable::nil_value());
                for(size_t dst_idx =0; dst_idx < same_variant_indices.size(); ++dst_idx){
                    auto& indices = same_variant_indices[dst_idx];
                    if(indices.empty())
                        continue;
                    bool has_value = false;
                    double target_value = std::numeric_limits<double>::max();
                    for(auto idx : indices){
                        if(idx < (int)opt->values.size() && !opt->is_nil(idx)){
                            has_value = true;
                            target_value = std::min(target_value, src_values[idx]);
                        }
                    }
 
                    if(has_value)
                        dst_values[dst_idx] = target_value;
                }
                opt->values = dst_values;
                break;
            }
            case coFloatsOrPercents:
            {
                ConfigOptionFloatsOrPercentsNullable* opt = this->option<ConfigOptionFloatsOrPercentsNullable>(key);
                auto src_values = opt->values;
                const auto* dst_opt = dst_config.option<ConfigOptionFloatsOrPercentsNullable>(key);
                if(!dst_opt){
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: %2% missing from destination config")%__LINE__%key;
                    break;
                }
                auto dst_values = dst_opt->values;
                dst_values.resize(dst_variant_count, ConfigOptionFloatsOrPercentsNullable::nil_value());
                for(size_t dst_idx =0; dst_idx < same_variant_indices.size(); ++dst_idx){
                    auto& indices = same_variant_indices[dst_idx];
                    if(indices.empty())
                        continue;
                    bool has_value = false;
                    FloatOrPercent target_value{9999.f, true};
                    for(auto idx : indices){
                        if(idx < (int)opt->values.size() && !opt->is_nil(idx)){
                            has_value = true;
                            target_value = src_values[idx].value < target_value.value ? src_values[idx] : target_value;
                        }
                    }
 
                    if(has_value)
                        dst_values[dst_idx] = target_value;
                }
                opt->values = dst_values;
                break;
            }
            case coBools:
            {
                ConfigOptionBoolsNullable* opt = this->option<ConfigOptionBoolsNullable>(key);
                auto src_values = opt->values;
                const auto* dst_opt = dst_config.option<ConfigOptionBoolsNullable>(key);
                if(!dst_opt){
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: %2% missing from destination config")%__LINE__%key;
                    break;
                }
                auto dst_values = dst_opt->values;
                dst_values.resize(dst_variant_count, ConfigOptionBoolsNullable::nil_value());
                for(size_t dst_idx =0; dst_idx < same_variant_indices.size(); ++dst_idx){
                    auto indices = same_variant_indices[dst_idx];
                    if(indices.empty())
                        continue;
                    bool has_value = false;
                    bool target_value = false;
                    for(auto idx : indices){
                        if(idx < (int)opt->values.size() && !opt->is_nil(idx)){
                            has_value = true;
                            target_value = src_values[idx];
                            break;
                        }
                    }
 
                    if(has_value)
                        dst_values[dst_idx] = target_value;
                }
 
                opt->values = dst_values;
                break;
            }
            default:
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
                break;
        }
 
    }
 
    return 0;
 
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coFloatsOrPercents, def(), Slic3r::ConfigDef::get(), Slic3r::DynamicConfig::keys(), Slic3r::ConfigOptionBoolsTempl< true >::nil_value(), Slic3r::ConfigOptionFloatsOrPercentsTempl< true >::nil_value(), Slic3r::ConfigOptionFloatsTempl< true >::nil_value(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionDef::type, and Slic3r::FloatOrPercent::value.

Referenced by Slic3r::GUI::Tab::load_current_preset(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

update_values_from_single_to_multi()

int Slic3r::DynamicPrintConfig::update_values_from_single_to_multi	(	DynamicPrintConfig &	multi_config,
		std::set< std::string > &	key_set,
		std::string	id_name,
		std::string	variant_name )

{
    auto print_variant_opt = dynamic_cast<const ConfigOptionStrings*>(multi_config.option(variant_name));
    if (!print_variant_opt) {
        BOOST_LOG_TRIVIAL(error) << boost::format("%1%:%2%, can not get %3% from config")%__FUNCTION__ %__LINE__ % variant_name;
        return -1;
    }
    int variant_count = print_variant_opt->size();
 
    const ConfigDef  *config_def     = this->def();
    if (!config_def) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
        return -1;
    }
    for (auto& key: key_set)
    {
        const ConfigOptionDef *optdef  = config_def->get(key);
        if (!optdef) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
            continue;
        }
        switch (optdef->type) {
            case coStrings:
            {
                ConfigOptionStrings* src_opt = multi_config.option<ConfigOptionStrings>(key);
                if (src_opt) {
                    ConfigOptionStrings* opt = this->option<ConfigOptionStrings>(key, true);
 
                    opt->values = src_opt->values;
                }
                break;
            }
            case coInts:
            {
                ConfigOptionInts* src_opt = multi_config.option<ConfigOptionInts>(key);
                if (src_opt) {
                    ConfigOptionInts* opt = this->option<ConfigOptionInts>(key, true);
 
                    opt->values = src_opt->values;
                }
                break;
            }
            case coFloats:
            {
                ConfigOptionFloats * src_opt = multi_config.option<ConfigOptionFloats>(key);
                if (src_opt) {
                    ConfigOptionFloats * opt = this->option<ConfigOptionFloats>(key, true);
 
                    assert(variant_count == src_opt->size());
                    opt->resize(variant_count, opt);
 
                    for (int index = 0; index < variant_count; index++)
                    {
                        //variant_count is the variant column width, src_opt the value array;
                        //they disagree when the source was authored at a different width
                        if (index >= (int)src_opt->values.size())
                            break;
                        if (opt->values[index] > src_opt->values[index])
                            opt->values[index] = src_opt->values[index];
                    }
                }
                break;
            }
            case coFloatsOrPercents:
            {
                ConfigOptionFloatsOrPercents * src_opt = multi_config.option<ConfigOptionFloatsOrPercents>(key);
                if (src_opt) {
                    ConfigOptionFloatsOrPercents * opt = this->option<ConfigOptionFloatsOrPercents>(key, true);
 
                    assert(variant_count == src_opt->size());
                    opt->resize(variant_count, opt);
 
                    for (int index = 0; index < variant_count; index++)
                    {
                        if (index >= (int)src_opt->values.size())
                            break;
                        if (opt->values[index].value > src_opt->values[index].value)
                            opt->values[index] = src_opt->values[index];
                    }
                }
                break;
            }
            case coBools:
            {
                ConfigOptionBools * src_opt = multi_config.option<ConfigOptionBools>(key);
                if (src_opt)
                {
                    ConfigOptionBools * opt = this->option<ConfigOptionBools>(key, true);
 
                    assert(variant_count == src_opt->size());
                    opt->resize(variant_count, opt);
                }
 
                break;
            }
            default:
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
                break;
        }
    }
 
    return 0;
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coStrings, def(), Slic3r::ConfigDef::get(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::ConfigOptionVector< FloatOrPercent >::size(), Slic3r::ConfigOptionVector< unsigned char >::size(), Slic3r::ConfigOptionDef::type, Slic3r::ConfigOptionVector< T >::values, Slic3r::ConfigOptionVector< double >::values, Slic3r::ConfigOptionVector< FloatOrPercent >::values, and Slic3r::ConfigOptionVector< int >::values.

Here is the call graph for this function:

update_values_to_printer_extruders()

std::vector< int > Slic3r::DynamicPrintConfig::update_values_to_printer_extruders	(	DynamicPrintConfig &	printer_config,
		int	extruder_count,
		int	extruder_nozzle_volume_count,
		std::vector< std::vector< NozzleVolumeType > > &	nv_types,
		std::set< std::string > &	key_set,
		std::string	id_name,
		std::string	variant_name,
		unsigned int	stride = 1,
		unsigned int	extruder_id = 0,
		NozzleVolumeType	filament_nvt = nvtStandard )

{
    std::vector<int> variant_index;
    int variant_count = extruder_count;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: extruder_count %2%, extruder_nozzle_volume_count %3%")%__LINE__ %extruder_count %extruder_nozzle_volume_count;
 
    auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("extruder_type"));
    auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("nozzle_volume_type"));
    if (!opt_extruder_type || !opt_nozzle_volume_type) {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: extruder_type or nozzle_volume_type option not found, skipping")%__LINE__;
        return variant_index;
    }
 
    if (extruder_id > 0 && extruder_id <= static_cast<unsigned> (extruder_count)) {
        variant_index.resize(1);
        ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(extruder_id - 1));
        NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(extruder_id - 1));
 
        if (nozzle_volume_type == nvtHybrid) {
            // a mixed-nozzle extruder has no preset column of its own: the filament's concrete
            // volume type selects the slot
            nozzle_volume_type = filament_nvt;
        }
        else if (nozzle_volume_type != filament_nvt) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__
                                    << boost::format(", Line %1%: nozzle_volume_type is %2%,  not equal to filament_nvt %3%") % __LINE__ % nozzle_volume_type % filament_nvt;
        }
 
        //variant index
        variant_index[0] = get_index_for_extruder(extruder_id, id_name, extruder_type, nozzle_volume_type, variant_name);
 
        if (variant_index[0] < 0) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: could not found extruder_type %2%, nozzle_volume_type %3%, for filament")
                % __LINE__ % s_keys_names_ExtruderType[extruder_type] % s_keys_names_NozzleVolumeType[nozzle_volume_type];
        }
 
        variant_count = 1;
    }
    else {
        if (id_name == "print_extruder_id")
            ensure_process_variant_columns(*this, printer_config);
        // Orca: emit the slots first, then size variant_count from what was actually
        // emitted. extruder_nozzle_volume_count only equals the emitted total when every
        // extruder carries per-type stats; an extruder with an empty stats entry combined
        // with a Hybrid extruder would otherwise overrun a table pre-sized from that count.
        for (int e_index = 0; e_index < extruder_count; e_index++)
        {
            ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(e_index));
            NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(e_index));
 
            // Orca: latch the decision before the inner loop reassigns nozzle_volume_type;
            // re-testing the reassigned value would make every slot after the first reuse
            // the first slot's volume type.
            const bool per_type_slots = extruder_nozzle_volume_count > extruder_count || nozzle_volume_type == nvtHybrid;
            const int nvt_count = per_type_slots ? int(nv_types[e_index].size()) : 1;
            for (int nvt_index = 0; nvt_index < nvt_count; nvt_index++)
            {
                if (per_type_slots)
                    nozzle_volume_type = nv_types[e_index][nvt_index];
                //variant index
                int slot_index = get_index_for_extruder(e_index+1, id_name, extruder_type, nozzle_volume_type, variant_name);
                if (slot_index < 0) {
                    // Orca: This is expected during transient UI states (e.g. popup windows),
                    // fall back to 0 silently.
                    slot_index = 0;
                }
                variant_index.push_back(slot_index);
            }
        }
        variant_count = int(variant_index.size());
    }
 
    const ConfigDef       *config_def     = this->def();
    if (!config_def) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
        return variant_index;
    }
    for (auto& key: key_set)
    {
        const ConfigOptionDef *optdef  = config_def->get(key);
        if (!optdef) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
            continue;
        }
        switch (optdef->type) {
            case coStrings:
            {
                ConfigOptionStrings * opt = this->option<ConfigOptionStrings>(key);
                if (!opt) continue;
                std::vector<std::string> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coInts:
            {
                ConfigOptionInts * opt = this->option<ConfigOptionInts>(key);
                if (!opt) continue;
                std::vector<int> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coFloats:
            {
                ConfigOptionFloats * opt = this->option<ConfigOptionFloats>(key);
                if (!opt) continue;
                std::vector<double> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coPercents:
            {
                ConfigOptionPercents * opt = this->option<ConfigOptionPercents>(key);
                if (!opt) continue;
                std::vector<double> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coFloatsOrPercents:
            {
                ConfigOptionFloatsOrPercents * opt = this->option<ConfigOptionFloatsOrPercents>(key);
                if (!opt) continue;
                std::vector<FloatOrPercent> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coBools:
            {
                ConfigOptionBools * opt = this->option<ConfigOptionBools>(key);
                if (!opt) continue;
                std::vector<unsigned char> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            case coEnums:
            {
                ConfigOptionEnumsGeneric * opt = this->option<ConfigOptionEnumsGeneric>(key);
                if (!opt) continue;
                std::vector<int> new_values;
 
                new_values.resize(variant_count * stride);
                for (int e_index = 0; e_index < variant_count; e_index++)
                {
                    for (unsigned int i = 0; i < stride; i++)
                        new_values[e_index*stride + i] = opt->get_at(variant_index[e_index]*stride + i);
                }
                opt->values = new_values;
                break;
            }
            default:
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
                break;
        }
    }
 
    return variant_index;
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coEnums, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coStrings, def(), Slic3r::ensure_process_variant_columns(), Slic3r::ConfigDef::get(), get_index_for_extruder(), Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::size(), and Slic3r::ConfigOptionDef::type.

Referenced by Slic3r::PresetBundle::construct_full_config(), and Slic3r::PresetBundle::full_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

update_values_to_printer_extruders_for_multiple_filaments()

void Slic3r::DynamicPrintConfig::update_values_to_printer_extruders_for_multiple_filaments	(	DynamicPrintConfig &	printer_config,
		int	extruder_count,
		int	extruder_nozzle_volume_count,
		std::set< std::string > &	key_set,
		std::string	id_name,
		std::string	variant_name )

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: extruder_count %2%, extruder_nozzle_volume_count %3%")%__LINE__ %extruder_count %extruder_nozzle_volume_count;
 
    {
        auto opt_filament_map = printer_config.option<ConfigOptionInts>("filament_map");
        if (!opt_filament_map) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: filament_map option not found, skipping")%__LINE__;
            return;
        }
        std::vector<int> filament_maps = opt_filament_map->values;
        auto opt_ids = id_name.empty()? nullptr: dynamic_cast<const ConfigOptionInts*>(this->option(id_name));
        // Orca: a map shorter than the filament count must not drop the filaments past its end;
        // they take the first extruder.
        if (opt_ids && !opt_ids->values.empty())
            filament_maps.resize(std::max<size_t>(filament_maps.size(), *std::max_element(opt_ids->values.begin(), opt_ids->values.end())), 1);
        size_t filament_count = filament_maps.size();
        //apply process settings
        auto opt_extruder_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("extruder_type"));
        auto opt_nozzle_volume_type = dynamic_cast<const ConfigOptionEnumsGeneric*>(printer_config.option("nozzle_volume_type"));
        if (!opt_extruder_type || !opt_nozzle_volume_type) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: extruder_type or nozzle_volume_type option not found, skipping")%__LINE__;
            return;
        }
 
        auto opt_filament_volume_maps = dynamic_cast<const ConfigOptionInts*>(printer_config.option("filament_volume_map"));
        std::vector<int> filament_volume_maps;
        // Orca: honour the per-filament volume map only when a producer sized it to the
        // filament count. The full-config producers (PresetBundle injection, engine
        // write-back) always size it; mis-sized maps (stale project values, CLI runs until
        // the per-filament synthesis lands there) must not distort slot resolution nor be
        // indexed out of bounds.
        if (opt_filament_volume_maps && opt_filament_volume_maps->values.size() == filament_count)
            filament_volume_maps = opt_filament_volume_maps->values;
        std::vector<int> variant_index;
 
        variant_index.resize(filament_count, -1);
 
        for (int f_index = 0; f_index < filament_count; f_index++)
        {
            ExtruderType extruder_type = (ExtruderType)(opt_extruder_type->get_at(filament_maps[f_index] - 1));
            NozzleVolumeType nozzle_volume_type = (NozzleVolumeType)(opt_nozzle_volume_type->get_at(filament_maps[f_index] - 1));
 
            if ((extruder_nozzle_volume_count > extruder_count || nozzle_volume_type == nvtHybrid) && (!filament_volume_maps.empty())) {
                nozzle_volume_type = (NozzleVolumeType)(filament_volume_maps[f_index]);
            }
 
            //variant index
            variant_index[f_index] = get_index_for_extruder(f_index+1, id_name, extruder_type, nozzle_volume_type, variant_name);
            if (variant_index[f_index] < 0) {
                // Orca: a filament need not define every extruder variant (a Direct Drive filament on a
                // Bowden printer), so this is not an invalid state: the filament's first variant is used.
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(", Line %1%: could not found extruder_type %2%, nozzle_volume_type %3%, filament_index %4%, extruder index %5%")
                    %__LINE__ %s_keys_names_ExtruderType[extruder_type] % s_keys_names_NozzleVolumeType[nozzle_volume_type] % (f_index+1) %filament_maps[f_index];
                //for some updates happens in a invalid state(caused by popup window)
                //we need to avoid crash
                variant_index[f_index] = 0;
                if (opt_ids) {
                    for (int i = 0; i < opt_ids->values.size(); i++)
                        if (opt_ids->values[i] == (f_index+1)) {
                            variant_index[f_index] = i;
                            break;
                        }
                }
            }
        }
 
        const ConfigDef       *config_def     = this->def();
        if (!config_def) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format(", Line %1%: can not find config define")%__LINE__;
            return;
        }
        bool has_id_key = !id_name.empty() && key_set.count(id_name) > 0;
        for (auto& key: key_set)
        {
            if (has_id_key && key == id_name)
                continue;
            const ConfigOptionDef *optdef  = config_def->get(key);
            if (!optdef) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: can not find opt define for %2%")%__LINE__%key;
                continue;
            }
            // An empty option has no first value to fall back on; give it one registered default per filament.
            if (auto *vec = dynamic_cast<ConfigOptionVectorBase*>(this->option(key)); vec && vec->empty() && optdef->default_value)
                vec->resize(filament_count, optdef->default_value.get());
 
            switch (optdef->type) {
                case coStrings:          gather_option_values<ConfigOptionStrings, std::string>(__FUNCTION__, key, this->option<ConfigOptionStrings>(key), variant_index); break;
                case coInts:             gather_option_values<ConfigOptionInts, int>(__FUNCTION__, key, this->option<ConfigOptionInts>(key), variant_index); break;
                case coFloats:           gather_option_values<ConfigOptionFloats, double>(__FUNCTION__, key, this->option<ConfigOptionFloats>(key), variant_index); break;
                case coPercents:         gather_option_values<ConfigOptionPercents, double>(__FUNCTION__, key, this->option<ConfigOptionPercents>(key), variant_index); break;
                case coFloatsOrPercents: gather_option_values<ConfigOptionFloatsOrPercents, FloatOrPercent>(__FUNCTION__, key, this->option<ConfigOptionFloatsOrPercents>(key), variant_index); break;
                case coBools:            gather_option_values<ConfigOptionBools, unsigned char>(__FUNCTION__, key, this->option<ConfigOptionBools>(key), variant_index); break;
                case coEnums:            gather_option_values<ConfigOptionEnumsGeneric, int>(__FUNCTION__, key, this->option<ConfigOptionEnumsGeneric>(key), variant_index); break;
                default:
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(", Line %1%: unsupported option type for %2%")%__LINE__%key;
                    break;
            }
        }
        // Orca: also require a non-empty id list; get_at on an empty vector is undefined.
        if (has_id_key && opt_ids && !opt_ids->values.empty()) {
            // remap the id list itself last: the lookups above still need the original ids
            std::vector<int> new_values;
            new_values.resize(filament_count);
            for (int f_index = 0; f_index < filament_count; f_index++) {
                new_values[f_index] = opt_ids->get_at(variant_index[f_index]);
            }
            const_cast<ConfigOptionInts*>(opt_ids)->values = new_values;
        }
    }
}

References DynamicPrintConfig(), Slic3r::coBools, Slic3r::coEnums, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coStrings, def(), Slic3r::ConfigOptionDef::default_value, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::gather_option_values(), Slic3r::ConfigDef::get(), get_index_for_extruder(), Slic3r::nozzle_volume_type(), Slic3r::nvtHybrid, Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionDef::type.

Here is the call graph for this function:

validate()

std::map< std::string, std::string > Slic3r::DynamicPrintConfig::validate

(

bool

under_cli = false

)

{
    // Full print config is initialized from the defaults.
    const ConfigOption *opt = this->option("printer_technology", false);
    auto printer_technology = (opt == nullptr) ? ptFFF : static_cast<PrinterTechnology>(dynamic_cast<const ConfigOptionEnumGeneric*>(opt)->value);
    switch (printer_technology) {
    case ptFFF:
    {
        FullPrintConfig fpc;
        fpc.apply(*this, true);
        // Verify this print options through the FullPrintConfig.
        return Slic3r::validate(fpc, under_cli);
    }
    default:
        //FIXME no validation on SLA data?
        return std::map<std::string, std::string>();
    }
}

References Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::printer_technology(), Slic3r::ptFFF, Slic3r::validate(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

Member Data Documentation

options

std::map<t_config_option_key, std::unique_ptr<ConfigOption> > Slic3r::DynamicConfig::options

privateinherited

Referenced by DynamicConfig(), cbegin(), cend(), diff_report(), empty(), Slic3r::DynamicPrintAndCLIConfig::handle_legacy(), keys(), operator+=(), operator=(), operator==(), optptr(), optptr(), read_cli(), remove_nil_options(), serialize(), size(), and swap().

---

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

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