Slic3r::CLIActionsConfigDef Class Reference

#include <src/libslic3r/PrintConfig.hpp>

Inheritance diagram for Slic3r::CLIActionsConfigDef:

Collaboration diagram for Slic3r::CLIActionsConfigDef:

Public Member Functions
	CLIActionsConfigDef ()
bool	has (const t_config_option_key &opt_key) const
const ConfigOptionDef *	get (const t_config_option_key &opt_key) const
std::vector< std::string >	keys () const
std::ostream &	print_cli_help (std::ostream &out, bool show_defaults, std::function< bool(const ConfigOptionDef &)> filter=[](const ConfigOptionDef &){ return true;}) const

Public Attributes
t_optiondef_map	options
std::map< size_t, const ConfigOptionDef * >	by_serialization_key_ordinal

Protected Member Functions
ConfigOptionDef *	add (const t_config_option_key &opt_key, ConfigOptionType type)
ConfigOptionDef *	add_nullable (const t_config_option_key &opt_key, ConfigOptionType type)
void	finalize ()

Detailed Description

Constructor & Destructor Documentation

CLIActionsConfigDef()

Slic3r::CLIActionsConfigDef::CLIActionsConfigDef

(

)

{
    ConfigOptionDef* def;
 
    // Actions:
    def = this->add("export_obj", coBool);
    def->label = L("Export OBJ");
    def->tooltip = L("Export the model(s) as OBJ.");
    def->set_default_value(new ConfigOptionBool(false));
 
/*
    def = this->add("export_svg", coBool);
    def->label = L("Export SVG");
    def->tooltip = L("Slice the model and export solid slices as SVG.");
    def->set_default_value(new ConfigOptionBool(false));
*/
 
    def = this->add("export_sla", coBool);
    def->label = L("Export SLA");
    def->tooltip = L("Slice the model and export SLA printing layers as PNG.");
    def->cli = "export-sla|sla";
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("export_3mf", coBool);
    def->label = L("Export 3MF");
    def->tooltip = L("Export the model(s) as 3MF.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("export_amf", coBool);
    def->label = L("Export AMF");
    def->tooltip = L("Export the model(s) as AMF.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("export_stl", coBool);
    def->label = L("Export STL");
    def->tooltip = L("Export the model(s) as STL.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("export_gcode", coBool);
    def->label = L("Export G-code");
    def->tooltip = L("Slice the model and export toolpaths as G-code.");
    def->cli = "export-gcode|gcode|g";
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("gcodeviewer", coBool);
    def->label = L("G-code viewer");
    def->tooltip = L("Visualize an already sliced and saved G-code");
    def->cli = "gcodeviewer";
    def->set_default_value(new ConfigOptionBool(false));
 
#if ENABLE_GL_CORE_PROFILE
    def = this->add("opengl-version", coString);
    def->label = L("OpenGL version");
    def->tooltip = L("Select a specific version of OpenGL");
    def->cli = "opengl-version";
    def->set_default_value(new ConfigOptionString());
 
    def = this->add("opengl-debug", coBool);
    def->label = L("OpenGL debug output");
    def->tooltip = L("Activate OpenGL debug output on graphic cards which support it");
    def->cli = "opengl-debug";
    def->set_default_value(new ConfigOptionBool(false));
#endif // ENABLE_GL_CORE_PROFILE
 
    def = this->add("slice", coBool);
    def->label = L("Slice");
    def->tooltip = L("Slice the model as FFF or SLA based on the printer_technology configuration value.");
    def->cli = "slice|s";
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("help", coBool);
    def->label = L("Help");
    def->tooltip = L("Show this help.");
    def->cli = "help|h";
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("help_fff", coBool);
    def->label = L("Help (FFF options)");
    def->tooltip = L("Show the full list of print/G-code configuration options.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("help_sla", coBool);
    def->label = L("Help (SLA options)");
    def->tooltip = L("Show the full list of SLA print configuration options.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("info", coBool);
    def->label = L("Output Model Info");
    def->tooltip = L("Write information about the model to the console.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("save", coString);
    def->label = L("Save config file");
    def->tooltip = L("Save configuration to the specified file.");
    def->set_default_value(new ConfigOptionString());
}

References Slic3r::ConfigDef::add(), Slic3r::ConfigOptionDef::cli, Slic3r::coBool, Slic3r::coString, L, Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionDef::set_default_value(), and Slic3r::ConfigOptionDef::tooltip.

Here is the call graph for this function:

Member Function Documentation

add()

ConfigOptionDef * Slic3r::ConfigDef::add ( const t_config_option_key &  opt_key, ConfigOptionType  type  )

protectedinherited

{
  static size_t serialization_key_ordinal_last = 0;
    ConfigOptionDef *opt = &this->options[opt_key];
    opt->opt_key = opt_key;
    opt->type = type;
    opt->serialization_key_ordinal = ++ serialization_key_ordinal_last;
    this->by_serialization_key_ordinal[opt->serialization_key_ordinal] = opt;
    return opt;
}

References Slic3r::ConfigDef::by_serialization_key_ordinal, Slic3r::ConfigOptionDef::opt_key, Slic3r::ConfigDef::options, Slic3r::ConfigOptionDef::serialization_key_ordinal, and Slic3r::ConfigOptionDef::type.

Referenced by Slic3r::AnycubicSLAFormatConfigDef::AnycubicSLAFormatConfigDef(), CLIActionsConfigDef(), Slic3r::CLIMiscConfigDef::CLIMiscConfigDef(), Slic3r::CLITransformConfigDef::CLITransformConfigDef(), Slic3r::ConfigDef::add_nullable(), Slic3r::PrintConfigDef::init_common_params(), Slic3r::PrintConfigDef::init_fff_params(), Slic3r::PrintConfigDef::init_sla_params(), and Slic3r::PrintConfigDef::init_sla_support_params().

Here is the caller graph for this function:

add_nullable()

ConfigOptionDef * Slic3r::ConfigDef::add_nullable ( const t_config_option_key &  opt_key, ConfigOptionType  type  )

protectedinherited

{
  ConfigOptionDef *def = this->add(opt_key, type);
  def->nullable = true;
  return def;
}

References Slic3r::ConfigDef::add(), and Slic3r::ConfigOptionDef::nullable.

Referenced by Slic3r::PrintConfigDef::init_fff_params(), and Slic3r::PrintConfigDef::init_sla_params().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

void Slic3r::ConfigDef::finalize ( )

protectedinherited

{
    // Validate & finalize open & closed enums.
    for (std::pair<const t_config_option_key, ConfigOptionDef> &kvp : options) {
        ConfigOptionDef& def = kvp.second;
        if (def.type == coEnum) {
            assert(def.enum_def);
            assert(def.enum_def->is_valid_closed_enum());
            assert(def.gui_type != ConfigOptionDef::GUIType::i_enum_open && 
                   def.gui_type != ConfigOptionDef::GUIType::f_enum_open && 
                   def.gui_type != ConfigOptionDef::GUIType::select_open);
            def.enum_def->finalize_closed_enum();
        } else if (def.gui_type == ConfigOptionDef::GUIType::i_enum_open || def.gui_type == ConfigOptionDef::GUIType::f_enum_open ||
                   def.gui_type == ConfigOptionDef::GUIType::select_open) {
            assert(def.enum_def);
            assert(def.enum_def->is_valid_open_enum());
            assert(def.gui_type != ConfigOptionDef::GUIType::i_enum_open || def.type == coInt || def.type == coInts);
            assert(def.gui_type != ConfigOptionDef::GUIType::f_enum_open || def.type == coFloat || def.type == coPercent || def.type == coFloatOrPercent);
            assert(def.gui_type != ConfigOptionDef::GUIType::select_open || def.type == coString || def.type == coStrings);
        } else {
            assert(! def.enum_def);
        }
    }
}

References Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coInts, Slic3r::coPercent, Slic3r::coString, Slic3r::coStrings, Slic3r::ConfigOptionDef::enum_def, Slic3r::ConfigOptionDef::f_enum_open, Slic3r::ConfigOptionDef::gui_type, Slic3r::ConfigOptionDef::i_enum_open, Slic3r::ConfigDef::options, Slic3r::ConfigOptionDef::select_open, and Slic3r::ConfigOptionDef::type.

Referenced by Slic3r::PrintConfigDef::PrintConfigDef().

Here is the caller graph for this function:

get()

const ConfigOptionDef * Slic3r::ConfigDef::get ( const t_config_option_key &  opt_key ) const

inlineinherited

                                                                          {
        t_optiondef_map::iterator it = const_cast<ConfigDef*>(this)->options.find(opt_key);
        return (it == this->options.end()) ? nullptr : &it->second;
    }

References Slic3r::ConfigDef::options.

Referenced by Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::PageTemperatures::PageTemperatures(), Slic3r::PhysicalPrinterCollection::PhysicalPrinterCollection(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::change_opt_value(), Slic3r::StaticPrintConfig::StaticCache< T >::finalize(), Slic3r::ConfigBase::get_abs_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(), Slic3r::ConfigBase::option_def(), Slic3r::DynamicConfig::optptr(), cereal::save(), Slic3r::client::MyContext::scalar_variable_to_expr(), Slic3r::StaticConfig::set_defaults(), Slic3r::ConfigBase::set_deserialize_raw(), Slic3r::GUI::PageMaterials::sort_list_data(), Slic3r::GUI::PlaterPresetComboBox::update(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::GUI::TabSLAPrint::update_description_lines(), and Slic3r::validate().

Here is the caller graph for this function:

has()

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

inlineinherited

{ return this->options.count(opt_key) > 0; }

Referenced by Slic3r::PrintConfigDef::handle_legacy(), and Slic3r::CLI::setup().

Here is the caller graph for this function:

keys()

std::vector< std::string > Slic3r::ConfigDef::keys ( ) const

inlineinherited

                                      {
        std::vector<std::string> out;
        out.reserve(options.size());
        for(auto const& kvp : options)
            out.push_back(kvp.first);
        return out;
    }

References Slic3r::ConfigDef::options.

print_cli_help()

std::ostream & Slic3r::ConfigDef::print_cli_help ( std::ostream &  out, bool  show_defaults, std::function< bool(const ConfigOptionDef &)>  filter = [](const ConfigOptionDef &){ return true; }  ) const

inherited

{
    // prepare a function for wrapping text
    auto wrap = [](const std::string& text, size_t line_length) -> std::string {
        std::istringstream words(text);
        std::ostringstream wrapped;
        std::string word;
 
        if (words >> word) {
            wrapped << word;
            size_t space_left = line_length - word.length();
            while (words >> word) {
                if (space_left < word.length() + 1) {
                    wrapped << '\n' << word;
                    space_left = line_length - word.length();
                } else {
                    wrapped << ' ' << word;
                    space_left -= word.length() + 1;
                }
            }
        }
        return wrapped.str();
    };
 
    // get the unique categories
    std::set<std::string> categories;
    for (const auto& opt : this->options) {
        const ConfigOptionDef& def = opt.second;
        if (filter(def))
            categories.insert(def.category);
    }
    
    for (const std::string& category : categories) {
        if (category != "") {
            out << category << ":" << std::endl;
        } else if (categories.size() > 1) {
            out << "Misc options:" << std::endl;
        }
        
        for (const auto& opt : this->options) {
            const ConfigOptionDef& def = opt.second;
      if (def.category != category || def.cli == ConfigOptionDef::nocli || !filter(def))
                continue;
            
            // get all possible variations: --foo, --foobar, -f...
            std::vector<std::string> cli_args = def.cli_args(opt.first);
      if (cli_args.empty())
        continue;
 
            for (auto& arg : cli_args) {
                arg.insert(0, (arg.size() == 1) ? "-" : "--");
                if (def.type == coFloat || def.type == coInt || def.type == coFloatOrPercent
                    || def.type == coFloats || def.type == coInts) {
                    arg += " N";
                } else if (def.type == coPoint) {
                    arg += " X,Y";
                } else if (def.type == coPoint3) {
                    arg += " X,Y,Z";
                } else if (def.type == coString || def.type == coStrings) {
                    arg += " ABCD";
                }
            }
            
            // left: command line options
            const std::string cli = boost::algorithm::join(cli_args, ", ");
            out << " " << std::left << std::setw(20) << cli;
            
            // right: option description
            std::string descr = def.tooltip;
            bool show_defaults_this = show_defaults || def.opt_key == "config_compatibility";
            if (show_defaults_this && def.default_value && def.type != coBool
                && (def.type != coString || !def.default_value->serialize().empty())) {
                descr += " (";
                if (!def.sidetext.empty()) {
                    descr += def.sidetext + ", ";
                } else if (def.enum_def->has_values()) {
                    descr += boost::algorithm::join(def.enum_def->values(), ", ") + "; ";
                }
                descr += "default: " + def.default_value->serialize() + ")";
            }
            
            // wrap lines of description
            descr = wrap(descr, 80);
            std::vector<std::string> lines;
            boost::split(lines, descr, boost::is_any_of("\n"));
            
            // if command line options are too long, print description in new line
            for (size_t i = 0; i < lines.size(); ++i) {
                if (i == 0 && cli.size() > 19)
                    out << std::endl;
                if (i > 0 || cli.size() > 19)
                    out << std::string(21, ' ');
                out << lines[i] << std::endl;
            }
        }
    }
    return out;
}

References arg(), Slic3r::ConfigOptionDef::category, Slic3r::ConfigOptionDef::cli, Slic3r::ConfigOptionDef::cli_args(), Slic3r::coBool, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coInt, Slic3r::coInts, Slic3r::coPoint, Slic3r::coPoint3, Slic3r::coString, Slic3r::coStrings, Slic3r::ConfigOptionDef::default_value, Slic3r::ConfigOptionDef::enum_def, Slic3r::ConfigOptionDef::nocli, Slic3r::ConfigOptionDef::opt_key, Slic3r::ConfigDef::options, Slic3r::ConfigOptionDef::sidetext, Slic3r::ConfigOptionDef::tooltip, and Slic3r::ConfigOptionDef::type.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

by_serialization_key_ordinal

std::map<size_t, const ConfigOptionDef*> Slic3r::ConfigDef::by_serialization_key_ordinal

inherited

Referenced by Slic3r::DynamicPrintAndCLIConfig::PrintAndCLIConfigDef::PrintAndCLIConfigDef(), Slic3r::ConfigDef::add(), and cereal::load().

options

t_optiondef_map Slic3r::ConfigDef::options

inherited

Referenced by Slic3r::DynamicPrintAndCLIConfig::PrintAndCLIConfigDef::PrintAndCLIConfigDef(), Slic3r::PrintConfigDef::PrintConfigDef(), Slic3r::DynamicPrintAndCLIConfig::PrintAndCLIConfigDef::~PrintAndCLIConfigDef(), Slic3r::ConfigDef::add(), Slic3r::AMFParserContext::endElement(), Slic3r::ConfigDef::finalize(), Slic3r::StaticPrintConfig::StaticCache< T >::finalize(), Slic3r::ConfigDef::get(), Slic3r::DynamicPrintAndCLIConfig::handle_legacy(), Slic3r::PrintConfigDef::init_fff_params(), Slic3r::ConfigDef::keys(), Slic3r::StaticConfig::keys(), Slic3r::ConfigDef::print_cli_help(), Slic3r::DynamicConfig::read_cli(), Slic3r::ConfigBase::set_deserialize_raw(), and Slic3r::CLI::setup().

---

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

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