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

Collaboration diagram for Slic3r::ConfigOptionDef:

Public Types
enum class	GUIType { undefined , i_enum_open , f_enum_open , color , select_open , slider , legend , one_string , plugin_picker , plugin_config , printer_agent_select }

Public Member Functions
void	set_default_value (const ConfigOption *ptr)
template<typename T>
const T *	get_default_value () const
ConfigOption *	create_empty_option () const
ConfigOption *	create_default_option () const
bool	is_scalar () const
template<class Archive>
ConfigOption *	load_option_from_archive (Archive &archive) const
template<class Archive>
ConfigOption *	save_option_to_archive (Archive &archive, const ConfigOption *opt) const
bool	is_plugin_backed () const
bool	is_value_valid (const double value, const int max_precision=4) const
bool	has_enum_value (const std::string &value) const
std::vector< std::string >	cli_args (const std::string &key) const

Public Attributes
t_config_option_key	opt_key
ConfigOptionType	type = coNone
bool	nullable = false
Slic3r::clonable_ptr< const ConfigOption >	default_value
GUIType	gui_type { GUIType::undefined }
std::string	gui_flags
std::string	plugin_type
std::string	label
std::string	full_label
PrinterTechnology	printer_technology = ptUnknown
std::string	category
std::string	tooltip
std::string	sidetext
std::string	cli
std::string	cli_params
t_config_option_key	ratio_over
bool	multiline = false
bool	full_width = false
bool	is_code = false
bool	readonly = false
int	height = -1
int	width = -1
float	min = -FLT_MAX
float	max = FLT_MAX
double	max_literal = 1
ConfigOptionMode	mode = comSimple
std::vector< t_config_option_key >	aliases
std::vector< t_config_option_key >	shortcut
std::vector< std::string >	enum_values
std::vector< std::string >	enum_labels
const t_config_enum_values *	enum_keys_map = nullptr
size_t	serialization_key_ordinal = 0

Static Public Attributes
static const constexpr char *	nocli = "~~~noCLI"

Detailed Description

Member Enumeration Documentation

◆ GUIType

enum class Slic3r::ConfigOptionDef::GUIType

strong

Enumerator
undefined
i_enum_open
f_enum_open
color
select_open
slider
legend
one_string
plugin_picker
plugin_config
printer_agent_select

                       {
        undefined,
        // Open enums, integer value could be one of the enumerated values or something else.
        i_enum_open,
        // Open enums, float value could be one of the enumerated values or something else.
        f_enum_open,
        // Color picker, string value.
        color,
        // ???
        select_open,
        // Currently unused.
        slider,
        // Static text
        legend,
        // Vector value, but edited as a single string.
        one_string,
        plugin_picker,
        // Raw JSON string value, edited through a dialog behind a button rather than in the row.
        plugin_config,
        // PrinterAgentChoice
        printer_agent_select,
    };

Member Function Documentation

◆ cli_args()

std::vector< std::string > Slic3r::ConfigOptionDef::cli_args ( const std::string & key ) const

{
  std::vector<std::string> args;
  if (this->cli != ConfigOptionDef::nocli) {
        const std::string &cli = this->cli;
        //FIXME What was that for? Check the "readline" documentation.
        // Neither '=' nor '!' is used in any of the cli parameters currently defined by PrusaSlicer.
//        std::string cli = this->cli.substr(0, this->cli.find("="));
//        boost::trim_right_if(cli, boost::is_any_of("!"));
    if (cli.empty()) {
            // Convert an option key to CLI argument by replacing underscores with dashes.
            std::string opt = key;
            boost::replace_all(opt, "_", "-");
            args.emplace_back(std::move(opt));
        } else
      boost::split(args, cli, boost::is_any_of("|"));
    }
    return args;
}

References cli, and nocli.

Referenced by Slic3r::ConfigDef::print_cli_help().

Here is the caller graph for this function:

◆ create_default_option()

ConfigOption * Slic3r::ConfigOptionDef::create_default_option ( ) const

{
    if (this->default_value) {
        ConfigOptionType type = this->default_value->type();
        if (type == coEnum)
            return new ConfigOptionEnumGeneric(this->enum_keys_map, this->default_value->getInt());
 
        if (type == coEnums) {
            // Enum list defaults are built without a keys map, which the copy needs to deserialize and serialize names.
            ConfigOption *opt = this->default_value->clone();
            if (auto *nullable_enums = dynamic_cast<ConfigOptionEnumsGenericNullable *>(opt))
                nullable_enums->keys_map = this->enum_keys_map;
            else if (auto *enums = dynamic_cast<ConfigOptionEnumsGeneric *>(opt))
                enums->keys_map = this->enum_keys_map;
            return opt;
        }
 
        return this->default_value->clone();
    }
    return this->create_empty_option();
}

References Slic3r::coEnum, Slic3r::coEnums, create_empty_option(), default_value, enum_keys_map, and type.

Referenced by Slic3r::DynamicConfig::optptr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_empty_option()

ConfigOption * Slic3r::ConfigOptionDef::create_empty_option ( ) const

{
  if (this->nullable) {
      switch (this->type) {
      case coFloats:          return new ConfigOptionFloatsNullable();
      case coInts:            return new ConfigOptionIntsNullable();
      case coPercents:        return new ConfigOptionPercentsNullable();
        case coFloatsOrPercents: return new ConfigOptionFloatsOrPercentsNullable();
      case coBools:           return new ConfigOptionBoolsNullable();
      default:                throw ConfigurationError(std::string("Unknown option type for nullable option ") + this->label);
      }
  } else {
      switch (this->type) {
      case coFloat:           return new ConfigOptionFloat();
      case coFloats:          return new ConfigOptionFloats();
      case coInt:             return new ConfigOptionInt();
      case coInts:            return new ConfigOptionInts();
      case coString:          return new ConfigOptionString();
      case coStrings:         return new ConfigOptionStrings();
      case coPercent:         return new ConfigOptionPercent();
      case coPercents:        return new ConfigOptionPercents();
      case coFloatOrPercent:  return new ConfigOptionFloatOrPercent();
        case coFloatsOrPercents: return new ConfigOptionFloatsOrPercents();
      case coPoint:           return new ConfigOptionPoint();
      case coPoints:          return new ConfigOptionPoints();
      case coPoint3:          return new ConfigOptionPoint3();
  //    case coPoint3s:         return new ConfigOptionPoint3s();
      case coBool:            return new ConfigOptionBool();
      case coBools:           return new ConfigOptionBools();
      case coEnum:            return new ConfigOptionEnumGeneric(this->enum_keys_map);
        // BBS
        case coEnums:           return new ConfigOptionEnumsGeneric(this->enum_keys_map);
      default:                throw ConfigurationError(std::string("Unknown option type for option ") + this->label);
      }
  }
}

References Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoint3, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, enum_keys_map, label, nullable, and type.

Referenced by create_default_option().

Here is the caller graph for this function:

◆ get_default_value()

template<typename T>

const T * Slic3r::ConfigOptionDef::get_default_value ( ) const

inline

2350{ return static_cast<const T*>(this->default_value.get()); }

References Slic3r::clonable_ptr< T >::get().

Referenced by Slic3r::CalibPressureAdvance::find_optimal_PA_speed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_enum_value()

bool Slic3r::ConfigOptionDef::has_enum_value ( const std::string & value ) const

inline

                                                      {
        for (const std::string &v : enum_values)
            if (v == value)
                return true;
        return false;
    }

References enum_values.

◆ is_plugin_backed()

bool Slic3r::ConfigOptionDef::is_plugin_backed ( ) const

inline

2561{ return !plugin_type.empty(); }

Slic3r::ConfigOptionDef::plugin_type

std::string plugin_type

Definition Config.hpp:2558

References plugin_type.

Referenced by Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::prune_stale_plugin_overrides(), and Slic3r::ConfigBase::save_plugin_collection().

Here is the caller graph for this function:

◆ is_scalar()

bool Slic3r::ConfigOptionDef::is_scalar ( ) const

inline

2357{ return (int(this->type) & int(coVectorType)) == 0; }

Slic3r::coVectorType

@ coVectorType

Definition Config.hpp:181

References Slic3r::coVectorType.

Referenced by Slic3r::GUI::get_type(), and Slic3r::GUI::EditGCodeDialog::selection_changed().

Here is the caller graph for this function:

◆ is_value_valid()

bool Slic3r::ConfigOptionDef::is_value_valid	(	const double	value,
		const int	max_precision = 4 ) const

{
    // Special handling for the nil values
    // The nil value is a valid one only for nullable options
    if (std::isnan(value))
        return this->nullable;
 
    // Special handling of 0
    if (this->min == 0.f && value < 0)
        return false;
 
    const double ep = std::pow(0.1, max_precision);
    if (is_approx(value, (double) this->min, ep) || is_approx(value, (double) this->max, ep))
        return true;
 
    return this->min <= value && value <= this->max;
}

References Slic3r::is_approx(), max, min, and nullable.

Referenced by Slic3r::validate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_option_from_archive()

template<class Archive>

ConfigOption * Slic3r::ConfigOptionDef::load_option_from_archive ( Archive & archive ) const

inline

    {
        if (this->nullable) {
            switch (this->type) {
            case coFloats: {
                auto opt = new ConfigOptionFloatsNullable();
                archive(*opt);
                return opt;
            }
            case coInts: {
                auto opt = new ConfigOptionIntsNullable();
                archive(*opt);
                return opt;
            }
            case coPercents: {
                auto opt = new ConfigOptionPercentsNullable();
                archive(*opt);
                return opt;
            }
            case coBools: {
                auto opt = new ConfigOptionBoolsNullable();
                archive(*opt);
                return opt;
            }
            case coFloatsOrPercents: {
                auto opt = new ConfigOptionFloatsOrPercentsNullable();
                archive(*opt);
                return opt;
            }
            case coEnums: {
                auto opt = new ConfigOptionEnumsGenericNullable(this->enum_keys_map);
                archive(*opt);
                return opt;
            }
            default:
                throw ConfigurationError(
                    std::string("ConfigOptionDef::load_option_from_archive(): Unknown nullable option type for option ") + this->opt_key);
            }
        } else {
            switch (this->type) {
            case coFloat: {
                auto opt = new ConfigOptionFloat();
                archive(*opt);
                return opt;
            }
            case coFloats: {
                auto opt = new ConfigOptionFloats();
                archive(*opt);
                return opt;
            }
            case coInt: {
                auto opt = new ConfigOptionInt();
                archive(*opt);
                return opt;
            }
            case coInts: {
                auto opt = new ConfigOptionInts();
                archive(*opt);
                return opt;
            }
            case coString: {
                auto opt = new ConfigOptionString();
                archive(*opt);
                return opt;
            }
            case coStrings: {
                auto opt = new ConfigOptionStrings();
                archive(*opt);
                return opt;
            }
            case coPercent: {
                auto opt = new ConfigOptionPercent();
                archive(*opt);
                return opt;
            }
            case coPercents: {
                auto opt = new ConfigOptionPercents();
                archive(*opt);
                return opt;
            }
            case coFloatOrPercent: {
                auto opt = new ConfigOptionFloatOrPercent();
                archive(*opt);
                return opt;
            }
            case coFloatsOrPercents: {
                auto opt = new ConfigOptionFloatsOrPercents();
                archive(*opt);
                return opt;
            }
            case coPoint: {
                auto opt = new ConfigOptionPoint();
                archive(*opt);
                return opt;
            }
            case coPoints: {
                auto opt = new ConfigOptionPoints();
                archive(*opt);
                return opt;
            }
            case coPoint3: {
                auto opt = new ConfigOptionPoint3();
                archive(*opt);
                return opt;
            }
            case coBool: {
                auto opt = new ConfigOptionBool();
                archive(*opt);
                return opt;
            }
            case coBools: {
                auto opt = new ConfigOptionBools();
                archive(*opt);
                return opt;
            }
            case coEnum: {
                auto opt = new ConfigOptionEnumGeneric(this->enum_keys_map);
                archive(*opt);
                return opt;
            }
            // BBS
            case coEnums: {
                auto opt = new ConfigOptionEnumsGeneric(this->enum_keys_map);
                archive(*opt);
                return opt;
            }
            case coIntsGroups: {
                auto opt = new ConfigOptionIntsGroups();
                archive(*opt);
                return opt;
            }
            case coPointsGroups: {
                auto opt = new ConfigOptionPointsGroups();
                archive(*opt);
                return opt;
            }
            default:
                throw ConfigurationError(std::string("ConfigOptionDef::load_option_from_archive(): Unknown option type for option ") +
                                         this->opt_key);
            }
        }
    }

References Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coIntsGroups, Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoint3, Slic3r::coPoints, Slic3r::coPointsGroups, Slic3r::coString, Slic3r::coStrings, and enum_keys_map.

Referenced by Slic3r::read_config().

Here is the caller graph for this function:

◆ save_option_to_archive()

template<class Archive>

ConfigOption * Slic3r::ConfigOptionDef::save_option_to_archive	(	Archive &	archive,
		const ConfigOption *	opt ) const

inline

                                                                                                                  {
      if (this->nullable) {
        switch (this->type) {
        case coFloats:          archive(*static_cast<const ConfigOptionFloatsNullable*>(opt));  break;
        case coInts:            archive(*static_cast<const ConfigOptionIntsNullable*>(opt));    break;
        case coPercents:        archive(*static_cast<const ConfigOptionPercentsNullable*>(opt));break;
        case coBools:           archive(*static_cast<const ConfigOptionBoolsNullable*>(opt));   break;
            case coFloatsOrPercents: archive(*static_cast<const ConfigOptionFloatsOrPercentsNullable*>(opt)); break;
            case coEnums: archive(*static_cast<const ConfigOptionEnumsGenericNullable*>(opt)); break;
            default:
                throw ConfigurationError(
                    std::string("ConfigOptionDef::save_option_to_archive(): Unknown nullable option type for option ") + this->opt_key);
            }
        } else {
            switch (this->type) {
            case coFloat: archive(*static_cast<const ConfigOptionFloat*>(opt)); break;
            case coFloats: archive(*static_cast<const ConfigOptionFloats*>(opt)); break;
            case coInt: archive(*static_cast<const ConfigOptionInt*>(opt)); break;
            case coInts: archive(*static_cast<const ConfigOptionInts*>(opt)); break;
            case coString: archive(*static_cast<const ConfigOptionString*>(opt)); break;
            case coStrings: archive(*static_cast<const ConfigOptionStrings*>(opt)); break;
            case coPercent: archive(*static_cast<const ConfigOptionPercent*>(opt)); break;
            case coPercents: archive(*static_cast<const ConfigOptionPercents*>(opt)); break;
            case coFloatOrPercent: archive(*static_cast<const ConfigOptionFloatOrPercent*>(opt)); break;
            case coFloatsOrPercents: archive(*static_cast<const ConfigOptionFloatsOrPercents*>(opt)); break;
            case coPoint: archive(*static_cast<const ConfigOptionPoint*>(opt)); break;
            case coPoints: archive(*static_cast<const ConfigOptionPoints*>(opt)); break;
            case coPoint3: archive(*static_cast<const ConfigOptionPoint3*>(opt)); break;
            case coBool: archive(*static_cast<const ConfigOptionBool*>(opt)); break;
            case coBools: archive(*static_cast<const ConfigOptionBools*>(opt)); break;
            case coEnum: archive(*static_cast<const ConfigOptionEnumGeneric*>(opt)); break;
            // BBS
            case coEnums: archive(*static_cast<const ConfigOptionEnumsGeneric*>(opt)); break;
            case coIntsGroups: archive(*static_cast<const ConfigOptionIntsGroups*>(opt)); break;
            case coPointsGroups: archive(*static_cast<const ConfigOptionPointsGroups*>(opt)); break;
            default:
                throw ConfigurationError(std::string("ConfigOptionDef::save_option_to_archive(): Unknown option type for option ") +
                                         this->opt_key);
            }
        }
        // Make the compiler happy, shut up the warnings.
        return nullptr;
    }