Slic3r::GUI::ConfigManipulation Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ConfigManipulation.hpp>

Collaboration diagram for Slic3r::GUI::ConfigManipulation:

Public Member Functions
	ConfigManipulation (std::function< void()> load_config, std::function< void(const std::string &, bool toggle, int opt_index)> cb_toggle_field, std::function< void(const std::string &, bool toggle, int opt_index)> cb_toggle_line, std::function< void(const std::string &, const boost::any &)> cb_value_change, const DynamicPrintConfig *local_config=nullptr, wxWindow *msg_dlg_parent=nullptr, std::function< void(const std::string &, const wxString &, int opt_index)> cb_set_option_label=nullptr)
	ConfigManipulation ()
	~ConfigManipulation ()
bool	is_applying () const
void	apply (DynamicPrintConfig *config, DynamicPrintConfig *new_config)
t_config_option_keys const &	applying_keys () const
void	toggle_field (const std::string &field_key, const bool toggle, int opt_index=-1)
void	toggle_line (const std::string &field_key, const bool toggle, int opt_index=-1)
void	set_option_label (const std::string &field_key, const wxString &label, int opt_index=-1)
void	update_print_fff_config (DynamicPrintConfig *config, const bool is_global_config=false, const bool is_plate_config=false)
void	toggle_print_fff_options (DynamicPrintConfig *config, int variant_index, const bool is_global_config=false)
void	apply_null_fff_config (DynamicPrintConfig *config, std::vector< std::string > const &keys, std::map< ObjectBase *, ModelConfig * > const &configs)
void	check_nozzle_recommended_temperature_range (DynamicPrintConfig *config, unsigned int variant_index)
void	check_nozzle_temperature_range (DynamicPrintConfig *config, unsigned int variant_index)
void	check_nozzle_temperature_initial_layer_range (DynamicPrintConfig *config, unsigned int variant_index)
void	check_adaptive_pressure_advance_model (DynamicPrintConfig *config)
void	check_filament_max_volumetric_speed (DynamicPrintConfig *config)
void	check_filament_ironing_spacing (DynamicPrintConfig *config)
void	check_chamber_temperature (DynamicPrintConfig *config)
void	check_chamber_minimal_temperature (DynamicPrintConfig *config)
bool	check_layer_height (DynamicPrintConfig *config)
bool	layer_height_out_of_range_dialog (DynamicPrintConfig *config, double clamp_to)
void	layer_height_limits (double &min_layer_height, double &max_layer_height) const
void	set_is_BBL_Printer (bool is_bbl_printer)
bool	get_is_BBL_Printer ()
void	update_print_sla_config (DynamicPrintConfig *config, const bool is_global_config=false)
void	toggle_print_sla_options (DynamicPrintConfig *config)
bool	is_initialized_support_material_overhangs_queried ()
void	initialize_support_material_overhangs_queried (bool queried)
int	show_spiral_mode_settings_dialog (bool is_object_config=false)

Private Member Functions
bool	get_temperature_range (DynamicPrintConfig *config, int &range_low, int &range_high, unsigned int variant_index)

Private Attributes
bool	is_msg_dlg_already_exist { false }
bool	m_is_initialized_support_material_overhangs_queried { false }
bool	m_support_material_overhangs_queried { false }
bool	is_BBL_Printer {false}
std::function< void()>	load_config = nullptr
std::function< void(const std::string &, bool toggle, int opt_index)>	cb_toggle_field = nullptr
std::function< void(const std::string &, bool toggle, int opt_index)>	cb_toggle_line = nullptr
std::function< void(const std::string &, const wxString &, int opt_index)>	cb_set_option_label = nullptr
std::function< void(const std::string &, const boost::any &)>	cb_value_change = nullptr
const DynamicPrintConfig *	local_config = nullptr
wxWindow *	m_msg_dlg_parent {nullptr}
t_config_option_keys	m_applying_keys

Detailed Description

Constructor & Destructor Documentation

ConfigManipulation() [1/2]

Slic3r::GUI::ConfigManipulation::ConfigManipulation ( std::function< void()> load_config, std::function< void(const std::string &, bool toggle, int opt_index)> cb_toggle_field, std::function< void(const std::string &, bool toggle, int opt_index)> cb_toggle_line, std::function< void(const std::string &, const boost::any &)> cb_value_change, const DynamicPrintConfig * local_config = nullptr, wxWindow * msg_dlg_parent = nullptr, std::function< void(const std::string &, const wxString &, int opt_index)> cb_set_option_label = nullptr )

inline

                                                                                                             :
        load_config(load_config),
        cb_toggle_field(cb_toggle_field),
        cb_toggle_line(cb_toggle_line),
        cb_set_option_label(cb_set_option_label),
        cb_value_change(cb_value_change),
        m_msg_dlg_parent(msg_dlg_parent),
        local_config(local_config) {}

References cb_set_option_label, cb_toggle_field, cb_toggle_line, cb_value_change, load_config, local_config, and m_msg_dlg_parent.

ConfigManipulation() [2/2]

Slic3r::GUI::ConfigManipulation::ConfigManipulation ( )

inline

{}

~ConfigManipulation()

Slic3r::GUI::ConfigManipulation::~ConfigManipulation ( )

inline

                          {
        load_config = nullptr;
        cb_toggle_field = nullptr;
        cb_toggle_line = nullptr;
        cb_set_option_label = nullptr;
        cb_value_change = nullptr;
    }

References cb_set_option_label, cb_toggle_field, cb_toggle_line, cb_value_change, and load_config.

Member Function Documentation

apply()

void Slic3r::GUI::ConfigManipulation::apply	(	DynamicPrintConfig *	config,
		DynamicPrintConfig *	new_config )

{
    bool modified = false;
    m_applying_keys = config->diff(*new_config);
    for (auto opt_key : m_applying_keys) {
        config->set_key_value(opt_key, new_config->option(opt_key)->clone());
        modified = true;
    }
    if (modified && load_config != nullptr)
        load_config();
    m_applying_keys.clear();
}

References Slic3r::ConfigOption::clone(), Slic3r::DynamicConfig::diff(), load_config, m_applying_keys, Slic3r::ConfigBase::option(), and Slic3r::DynamicConfig::set_key_value().

Referenced by check_chamber_minimal_temperature(), check_filament_ironing_spacing(), check_filament_max_volumetric_speed(), check_layer_height(), layer_height_out_of_range_dialog(), toggle_print_fff_options(), update_print_fff_config(), and update_print_sla_config().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_null_fff_config()

void Slic3r::GUI::ConfigManipulation::apply_null_fff_config	(	DynamicPrintConfig *	config,
		std::vector< std::string > const &	keys,
		std::map< ObjectBase *, ModelConfig * > const &	configs )

{
    for (auto &k : keys) {
        if (k == "independent_support_layer_height" || k == "enable_support" || k == "detect_thin_wall")
            config->set_key_value(k, new ConfigOptionBool(true));
        else if (k == "wall_loops")
            config->set_key_value(k, new ConfigOptionInt(0));
        else if (k == "top_shell_layers" || k == "enforce_support_layers")
            config->set_key_value(k, new ConfigOptionInt(1));
        else if (k == "sparse_infill_density") {
            double v = config->option<ConfigOptionPercent>(k)->value;
            for (auto &c : configs) {
                auto o = c.second->get().option<ConfigOptionPercent>(k);
                if (o && o->value > v) v = o->value;
            }
            config->set_key_value(k, new ConfigOptionPercent(v)); // sparse_infill_pattern
        }
        else if (k == "detect_overhang_wall")
            config->set_key_value(k, new ConfigOptionBool(false));
        else if (k == "sparse_infill_pattern")
            config->set_key_value(k, new ConfigOptionEnum<InfillPattern>(ipGrid));
    }
}

References Slic3r::ipGrid, Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::ConfigOptionSingle< T >::value.

Here is the call graph for this function:

applying_keys()

t_config_option_keys const & Slic3r::GUI::ConfigManipulation::applying_keys

(

)

const

{
    return m_applying_keys;
}

References m_applying_keys.

check_adaptive_pressure_advance_model()

void Slic3r::GUI::ConfigManipulation::check_adaptive_pressure_advance_model

(

DynamicPrintConfig *

config

)

{
    if (is_msg_dlg_already_exist || !config->has("adaptive_pressure_advance_model"))
        return;
 
    const auto* model = config->option<ConfigOptionStrings>("adaptive_pressure_advance_model");
    if (model == nullptr)
        return;
 
    // Each extruder variant holds its own model.
    std::string error;
    for (const std::string& variant_model : model->values) {
        error = AdaptivePAProcessor::validate_adaptive_pa_model(variant_model);
        if (!error.empty())
            break;
    }
    if (!error.empty()) {
        wxString msg_text = _L("Adaptive Pressure Advance model validation failed:\n");
        msg_text += from_u8(error);
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        is_msg_dlg_already_exist = false;
    }
}

References _L, Slic3r::GUI::from_u8(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, m_msg_dlg_parent, Slic3r::ConfigBase::option(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::AdaptivePAProcessor::validate_adaptive_pa_model().

Here is the call graph for this function:

check_chamber_minimal_temperature()

void Slic3r::GUI::ConfigManipulation::check_chamber_minimal_temperature

(

DynamicPrintConfig *

config

)

{
    // Orca: the minimal chamber temperature is a "start printing" threshold that is passed to the
    // print start macro. It must not exceed the target chamber temperature, otherwise the macro
    // could wait forever for a temperature the heater is never asked to reach.
    if (config->has("chamber_minimal_temperature") && config->has("chamber_temperature")) {
        const int chamber_min_temp    = config->option<ConfigOptionInts>("chamber_minimal_temperature")->get_at(0);
        const int chamber_target_temp = config->option<ConfigOptionInts>("chamber_temperature")->get_at(0);
        if (chamber_min_temp > chamber_target_temp) {
            wxString msg_text = wxString::Format(_L("The minimal chamber temperature (%d℃) is higher than the target chamber temperature (%d℃). "
                                                    "The minimal value is the threshold at which printing starts while the chamber keeps heating toward the target, "
                                                    "so it should not exceed it. It will be clamped to the target."),
                                                 chamber_min_temp, chamber_target_temp);
            MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
            DynamicPrintConfig new_conf = *config;
            is_msg_dlg_already_exist    = true;
            dialog.ShowModal();
            new_conf.set_key_value("chamber_minimal_temperature", new ConfigOptionInts({chamber_target_temp}));
            apply(config, &new_conf);
            is_msg_dlg_already_exist = false;
        }
    }
}

References _L, apply(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, m_msg_dlg_parent, Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

check_chamber_temperature()

void Slic3r::GUI::ConfigManipulation::check_chamber_temperature

(

DynamicPrintConfig *

config

)

{
   bool support_chamber_temp_control=GUI::wxGetApp().preset_bundle->printers.get_selected_preset().config.opt_bool("support_chamber_temp_control");
    if (support_chamber_temp_control&&config->has("chamber_temperature")) {
        std::string filament_type = config->option<ConfigOptionStrings>("filament_type")->get_at(0);
        int chamber_min_temp, chamber_max_temp;
    if (MaterialType::get_chamber_temperature_range(filament_type, chamber_min_temp, chamber_max_temp)) {
            if (chamber_max_temp < config->option<ConfigOptionInts>("chamber_temperature")->get_at(0)) {
                wxString msg_text = wxString::Format(_L("Current chamber temperature is higher than the material\'s safe temperature; this may result in material softening and nozzle clogs. The maximum safe temperature for the material is %d"), chamber_max_temp);
                MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
                is_msg_dlg_already_exist = true;
                dialog.ShowModal();
                is_msg_dlg_already_exist = false;
            }
        }
    }
}

References _L, Slic3r::filament_type(), Slic3r::MaterialType::get_chamber_temperature_range(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, m_msg_dlg_parent, Slic3r::ConfigBase::option(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::support_chamber_temp_control().

Here is the call graph for this function:

check_filament_ironing_spacing()

void Slic3r::GUI::ConfigManipulation::check_filament_ironing_spacing

(

DynamicPrintConfig *

config

)

{
    const auto *opt = config->option<ConfigOptionFloatsNullable>("filament_ironing_spacing");
    if (opt == nullptr)
        return;
    std::vector<double> values = opt->values;
    bool                reset  = false;
    for (size_t i = 0; i < values.size(); ++i)
        if (!opt->is_nil(i) && values[i] < IRONING_SPACING_MIN) {
            values[i] = 0.1;
            reset     = true;
        }
    if (!reset)
        return;
    const wxString     msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
    MessageDialog      dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
    DynamicPrintConfig new_conf = *config;
    is_msg_dlg_already_exist    = true;
    dialog.ShowModal();
    new_conf.set_key_value("filament_ironing_spacing", new ConfigOptionFloatsNullable(values));
    apply(config, &new_conf);
    is_msg_dlg_already_exist = false;
}

References _, apply(), Slic3r::IRONING_SPACING_MIN, is_msg_dlg_already_exist, L, Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

check_filament_max_volumetric_speed()

void Slic3r::GUI::ConfigManipulation::check_filament_max_volumetric_speed

(

DynamicPrintConfig *

config

)

{
    //if (is_msg_dlg_already_exist) return;
    //float max_volumetric_speed = config->opt_float("filament_max_volumetric_speed");
 
    float max_volumetric_speed = config->has("filament_max_volumetric_speed") ? config->opt_float("filament_max_volumetric_speed", (float) 0.5) : 0.5;
    // BBS: limite the min max_volumetric_speed
    if (max_volumetric_speed < 0.5) {
        const wxString     msg_text = _(L("Too small max volumetric speed.\nValue was reset to 0.5"));
        MessageDialog      dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist    = true;
        dialog.ShowModal();
        new_conf.set_key_value("filament_max_volumetric_speed", new ConfigOptionFloats({0.5}));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
}

References _, apply(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, L, Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

check_layer_height()

bool Slic3r::GUI::ConfigManipulation::check_layer_height

(

DynamicPrintConfig *

config

)

{
    double min_layer_height = 0., max_layer_height = 0.;
    layer_height_limits(min_layer_height, max_layer_height);
    const double layer_height = config->opt_float("layer_height");
 
    if (min_layer_height > EPSILON && layer_height < EPSILON) {
        const wxString msg_text = wxString::Format(_L("Layer height is too small. It will be set to the minimum (%g mm)."), min_layer_height);
        MessageDialog dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxOK);
        dialog.SetButtonLabel(wxID_OK, _L("OK"));
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        is_msg_dlg_already_exist = false;
        DynamicPrintConfig new_conf = *config;
        new_conf.set_key_value("layer_height", new ConfigOptionFloat(min_layer_height));
        apply(config, &new_conf);
        return true;
    }
    if (max_layer_height > EPSILON && layer_height > max_layer_height + EPSILON)
        return layer_height_out_of_range_dialog(config, max_layer_height);
    if (min_layer_height > EPSILON && layer_height < min_layer_height - EPSILON)
        return layer_height_out_of_range_dialog(config, min_layer_height);
    return false;
}

References _L, apply(), Slic3r::ConfigOptionFloat, EPSILON, is_msg_dlg_already_exist, Slic3r::GUI::layer_height, layer_height_limits(), layer_height_out_of_range_dialog(), Slic3r::DynamicConfig::opt_float(), Slic3r::GUI::plater(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::MsgDialog::SetButtonLabel(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_config_values().

Here is the call graph for this function:

Here is the caller graph for this function:

check_nozzle_recommended_temperature_range()

void Slic3r::GUI::ConfigManipulation::check_nozzle_recommended_temperature_range	(	DynamicPrintConfig *	config,
		unsigned int	variant_index )

                                                                                                                          {
    if (is_msg_dlg_already_exist)
        return;
 
    int temperature_range_low, temperature_range_high;
    if (!get_temperature_range(config, temperature_range_low, temperature_range_high, variant_index)) return;
 
    // Get the selected filament type
    std::string filament_type = "";
    if (config->has("filament_type") && config->option<ConfigOptionStrings>("filament_type")->values.size() > 0) {
        filament_type = config->option<ConfigOptionStrings>("filament_type")->values[0];
    }
 
    int min_recommended_temp = 190;
    int max_recommended_temp = 300;
 
    if (!MaterialType::get_temperature_range(filament_type, min_recommended_temp, max_recommended_temp)){
        filament_type = "Unknown";
    }
 
    wxString msg_text;
    bool     need_check = false;
    if (temperature_range_low < min_recommended_temp) {
        msg_text += wxString::Format(_L("A minimum temperature above %d\u2103 is recommended for %s.\n"),
                                        min_recommended_temp, filament_type);
        need_check = true;
    }
    if (temperature_range_high > max_recommended_temp) {
        msg_text += wxString::Format(_L("A maximum temperature below %d\u2103 is recommended for %s.\n"),
                                        max_recommended_temp, filament_type);
        need_check = true;
    }
    if (temperature_range_low > temperature_range_high) {
        msg_text += _L("The recommended minimum temperature cannot be higher than the recommended maximum temperature.\n");
        need_check = true;
    }
    if (need_check) {
        msg_text += _L("Please check.\n");
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        is_msg_dlg_already_exist = false;
    }
}

References _L, Slic3r::filament_type(), get_temperature_range(), Slic3r::MaterialType::get_temperature_range(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, m_msg_dlg_parent, Slic3r::ConfigBase::option(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::ConfigOptionVector< T >::values.

Here is the call graph for this function:

check_nozzle_temperature_initial_layer_range()

void Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_initial_layer_range	(	DynamicPrintConfig *	config,
		unsigned int	variant_index )

{
    if (is_msg_dlg_already_exist)
        return;
 
    int temperature_range_low, temperature_range_high;
    if (!get_temperature_range(config, temperature_range_low, temperature_range_high, variant_index)) return;
 
    if (config->has("nozzle_temperature_initial_layer")) {
        if (config->opt_int("nozzle_temperature_initial_layer", variant_index) < temperature_range_low ||
            config->opt_int("nozzle_temperature_initial_layer", variant_index) > temperature_range_high)
        {
            wxString msg_text = _(L("The nozzle may become clogged when the temperature is out of the recommended range.\nPlease make sure whether to use this temperature to print.\n\n"));
            msg_text += wxString::Format(_L("The recommended nozzle temperature for this filament type is [%d, %d] degrees Celsius."), temperature_range_low, temperature_range_high);
            MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
            is_msg_dlg_already_exist = true;
            dialog.ShowModal();
            is_msg_dlg_already_exist = false;
        }
    }
}

References _, _L, get_temperature_range(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, L, m_msg_dlg_parent, Slic3r::DynamicConfig::opt_int(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

check_nozzle_temperature_range()

void Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_range	(	DynamicPrintConfig *	config,
		unsigned int	variant_index )

{
    if (is_msg_dlg_already_exist)
        return;
 
    int temperature_range_low, temperature_range_high;
    if (!get_temperature_range(config, temperature_range_low, temperature_range_high, variant_index)) return;
 
    if (config->has("nozzle_temperature")) {
        if (config->opt_int("nozzle_temperature", variant_index) < temperature_range_low || config->opt_int("nozzle_temperature", variant_index) > temperature_range_high) {
            wxString msg_text = _(L("The nozzle may become clogged when the temperature is out of the recommended range.\nPlease make sure whether to use this temperature to print.\n\n"));
            msg_text += wxString::Format(_L("The recommended nozzle temperature for this filament type is [%d, %d] degrees Celsius."), temperature_range_low, temperature_range_high);
            MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
            is_msg_dlg_already_exist = true;
            dialog.ShowModal();
            is_msg_dlg_already_exist = false;
        }
    }
}

References _, _L, get_temperature_range(), Slic3r::ConfigOptionResolver::has(), is_msg_dlg_already_exist, L, m_msg_dlg_parent, Slic3r::DynamicConfig::opt_int(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

get_is_BBL_Printer()

bool Slic3r::GUI::ConfigManipulation::get_is_BBL_Printer ( )

inline

{ return is_BBL_Printer; };

References is_BBL_Printer.

get_temperature_range()

bool Slic3r::GUI::ConfigManipulation::get_temperature_range ( DynamicPrintConfig * config, int & range_low, int & range_high, unsigned int variant_index )

private

{
    bool range_low_exist = false, range_high_exist = false;
    if (config->has("nozzle_temperature_range_low")) {
        range_low       = config->opt_int("nozzle_temperature_range_low", variant_index);
        range_low_exist       = true;
    }
    if (config->has("nozzle_temperature_range_high")) {
        range_high       = config->opt_int("nozzle_temperature_range_high", variant_index);
        range_high_exist       = true;
    }
    return range_low_exist && range_high_exist;
}

References Slic3r::ConfigOptionResolver::has(), and Slic3r::DynamicConfig::opt_int().

Referenced by check_nozzle_recommended_temperature_range(), check_nozzle_temperature_initial_layer_range(), and check_nozzle_temperature_range().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_support_material_overhangs_queried()

void Slic3r::GUI::ConfigManipulation::initialize_support_material_overhangs_queried ( bool queried )

inline

    {
        m_is_initialized_support_material_overhangs_queried = true;
        m_support_material_overhangs_queried = queried;
    }

References m_is_initialized_support_material_overhangs_queried, and m_support_material_overhangs_queried.

is_applying()

bool Slic3r::GUI::ConfigManipulation::is_applying

(

)

const

{ return is_msg_dlg_already_exist; }

References is_msg_dlg_already_exist.

is_initialized_support_material_overhangs_queried()

bool Slic3r::GUI::ConfigManipulation::is_initialized_support_material_overhangs_queried ( )

inline

{ return m_is_initialized_support_material_overhangs_queried; }

References m_is_initialized_support_material_overhangs_queried.

layer_height_limits()

void Slic3r::GUI::ConfigManipulation::layer_height_limits	(	double &	min_layer_height,
		double &	max_layer_height ) const

{
    const DynamicPrintConfig& printer_config = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config;
    const std::vector<double>& min_limits = printer_config.option<ConfigOptionFloats>("min_layer_height")->values;
    const std::vector<double>& max_limits = printer_config.option<ConfigOptionFloats>("max_layer_height")->values;
    min_layer_height = *std::min_element(min_limits.begin(), min_limits.end());
    max_layer_height = *std::max_element(max_limits.begin(), max_limits.end());
}

References Slic3r::GUI::printer_config().

Referenced by check_layer_height().

Here is the call graph for this function:

Here is the caller graph for this function:

layer_height_out_of_range_dialog()

bool Slic3r::GUI::ConfigManipulation::layer_height_out_of_range_dialog	(	DynamicPrintConfig *	config,
		double	clamp_to )

{
    wxString msg_text = _(L("Layer height is outside the limits set in Printer Settings -> Extruder -> Layer height limits, "
                            "this may cause printing quality issues."));
    msg_text += "\n\n" + wxString::Format(_L("Adjust it to the limit (%g mm) automatically?"), clamp_to);
    MessageDialog dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxYES | wxNO);
    dialog.SetButtonLabel(wxID_YES, _L("Adjust"));
    dialog.SetButtonLabel(wxID_NO, _L("Ignore"));
    is_msg_dlg_already_exist = true;
    const bool adjust = dialog.ShowModal() == wxID_YES;
    if (adjust) {
        DynamicPrintConfig new_conf = *config;
        new_conf.set_key_value("layer_height", new ConfigOptionFloat(clamp_to));
        apply(config, &new_conf);
    }
    is_msg_dlg_already_exist = false;
    return adjust;
}

References _, _L, apply(), Slic3r::ConfigOptionFloat, is_msg_dlg_already_exist, L, Slic3r::GUI::plater(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::MsgDialog::SetButtonLabel(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by check_layer_height().

Here is the call graph for this function:

Here is the caller graph for this function:

set_is_BBL_Printer()

void Slic3r::GUI::ConfigManipulation::set_is_BBL_Printer ( bool is_bbl_printer )

inline

{ is_BBL_Printer = is_bbl_printer; };

References is_BBL_Printer.

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), Slic3r::GUI::ObjectTableSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_settings_list().

Here is the caller graph for this function:

set_option_label()

void Slic3r::GUI::ConfigManipulation::set_option_label	(	const std::string &	field_key,
		const wxString &	label,
		int	opt_index = -1 )

{
    if (cb_set_option_label)
        cb_set_option_label(opt_key, label, opt_index);
}

References cb_set_option_label.

Referenced by toggle_print_fff_options().

Here is the caller graph for this function:

show_spiral_mode_settings_dialog()

int Slic3r::GUI::ConfigManipulation::show_spiral_mode_settings_dialog

(

bool

is_object_config = false

)

{
    wxString msg_text = _(L("Spiral mode only works when wall loops is 1, support is disabled, clumping detection by probing is disabled, top shell layers is 0, sparse infill density is 0 and timelapse type is traditional."));
    auto printer_structure_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
    if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
        msg_text += _(L(" But machines with I3 structure will not generate timelapse videos."));
    }
    if (!is_object_config)
        msg_text += "\n\n" + _(L("Change these settings automatically\?\nYes - Change these settings and enable spiral/vase mode automatically\nNo  - Cancel enabling spiral mode"));
 
    MessageDialog dialog(wxGetApp().plater(), msg_text, "",
        wxICON_WARNING | (!is_object_config ? wxYES | wxNO : wxOK));
    is_msg_dlg_already_exist = true;
    auto answer = dialog.ShowModal();
    is_msg_dlg_already_exist = false;
    if (is_object_config)
        answer = wxID_YES;
    return answer;
}

References _, is_msg_dlg_already_exist, L, Slic3r::GUI::plater(), Slic3r::psI3, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by update_print_fff_config().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_field()

void Slic3r::GUI::ConfigManipulation::toggle_field	(	const std::string &	field_key,
		const bool	toggle,
		int	opt_index = -1 )

{
    if (local_config) {
        if (local_config->option(opt_key) == nullptr) return;
    }
    cb_toggle_field(opt_key, toggle, opt_index);
}

References cb_toggle_field, and local_config.

Referenced by toggle_print_fff_options(), and toggle_print_sla_options().

Here is the caller graph for this function:

toggle_line()

void Slic3r::GUI::ConfigManipulation::toggle_line	(	const std::string &	field_key,
		const bool	toggle,
		int	opt_index = -1 )

{
    if (local_config) {
        if (local_config->option(opt_key) == nullptr)
            return;
    }
    if (cb_toggle_line)
        cb_toggle_line(opt_key, toggle, opt_index);
}

References cb_toggle_line, and local_config.

Referenced by toggle_print_fff_options().

Here is the caller graph for this function:

toggle_print_fff_options()

void Slic3r::GUI::ConfigManipulation::toggle_print_fff_options	(	DynamicPrintConfig *	config,
		int	variant_index,
		const bool	is_global_config = false )

{
    PresetBundle *preset_bundle  = wxGetApp().preset_bundle;
 
    const GCodeFlavor gcflavor = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor")->value;
 
    // Orca: use booleans to avoid repeated comparisons with enum values
    const bool gcf_is_marlin_firmware = gcflavor == GCodeFlavor::gcfMarlinFirmware;
    const bool gcf_is_klipper = gcflavor == GCodeFlavor::gcfKlipper;
 
    // Belt printer: detect early since it affects multiple toggle decisions below.
    // `is_belt_tilted` is the stricter test that mirrors PrintObject::has_belt_brim():
    // only a tilted belt gets the belt-plane brim, while a belt printer with no
    // rotation is geometrically a flat bed and keeps the ordinary plate brim.
    bool is_belt_printer = false;
    bool is_belt_tilted  = false;
    {
        const auto &printer_cfg = preset_bundle->printers.get_edited_preset().config;
        const auto *belt_opt = printer_cfg.option<ConfigOptionBool>("belt_printer");
        if (belt_opt)
            is_belt_printer = belt_opt->value;
        const auto *axis  = printer_cfg.option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation");
        const auto *angle = printer_cfg.option<ConfigOptionFloat>("belt_slice_rotation_angle");
        if (is_belt_printer && axis != nullptr && angle != nullptr) {
            // Same window as Print::has_tilted_belt(); shared constants so the GUI and
            // the backend cannot drift apart.
            const double tilt = std::abs(angle->value);
            is_belt_tilted = (axis->value == BeltRotationAxis::X || axis->value == BeltRotationAxis::Y)
                          && tilt >= BELT_BRIM_MIN_TILT_DEG && tilt <= BELT_BRIM_MAX_TILT_DEG;
        }
    }
 
    bool have_volumetric_extrusion_rate_slope = config->option<ConfigOptionFloat>("max_volumetric_extrusion_rate_slope")->value > 0;
    float have_volumetric_extrusion_rate_slope_segment_length = config->option<ConfigOptionFloat>("max_volumetric_extrusion_rate_slope_segment_length")->value;
    toggle_field("enable_arc_fitting", !have_volumetric_extrusion_rate_slope && !is_belt_printer);
    toggle_line("max_volumetric_extrusion_rate_slope_segment_length", have_volumetric_extrusion_rate_slope);
    toggle_line("extrusion_rate_smoothing_external_perimeter_only", have_volumetric_extrusion_rate_slope);
    if(have_volumetric_extrusion_rate_slope) config->set_key_value("enable_arc_fitting", new ConfigOptionEnum<ArcFittingMode>(ArcFittingMode::Disabled));
    if(have_volumetric_extrusion_rate_slope_segment_length < 0.5) {
        DynamicPrintConfig new_conf = *config;
        new_conf.set_key_value("max_volumetric_extrusion_rate_slope_segment_length", new ConfigOptionFloat(1));
        apply(config, &new_conf);
    }
 
    bool have_perimeters = config->opt_int("wall_loops") > 0;
    for (auto el : { "extra_perimeters_on_overhangs", "ensure_vertical_shell_thickness", "detect_thin_wall", "detect_overhang_wall",
        "seam_position", "staggered_inner_seams", "wall_sequence", "outer_wall_line_width" })
        toggle_field(el, have_perimeters);
    for (auto el : { "inner_wall_speed", "outer_wall_speed", "small_perimeter_speed", "small_perimeter_threshold" })
        toggle_field(el, have_perimeters, variant_index);
 
    bool have_infill = config->option<ConfigOptionPercent>("sparse_infill_density")->value > 0;
    // sparse_infill_filament_id uses the same logic as in Print::extruders()
    for (auto el : { "sparse_infill_pattern", "infill_combination", "fill_multiline","infill_direction",
                     "infill_complete_top",
        "minimum_sparse_infill_area", "sparse_infill_filament_id","infill_shift_step","sparse_infill_rotate_template","symmetric_infill_y_axis"})
        toggle_line(el, have_infill);
 
    InfillPattern pattern = config->opt_enum<InfillPattern>("sparse_infill_pattern");
 
    // Orca: the concentric patterns follow the surface outline instead of crossing it, so there is
    // nothing for an infill anchor to attach to. Hide the anchor settings for them.
    bool have_infill_anchor = have_infill && pattern != ipConcentric && pattern != ipSpiralInset;
    toggle_line("infill_anchor", have_infill_anchor);
    toggle_line("infill_anchor_max", have_infill_anchor);
 
    bool have_combined_infill = config->opt_bool("infill_combination") && have_infill;
    toggle_line("infill_combination_max_layer_height", have_combined_infill);
 
    // Infill patterns that support multiline infill.
    bool          have_multiline_infill_pattern = pattern == ipGyroid || pattern == ipGrid || pattern == ipRectilinear || pattern == ipTpmsD || pattern == ipTpmsFK || pattern == ipCrossHatch || pattern == ipHoneycomb || pattern == ipLateralLattice || pattern == ipLateralHoneycomb || pattern == ipConcentric ||
                                                  pattern == ipCubic || pattern == ipStars || pattern == ipAlignedRectilinear || pattern == ipLightning || pattern == ip3DHoneycomb || pattern == ipAdaptiveCubic || pattern == ipSupportCubic|| pattern == ipTriangles || pattern == ipQuarterCubic|| pattern == ipArchimedeanChords || pattern == ipHilbertCurve || pattern == ipOctagramSpiral;
 
    // The sparse infill density is the surface density of the adaptive infill; at 100% the infill is solid.
    bool have_adaptive_infill_pattern = have_infill && config->option<ConfigOptionPercent>("sparse_infill_density")->value < 100 &&
                            is_adaptive_infill_pattern(pattern);
    toggle_line("adaptive_infill_mode", have_adaptive_infill_pattern);
    bool have_adaptive_infill = have_adaptive_infill_pattern && config->opt_enum<AdaptiveInfillMode>("adaptive_infill_mode") != AdaptiveInfillMode::Disabled;
    toggle_line("adaptive_infill_interior_density", have_adaptive_infill);
    toggle_line("adaptive_infill_gradient", have_adaptive_infill);
 
    // gyroid_optimized only applies when the sparse infill pattern is gyroid without adaptive density;
    // hide the whole line otherwise.
    toggle_line("gyroid_optimized", have_infill && pattern == ipGyroid && !have_adaptive_infill);
 
    // If there is infill, enable/disable fill_multiline according to whether the pattern supports multiline infill.
    if (have_infill) {
        toggle_field("fill_multiline", have_multiline_infill_pattern);
        // If the infill pattern does not support multiline fill_multiline is changed to 1.
        // Necessary when the pattern contains params.multiline (for example, triangles because they belong to the rectilinear class)
        if (!have_multiline_infill_pattern) {
            DynamicPrintConfig new_conf = *config;
            new_conf.set_key_value("fill_multiline", new ConfigOptionInt(1));
            apply(config, &new_conf);
        }
        // Hide infill anchor max if sparse_infill_pattern is not line or if sparse_infill_pattern is line but infill_anchor_max is 0.
        bool infill_anchor = config->opt_enum<InfillPattern>("sparse_infill_pattern") != ipLine;
        toggle_field("infill_anchor_max", infill_anchor);
 
        // Only allow configuration of open anchors if the anchoring is enabled.
        bool has_infill_anchors = infill_anchor && config->option<ConfigOptionFloatOrPercent>("infill_anchor_max")->value > 0;
        toggle_field("infill_anchor", has_infill_anchors);
    }
 
    //cross zag
    bool is_cross_zag = config->option<ConfigOptionEnum<InfillPattern>>("sparse_infill_pattern")->value == InfillPattern::ipCrossZag;
    bool is_locked_zig = config->option<ConfigOptionEnum<InfillPattern>>("sparse_infill_pattern")->value == InfillPattern::ipLockedZag;
 
    toggle_line("infill_shift_step", is_cross_zag || is_locked_zig);
    
    for (auto el : { "skeleton_infill_density", "skin_infill_density", "infill_lock_depth", "skin_infill_depth","skin_infill_line_width", "skeleton_infill_line_width" })
        toggle_line(el, is_locked_zig);
 
    bool is_zig_zag = config->option<ConfigOptionEnum<InfillPattern>>("sparse_infill_pattern")->value == InfillPattern::ipZigZag;
 
    toggle_line("symmetric_infill_y_axis", is_zig_zag || is_cross_zag || is_locked_zig);
 
    bool is_3Dhoneycomb = config->option<ConfigOptionEnum<InfillPattern>>("sparse_infill_pattern")->value == InfillPattern::ip3DHoneycomb;
    toggle_line("infill_complete_top", have_infill && is_3Dhoneycomb);
 
    bool has_spiral_vase         = config->opt_bool("spiral_mode");
    toggle_line("spiral_mode_smooth", has_spiral_vase);
    toggle_line("spiral_mode_max_xy_smoothing", has_spiral_vase && config->opt_bool("spiral_mode_smooth"));
    toggle_line("spiral_starting_flow_ratio", has_spiral_vase);
    toggle_line("spiral_finishing_flow_ratio", has_spiral_vase);
    bool has_top_shell_layers = config->opt_int("top_shell_layers") > 0 || (has_spiral_vase && config->opt_int("bottom_shell_layers") > 1);
    bool has_top_shell    = has_top_shell_layers && config->option<ConfigOptionPercent>("top_surface_density")->value > 0;
    bool has_bottom_shell = config->opt_int("bottom_shell_layers") > 0;
    bool has_solid_infill = has_top_shell_layers || has_bottom_shell;
    toggle_line("sparse_infill_smooth_factor", have_infill && is_smoothable_infill_pattern(pattern, config->opt_int("fill_multiline")));
    toggle_field("top_surface_pattern", has_top_shell);
    toggle_field("bottom_surface_pattern", has_bottom_shell);
    toggle_field("top_surface_density", has_top_shell_layers);
    toggle_field("bottom_surface_density", has_bottom_shell);
    toggle_field("top_layer_direction", has_top_shell);
    toggle_field("bottom_layer_direction", has_bottom_shell);
 
    toggle_line("top_surface_expansion", has_top_shell);
    toggle_line("top_surface_expansion_margin", has_top_shell);
    bool has_top_surface_expansion = config->opt_float("top_surface_expansion") > 0;
    toggle_field("top_surface_expansion_margin", has_top_surface_expansion);
    toggle_line("top_surface_expansion_direction", has_top_shell);
    toggle_field("top_surface_expansion_direction", has_top_surface_expansion);
 
    // Orca: Archimedean Chords and Octagram Spiral are the centered surface patterns that the
    // pattern-centering feature acts on.
    auto is_centered_pattern = [](InfillPattern p) {
        return p == InfillPattern::ipArchimedeanChords || p == InfillPattern::ipOctagramSpiral;
    };
    bool is_top_centered    = is_centered_pattern(config->option<ConfigOptionEnum<InfillPattern>>("top_surface_pattern")->value);
    bool is_bottom_centered = is_centered_pattern(config->option<ConfigOptionEnum<InfillPattern>>("bottom_surface_pattern")->value);
    bool has_centered_surface = (has_top_shell && is_top_centered) || (has_bottom_shell && is_bottom_centered);
 
    // Orca: center of surface pattern
    toggle_line("center_of_surface_pattern", has_centered_surface);
 
    // Orca: separate infills
    toggle_line("separated_infills", is_separable_infill_pattern(pattern));
 
    // Fill order is only meaningful for the center-based surface fill patterns; hide it otherwise.
    auto is_centered_fill = [](InfillPattern p) { return p == ipConcentric || p == ipSpiralInset || p == ipArchimedeanChords || p == ipOctagramSpiral; };
    toggle_line("top_surface_fill_order", has_top_shell && is_centered_fill(config->opt_enum<InfillPattern>("top_surface_pattern")));
    toggle_line("bottom_surface_fill_order", has_bottom_shell && is_centered_fill(config->opt_enum<InfillPattern>("bottom_surface_pattern")));
 
    for (auto el : { "infill_direction", "sparse_infill_line_width", "gap_fill_target","filter_out_gap_fill","infill_wall_overlap",
        "bridge_angle", "internal_bridge_angle", "relative_bridge_angle",
        "solid_infill_direction", "solid_infill_rotate_template", "internal_solid_infill_pattern", "internal_solid_filament_id", "top_surface_filament_id", "bottom_surface_filament_id",
        })
        toggle_field(el, have_infill || has_solid_infill);
    for (auto el : { "sparse_infill_speed", "bridge_speed", "internal_bridge_speed"})
        toggle_field(el, have_infill || has_solid_infill, variant_index);
 
    toggle_field("top_shell_thickness", ! has_spiral_vase && has_top_shell_layers);
    toggle_field("bottom_shell_thickness", ! has_spiral_vase && has_bottom_shell);
 
    // Gap fill is newly allowed in between perimeter lines even for empty infill (see GH #1476).
    toggle_field("gap_infill_speed", have_perimeters, variant_index);
    
    toggle_field("top_surface_line_width", has_top_shell);
    toggle_field("top_surface_speed", has_top_shell, variant_index);
 
    bool have_default_acceleration = config->opt_float_nullable("default_acceleration", variant_index) > 0;
 
    for (auto el : {"outer_wall_acceleration", "inner_wall_acceleration", "initial_layer_acceleration", "initial_layer_travel_acceleration",
        "top_surface_acceleration", "travel_acceleration", "bridge_acceleration", "sparse_infill_acceleration", "internal_solid_infill_acceleration"})
        toggle_field(el, have_default_acceleration, variant_index);
 
    bool machine_supports_junction_deviation = false;
    if (gcf_is_marlin_firmware) {
        if (const auto *machine_jd = preset_bundle->printers.get_edited_preset().config.option<ConfigOptionFloats>("machine_max_junction_deviation")) {
            machine_supports_junction_deviation = !machine_jd->values.empty() && machine_jd->values.front() > 0.0;
        }
    }
    toggle_line("default_junction_deviation", gcf_is_marlin_firmware, variant_index);
    if (machine_supports_junction_deviation) {
        toggle_field("default_junction_deviation", true, variant_index);
        toggle_field("default_jerk", false, variant_index);
        for (auto el : { "outer_wall_jerk", "inner_wall_jerk", "initial_layer_jerk", "initial_layer_travel_jerk", "top_surface_jerk", "travel_jerk", "infill_jerk"})
            toggle_line(el, false, variant_index);
    } else {
        toggle_field("default_junction_deviation", false, variant_index);
        toggle_field("default_jerk", true, variant_index);
        bool have_default_jerk = config->has("default_jerk") && config->opt_float_nullable("default_jerk", variant_index) > 0;
        for (auto el : { "outer_wall_jerk", "inner_wall_jerk", "initial_layer_jerk", "initial_layer_travel_jerk", "top_surface_jerk", "travel_jerk", "infill_jerk"}) {
            toggle_line(el, true, variant_index);
            toggle_field(el, have_default_jerk, variant_index);
        }
    }
 
    // Belt printer: disable skirt, brim, raft, and draft shield controls.
    bool have_skirt = config->opt_int("skirt_loops") > 0 && !is_belt_printer;
    toggle_field("skirt_height", have_skirt && config->opt_enum<DraftShield>("draft_shield") != dsEnabled);
    toggle_line("single_loop_draft_shield", have_skirt); // ORCA: Display one wall if skirt enabled
    for (auto el : {"skirt_type", "min_skirt_length", "skirt_distance", "skirt_start_angle", "skirt_speed", "draft_shield"})
        toggle_field(el, have_skirt);
    if (is_belt_printer) {
        toggle_field("skirt_loops", false);
        toggle_field("skirt_height", false);
    }
 
    // Belt printers now get a brim too, laid onto the tilted belt by BeltBrim.cpp,
    // so brim type / width / object gap all apply.  A belt printer with no tilt is
    // geometrically a flat bed and uses the ordinary plate brim, hence the separate
    // is_belt_tilted test.
    bool have_brim = config->opt_enum<BrimType>("brim_type") != btNoBrim;
    toggle_field("brim_object_gap", have_brim);
    // Both are first-layer-only concepts that the belt path cannot honour.
    toggle_field("brim_use_efc_outline", have_brim && !is_belt_tilted);
    toggle_field("combine_brims", have_brim && !is_belt_tilted);
    bool have_brim_width = have_brim && config->opt_enum<BrimType>("brim_type") != btAutoBrim &&
                           config->opt_enum<BrimType>("brim_type") != btPainted;
    // On a tilted belt Auto / Mouse ear / Painted all collapse to outer-only at the
    // configured width, so the width field has to stay live for them too.
    toggle_field("brim_width", have_brim_width || (have_brim && is_belt_tilted));
    toggle_field("brim_flow_ratio", have_brim);
    // Paired toggle_line + toggle_field: cb_toggle_line is null in the per-object
    // override panel, so the row cannot be hidden there and greying out is the
    // fallback.  Both extras are belt-only: one extends the brim ahead along the belt,
    // the other widens it across the belt.
    for (auto el : { "leading_brim_length", "extra_brim_width" }) {
        toggle_line(el, is_belt_tilted);
        toggle_field(el, is_belt_tilted && have_brim);
    }
    // Wall filament selectors use the same logic as in Print::extruders().
    toggle_field("outer_wall_filament_id", have_perimeters || have_brim);
    toggle_field("inner_wall_filament_id", have_perimeters || have_brim);
 
    const BrimType brim_type = config->opt_enum<BrimType>("brim_type");
    const bool have_auto_brim_ear = brim_type == btEar && !is_belt_tilted;
    const bool have_painted_brim_ear = brim_type == btPainted && !is_belt_tilted;
    set_option_label("brim_width", have_auto_brim_ear ? L("Brim ear radius") : L("Brim width"));
    const auto brim_width = config->opt_float("brim_width");
    // Automatic brim ear settings require a non-zero brim width.
    toggle_field("brim_ears_max_angle", brim_width > 0.0f);
    toggle_field("brim_ears_detection_length", brim_width > 0.0f);
    // Painted ears carry their own radius and do not depend on brim_width.
    toggle_field("brim_ears_outer_only", have_painted_brim_ear || brim_width > 0.0f);
    toggle_line("brim_ears_max_angle", have_auto_brim_ear);
    toggle_line("brim_ears_detection_length", have_auto_brim_ear);
    toggle_line("brim_ears_outer_only", have_auto_brim_ear || have_painted_brim_ear);
 
    // Hide Elephant foot compensation layers if elefant_foot_compensation is not enabled
    toggle_line("elefant_foot_compensation_layers", config->opt_float("elefant_foot_compensation") > 0 || config->option<ConfigOptionPercent>("elefant_foot_layers_density")->get_abs_value(1.0f) < 1.0f);
 
    bool have_raft = config->opt_int("raft_layers") > 0 && !is_belt_printer;
    if (is_belt_printer)
        toggle_field("raft_layers", false);
    bool have_support_material = config->opt_bool("enable_support") || have_raft;
 
    SupportType support_type = config->opt_enum<SupportType>("support_type");
    bool have_support_interface = config->opt_int("support_interface_top_layers") > 0 || config->opt_int("support_interface_bottom_layers") > 0;
    bool have_support_soluble = have_support_material && config->opt_float("support_top_z_distance") == 0;
    auto support_style = config->opt_enum<SupportMaterialStyle>("support_style");
    for (auto el : { "support_style", "support_base_pattern",
        "support_base_pattern_spacing", "support_expansion", "support_angle",
        "support_interface_pattern", "support_interface_top_layers", "support_interface_bottom_layers",
        "bridge_no_support", "max_bridge_length", "support_top_z_distance", "support_bottom_z_distance",
        "support_type", "support_on_build_plate_only", "support_critical_regions_only", "support_interface_not_for_body",
        "support_object_xy_distance", "support_object_first_layer_gap", "independent_support_layer_height"})
        toggle_field(el, have_support_material);
    toggle_field("support_threshold_angle", have_support_material && is_auto(support_type));
    toggle_field("support_threshold_overlap", config->opt_int("support_threshold_angle") == 0 && have_support_material && is_auto(support_type));
    //toggle_field("support_closing_radius", have_support_material && support_style == smsSnug);
 
    bool support_is_tree = config->opt_bool("enable_support") && is_tree(support_type);
    bool support_is_organic = support_is_tree && (support_style == smsTreeOrganic || support_style == smsDefault);
    bool support_is_normal_tree = support_is_tree && !support_is_organic;
 
    // hide settings that are not used by tree supports
    toggle_line("support_threshold_overlap", !support_is_tree); // ORCA: tree supports do not use Threshold Overlap
    // settings specific to normal trees
    for (auto el : {"tree_support_branch_angle", "tree_support_branch_distance", "tree_support_branch_diameter", "tree_support_auto_brim", "tree_support_brim_width"})
        toggle_line(el, support_is_normal_tree);
    // settings specific to organic trees
    for (auto el : {"tree_support_branch_angle_organic", "tree_support_branch_distance_organic", "tree_support_branch_diameter_organic", "tree_support_angle_slow", "tree_support_tip_diameter", "tree_support_top_rate", "tree_support_branch_diameter_angle"})
        toggle_line(el, support_is_organic);
    // ORCA: Independent support layer height is not compatible with organic tree supports,
    // as they rely on the support layers being the same as the object layers to determine where to place branches.
    toggle_line("independent_support_layer_height", have_support_material && !support_is_organic);
 
    toggle_field("tree_support_brim_width", support_is_tree && !config->opt_bool("tree_support_auto_brim"));
    // tree support use max_bridge_length instead of bridge_no_support
    toggle_line("max_bridge_length", support_is_tree);
    toggle_line("bridge_no_support", !support_is_tree);
    toggle_line("support_critical_regions_only", is_auto(support_type) && support_is_tree);
 
    for (auto el : { "support_interface_filament",
        "support_interface_loop_pattern", "support_bottom_interface_spacing" })
        toggle_field(el, have_support_material && have_support_interface);
 
    bool can_ironing_support = have_raft || (have_support_material && config->opt_int("support_interface_top_layers") > 0);
    toggle_field("support_ironing", can_ironing_support);
    bool has_support_ironing = can_ironing_support && config->opt_bool("support_ironing");
    for (auto el : {"support_ironing_pattern", "support_ironing_flow", "support_ironing_spacing" })
        toggle_line(el, has_support_ironing);
    // Orca: Force solid support interface when using support ironing
    toggle_field("support_interface_spacing", have_support_material && have_support_interface && !has_support_ironing);
 
//    see issue #10915
//    bool have_skirt_height = have_skirt &&
//    (config->opt_int("skirt_height") > 1 || config->opt_enum<DraftShield>("draft_shield") != dsEnabled);
//    toggle_line("support_speed", have_support_material || have_skirt_height);
//    toggle_line("support_interface_speed", have_support_material && have_support_interface);
 
    // Orca:
    for (auto el : {"small_support_perimeter_speed", "small_support_perimeter_threshold"})
        toggle_field(el, config->opt_bool("enable_support"));
 
    // BBS
    //toggle_field("support_material_synchronize_layers", have_support_soluble);
 
    toggle_field("inner_wall_line_width", have_perimeters || have_skirt || have_brim);
    toggle_field("support_filament", have_support_material || have_skirt);
 
    toggle_line("raft_contact_distance", have_raft && !have_support_soluble);
    // Orca:Hide raft expansion when raft is not enabled
    toggle_line("raft_expansion", have_raft);
    // Orca: Slim, Strong and Hybrid tree supports size their raft by first layer expansion only.
    toggle_field("raft_expansion", !(is_tree(support_type) && (support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid)));
 
    // Orca: First-layer density is available for supports broadly.
    toggle_field("raft_first_layer_density", have_support_material);
    // Orca: For regular tree (Slim/Strong) without raft, hide first-layer expansion.
    // Keep it enabled for non-tree supports, organic tree, hybrid tree, and any raft case.
    toggle_field("raft_first_layer_expansion",
                 have_support_material && ((!support_is_normal_tree || support_style == smsTreeHybrid) || have_raft));
 
    bool has_ironing = (config->opt_enum<IroningType>("ironing_type") != IroningType::NoIroning);
    for (auto el : { "ironing_pattern", "ironing_flow", "ironing_spacing", "ironing_angle", "ironing_inset", "ironing_angle_fixed" })
        toggle_line(el, has_ironing);
    bool has_rectilinear_ironing = (config->opt_enum<InfillPattern>("ironing_pattern") == InfillPattern::ipRectilinear);
    for (auto el : {"ironing_angle", "ironing_angle_fixed"})
        toggle_field(el, has_ironing && has_rectilinear_ironing);
    
    toggle_line("ironing_speed", has_ironing || has_support_ironing);
 
    bool has_zaa = config->opt_bool("zaa_enabled");
    for (auto el : {"zaa_minimize_perimeter_height", "zaa_min_z", "zaa_dont_alternate_fill_direction", "ironing_expansion"})
        toggle_line(el, has_zaa);
 
    bool have_sequential_printing = (config->opt_enum<PrintSequence>("print_sequence") == PrintSequence::ByObject);
    // for (auto el : { "extruder_clearance_radius", "extruder_clearance_height_to_rod", "extruder_clearance_height_to_lid" })
    //     toggle_field(el, have_sequential_printing);
    toggle_field("print_order", !have_sequential_printing);
 
    toggle_field("single_extruder_multi_material", !is_BBL_Printer);
 
    auto bSEMM = preset_bundle->printers.get_edited_preset().config.opt_bool("single_extruder_multi_material");
    const bool supports_wipe_tower_2 = !is_BBL_Printer && preset_bundle->printers.get_edited_preset().config.opt_enum<WipeTowerType>("wipe_tower_type") == WipeTowerType::Type2;
 
    toggle_field("ooze_prevention", !bSEMM);
    bool have_ooze_prevention = config->opt_bool("ooze_prevention");
    toggle_line("standby_temperature_delta", have_ooze_prevention);
    toggle_line("preheat_time", have_ooze_prevention);
    int preheat_steps = config->opt_int("preheat_steps");
    toggle_line("preheat_steps", have_ooze_prevention && (preheat_steps > 0));
 
    bool have_prime_tower = config->opt_bool("enable_prime_tower");
    // ORCA-Belt: belt printers replace the classic wipe tower with the
    // auto-generated belt purge prism, enabled by the belt-only printer option
    // enable_belt_purge_tower. Its width (a process option) is only relevant
    // then. (is_belt_printer is computed at the top of this function.)
    const bool have_belt_purge_tower = is_belt_printer
        && preset_bundle->printers.get_edited_preset().config.has("enable_belt_purge_tower")
        && preset_bundle->printers.get_edited_preset().config.opt_bool("enable_belt_purge_tower");
    toggle_line("belt_purge_tower_width", have_belt_purge_tower);
    for (auto el : {"prime_tower_width", "prime_tower_brim_width", "prime_tower_skip_points", "wipe_tower_wall_type", "prime_tower_infill_gap","prime_tower_enable_framework", "enable_tower_interface_features"})
        toggle_line(el, have_prime_tower && !is_belt_printer);
 
    toggle_line("enable_tower_interface_cooldown_during_tower",
                have_prime_tower && !is_belt_printer && config->opt_bool("enable_tower_interface_features"));
 
    bool purge_in_primetower = preset_bundle->printers.get_edited_preset().config.opt_bool("purge_in_prime_tower");
 
    for (auto el : {"wipe_tower_rotation_angle", "wipe_tower_cone_angle",
                    "wipe_tower_extra_spacing", "wipe_tower_max_purge_speed",
                    "wipe_tower_bridging", "wipe_tower_extra_flow"})
            toggle_line(el, have_prime_tower && supports_wipe_tower_2 && !is_belt_printer);
 
    // Orca: both tower generators skip sparse layers, so this is not a wipe tower 2 exclusive.
    toggle_line("wipe_tower_no_sparse_layers", have_prime_tower && !is_belt_printer);
    // Dropping the sparse layers outright leaves nothing to combine, so the two are exclusive.
    toggle_line("wipe_tower_sparse_layers_combination", have_prime_tower && !is_belt_printer && !config->opt_bool("wipe_tower_no_sparse_layers"));
 
    WipeTowerWallType wipe_tower_wall_type = config->opt_enum<WipeTowerWallType>("wipe_tower_wall_type");
    bool have_rib_wall = (wipe_tower_wall_type == WipeTowerWallType::wtwRib)&&have_prime_tower&&!is_belt_printer;
    toggle_line("wipe_tower_cone_angle", have_prime_tower && supports_wipe_tower_2 && !is_belt_printer && wipe_tower_wall_type == WipeTowerWallType::wtwCone);
    toggle_line("wipe_tower_extra_rib_length", have_rib_wall);
    toggle_line("wipe_tower_rib_width", have_rib_wall);
    toggle_line("wipe_tower_fillet_wall", have_rib_wall);
    toggle_field("prime_tower_width", have_prime_tower && !have_rib_wall && !is_belt_printer);
 
    toggle_line("single_extruder_multi_material_priming", !bSEMM && have_prime_tower && supports_wipe_tower_2 && !is_belt_printer);
 
    bool use_cyclic_ordering = config->opt_enum<ToolChangeOrderingType>("toolchange_ordering") == ToolChangeOrderingType::Cyclic;
    toggle_line("toolchange_cyclic_order", use_cyclic_ordering);
    toggle_line("toolchange_cyclic_first_layer", use_cyclic_ordering);
 
    toggle_line("prime_volume",have_prime_tower && (!purge_in_primetower || !bSEMM));
 
    for (auto el : {"flush_into_infill", "flush_into_support", "flush_into_objects"})
        toggle_field(el, have_prime_tower);
 
    bool have_avoid_crossing_perimeters = config->opt_bool("reduce_crossing_wall");
    toggle_line("max_travel_detour_distance", have_avoid_crossing_perimeters);
 
    bool has_set_other_flow_ratios = config->opt_bool("set_other_flow_ratios");
    for (auto el : {"first_layer_flow_ratio", "outer_wall_flow_ratio", "inner_wall_flow_ratio", "overhang_flow_ratio", "sparse_infill_flow_ratio", "internal_solid_infill_flow_ratio", "gap_fill_flow_ratio", "support_flow_ratio", "support_interface_flow_ratio"})
        toggle_line(el, has_set_other_flow_ratios);
 
    bool has_overhang_speed = config->opt_bool_nullable("enable_overhang_speed", variant_index);
    for (auto el : {"overhang_1_4_speed", "overhang_2_4_speed", "overhang_3_4_speed", "overhang_4_4_speed"})
        toggle_line(el, has_overhang_speed, variant_index);
 
    toggle_line("slowdown_for_curled_perimeters", has_overhang_speed, variant_index);
 
    toggle_line("flush_into_objects", !is_global_config);
 
    toggle_line("support_interface_not_for_body",config->opt_int("support_interface_filament")&&!config->opt_int("support_filament"));
 
    // Get the current fuzzy skin state
    bool has_fuzzy_skin = config->opt_enum<FuzzySkinType>("fuzzy_skin") != FuzzySkinType::Disabled_fuzzy;
    
    // Show fuzzy skin options when fuzzy skin is not disabled
    for (auto el : {"fuzzy_skin_mode", "fuzzy_skin_noise_type", "fuzzy_skin_point_distance", "fuzzy_skin_thickness", "fuzzy_skin_first_layer"})
        toggle_line(el, has_fuzzy_skin);
    
    // Show noise type specific options with the same logic
    NoiseType fuzzy_skin_noise_type = config->opt_enum<NoiseType>("fuzzy_skin_noise_type");
    const bool is_ripple = fuzzy_skin_noise_type == NoiseType::Ripple;
    toggle_line("fuzzy_skin_scale", fuzzy_skin_noise_type != NoiseType::Classic && has_fuzzy_skin && !is_ripple);
    toggle_line("fuzzy_skin_octaves", fuzzy_skin_noise_type != NoiseType::Classic && fuzzy_skin_noise_type != NoiseType::Voronoi && has_fuzzy_skin && !is_ripple);
    toggle_line("fuzzy_skin_persistence", (fuzzy_skin_noise_type == NoiseType::Perlin || fuzzy_skin_noise_type == NoiseType::Billow) && has_fuzzy_skin && !is_ripple);
    toggle_line("fuzzy_skin_ripples_per_layer", is_ripple && has_fuzzy_skin);
    toggle_line("fuzzy_skin_ripple_offset", is_ripple && has_fuzzy_skin);
    toggle_line("fuzzy_skin_layers_between_ripple_offset", is_ripple && has_fuzzy_skin);
 
    bool have_arachne = config->opt_enum<PerimeterGeneratorType>("wall_generator") == PerimeterGeneratorType::Arachne;
    for (auto el : {"wall_transition_length", "wall_transition_filter_deviation", "wall_transition_angle", "min_feature_size", "min_length_factor",
        "min_bead_width", "wall_distribution_count", "initial_layer_min_bead_width", "wall_maximum_resolution", "wall_maximum_deviation"})
        toggle_line(el, have_arachne);
    toggle_field("detect_thin_wall", !have_arachne);
 
    // Orca
    auto is_role_based_wipe_speed = config->opt_bool("role_based_wipe_speed");
    toggle_field("wipe_speed",!is_role_based_wipe_speed);
 
    const bool have_wipe_inward = config->opt_bool("wipe_inward");
    toggle_line("wipe_inward_distance", have_wipe_inward);
 
    for (auto el : {"accel_to_decel_enable", "accel_to_decel_factor"})
        toggle_line(el, gcf_is_klipper);
    if(gcf_is_klipper)
        toggle_field("accel_to_decel_factor", config->opt_bool("accel_to_decel_enable"));
 
    toggle_line("exclude_object_tolerance", gcf_is_klipper && config->opt_bool("exclude_object"));
 
    bool have_make_overhang_printable = config->opt_bool("make_overhang_printable");
    toggle_line("make_overhang_printable_angle", have_make_overhang_printable);
    toggle_line("make_overhang_printable_hole_size", have_make_overhang_printable);
 
    // Orca: the one-wall options act on top/bottom surfaces, which exist only with a shell. An unfilled surface
    // (0% surface density) is still a surface, so these are gated on the layer counts alone.
    toggle_line("only_one_wall_first_layer", has_bottom_shell);
    toggle_line("only_one_wall_top", has_top_shell_layers);
    toggle_line("min_width_top_surface", (has_top_shell_layers && config->opt_bool("only_one_wall_top")) || ((config->opt_float("min_length_factor") > 0.5f) && have_arachne)); // 0.5 is default value
 
    for (auto el : { "hole_to_polyhole_threshold", "hole_to_polyhole_twisted", "hole_to_polyhole_max_edges" })
        toggle_line(el, config->opt_bool("hole_to_polyhole"));
 
    bool has_detect_overhang_wall = config->opt_bool("detect_overhang_wall");
    bool has_overhang_reverse     = config->opt_bool("overhang_reverse");
    bool allow_overhang_reverse   = !has_spiral_vase;
    toggle_line("unsupported_wall_last", has_detect_overhang_wall);
    toggle_line("overhang_reverse", allow_overhang_reverse);
    toggle_line("overhang_reverse_internal_only", allow_overhang_reverse && has_overhang_reverse);
    bool has_overhang_reverse_internal_only = config->opt_bool("overhang_reverse_internal_only");
    if (has_overhang_reverse_internal_only){
        DynamicPrintConfig new_conf = *config;
        new_conf.set_key_value("overhang_reverse_threshold", new ConfigOptionFloatOrPercent(0,true));
        apply(config, &new_conf);
    }
    toggle_line("overhang_reverse_threshold", has_detect_overhang_wall && allow_overhang_reverse && has_overhang_reverse && !has_overhang_reverse_internal_only);
    toggle_line("timelapse_type", is_BBL_Printer);
 
 
    bool have_small_area_infill_flow_compensation = config->opt_bool("small_area_infill_flow_compensation");
    toggle_line("small_area_infill_flow_compensation_model", have_small_area_infill_flow_compensation);
 
 
    // Belt printers: the scarf would start one layer back along the belt, inside the
    // previous layer (GCode::extrude_loop skips it there too).
    toggle_field("seam_slope_type", !has_spiral_vase && !is_belt_printer);
    bool has_seam_slope = !has_spiral_vase && !is_belt_printer && config->opt_enum<SeamScarfType>("seam_slope_type") != SeamScarfType::None;
    toggle_line("seam_slope_conditional", has_seam_slope);
    toggle_line("seam_slope_start_height", has_seam_slope);
    toggle_line("seam_slope_entire_loop", has_seam_slope);
    toggle_line("seam_slope_min_length", has_seam_slope);
    toggle_line("seam_slope_steps", has_seam_slope);
    toggle_line("seam_slope_inner_walls", has_seam_slope);
    toggle_line("scarf_joint_speed", has_seam_slope);
    toggle_line("scarf_joint_flow_ratio", has_seam_slope);
    toggle_field("seam_slope_min_length", !config->opt_bool("seam_slope_entire_loop"));
    toggle_line("scarf_angle_threshold", has_seam_slope && config->opt_bool("seam_slope_conditional"));
    toggle_line("scarf_overhang_threshold", has_seam_slope && config->opt_bool("seam_slope_conditional"));
 
    bool use_beam_interlocking = config->opt_bool("interlocking_beam");
    toggle_line("mmu_segmented_region_interlocking_depth", !use_beam_interlocking);
    toggle_line("interlocking_beam_width", use_beam_interlocking);
    toggle_line("interlocking_orientation", use_beam_interlocking);
    toggle_line("interlocking_beam_layer_count", use_beam_interlocking);
    toggle_line("interlocking_depth", use_beam_interlocking);
    toggle_line("interlocking_boundary_avoidance", use_beam_interlocking);
 
    bool lattice_options = config->opt_enum<InfillPattern>("sparse_infill_pattern") == InfillPattern::ipLateralLattice;
    for (auto el : { "lateral_lattice_angle_1", "lateral_lattice_angle_2"})
        toggle_line(el, lattice_options);
 
    bool lightning_options = config->opt_enum<InfillPattern>("sparse_infill_pattern") == InfillPattern::ipLightning;
    for (auto el : { "lightning_overhang_angle", "lightning_prune_angle", "lightning_straightening_angle" })
        toggle_line(el, lightning_options);
        
    // Adaptative Cubic and support cubic infill patterns do not support infill rotation.
    bool FillAdaptive = (pattern == InfillPattern::ipAdaptiveCubic || pattern == InfillPattern::ipSupportCubic);
 
    //Orca: disable infill_direction/solid_infill_direction if sparse_infill_rotate_template/solid_infill_rotate_template is not empty value and adaptive cubic/support cubic infill pattern is not selected
    toggle_field("sparse_infill_rotate_template", !FillAdaptive);
    toggle_field("infill_direction", config->opt_string("sparse_infill_rotate_template") == "" && !FillAdaptive);
    toggle_field("solid_infill_direction", config->opt_string("solid_infill_rotate_template") == "");
    
    toggle_line("infill_overhang_angle", config->opt_enum<InfillPattern>("sparse_infill_pattern") == InfillPattern::ipLateralHoneycomb);
 
    std::string printer_type = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
    toggle_line("enable_wrapping_detection", DevPrinterConfigUtil::support_wrapping_detection(printer_type));
}

References Slic3r::angle(), apply(), Slic3r::Arachne, Slic3r::BELT_BRIM_MAX_TILT_DEG, Slic3r::BELT_BRIM_MIN_TILT_DEG, Slic3r::Billow, Slic3r::btAutoBrim, Slic3r::btEar, Slic3r::btNoBrim, Slic3r::btPainted, Slic3r::ByObject, Slic3r::Classic, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::Cyclic, Slic3r::Disabled, Slic3r::Disabled_fuzzy, Slic3r::dsEnabled, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::ConfigOptionPercent::get_abs_value(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::ConfigOptionResolver::has(), Slic3r::has_top_shell_layers(), Slic3r::infill_anchor(), Slic3r::ip3DHoneycomb, Slic3r::ipAdaptiveCubic, Slic3r::ipAlignedRectilinear, Slic3r::ipArchimedeanChords, Slic3r::ipConcentric, Slic3r::ipCrossHatch, Slic3r::ipCrossZag, Slic3r::ipCubic, Slic3r::ipGrid, Slic3r::ipGyroid, Slic3r::ipHilbertCurve, Slic3r::ipHoneycomb, Slic3r::ipLateralHoneycomb, Slic3r::ipLateralLattice, Slic3r::ipLightning, Slic3r::ipLine, Slic3r::ipLockedZag, Slic3r::ipOctagramSpiral, Slic3r::ipQuarterCubic, Slic3r::ipRectilinear, Slic3r::ipSpiralInset, Slic3r::ipStars, Slic3r::ipSupportCubic, Slic3r::ipTpmsD, Slic3r::ipTpmsFK, Slic3r::ipTriangles, Slic3r::ipZigZag, Slic3r::is_adaptive_infill_pattern(), Slic3r::is_auto(), is_BBL_Printer, Slic3r::is_separable_infill_pattern(), Slic3r::is_smoothable_infill_pattern(), Slic3r::is_tree(), L, Slic3r::NoIroning, Slic3r::None, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_bool_nullable(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_float_nullable(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::Perlin, Slic3r::preheat_steps(), Slic3r::PresetBundle::printers, Slic3r::Ripple, Slic3r::DynamicConfig::set_key_value(), set_option_label(), Slic3r::smsDefault, Slic3r::smsTreeHybrid, Slic3r::smsTreeOrganic, Slic3r::smsTreeSlim, Slic3r::smsTreeStrong, Slic3r::DevPrinterConfigUtil::support_wrapping_detection(), toggle_field(), toggle_line(), Slic3r::Type2, Slic3r::ConfigOptionSingle< T >::value, Slic3r::Voronoi, Slic3r::wtwCone, Slic3r::wtwRib, Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), Slic3r::GUI::ObjectTableSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_settings_list().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_print_sla_options()

void Slic3r::GUI::ConfigManipulation::toggle_print_sla_options

(

DynamicPrintConfig *

config

)

{
    bool supports_en = config->opt_bool("supports_enable");
 
    toggle_field("support_head_front_diameter", supports_en);
    toggle_field("support_head_penetration", supports_en);
    toggle_field("support_head_width", supports_en);
    toggle_field("support_pillar_diameter", supports_en);
    toggle_field("support_small_pillar_diameter_percent", supports_en);
    toggle_field("support_max_bridges_on_pillar", supports_en);
    toggle_field("support_pillar_connection_mode", supports_en);
    toggle_field("support_buildplate_only", supports_en);
    toggle_field("support_base_diameter", supports_en);
    toggle_field("support_base_height", supports_en);
    toggle_field("support_base_safety_distance", supports_en);
    toggle_field("support_critical_angle", supports_en);
    toggle_field("support_max_bridge_length", supports_en);
    toggle_field("support_max_pillar_link_distance", supports_en);
    toggle_field("support_points_density_relative", supports_en);
    toggle_field("support_points_minimal_distance", supports_en);
 
    bool pad_en = config->opt_bool("pad_enable");
 
    toggle_field("pad_wall_thickness", pad_en);
    toggle_field("pad_wall_height", pad_en);
    toggle_field("pad_brim_size", pad_en);
    toggle_field("pad_max_merge_distance", pad_en);
 // toggle_field("pad_edge_radius", supports_en);
    toggle_field("pad_wall_slope", pad_en);
    toggle_field("pad_around_object", pad_en);
    toggle_field("pad_around_object_everywhere", pad_en);
 
    bool zero_elev = config->opt_bool("pad_around_object") && pad_en;
 
    toggle_field("support_object_elevation", supports_en && !zero_elev);
    toggle_field("pad_object_gap", zero_elev);
    toggle_field("pad_around_object_everywhere", zero_elev);
    toggle_field("pad_object_connector_stride", zero_elev);
    toggle_field("pad_object_connector_width", zero_elev);
    toggle_field("pad_object_connector_penetration", zero_elev);
}

References Slic3r::DynamicConfig::opt_bool(), and toggle_field().

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), Slic3r::GUI::ObjectTableSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_settings_list().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_fff_config()

void Slic3r::GUI::ConfigManipulation::update_print_fff_config	(	DynamicPrintConfig *	config,
		const bool	is_global_config = false,
		const bool	is_plate_config = false )

Temporary workaround for the correct updates of the TextCtrl (like "layer_height"):

{
    // #ys_FIXME_to_delete
    // KillFocus() for the wxSpinCtrl use CallAfter function. So,
    // to except the duplicate call of the update() after dialog->ShowModal(),
    // let check if this process is already started.
    if (is_msg_dlg_already_exist)
        return;
 
    bool is_object_config = (!is_global_config && !is_plate_config);
 
    // Belt printer: a raft and a draft shield are refused by Print::validate(), and
    // the fields that would clear them are greyed out in belt mode, so a preset that
    // carries either could not be sliced at all. Reset them instead of only disabling
    // the fields.
    if (GUI::wxGetApp().preset_bundle != nullptr) {
        const auto *belt_opt = GUI::wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionBool>("belt_printer");
        const auto *raft_opt = config->option<ConfigOptionInt>("raft_layers");
        const auto *shield_opt = config->option<ConfigOptionEnum<DraftShield>>("draft_shield");
        const bool has_raft   = raft_opt != nullptr && raft_opt->value > 0;
        const bool has_shield = shield_opt != nullptr && shield_opt->value != dsDisabled;
        if (belt_opt != nullptr && belt_opt->value && (has_raft || has_shield)) {
            const wxString msg_text = _(L("Raft and draft shield are not available on belt printers.\nThey have been disabled."));
            MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
            DynamicPrintConfig new_conf = *config;
            is_msg_dlg_already_exist = true;
            dialog.ShowModal();
            if (has_raft)
                new_conf.set_key_value("raft_layers", new ConfigOptionInt(0));
            if (has_shield)
                new_conf.set_key_value("draft_shield", new ConfigOptionEnum<DraftShield>(dsDisabled));
            apply(config, &new_conf);
            is_msg_dlg_already_exist = false;
        }
    }
 
    // layer_height shouldn't be equal to zero
    auto layer_height = config->opt_float("layer_height");
    if (layer_height < EPSILON)
    {
        const wxString msg_text = _(L("Layer height too small\nIt has been reset to 0.2"));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("layer_height", new ConfigOptionFloat(0.2));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    //BBS: ironing_spacing shouldn't be too small or equal to zero
    if (config->opt_float("ironing_spacing") < IRONING_SPACING_MIN)
    {
        const wxString msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
        MessageDialog dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("ironing_spacing", new ConfigOptionFloat(0.1));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
    if (config->opt_float("support_ironing_spacing") < IRONING_SPACING_MIN)
    {
        const wxString msg_text = _(L("Ironing spacing too small\nIt has been reset to 0.1"));
        MessageDialog dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("support_ironing_spacing", new ConfigOptionFloat(0.1));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (config->option<ConfigOptionFloat>("initial_layer_print_height")->value < EPSILON)
    {
        const wxString msg_text = _(L("Zero initial layer height is invalid.\n\nThe first layer height will be reset to 0.2."));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("initial_layer_print_height", new ConfigOptionFloat(0.2));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (abs(config->option<ConfigOptionFloat>("xy_hole_compensation")->value) > 2)
    {
        const wxString msg_text = _(L("This setting is only used for tuning model size by small amounts.\nFor example, when the model size has small errors or when tolerances are incorrect. For large adjustments, please use the model scale function.\n\nThe value will be reset to 0."));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("xy_hole_compensation", new ConfigOptionFloat(0));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (abs(config->option<ConfigOptionFloat>("xy_contour_compensation")->value) > 2)
    {
        const wxString msg_text = _(L("This setting is only used for tuning model size by small amounts.\nFor example, when the model size has small errors or when tolerances are incorrect. For large adjustments, please use the model scale function.\n\nThe value will be reset to 0."));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("xy_contour_compensation", new ConfigOptionFloat(0));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (config->option<ConfigOptionFloat>("elefant_foot_compensation")->value > 1)
    {
        const wxString msg_text = _(L("The elephant foot compensation value is too large.\nIf there are significant elephant foot issues, please check other settings.\nThe bed temperature may be too high, for example.\n\nThe value will be reset to 0."));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        dialog.ShowModal();
        new_conf.set_key_value("elefant_foot_compensation", new ConfigOptionFloat(0));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (config->option<ConfigOptionBool>("enable_wrapping_detection")->value) {
        std::string printer_type = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
        if (!DevPrinterConfigUtil::support_wrapping_detection(printer_type)) {
            DynamicPrintConfig new_conf = *config;
            new_conf.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
            apply(config, &new_conf);
        }
    }
 
    double sparse_infill_density = config->option<ConfigOptionPercent>("sparse_infill_density")->value;
    int    fill_multiline        = config->option<ConfigOptionInt>("fill_multiline")->value;
    auto timelapse_type = config->opt_enum<TimelapseType>("timelapse_type");
 
    if (!is_plate_config &&
        config->opt_bool("spiral_mode") &&
        ! (config->opt_int("wall_loops") == 1 &&
           config->opt_int("top_shell_layers") == 0 &&
           sparse_infill_density == 0 &&
           ! config->opt_bool("enable_support") &&
           config->opt_int("enforce_support_layers") == 0 &&
           ! config->opt_bool("detect_thin_wall") &&
           ! config->opt_bool("overhang_reverse") &&
            config->opt_enum<TimelapseType>("timelapse_type") == TimelapseType::tlTraditional &&
            !config->opt_bool("enable_wrapping_detection")))
    {
        DynamicPrintConfig new_conf = *config;
        auto answer = show_spiral_mode_settings_dialog(is_object_config);
        bool support = true;
        if (answer == wxID_YES) {
            new_conf.set_key_value("wall_loops", new ConfigOptionInt(1));
            new_conf.set_key_value("top_shell_layers", new ConfigOptionInt(0));
            new_conf.set_key_value("sparse_infill_density", new ConfigOptionPercent(0));
            new_conf.set_key_value("enable_support", new ConfigOptionBool(false));
            new_conf.set_key_value("enforce_support_layers", new ConfigOptionInt(0));
            new_conf.set_key_value("detect_thin_wall", new ConfigOptionBool(false));
            new_conf.set_key_value("overhang_reverse", new ConfigOptionBool(false));
            new_conf.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(tlTraditional));
            new_conf.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
            sparse_infill_density = 0;
            timelapse_type = TimelapseType::tlTraditional;
            support = false;
        }
        else {
            new_conf.set_key_value("spiral_mode", new ConfigOptionBool(false));
        }
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    if (config->opt_bool("alternate_extra_wall") &&
        (config->opt_enum<EnsureVerticalShellThickness>("ensure_vertical_shell_thickness") == evstAll)) {
        wxString msg_text = _(L("Alternate extra wall doesn't work well when ensure vertical shell thickness is set to All."));
 
        if (is_global_config)
            msg_text += "\n\n" + _(L("Change these settings automatically?\n"
                                     "Yes - Change ensure vertical shell thickness to Moderate and enable alternate extra wall\n"
                                     "No  - Don't use alternate extra wall"));
 
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "",
                               wxICON_WARNING | (is_global_config ? wxYES | wxNO : wxOK));
        DynamicPrintConfig new_conf = *config;
        auto answer = dialog.ShowModal();
        if (!is_global_config || answer == wxID_YES) {
            new_conf.set_key_value("ensure_vertical_shell_thickness", new ConfigOptionEnum<EnsureVerticalShellThickness>(evstModerate));
            new_conf.set_key_value("alternate_extra_wall", new ConfigOptionBool(true));
        }
        else {
            new_conf.set_key_value("ensure_vertical_shell_thickness", new ConfigOptionEnum<EnsureVerticalShellThickness>(evstAll));
            new_conf.set_key_value("alternate_extra_wall", new ConfigOptionBool(false));
        }
        apply(config, &new_conf);
    }
 
    // BBS
    int filament_cnt = wxGetApp().preset_bundle->filament_presets.size();
#if 0
    bool has_wipe_tower = filament_cnt > 1 && config->opt_bool("enable_prime_tower");
    if (has_wipe_tower && (config->opt_bool("adaptive_layer_height") || config->opt_bool("independent_support_layer_height"))) {
        wxString msg_text;
        if (config->opt_bool("adaptive_layer_height") && config->opt_bool("independent_support_layer_height")) {
            msg_text = _(L("Prime tower does not work when Adaptive Layer Height or Independent Support Layer Height is on.\n"
                "Which do you want to keep?\n"
                "YES - Keep Prime Tower\n"
                "NO  - Keep Adaptive Layer Height and Independent Support Layer Height"));
        }
        else if (config->opt_bool("adaptive_layer_height")) {
            msg_text = _(L("Prime tower does not work when Adaptive Layer Height is on.\n"
                "Which do you want to keep?\n"
                "YES - Keep Prime Tower\n"
                "NO  - Keep Adaptive Layer Height"));
        }
        else {
            msg_text = _(L("Prime tower does not work when Independent Support Layer Height is on.\n"
                "Which do you want to keep?\n"
                "YES - Keep Prime Tower\n"
                "NO  - Keep Independent Support Layer Height"));
        }
 
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxYES | wxNO);
        is_msg_dlg_already_exist = true;
        auto answer = dialog.ShowModal();
 
        DynamicPrintConfig new_conf = *config;
        if (answer == wxID_YES) {
            if (config->opt_bool("adaptive_layer_height"))
                 new_conf.set_key_value("adaptive_layer_height", new ConfigOptionBool(false));
 
            if (config->opt_bool("independent_support_layer_height"))
                new_conf.set_key_value("independent_support_layer_height", new ConfigOptionBool(false));
        }
        else
            new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(false));
 
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    // BBS
    if (has_wipe_tower && config->opt_bool("enable_support") && !config->opt_bool("independent_support_layer_height")) {
        double top_gap_raw = config->opt_float("support_top_z_distance");
        //double bottom_gap_raw = config->opt_float("support_bottom_z_distance");
        double top_gap = std::round(top_gap_raw / layer_height) * layer_height;
        //double bottom_gap = std::round(bottom_gap_raw / layer_height) * layer_height;
        if (top_gap != top_gap_raw /* || bottom_gap != bottom_gap_raw*/) {
            DynamicPrintConfig new_conf = *config;
            new_conf.set_key_value("support_top_z_distance", new ConfigOptionFloat(top_gap));
            //new_conf.set_key_value("support_bottom_z_distance", new ConfigOptionFloat(bottom_gap));
            apply(config, &new_conf);
 
            //wxMessageBox(_L("Support top/bottom Z distance is automatically changed to multiple of layer height."));
        }
    }
#endif
 
    // BBL printers do not support cone wipe tower
    if (config->opt_bool("enable_prime_tower") && is_BBL_Printer) {
        auto wipe_tower_wall_type = config->opt_enum<WipeTowerWallType>("wipe_tower_wall_type");
        if (wipe_tower_wall_type == WipeTowerWallType::wtwCone) {
            DynamicPrintConfig new_conf = *config;
            new_conf.set_key_value("wipe_tower_wall_type", new ConfigOptionEnum<WipeTowerWallType>(WipeTowerWallType::wtwRectangle));
            apply(config, &new_conf);
        }
    }
 
    // Check "enable_support" and "overhangs" relations only on global settings level
    if (is_global_config && config->opt_bool("enable_support")) {
        // Ask only once.
        if (!m_support_material_overhangs_queried) {
            m_support_material_overhangs_queried = true;
            if (!config->opt_bool("detect_overhang_wall")/* != 1*/) {
                //BBS: detect_overhang_wall is setting in develop mode. Enable it directly.
                DynamicPrintConfig new_conf = *config;
                new_conf.set_key_value("detect_overhang_wall", new ConfigOptionBool(true));
                apply(config, &new_conf);
            }
        }
    }
    else {
        m_support_material_overhangs_queried = false;
    }
 
    if (config->opt_bool("enable_support")) {
        auto   support_type = config->opt_enum<SupportType>("support_type");
        auto   support_style = config->opt_enum<SupportMaterialStyle>("support_style");
        std::set<int> enum_set_normal = { smsDefault, smsGrid, smsSnug };
        std::set<int> enum_set_tree   = { smsDefault, smsTreeSlim, smsTreeStrong, smsTreeHybrid, smsTreeOrganic };
        auto &           set             = is_tree(support_type) ? enum_set_tree : enum_set_normal;
        if (set.find(support_style) == set.end()) {
            DynamicPrintConfig new_conf = *config;
            new_conf.set_key_value("support_style", new ConfigOptionEnum<SupportMaterialStyle>(smsDefault));
            apply(config, &new_conf);
        }
    }
 
    // BBS
    // Reset filament overrides pointing at a slot that no longer exists. Support and the wipe
    // tower additionally reject mixed slots: the engine consumes those keys directly, so a virtual
    // slot would reach the G-code unresolved, while the per-feature keys are resolved per layer.
    static const char* physical_only_keys[] = { "support_filament", "support_interface_filament", "wipe_tower_filament" };
    static const char* feature_keys[] = { "outer_wall_filament_id", "inner_wall_filament_id",
                                          "sparse_infill_filament_id", "internal_solid_filament_id",
                                          "top_surface_filament_id", "bottom_surface_filament_id" };
    auto reset_invalid_filament = [this, config, filament_cnt](const char* key, bool allow_mixed) {
        auto* opt = dynamic_cast<ConfigOptionInt*>(config->option(key, false));
        if (opt == nullptr)
            return;
        const int  val          = opt->getInt();
        const bool out_of_range = val > filament_cnt;
        const bool is_mixed     = !allow_mixed && val > 0 && val <= filament_cnt &&
                                  wxGetApp().preset_bundle->is_mixed_filament(val - 1);
        if (!out_of_range && !is_mixed)
            return;
        DynamicPrintConfig new_conf = *config;
        int new_value = 0;
        if (out_of_range) {
            const DynamicPrintConfig *conf_temp = wxGetApp().plater()->config();
            if (conf_temp != nullptr && conf_temp->has(key))
                new_value = conf_temp->opt_int(key);
        }
        new_conf.set_key_value(key, new ConfigOptionInt(new_value));
        apply(config, &new_conf);
    };
    for (const char* key : physical_only_keys)
        reset_invalid_filament(key, false);
    for (const char* key : feature_keys)
        reset_invalid_filament(key, true);
 
    // Sub-layer splitting divides each layer by the mix ratio; an adaptive layer profile makes
    // those sub-layer heights vary per layer, which degrades the blend. Warn once per enable.
    {
        static bool s_mixed_sublayer_warned = false;
        bool sublayer_on = config->opt_bool("enable_mixed_color_sublayer");
        if (sublayer_on && !s_mixed_sublayer_warned &&
            wxGetApp().app_config->get("no_warn_mixed_sublayer_variable_layer") != "1") {
            bool has_variable_layer = false;
            for (const auto* obj : wxGetApp().model().objects) {
                if (obj->layer_height_profile.get().size() > 4) {
                    has_variable_layer = true;
                    break;
                }
            }
            if (has_variable_layer) {
                MessageDialog dialog(m_msg_dlg_parent,
                    _L("Using variable layer height together with mixed color sublayer may result in poor color mixing quality."),
                    "", wxICON_WARNING | wxOK);
                dialog.show_dsa_button();
                is_msg_dlg_already_exist = true;
                dialog.ShowModal();
                is_msg_dlg_already_exist = false;
                if (dialog.get_checkbox_state())
                    wxGetApp().app_config->set("no_warn_mixed_sublayer_variable_layer", "1");
                s_mixed_sublayer_warned = true;
            }
        }
        if (!sublayer_on)
            s_mixed_sublayer_warned = false;
    }
 
    if (config->opt_enum<SeamScarfType>("seam_slope_type") != SeamScarfType::None &&
        config->get_abs_value("seam_slope_start_height") >= layer_height) {
        const wxString     msg_text = _(L("seam_slope_start_height needs to be smaller than layer_height.\nReset to 0."));
        MessageDialog      dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist    = true;
        dialog.ShowModal();
        new_conf.set_key_value("seam_slope_start_height", new ConfigOptionFloatOrPercent(0, false));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
 
    // layer_height shouldn't be equal to zero
    float skin_depth = config->opt_float("skin_infill_depth");
    if (config->opt_float("infill_lock_depth") > skin_depth) {
        // xgettext:no-c-format, no-boost-format
        const wxString     msg_text = _(L("Lock depth should be smaller than skin depth.\nReset to 50% of skin depth."));
        MessageDialog      dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist    = true;
        dialog.ShowModal();
        new_conf.set_key_value("infill_lock_depth", new ConfigOptionFloat(skin_depth / 2));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
    
    bool have_arachne = config->opt_enum<PerimeterGeneratorType>("wall_generator") == PerimeterGeneratorType::Arachne;
    if (config->opt_enum<FuzzySkinMode>("fuzzy_skin_mode") != FuzzySkinMode::Displacement && !have_arachne) {
        wxString msg_text = _(L("Both [Extrusion] and [Combined] modes of Fuzzy Skin require the Arachne Wall Generator to be enabled."));
        msg_text += "\n\n" + _(L("Change these settings automatically?\n"
                                    "Yes - Enable Arachne Wall Generator\n"
                                    "No  - Disable Arachne Wall Generator and set [Displacement] mode of the Fuzzy Skin"));
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "", wxICON_WARNING | wxYES | wxNO);
        DynamicPrintConfig new_conf = *config;
        is_msg_dlg_already_exist = true;
        auto answer = dialog.ShowModal();
        if (answer == wxID_YES)
            new_conf.set_key_value("wall_generator", new ConfigOptionEnum<PerimeterGeneratorType>(PerimeterGeneratorType::Arachne));
        else 
            new_conf.set_key_value("fuzzy_skin_mode", new ConfigOptionEnum<FuzzySkinMode>(FuzzySkinMode::Displacement));
        apply(config, &new_conf);
        is_msg_dlg_already_exist = false;
    }
}

References _, _L, apply(), Slic3r::Arachne, Slic3r::ConfigOptionFloat, Slic3r::Displacement, Slic3r::dsDisabled, EPSILON, Slic3r::evstAll, Slic3r::evstModerate, Slic3r::ConfigBase::get_abs_value(), Slic3r::GUI::MsgDialog::get_checkbox_state(), Slic3r::ConfigOptionResolver::has(), Slic3r::IRONING_SPACING_MIN, is_BBL_Printer, is_msg_dlg_already_exist, Slic3r::is_tree(), L, Slic3r::GUI::layer_height, m_msg_dlg_parent, m_support_material_overhangs_queried, Slic3r::None, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_enum(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_int(), Slic3r::ConfigBase::option(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::MsgDialog::show_dsa_button(), show_spiral_mode_settings_dialog(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::smsDefault, Slic3r::smsGrid, Slic3r::smsSnug, Slic3r::smsTreeHybrid, Slic3r::smsTreeOrganic, Slic3r::smsTreeSlim, Slic3r::smsTreeStrong, Slic3r::sparse_infill_density(), Slic3r::DevPrinterConfigUtil::support_wrapping_detection(), Slic3r::tlTraditional, Slic3r::ConfigOptionSingle< T >::value, Slic3r::wtwCone, and Slic3r::wtwRectangle.

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_config_values().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_sla_config()

void Slic3r::GUI::ConfigManipulation::update_print_sla_config	(	DynamicPrintConfig *	config,
		const bool	is_global_config = false )

{
    double head_penetration = config->opt_float("support_head_penetration");
    double head_width = config->opt_float("support_head_width");
    if (head_penetration > head_width) {
        //wxString msg_text = _(L("Head penetration should not be greater than the head width."));
        wxString msg_text = "Head penetration should not be greater than the head width.";
 
        //MessageDialog dialog(m_msg_dlg_parent, msg_text, _(L("Invalid Head penetration")), wxICON_WARNING | wxOK);
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "Invalid Head penetration", wxICON_WARNING | wxOK);
        DynamicPrintConfig new_conf = *config;
        if (dialog.ShowModal() == wxID_OK) {
            new_conf.set_key_value("support_head_penetration", new ConfigOptionFloat(head_width));
            apply(config, &new_conf);
        }
    }
 
    double pinhead_d = config->opt_float("support_head_front_diameter");
    double pillar_d = config->opt_float("support_pillar_diameter");
    if (pinhead_d > pillar_d) {
        //wxString msg_text = _(L("Pinhead diameter should be smaller than the pillar diameter."));
        wxString msg_text = "Pinhead diameter should be smaller than the pillar diameter.";
 
        //MessageDialog dialog(m_msg_dlg_parent, msg_text, _(L("Invalid pinhead diameter")), wxICON_WARNING | wxOK);
        MessageDialog dialog(m_msg_dlg_parent, msg_text, "Invalid pinhead diameter", wxICON_WARNING | wxOK);
 
        DynamicPrintConfig new_conf = *config;
        if (dialog.ShowModal() == wxID_OK) {
            new_conf.set_key_value("support_head_front_diameter", new ConfigOptionFloat(pillar_d / 2.0));
            apply(config, &new_conf);
        }
    }
}

References apply(), Slic3r::ConfigOptionFloat, m_msg_dlg_parent, Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::set_key_value(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by Slic3r::GUI::ObjectSettings::update_config_values(), and Slic3r::GUI::ObjectTableSettings::update_config_values().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cb_set_option_label

std::function<void(const std::string &, const wxString &, int opt_index)> Slic3r::GUI::ConfigManipulation::cb_set_option_label = nullptr

private

Referenced by ConfigManipulation(), ~ConfigManipulation(), and set_option_label().

cb_toggle_field

std::function<void (const std::string&, bool toggle, int opt_index)> Slic3r::GUI::ConfigManipulation::cb_toggle_field = nullptr

private

Referenced by ConfigManipulation(), ~ConfigManipulation(), and toggle_field().

cb_toggle_line

std::function<void(const std::string &, bool toggle, int opt_index)> Slic3r::GUI::ConfigManipulation::cb_toggle_line = nullptr

private

Referenced by ConfigManipulation(), ~ConfigManipulation(), and toggle_line().

cb_value_change

std::function<void(const std::string&, const boost::any&)> Slic3r::GUI::ConfigManipulation::cb_value_change = nullptr

private

Referenced by ConfigManipulation(), and ~ConfigManipulation().

is_BBL_Printer

bool Slic3r::GUI::ConfigManipulation::is_BBL_Printer {false}

private

{false};

Referenced by get_is_BBL_Printer(), set_is_BBL_Printer(), toggle_print_fff_options(), and update_print_fff_config().

is_msg_dlg_already_exist

bool Slic3r::GUI::ConfigManipulation::is_msg_dlg_already_exist { false }

private

{ false };

Referenced by check_adaptive_pressure_advance_model(), check_chamber_minimal_temperature(), check_chamber_temperature(), check_filament_ironing_spacing(), check_filament_max_volumetric_speed(), check_layer_height(), check_nozzle_recommended_temperature_range(), check_nozzle_temperature_initial_layer_range(), check_nozzle_temperature_range(), is_applying(), layer_height_out_of_range_dialog(), show_spiral_mode_settings_dialog(), and update_print_fff_config().

load_config

std::function<void()> Slic3r::GUI::ConfigManipulation::load_config = nullptr

private

Referenced by ConfigManipulation(), ~ConfigManipulation(), and apply().

local_config

const DynamicPrintConfig* Slic3r::GUI::ConfigManipulation::local_config = nullptr

private

Referenced by ConfigManipulation(), toggle_field(), and toggle_line().

m_applying_keys

t_config_option_keys Slic3r::GUI::ConfigManipulation::m_applying_keys

private

Referenced by apply(), and applying_keys().

m_is_initialized_support_material_overhangs_queried

bool Slic3r::GUI::ConfigManipulation::m_is_initialized_support_material_overhangs_queried { false }

private

{ false };

Referenced by initialize_support_material_overhangs_queried(), and is_initialized_support_material_overhangs_queried().

m_msg_dlg_parent

wxWindow* Slic3r::GUI::ConfigManipulation::m_msg_dlg_parent {nullptr}

private

{nullptr};

Referenced by ConfigManipulation(), check_adaptive_pressure_advance_model(), check_chamber_minimal_temperature(), check_chamber_temperature(), check_nozzle_recommended_temperature_range(), check_nozzle_temperature_initial_layer_range(), check_nozzle_temperature_range(), update_print_fff_config(), and update_print_sla_config().

m_support_material_overhangs_queried

bool Slic3r::GUI::ConfigManipulation::m_support_material_overhangs_queried { false }

private

{ false };

Referenced by initialize_support_material_overhangs_queried(), and update_print_fff_config().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ConfigManipulation.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ConfigManipulation.cpp