Slic3r::DynamicPrintConfig Class Reference

#include <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 ()
void	set_num_extruders (unsigned int num_extruders)
std::string	validate ()
void	handle_legacy (t_config_option_key &opt_key, std::string &value) const override
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 ()
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
bool	equals (const ConfigBase &other) const
t_config_option_keys	diff (const DynamicConfig &other) const
t_config_option_keys	diff (const ConfigBase &other) const
t_config_option_keys	equal (const DynamicConfig &other) const
t_config_option_keys	equal (const ConfigBase &other) 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
ConfigOption *	option (const t_config_option_key &opt_key, bool create=false)
template<typename TYPE >
TYPE *	option (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option (const t_config_option_key &opt_key) const
template<typename TYPE >
const TYPE *	option (const t_config_option_key &opt_key) const
ConfigOption *	option_throw (const t_config_option_key &opt_key, bool create=false)
template<typename TYPE >
TYPE *	option_throw (const t_config_option_key &opt_key, bool create=false)
const ConfigOption *	option_throw (const t_config_option_key &opt_key) const
template<typename TYPE >
const TYPE *	option_throw (const t_config_option_key &opt_key) const
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 ConfigOptionDef *	option_def (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 (const t_config_option_key &opt_key) const
double	get_abs_value (const t_config_option_key &opt_key, double ratio_over) 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
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
template<typename ENUM >
ENUM	opt_enum (const t_config_option_key &opt_key) 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
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_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	null_nullables ()
bool	has (const t_config_option_key &opt_key) const

Static Public Member Functions
static DynamicPrintConfig	full_print_config ()
static DynamicPrintConfig	full_print_config_with (const t_config_option_key &opt_key, const std::string &str, bool append=false)
static DynamicPrintConfig	full_print_config_with (std::initializer_list< SetDeserializeItem > items)
static DynamicPrintConfig	new_with (const t_config_option_key &opt_key, const std::string &str, bool append=false)
static DynamicPrintConfig	new_with (std::initializer_list< SetDeserializeItem > items)
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)

Private Member Functions
template<class Archive >
void	serialize (Archive &ar)
bool	set_deserialize_raw (const t_config_option_key &opt_key_src, const std::string &value, ConfigSubstitutionContext &substitutions, bool append)

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 full_print_config(), and new_from_defaults_keys().

Here is the caller graph for this function:

DynamicPrintConfig() [2/5]

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

inline

: DynamicConfig(rhs) {}

DynamicPrintConfig() [3/5]

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

inlinenoexcept

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

DynamicPrintConfig() [4/5]

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

explicit

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

DynamicPrintConfig() [5/5]

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

inlineexplicit

: DynamicConfig(rhs) {}

Member Function Documentation

apply()

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

inlineinherited

{ this->apply_only(other, other.keys(), ignore_nonexistent); }

References Slic3r::ConfigBase::apply_only(), and Slic3r::ConfigBase::keys().

Referenced by Slic3r::PresetCollection::PresetCollection(), Slic3r::GCodeProcessor::apply_config_superslicer(), Slic3r::GUI::SLAImportJob::finalize(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::PresetBundle::load_config_file(), Slic3r::PresetBundle::load_configbundle(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::PresetCollection::load_presets(), Slic3r::GCodeProcessor::process_file(), Slic3r::CLI::run(), and Slic3r::GUI::ObjectSettings::update_config_values().

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 (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 Slic3r::ConfigBase::keys(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOption::set().

Referenced by Slic3r::PresetBundle::PresetBundle(), Slic3r::ConfigBase::apply(), Slic3r::ModelConfig::apply(), Slic3r::ModelConfig::apply_only(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::load_preset(), Slic3r::GUI::Tab::may_discard_current_dirty_preset(), Slic3r::PresetBundle::save_changes_for_preset(), Slic3r::PresetBundle::transfer_and_save(), Slic3r::PhysicalPrinter::update_from_config(), and Slic3r::PhysicalPrinter::update_from_preset().

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 Slic3r::DynamicConfig::options.

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::ModelConfig::cbegin(), Slic3r::dynamic_config_iterate(), and cereal::save().

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 Slic3r::DynamicConfig::options.

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::ModelConfig::cend(), Slic3r::dynamic_config_iterate(), and cereal::save().

Here is the caller graph for this function:

clear()

void Slic3r::DynamicConfig::clear ( )

inlineinherited

    { 
        this->options.clear(); 
    }

Referenced by Slic3r::PlaceholderParser::clear_config(), cereal::load(), Slic3r::PresetBundle::load_configbundle(), Slic3r::DynamicConfig::operator=(), Slic3r::DynamicConfig::operator=(), Slic3r::GCode::PlaceholderParserIntegration::reset(), Slic3r::ModelConfig::reset(), Slic3r::GUI::ObjectList::Clipboard::reset(), and Slic3r::GUI::GLCanvas3D::LayersEditing::set_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::GUI::TabSLAMaterial::build(), Slic3r::GUI::change_opt_value(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_full_label(), Slic3r::GUI::get_full_settings_hierarchy(), Slic3r::GUI::ConfigOptionsGroup::get_option(), Slic3r::GUI::get_string_value(), and Slic3r::GUI::TabSLAPrint::update_description_lines().

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 Slic3r::ConfigBase::diff(), Slic3r::ConfigBase::keys(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::ConfigBase::diff(), and Slic3r::DynamicConfig::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 Slic3r::ConfigBase::diff(), and Slic3r::dynamic_config_iterate().

Referenced by Slic3r::GUI::ObjectSettings::add_missed_options(), Slic3r::GUI::ConfigManipulation::apply(), Slic3r::PresetCollection::dirty_options(), Slic3r::profile_print_params_same(), and Slic3r::Preset::set_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::DynamicConfig::empty ( ) const

inlineinherited

{ return options.empty(); }

References Slic3r::DynamicConfig::options.

Referenced by Slic3r::ModelConfig::empty(), Slic3r::extract_profile(), Slic3r::load_3mf(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::paste_settings_into_list(), and Slic3r::GUI::GUI_App::post_init().

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 Slic3r::ConfigBase::equal(), Slic3r::ConfigBase::keys(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::ConfigBase::equal(), and Slic3r::DynamicConfig::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 Slic3r::dynamic_config_iterate(), and Slic3r::ConfigBase::equal().

Here is the call graph for this function:

equals() [1/2]

bool Slic3r::ConfigBase::equals ( const ConfigBase &  other ) const

inherited

{ 
    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)
            return false;
    }
    return true;
}

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

Here is the call graph for this function:

equals() [2/2]

bool Slic3r::DynamicConfig::equals ( const DynamicConfig &  other ) const

inherited

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

References Slic3r::dynamic_config_iterate().

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

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::ModelConfig::erase(), Slic3r::PresetBundle::full_config_secure(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), normalize_fdm(), and Slic3r::Preset::remove_invalid_keys().

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.

Referenced by full_print_config_with(), and full_print_config_with().

Here is the call graph for this function:

Here is the caller graph for this function:

full_print_config_with() [1/2]

static DynamicPrintConfig Slic3r::DynamicPrintConfig::full_print_config_with ( const t_config_option_key &  opt_key, const std::string &  str, bool  append = false  )

inlinestatic

                                                                                                                                     {
        auto config = DynamicPrintConfig::full_print_config();
        config.set_deserialize_strict(opt_key, str, append);
        return config;
    }

References Slic3r::append(), and full_print_config().

Here is the call graph for this function:

full_print_config_with() [2/2]

static DynamicPrintConfig Slic3r::DynamicPrintConfig::full_print_config_with ( std::initializer_list< SetDeserializeItem >  items )

inlinestatic

                                                                                                     {
        auto config = DynamicPrintConfig::full_print_config();
        config.set_deserialize_strict(items);
        return config;
    }

References full_print_config().

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);
    assert(raw_opt != nullptr);
    if (raw_opt->type() == coFloat)
        return static_cast<const ConfigOptionFloat*>(raw_opt)->value;
    if (raw_opt->type() == coFloatOrPercent) {
        // 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);
        // 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::coFloat, Slic3r::coFloatOrPercent, Slic3r::ConfigBase::def(), Slic3r::ConfigDef::get(), Slic3r::ConfigBase::get_abs_value(), Slic3r::ConfigOptionDef::ratio_over, and Slic3r::ConfigOption::type().

Referenced by Slic3r::ConfigBase::get_abs_value(), Slic3r::ConfigBase::get_abs_value(), Slic3r::PresetHints::maximum_volumetric_flow_description(), and Slic3r::CLI::run().

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);
    assert(raw_opt != nullptr);
    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, Slic3r::ConfigBase::get_abs_value(), and Slic3r::ConfigOption::type().

Here is the call 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:

has()

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

inlineinherited

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

References Slic3r::ConfigOptionResolver::optptr().

Referenced by Slic3r::GUI::Bed3D::detect_type(), Slic3r::PresetCollection::dirty_options(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_f(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_i(), Slic3r::GUI::GLGizmoHollow::get_config_options(), Slic3r::GUI::GLGizmoSlaSupports::get_config_options(), Slic3r::GUI::Plater::get_extruder_colors_from_plater_config(), Slic3r::GUI::ConfigOptionsGroup::get_option(), Slic3r::handle_legacy_project_loaded(), Slic3r::handle_legacy_sla(), Slic3r::ModelConfig::has(), Slic3r::PresetCollection::is_dirty(), normalize_fdm(), Slic3r::DynamicConfig::read_cli(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::Preset::remove_invalid_keys(), and Slic3r::PresetBundle::update_compatible().

Here is the call graph for this function:

Here is the caller 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 Slic3r::ConfigBase::keys(), and Slic3r::ConfigBase::opt().

Referenced by Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::GCode::append_full_config(), Slic3r::Search::OptionsSearcher::append_options(), Slic3r::PlaceholderParser::apply_config(), Slic3r::PlaceholderParser::config_diff(), Slic3r::PresetBundle::full_fff_config(), Slic3r::full_print_config_diffs(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::ModelConfig::keys(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::PresetCollection::load_external_preset(), Slic3r::PresetCollection::load_preset(), new_from_defaults_keys(), Slic3r::GUI::ObjectList::paste_settings_into_list(), Slic3r::Preset::remove_invalid_keys(), and Slic3r::store_amf().

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
        }
    }
    return std::move(substitutions_ctxt.substitutions);
}

References Slic3r::ConfigBase::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

{
    return is_gcode_file(file) ? 
        this->load_from_gcode_file(file, compatibility_rule) :
        this->load_from_ini(file, compatibility_rule);
}

References Slic3r::is_gcode_file(), Slic3r::ConfigBase::load_from_gcode_file(), and Slic3r::ConfigBase::load_from_ini().

Referenced by Slic3r::extract_profile(), Slic3r::PresetBundle::load_config_file(), Slic3r::ConfigBase::load_from_ini(), Slic3r::ConfigBase::load_from_ini_string(), Slic3r::SL1Reader::read(), Slic3r::SL1_SVGReader::read(), and Slic3r::CLI::run().

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, std::ifstream::binary);
    // Look for Slic3r or PrusaSlicer 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.
    bool has_delimiters = false;
    {
      static constexpr const char slic3r_gcode_header[] = "; generated by Slic3r ";
        static constexpr const char prusaslicer_gcode_header[] = "; generated by PrusaSlicer ";
        std::string header;
        bool        header_found = false;
        while (std::getline(ifs, header)) {
            if (strncmp(slic3r_gcode_header, header.c_str(), strlen(slic3r_gcode_header)) == 0) {
                header_found = true;
                break;
            } else if (strncmp(prusaslicer_gcode_header, header.c_str(), strlen(prusaslicer_gcode_header)) == 0) {
                // Parse PrusaSlicer version.
                size_t i = strlen(prusaslicer_gcode_header);
                for (; i < header.size() && header[i] == ' '; ++ i) ;
                size_t j = i;
                for (; j < header.size() && header[j] != ' '; ++ j) ;
                try {
                    Semver semver(header.substr(i, j - i));
                    has_delimiters = semver >= Semver(2, 4, 0, nullptr, "alpha0");
                } catch (const RuntimeError &) {
                }
                header_found = true;
                break;
            }
        }
        if (! header_found)
            throw Slic3r::RuntimeError("Not a PrusaSlicer / Slic3r PE generated g-code.");
    }
 
    auto                      header_end_pos = ifs.tellg();
    ConfigSubstitutionContext substitutions_ctxt(compatibility_rule);
    size_t                    key_value_pairs = 0;
 
    if (has_delimiters)
    {
        // PrusaSlicer starting with 2.4.0-alpha0 delimits the config section stored into G-code with 
        // ; prusaslicer_config = begin
        // ...
        // ; prusaslicer_config = end
        // The begin / end tags look like any other key / value pairs on purpose to be compatible with older G-code viewer.
        // Read the file in reverse line by line.
        ReverseLineReader reader(ifs, header_end_pos);
        // Read the G-code file by 64k blocks back to front.
        bool begin_found = false;
        bool end_found   = false;
        std::string line;
        while (reader.getline(line))
            if (line == "; prusaslicer_config = end") {
                end_found = true;
                break;
            }
        if (! end_found) 
            throw Slic3r::RuntimeError(format("Configuration block closing tag \"; prusaslicer_config = end\" not found when reading %1%", file));
        std::string key, value;
        while (reader.getline(line)) {
            if (line == "; prusaslicer_config = begin") {
                begin_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 (! begin_found) 
            throw Slic3r::RuntimeError(format("Configuration block opening tag \"; prusaslicer_config = begin\" not found when reading %1%", file));
    }
    else
    {
        // Slic3r or PrusaSlicer 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)
        throw Slic3r::RuntimeError(format("Suspiciously low number of configuration values extracted from %1%: %2%", file, key_value_pairs));
    return std::move(substitutions_ctxt.substitutions);
}

References Slic3r::format(), Slic3r::ReverseLineReader::getline(), Slic3r::ConfigBase::load_from_gcode_string_legacy(), Slic3r::ConfigBase::set_deserialize(), and Slic3r::ConfigSubstitutionContext::substitutions.

Referenced by Slic3r::ConfigBase::load(), Slic3r::PresetBundle::load_config_file(), 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;
 
    // Walk line by line in reverse until a non-configuration key appears.
    const char *data_start = str;
    // 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(str);
    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;
    }
 
    return num_key_value_pairs;
}

References Slic3r::ConfigBase::set_deserialize().

Referenced by Slic3r::AMFParserContext::endElement(), Slic3r::ConfigBase::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("Failed loading configuration file \"%1%\": %2%", file, e.what()));
    }
}

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

Referenced by Slic3r::ConfigBase::load(), Slic3r::PresetCollection::load_presets(), and Slic3r::PhysicalPrinterCollection::load_printers().

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 Slic3r::ConfigBase::load().

Referenced by Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), and Slic3r::ConfigBase::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 Slic3r::ConfigBase::load_from_ini_string().

Here is the call 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::GLGizmoHollow::get_config_options(), Slic3r::GUI::GLGizmoSlaSupports::get_config_options(), and Slic3r::GUI::ObjectList::merge().

Here is the call graph for this function:

Here is the caller graph for this function:

new_with() [1/2]

static DynamicPrintConfig Slic3r::DynamicPrintConfig::new_with ( const t_config_option_key &  opt_key, const std::string &  str, bool  append = false  )

inlinestatic

                                                                                                                       {
        DynamicPrintConfig config;
        config.set_deserialize_strict(opt_key, str, append);
        return config;
    }

References Slic3r::append(), and Slic3r::ConfigBase::set_deserialize_strict().

Here is the call graph for this function:

new_with() [2/2]

static DynamicPrintConfig Slic3r::DynamicPrintConfig::new_with ( std::initializer_list< SetDeserializeItem >  items )

inlinestatic

                                                                                       {
        DynamicPrintConfig config;
        config.set_deserialize_strict(items);
        return config;
    }

References Slic3r::ConfigBase::set_deserialize_strict().

Here is the call graph for this function:

normalize_fdm()

void Slic3r::DynamicPrintConfig::normalize_fdm

(

)

{
    if (this->has("extruder")) {
        int extruder = this->option("extruder")->getInt();
        this->erase("extruder");
        if (extruder != 0) {
            if (!this->has("infill_extruder"))
                this->option("infill_extruder", true)->setInt(extruder);
            if (!this->has("perimeter_extruder"))
                this->option("perimeter_extruder", 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_material_extruder"))
            //     this->option("support_material_extruder", true)->setInt(extruder);
            // if (!this->has("support_material_interface_extruder"))
            //     this->option("support_material_interface_extruder", true)->setInt(extruder);
        }
    }
 
    if (this->has("wipe_tower_extruder")) {
        // If invalid, replace with 0.
        int extruder = this->opt<ConfigOptionInt>("wipe_tower_extruder")->value;
        int num_extruders = this->opt<ConfigOptionFloats>("nozzle_diameter")->size();
        if (extruder < 0 || extruder > num_extruders)
            this->option("wipe_tower_extruder")->setInt(0);
    }
 
    if (!this->has("solid_infill_extruder") && this->has("infill_extruder"))
        this->option("solid_infill_extruder", true)->setInt(this->option("infill_extruder")->getInt());
 
    if (this->has("spiral_vase") && this->opt<ConfigOptionBool>("spiral_vase", true)->value) {
        {
            // this should be actually done only on the spiral layers instead of all
            auto* opt = this->opt<ConfigOptionBools>("retract_layer_change", 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_layer_change", true);
            opt_n->values.assign(opt_n->values.size(), false);  // Set all values to false.
        }
        {
            this->opt<ConfigOptionInt>("perimeters", true)->value       = 1;
            this->opt<ConfigOptionInt>("top_solid_layers", true)->value = 0;
            this->opt<ConfigOptionPercent>("fill_density", true)->value = 0;
        }
    }
 
    if (auto *opt_gcode_resolution = this->opt<ConfigOptionFloat>("gcode_resolution", false); opt_gcode_resolution)
        // Resolution will be above 1um.
        opt_gcode_resolution->value = std::max(opt_gcode_resolution->value, 0.001);
 
    if (auto *opt_min_bead_width = this->opt<ConfigOptionFloat>("min_bead_width", false); opt_min_bead_width)
        opt_min_bead_width->value = std::max(opt_min_bead_width->value, 0.001);
    if (auto *opt_wall_transition_length = this->opt<ConfigOptionFloat>("wall_transition_length", false); opt_wall_transition_length)
        opt_wall_transition_length->value = std::max(opt_wall_transition_length->value, 0.001);
}

References Slic3r::DynamicConfig::erase(), Slic3r::ConfigOptionResolver::has(), and Slic3r::ConfigBase::opt().

Referenced by Slic3r::Print::apply(), Slic3r::PrintObject::object_config_from_model_object(), and Slic3r::CLI::run().

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::ConfigOption::deserialize(), Slic3r::Disable, Slic3r::ConfigBase::keys(), Slic3r::ConfigOption::nullable(), Slic3r::ConfigBase::opt(), and Slic3r::ConfigBase::optptr().

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

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

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

inlineinherited

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

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 Slic3r::DynamicConfig::def(), and Slic3r::DynamicConfig::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 Slic3r::DynamicConfig::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 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 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 Slic3r::DynamicConfig::options.

opt() [1/2]

template<class T >

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

inlineinherited

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

References Slic3r::ConfigBase::optptr().

Here is the call graph for this function:

opt() [2/2]

template<class T >

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

inlineinherited

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

References Slic3r::ConfigBase::optptr().

Referenced by Slic3r::apply_to_print_region_config(), Slic3r::GUI::GLCanvas3D::WipeTowerInfo::apply_wipe_tower(), Slic3r::PrinterPresetCollection::default_preset_for(), Slic3r::get_bed_shape(), Slic3r::GUI::Materials::get_filament_type(), Slic3r::GUI::Materials::get_filament_vendor(), Slic3r::GUI::Materials::get_material_type(), Slic3r::GUI::Materials::get_material_vendor(), Slic3r::GUI::get_string_value(), Slic3r::handle_legacy_sla(), Slic3r::is_XL_printer(), Slic3r::DynamicConfig::keys(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::priv::load_model_objects(), normalize_fdm(), Slic3r::ConfigBase::null_nullables(), Slic3r::GUI::Plater::priv::on_wipetower_moved(), Slic3r::GUI::Plater::priv::on_wipetower_rotated(), Slic3r::ConfigBase::opt_serialize(), Slic3r::ConfigBase::option(), Slic3r::ConfigBase::option_throw(), Slic3r::DynamicConfig::optptr(), Slic3r::PresetHints::recommended_thin_wall_thickness(), Slic3r::CLI::run(), Slic3r::run_post_process_scripts(), Slic3r::ConfigBase::set(), Slic3r::ConfigBase::set(), Slic3r::StaticConfig::set_defaults(), Slic3r::ConfigBase::set_deserialize_raw(), set_num_extruders(), Slic3r::CLI::setup(), Slic3r::PresetUtils::system_printer_model(), Slic3r::GUI::anonymous_namespace{HintNotification.cpp}::tag_check_material(), Slic3r::GUI::DiffPresetDialog::update_tree(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), and validate().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_bool() [1/2]

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

inlineinherited

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

Referenced by Slic3r::PresetHints::cooling_description(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_string_value(), Slic3r::CLI::has_print_action(), Slic3r::GUI::Plater::priv::layers_height_allowed(), Slic3r::GUI::pad_combo_value_for_config(), Slic3r::GUI::Plater::priv::process_validation_warning(), Slic3r::PresetHints::recommended_thin_wall_thickness(), Slic3r::CLI::run(), Slic3r::GUI::support_combo_value_for_config(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::ConfigManipulation::toggle_print_sla_options(), Slic3r::PresetHints::top_bottom_shell_thickness_explanation(), Slic3r::GUI::Plater::priv::update_background_process(), Slic3r::ExtruderFilaments::update_compatible_internal(), Slic3r::GUI::TabSLAPrint::update_description_lines(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the caller graph for this function:

opt_bool() [2/2]

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

inlineinherited

{ return this->option<ConfigOptionBools>(opt_key)->get_at(idx) != 0; }

opt_enum()

template<typename ENUM >

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

inlineinherited

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

Referenced by Slic3r::BackgroundSlicingProcess::apply(), Slic3r::GUI::Plater::on_config_change(), 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 caller graph for this function:

opt_float() [1/4]

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

inlineinherited

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

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), Slic3r::GUI::change_opt_value(), Slic3r::PresetHints::cooling_description(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_max_layer_height(), Slic3r::GUI::get_min_layer_height(), Slic3r::GUI::get_string_value(), Slic3r::GUI::GLCanvas3D::get_wipe_tower_info(), Slic3r::Slicing::max_layer_height_from_nozzle(), Slic3r::PresetHints::maximum_volumetric_flow_description(), Slic3r::Slicing::min_layer_height_from_nozzle(), Slic3r::ModelConfig::opt_float(), Slic3r::PresetHints::recommended_thin_wall_thickness(), Slic3r::CLI::run(), Slic3r::GUI::Plater::priv::take_snapshot(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::PresetHints::top_bottom_shell_thickness_explanation(), Slic3r::GUI::Plater::priv::undo_redo_to(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::ConfigManipulation::update_print_sla_config().

Here is the caller graph for this function:

opt_float() [2/4]

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

inlineinherited

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

opt_float() [3/4]

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

inlineinherited

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

opt_float() [4/4]

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

inlineinherited

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

opt_int() [1/4]

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

inlineinherited

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

Referenced by Slic3r::PresetHints::cooling_description(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_string_value(), Slic3r::PresetHints::maximum_volumetric_flow_description(), Slic3r::ModelConfig::opt_int(), Slic3r::PresetHints::recommended_thin_wall_thickness(), Slic3r::CLI::run(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::PresetHints::top_bottom_shell_thickness_explanation(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the caller graph for this function:

opt_int() [2/4]

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

inlineinherited

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

opt_int() [3/4]

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

inlineinherited

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

opt_int() [4/4]

int Slic3r::ConfigBase::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); }

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 Slic3r::ConfigBase::opt(), and Slic3r::ConfigOption::serialize().

Referenced by Slic3r::_3MF_Exporter::_add_print_config_file_to_archive(), Slic3r::GCode::append_full_config(), Slic3r::anonymous_namespace{SL1.cpp}::fill_slicerconf(), Slic3r::ModelConfig::opt_serialize(), Slic3r::ConfigBase::save(), and Slic3r::store_amf().

Here is the call graph for this function:

Here is the caller graph for this function:

opt_string() [1/4]

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

inlineinherited

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

References Slic3r::ConfigBase::opt_string().

Referenced by Slic3r::ConfigBase::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::ConfigBase::opt_string ( const t_config_option_key &  opt_key, bool  create = false  )

inlineinherited

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

Referenced by Slic3r::PresetBundle::PresetBundle(), Slic3r::_3MF_Exporter::_add_custom_gcode_per_print_z_file_to_archive(), Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::PhysicalPrinterCollection::find_printer_with_same_config(), Slic3r::PrinterPresetCollection::find_system_preset_by_model_and_variant(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_string_value(), Slic3r::PhysicalPrinter::has_empty_config(), Slic3r::PhysicalPrinter::has_print_host_information(), Slic3r::PresetBundle::load_config_file_config(), Slic3r::PresetBundle::load_configbundle(), Slic3r::PhysicalPrinterCollection::load_printers_from_presets(), Slic3r::GUI::PresetComboBox::open_physical_printer_url(), Slic3r::PrintBase::output_filename(), Slic3r::CLI::output_filepath(), Slic3r::CLI::run(), Slic3r::GUI::Tab::save_preset(), Slic3r::Preset::set_visible_from_appconfig(), Slic3r::CLI::setup(), Slic3r::GUI::PlaterPresetComboBox::show_edit_menu(), Slic3r::store_amf(), Slic3r::GUI::TabSLAMaterial::toggle_options(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::Plater::update_filament_colors_in_full_config(), Slic3r::PresetBundle::update_filaments_compatible(), Slic3r::GUI::PhysicalPrinterDialog::update_host_type(), Slic3r::GUI::Tab::update_preset_description_line(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the caller graph for this function:

opt_string() [3/4]

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

inlineinherited

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

opt_string() [4/4]

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

inlineinherited

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

References Slic3r::ConfigBase::opt_string().

Referenced by Slic3r::ConfigBase::opt_string().

Here is the call graph for this function:

Here is the caller graph for this function:

option() [1/4]

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

inlineinherited

{ return this->optptr(opt_key); }

option() [2/4]

template<typename TYPE >

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

inlineinherited

    {
        const ConfigOption* opt = this->optptr(opt_key);
        return (opt == nullptr || opt->type() != TYPE::static_type()) ? nullptr : static_cast<const TYPE*>(opt);
    }

option() [3/4]

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

inlineinherited

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

References Slic3r::ConfigBase::optptr().

Referenced by Slic3r::DynamicConfig::DynamicConfig(), Slic3r::PresetBundle::PresetBundle(), Slic3r::GCode::_do_export(), Slic3r::GUI::GLCanvas3D::_render_arrange_menu(), 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::add_correct_opts_to_options_list(), Slic3r::GUI::ObjectSettings::add_missed_options(), Slic3r::GCode::append_full_config(), Slic3r::Search::OptionsSearcher::append_options(), Slic3r::Print::apply(), Slic3r::SLAPrint::apply(), Slic3r::GUI::ConfigManipulation::apply(), Slic3r::GCodeProcessor::apply_config(), Slic3r::PlaceholderParser::apply_config(), Slic3r::ConfigBase::apply_only(), Slic3r::PlaceholderParser::apply_only(), Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabPrinter::build_extruder_pages(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::cache_extruder_cnt(), Slic3r::GUI::PlaterPresetComboBox::change_extruder_color(), Slic3r::Search::change_opt_key(), Slic3r::GUI::change_opt_value(), Slic3r::Preset::compatible_printers_condition(), Slic3r::Preset::compatible_prints_condition(), Slic3r::copy_bed_model_and_texture_if_needed(), Slic3r::deep_diff(), Slic3r::GUI::Bed3D::detect_type(), Slic3r::ConfigBase::diff(), Slic3r::ConfigBase::equal(), Slic3r::ConfigBase::equals(), Slic3r::GUI::GUI_App::extruders_cnt(), Slic3r::GUI::GUI_App::extruders_edited_cnt(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::GUI::Plater::force_filament_colors_update(), Slic3r::PresetBundle::full_fff_config(), Slic3r::full_print_config_diffs(), Slic3r::PresetBundle::full_sla_config(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_f(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_i(), Slic3r::GUI::GLGizmoHollow::get_config_options(), Slic3r::GUI::GLGizmoSlaSupports::get_config_options(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::Plater::get_extruder_colors_from_plater_config(), Slic3r::GUI::get_full_label(), Slic3r::PrintHost::get_print_host(), get_printer_technology(), Slic3r::get_raster_params(), Slic3r::get_sla_suptree_prefix(), Slic3r::get_slice_params(), Slic3r::GUI::get_string_value(), Slic3r::handle_legacy_project_loaded(), Slic3r::Preset::inherits(), Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::is_compatible_with_printer(), Slic3r::GUI::MainFrame::load_config(), Slic3r::GUI::Tab::load_config(), Slic3r::GUI::Tab::load_current_preset(), Slic3r::PresetHints::maximum_volumetric_flow_description(), Slic3r::min_object_distance(), Slic3r::Preset::normalize(), Slic3r::GUI::Plater::on_config_change(), Slic3r::GUI::GLGizmoSlaSupports::on_set_state(), Slic3r::PlaceholderParser::option(), Slic3r::ModelConfig::option(), Slic3r::client::MyContext::optptr(), Slic3r::opts_equal(), Slic3r::GUI::ObjectList::paste_settings_into_list(), Slic3r::BackgroundSlicingProcess::prepare_upload(), Slic3r::print_config_diffs(), Slic3r::Preset::printer_technology(), Slic3r::PhysicalPrinter::printer_technology(), Slic3r::Preset::printer_technology_ref(), Slic3r::BackgroundSlicingProcess::process_sla(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::CLI::run(), Slic3r::CLI::setup(), Slic3r::GUI::Plater::priv::show_action_buttons(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GUI::PhysicalPrinterDialog::update(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::PresetCollection::update_compatible_internal(), Slic3r::ExtruderFilaments::update_compatible_internal(), Slic3r::CustomGCode::update_custom_gcode_per_print_z_from_config(), Slic3r::PresetBundle::update_filaments_compatible(), Slic3r::PhysicalPrinter::update_from_config(), Slic3r::GUI::PhysicalPrinterDialog::update_host_type(), Slic3r::GUI::Tab::update_preset_description_line(), Slic3r::PhysicalPrinter::update_preset_names_in_config(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::Sidebar::update_sliced_info_sizer().

Here is the call graph for this function:

option() [4/4]

template<typename TYPE >

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

inlineinherited

    { 
        ConfigOption *opt = this->optptr(opt_key, create);
        return (opt == nullptr || opt->type() != TYPE::static_type()) ? nullptr : static_cast<TYPE*>(opt);
    }

References Slic3r::ConfigBase::opt(), Slic3r::ConfigBase::optptr(), and Slic3r::ConfigOption::type().

Here is the call graph for this function:

option_def()

const ConfigOptionDef * Slic3r::ConfigBase::option_def ( const t_config_option_key &  opt_key ) const

inlineinherited

        { return this->def()->get(opt_key); }

References Slic3r::ConfigBase::def(), and Slic3r::ConfigDef::get().

Referenced by Slic3r::Search::OptionsSearcher::append_options(), Slic3r::GUI::GLGizmoHollow::get_config_options(), Slic3r::GUI::get_string_value(), Slic3r::DynamicConfig::read_cli(), and Slic3r::GUI::ConfigManipulation::update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

option_throw() [1/4]

template<typename TYPE >

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

inlineinherited

    {
        const ConfigOption* opt = this->option_throw(opt_key);
        if (opt->type() != TYPE::static_type())
            throw BadOptionTypeException("Conversion to a wrong type");
        return static_cast<TYPE*>(opt);
    }

option_throw() [2/4]

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() [3/4]

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 Slic3r::ConfigBase::opt(), and Slic3r::ConfigBase::optptr().

Referenced by Slic3r::ConfigBase::option_throw(), Slic3r::ConfigBase::set(), and Slic3r::ConfigBase::set().

Here is the call graph for this function:

Here is the caller graph for this function:

option_throw() [4/4]

template<typename TYPE >

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

inlineinherited

    { 
        ConfigOption *opt = this->option_throw(opt_key, create);
        if (opt->type() != TYPE::static_type())
            throw BadOptionTypeException("Conversion to a wrong type");
        return static_cast<TYPE*>(opt);
    }

References Slic3r::ConfigBase::opt(), Slic3r::ConfigBase::option_throw(), and Slic3r::ConfigOption::type().

Here is the call 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();
}

Referenced by Slic3r::PresetBundle::PresetBundle(), Slic3r::GUI::get_string_value(), Slic3r::PresetBundle::load_config_file_config_bundle(), 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(), Slic3r::ConfigBase::def(), Slic3r::ConfigDef::get(), and Slic3r::ConfigBase::opt().

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()) {
            // 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 << "Unknown 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->option_def(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 << "No value supplied for --" << 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.
        opt_vector->deserialize(value, true);
        } else if (opt_base->type() == coBool) {
            if (value.empty())
                static_cast<ConfigOptionBool*>(opt_base)->value = !no;
            else
                opt_base->deserialize(value);
        } 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 supplied for --" << token.c_str() << std::endl;
        return false;
      }
        }
    }
    return true;
}

References Slic3r::ConfigOptionVectorBase::clear(), Slic3r::coBool, Slic3r::coBools, Slic3r::coString, Slic3r::ConfigBase::def(), Slic3r::ConfigOption::deserialize(), Slic3r::Disable, Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigOption::is_vector(), Slic3r::ConfigBase::keys(), Slic3r::ConfigBase::option_def(), Slic3r::ConfigDef::options, Slic3r::ConfigBase::set_deserialize_nothrow(), Slic3r::ConfigOption::type(), Slic3r::ConfigOptionDef::type, and Slic3r::ConfigOptionSingle< T >::value.

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

Here is the call graph for this function:

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

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();
}

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

Referenced by Slic3r::CLI::run(), Slic3r::Preset::save(), Slic3r::PhysicalPrinter::save(), and Slic3r::PhysicalPrinter::save().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<class Archive >

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

inlineprivateinherited

{ ar(options); }

References Slic3r::DynamicConfig::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; }

Referenced by Slic3r::extract_profile(), and Slic3r::ModelConfig::set().

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; }

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; }

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(), Slic3r::ConfigBase::opt(), Slic3r::ConfigBase::option_throw(), and Slic3r::ConfigOption::type().

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, Slic3r::ConfigBase::opt(), Slic3r::ConfigBase::option_throw(), and Slic3r::ConfigOption::type().

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("Invalid value provided for parameter %1%: %2%", opt_key_src,  value_src));
}

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

Referenced by Slic3r::ConfigBase::load(), Slic3r::PresetBundle::load_configbundle(), Slic3r::ConfigBase::load_from_gcode_file(), Slic3r::ConfigBase::load_from_gcode_string_legacy(), Slic3r::ModelConfig::set_deserialize(), Slic3r::ConfigBase::set_deserialize(), Slic3r::ConfigBase::set_deserialize_strict(), and Slic3r::ConfigBase::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 Slic3r::ConfigBase::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.
        return true;
    return this->set_deserialize_raw(opt_key, value, substitutions_ctxt, append);
}

References Slic3r::append(), Slic3r::ConfigBase::handle_legacy(), and Slic3r::ConfigBase::set_deserialize_raw().

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_deserialize_raw()

bool Slic3r::ConfigBase::set_deserialize_raw ( const t_config_option_key &  opt_key_src, const std::string &  value, ConfigSubstitutionContext &  substitutions, bool  append  )

privateinherited

{
    t_config_option_key    opt_key = opt_key_src;
    // Try to deserialize the option by its name.
    const ConfigDef       *def     = this->def();
    if (def == nullptr)
        throw NoDefinitionException(opt_key);
    const ConfigOptionDef *optdef  = 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 : 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;
        }
        if (optdef == nullptr)
            throw UnknownOptionException(opt_key);
    }
    
    if (! optdef->shortcut.empty()) {
        // Aliasing for example "solid_layers" to "top_solid_layers" and "bottom_solid_layers".
        for (const t_config_option_key &shortcut : optdef->shortcut)
            // Recursive call.
            if (! this->set_deserialize_raw(shortcut, value, substitutions_ctxt, append))
                return false;
        return true;
    }
    
    ConfigOption *opt = this->option(opt_key, true);
    assert(opt != nullptr);
    bool success     = false;
    bool substituted = false;
    if (optdef->type == coBools && substitutions_ctxt.rule != ForwardCompatibilitySubstitutionRule::Disable) {
      //FIXME Special handling of vectors of bools, quick and not so dirty solution before PrusaSlicer 2.3.2 release.
      bool nullable = opt->nullable();
      ConfigHelpers::DeserializationSubstitution default_value = ConfigHelpers::DeserializationSubstitution::DefaultsToFalse;
      if (optdef->default_value) {
        // Default value for vectors of booleans used in a "per extruder" context, thus the default contains just a single value.
        assert(dynamic_cast<const ConfigOptionVector<unsigned char>*>(optdef->default_value.get()));
      auto &values = static_cast<const ConfigOptionVector<unsigned char>*>(optdef->default_value.get())->values;
      if (values.size() == 1 && values.front() == 1)
        default_value = ConfigHelpers::DeserializationSubstitution::DefaultsToTrue;
    }
      auto result = nullable ?
        static_cast<ConfigOptionBoolsNullable*>(opt)->deserialize_with_substitutions(value, append, default_value) :
        static_cast<ConfigOptionBools*>(opt)->deserialize_with_substitutions(value, append, default_value);
      success     = result != ConfigHelpers::DeserializationResult::Failed;
      substituted = result == ConfigHelpers::DeserializationResult::Substituted;
    } else {
    success = opt->deserialize(value, append);
      if (! success && substitutions_ctxt.rule != ForwardCompatibilitySubstitutionRule::Disable &&
          // Only allow substitutions of an enum value by another enum value or a boolean value with an enum value.
          // That means, we expect enum values being added in the future and possibly booleans being converted to enums.
          (optdef->type == coEnum || optdef->type == coBool) && ConfigHelpers::looks_like_enum_value(value)) {
          // Deserialize failed, try to substitute with a default value.
          assert(substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::Enable || substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::EnableSilent);
          if (optdef->type == coBool)
              static_cast<ConfigOptionBool*>(opt)->value = ConfigHelpers::enum_looks_like_true_value(value);
          else
            // Just use the default of the option.
              opt->set(optdef->default_value.get());
            success     = true;
            substituted = true;
      }
  }
 
    if (substituted && (substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::Enable ||
                        substitutions_ctxt.rule == ForwardCompatibilitySubstitutionRule::EnableSystemSilent)) {
        // Log the substitution.
        ConfigSubstitution config_substitution;
        config_substitution.opt_def   = optdef;
        config_substitution.old_value = value;
        config_substitution.new_value = ConfigOptionUniquePtr(opt->clone());
        substitutions_ctxt.substitutions.emplace_back(std::move(config_substitution));
    }
    return success;
}

References Slic3r::append(), Slic3r::ConfigOption::clone(), Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::ConfigBase::def(), Slic3r::ConfigOptionDef::default_value, Slic3r::ConfigHelpers::DefaultsToFalse, Slic3r::ConfigHelpers::DefaultsToTrue, Slic3r::ConfigOption::deserialize(), Slic3r::Disable, Slic3r::Enable, Slic3r::EnableSilent, Slic3r::EnableSystemSilent, Slic3r::ConfigHelpers::enum_looks_like_true_value(), Slic3r::ConfigHelpers::Failed, Slic3r::ConfigDef::get(), Slic3r::ConfigHelpers::looks_like_enum_value(), Slic3r::ConfigSubstitution::new_value, Slic3r::ConfigOption::nullable(), Slic3r::ConfigSubstitution::old_value, Slic3r::ConfigBase::opt(), Slic3r::ConfigSubstitution::opt_def, Slic3r::ConfigDef::options, Slic3r::ConfigSubstitutionContext::rule, Slic3r::ConfigOption::set(), Slic3r::ConfigBase::set_deserialize_raw(), Slic3r::ConfigOptionDef::shortcut, Slic3r::ConfigHelpers::Substituted, Slic3r::ConfigSubstitutionContext::substitutions, and Slic3r::ConfigOptionDef::type.

Referenced by Slic3r::ConfigBase::set_deserialize_nothrow(), and Slic3r::ConfigBase::set_deserialize_raw().

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 Slic3r::ConfigBase::set_deserialize().

Referenced by new_with(), new_with(), and Slic3r::ModelConfig::set_deserialize_strict().

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 Slic3r::ConfigBase::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;
        }
    }

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), Slic3r::PhysicalPrinterCollection::PhysicalPrinterCollection(), Slic3r::WipeTowerIntegration::append_tcr(), Slic3r::GUI::ConfigManipulation::apply(), Slic3r::GUI::PageFirmware::apply_custom_config(), Slic3r::GUI::PageBedShape::apply_custom_config(), Slic3r::GUI::PageBuildVolume::apply_custom_config(), Slic3r::GUI::PageDiameters::apply_custom_config(), Slic3r::GUI::PageTemperatures::apply_custom_config(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabPrinter::build_extruder_pages(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::build_kinematics_page(), Slic3r::GUI::PlaterPresetComboBox::change_extruder_color(), Slic3r::GUI::change_opt_value(), Slic3r::PrintStatistics::config(), Slic3r::ProcessLayer::emit_custom_gcode_per_print_z(), Slic3r::PresetBundle::full_fff_config(), Slic3r::PresetBundle::full_sla_config(), Slic3r::is_compatible_with_printer(), cereal::load(), Slic3r::Print::output_filename(), Slic3r::SLAPrint::output_filename(), Slic3r::PrintBase::output_filename(), Slic3r::PrintStatistics::placeholders(), Slic3r::print_config_diffs(), Slic3r::GUI::Plater::priv::process_validation_warning(), Slic3r::PlaceholderParser::set(), Slic3r::ModelConfig::set_key_value(), Slic3r::GUI::PhysicalPrinterDialog::set_printer_technology(), Slic3r::client::MyContext::store_new_variable(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::Plater::priv::undo_redo_to(), Slic3r::PresetCollection::update_compatible_internal(), Slic3r::ExtruderFilaments::update_compatible_internal(), Slic3r::GUI::PhysicalPrinterDialog::update_host_type(), Slic3r::PrintBase::update_object_placeholders(), Slic3r::update_preset_name_option(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), Slic3r::GUI::ConfigManipulation::update_print_sla_config(), and Slic3r::PlaceholderParser::update_timestamp().

Here is the caller graph for this function:

set_num_extruders()

void Slic3r::DynamicPrintConfig::set_num_extruders

(

unsigned int

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(num_extruders, defaults.option(key));
    }
}

References Slic3r::PrintConfigDef::extruder_option_keys(), Slic3r::ConfigBase::opt(), and Slic3r::print_config_def.

Referenced by Slic3r::Preset::normalize(), and Slic3r::Preset::set_num_extruders().

Here is the call graph for this function:

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 Slic3r::ConfigBase::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 Slic3r::DynamicConfig::options.

Referenced by cereal::save(), and Slic3r::ModelConfig::size().

Here is the caller graph for this function:

swap()

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

inlineinherited

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

References Slic3r::DynamicConfig::options.

validate()

std::string Slic3r::DynamicPrintConfig::validate

(

)

{
    // 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);
    }
    default:
        //FIXME no validation on SLA data?
        return std::string();
    }
}

References Slic3r::ConfigBase::opt(), Slic3r::printer_technology(), Slic3r::ptFFF, and Slic3r::validate().

Referenced by Slic3r::CLI::run(), and Slic3r::CLI::setup().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

options

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

privateinherited

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

---

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

• src/libslic3r/PrintConfig.hpp
• src/libslic3r/PrintConfig.cpp