Slic3r::CLITransformConfigDef Class Reference

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

Inheritance diagram for Slic3r::CLITransformConfigDef:

Collaboration diagram for Slic3r::CLITransformConfigDef:

Public Member Functions
	CLITransformConfigDef ()
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
bool	empty ()
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)

Detailed Description

Constructor & Destructor Documentation

CLITransformConfigDef()

Slic3r::CLITransformConfigDef::CLITransformConfigDef

(

)

{
    ConfigOptionDef* def;
 
    // Transform options:
    /*def = this->add("align_xy", coPoint);
    def->label = L("Align XY");
    def->tooltip = L("Align the model to the given point.");
    def->set_default_value(new ConfigOptionPoint(Vec2d(100,100)));
 
    def = this->add("cut", coFloat);
    def->label = L("Cut");
    def->tooltip = L("Cut model at the given Z.");
    def->set_default_value(new ConfigOptionFloat(0));*/
 
/*
    def = this->add("cut_grid", coFloat);
    def->label = L("Cut");
    def->tooltip = L("Cut model in the XY plane into tiles of the specified max size.");
    def->set_default_value(new ConfigOptionPoint());
 
    def = this->add("cut_x", coFloat);
    def->label = L("Cut");
    def->tooltip = L("Cut model at the given X.");
    def->set_default_value(new ConfigOptionFloat(0));
 
    def = this->add("cut_y", coFloat);
    def->label = L("Cut");
    def->tooltip = L("Cut model at the given Y.");
    def->set_default_value(new ConfigOptionFloat(0));
*/
 
    /*def = this->add("center", coPoint);
    def->label = L("Center");
    def->tooltip = L("Center the print around the given center.");
    def->set_default_value(new ConfigOptionPoint(Vec2d(100,100)));*/
 
    def = this->add("arrange", coInt);
    def->label = L("Arrange Options");
    def->tooltip = L("Arrange options: 0-disable, 1-enable, others-auto");
    def->cli_params = "option";
    //def->cli = "arrange|a";
    def->set_default_value(new ConfigOptionInt(0));
 
    def = this->add("repetitions", coInt);
    def->label = L("Repetition count");
    def->tooltip = L("Repetition count of the whole model.");
    def->cli_params = "count";
    def->set_default_value(new ConfigOptionInt(1));
 
    def = this->add("ensure_on_bed", coBool);
    def->label = L("Ensure on bed");
    def->tooltip = L("Lift the object above the bed when it is partially below. Disabled by default.");
    def->set_default_value(new ConfigOptionBool(false));
 
    /*def = this->add("copy", coInt);
    def->label = L("Copy");
    def->tooltip =L("Duplicate copies of model.");
    def->min = 1;
    def->set_default_value(new ConfigOptionInt(1));*/
 
    /*def = this->add("duplicate_grid", coPoint);
    def->label = L("Duplicate by grid");
    def->tooltip = L("Multiply copies by creating a grid.");*/
 
    def = this->add("assemble", coBool);
    def->label = L("Assemble");
    def->tooltip = L("Arrange the supplied models in a plate and merge them in a single model in order to perform actions once.");
    //def->cli = "merge|m";
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("convert_unit", coBool);
    def->label = L("Convert Unit");
    def->tooltip = L("Convert the units of model.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("orient", coInt);
    def->label = L("Orient Options");
    def->tooltip = L("Orient options: 0-disable, 1-enable, others-auto");
    //def->cli = "orient|o";
    def->set_default_value(new ConfigOptionInt(0));
 
    def = this->add("repair", coBool);
    def->label = L("Repair");
    def->tooltip = L("Repair the meshes of the models as Fix Model does: close holes and cracks, orient them outward and "
                     "remove self-intersections.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("rotate", coFloat);
    def->label = L("Rotate");
    def->tooltip = L("Rotation angle around the Z axis in degrees.");
    def->sidetext = u8"°";  // degrees, don't need translation
    def->set_default_value(new ConfigOptionFloat(0));
 
    def = this->add("rotate_x", coFloat);
    def->label = L("Rotate around X");
    def->tooltip = L("Rotation angle around the X axis in degrees.");
    def->sidetext = u8"°";  // degrees, don't need translation
    def->set_default_value(new ConfigOptionFloat(0));
 
    def = this->add("rotate_y", coFloat);
    def->label = L("Rotate around Y");
    def->tooltip = L("Rotation angle around the Y axis in degrees.");
    def->sidetext = u8"°";  // degrees, don't need translation
    def->set_default_value(new ConfigOptionFloat(0));
 
    // The --ground-* options choose from the faces the "Lay on Face" gizmo offers. Like the other
    // transforms they run in command-line order, so they see the rotations given before them.
    def = this->add("ground_largest_face", coBool);
    def->label = L("Ground largest face");
    def->tooltip = L("Lay each object on the largest face of its convex hull and drop it onto the bed. Of equally large "
                     "faces, the one already facing down is kept. Objects without a face large enough to rest on are left "
                     "as they are. Transforms run in command-line order, so rotations given before this option are respected. "
                     "--orient 1 runs after all transforms and replaces the orientation.");
    def->set_default_value(new ConfigOptionBool(false));
 
    def = this->add("ground_face_normal", coString);
    def->label = L("Ground face by normal");
    def->tooltip = L("Lay each object on the convex hull face whose outward normal is closest to the direction NX,NY,NZ "
                     "and drop it onto the bed. The direction is in object coordinates, which include the rotations given "
                     "before this option and match the plate axes unless the input file rotates the object. For example, "
                     "1,0,0 stands the object on its +X side. --orient 1 runs after all transforms and replaces the orientation.");
    def->cli_params = "NX,NY,NZ";
    def->set_default_value(new ConfigOptionString(""));
 
    def = this->add("ground_face_point", coString);
    def->label = L("Ground face at point");
    def->tooltip = L("Lay each object on the convex hull face that contains the point X,Y,Z and drop it onto the bed. "
                     "The point is in object coordinates, which include the rotations given before this option; "
                     "--inspect-mesh reports face centers in them. Objects without such a face are left as they are, and "
                     "the run fails if no object has one. --orient 1 runs after all transforms and replaces the orientation.");
    def->cli_params = "X,Y,Z";
    def->set_default_value(new ConfigOptionString(""));
 
    def = this->add("scale", coFloat);
    def->label = L("Scale");
    def->tooltip = L("Scale the model by a float factor.");
    def->cli_params = "factor";
    def->set_default_value(new ConfigOptionFloat(1.f));
 
    /*def = this->add("split", coBool);
    def->label = L("Split");
    def->tooltip = L("Detect unconnected parts in the given models and split them into separate objects.");
 
    def = this->add("scale_to_fit", coPoint3);
    def->label = L("Scale to Fit");
    def->tooltip = L("Scale to fit the given volume.");
    def->set_default_value(new ConfigOptionPoint3(Vec3d(0,0,0)));*/
}

References Slic3r::ConfigDef::add(), Slic3r::ConfigOptionDef::cli_params, Slic3r::coBool, Slic3r::coFloat, Slic3r::coInt, Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::coString, L, Slic3r::ConfigOptionDef::label, Slic3r::ConfigOptionDef::set_default_value(), Slic3r::ConfigOptionDef::sidetext, 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 by_serialization_key_ordinal, and options.

Referenced by Slic3r::CLIMiscConfigDef::CLIMiscConfigDef(), Slic3r::CLITransformConfigDef::CLITransformConfigDef(), Slic3r::CustomGcodeSpecificConfigDef::CustomGcodeSpecificConfigDef(), Slic3r::DimensionsConfigDef::DimensionsConfigDef(), Slic3r::ObjectsInfoConfigDef::ObjectsInfoConfigDef(), Slic3r::OtherPresetsConfigDef::OtherPresetsConfigDef(), Slic3r::OtherSlicingStatesConfigDef::OtherSlicingStatesConfigDef(), Slic3r::PrintStatisticsConfigDef::PrintStatisticsConfigDef(), Slic3r::ReadOnlySlicingStatesConfigDef::ReadOnlySlicingStatesConfigDef(), Slic3r::ReadWriteSlicingStatesConfigDef::ReadWriteSlicingStatesConfigDef(), Slic3r::TimestampsConfigDef::TimestampsConfigDef(), add_nullable(), Slic3r::PrintConfigDef::init_common_params(), Slic3r::PrintConfigDef::init_fff_params(), and Slic3r::PrintConfigDef::init_sla_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 add(), and Slic3r::ConfigOptionDef::nullable.

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

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool Slic3r::ConfigDef::empty ( )

inlineinherited

{ return options.empty(); }

References options.

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 options.

Referenced by Slic3r::GUI::change_opt_value(), Slic3r::StaticPrintConfig::StaticCache< T >::finalize(), Slic3r::CalibPressureAdvance::find_optimal_PA_speed(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::GUI::SettingsFactory::get_bundle(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::ConfigOptionsGroup::get_config_value2(), Slic3r::GUI::get_full_label(), Slic3r::GUI::get_full_settings_hierarchy(), Slic3r::GUI::get_string_value(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::ConfigBase::load_from_json(), Slic3r::prune_stale_plugin_overrides(), Slic3r::DynamicPrintConfig::update_filament_config_values_for_multiple_extruders(), Slic3r::GUI::Sidebar::update_presets(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), Slic3r::DynamicPrintConfig::update_values_from_single_to_multi(), Slic3r::DynamicPrintConfig::update_values_to_printer_extruders(), and Slic3r::DynamicPrintConfig::update_values_to_printer_extruders_for_multiple_filaments().

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::GUI::EditGCodeDialog::selection_changed().

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 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 = [](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 (auto 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) ? "-" : "--");
                //BBS: refine the print help format
                if (!def.cli_params.empty())
                    arg += " " + def.cli_params;
                /*if ( def.type == coInt || def.type == coInts) {
                    arg += " int_value";
                } else if (def.type == coFloat ||  def.type == coFloatOrPercent || def.type == coFloats) {
                    arg += " float_value";
                } 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 += " filename_lists";
                }*/
            }
 
            // 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_values.empty()) {
                    descr += boost::algorithm::join(def.enum_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 Slic3r::ConfigOptionDef::category, Slic3r::ConfigOptionDef::cli, Slic3r::ConfigOptionDef::cli_args(), Slic3r::ConfigOptionDef::cli_params, Slic3r::coBool, Slic3r::coString, Slic3r::ConfigOptionDef::default_value, Slic3r::ConfigOptionDef::enum_values, Slic3r::ConfigOptionDef::nocli, Slic3r::ConfigOptionDef::opt_key, options, Slic3r::ConfigOptionDef::sidetext, Slic3r::ConfigOptionDef::tooltip, and Slic3r::ConfigOptionDef::type.

Here is the call 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(), and add().

options

t_optiondef_map Slic3r::ConfigDef::options

inherited

Referenced by Slic3r::DynamicPrintAndCLIConfig::PrintAndCLIConfigDef::PrintAndCLIConfigDef(), Slic3r::PrintConfigDef::PrintConfigDef(), Slic3r::DynamicPrintAndCLIConfig::PrintAndCLIConfigDef::~PrintAndCLIConfigDef(), add(), Slic3r::Search::SettingsIndex::append_options(), empty(), Slic3r::StaticPrintConfig::StaticCache< T >::finalize(), get(), Slic3r::GUI::get_string_from_enum(), Slic3r::PrintConfigDef::init_fff_params(), keys(), Slic3r::ConfigBase::load_from_json(), print_cli_help(), and Slic3r::DynamicConfig::read_cli().

---

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

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