Slic3r::GUI::TabPrinter Class Reference

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

Inheritance diagram for Slic3r::GUI::TabPrinter:

Collaboration diagram for Slic3r::GUI::TabPrinter:

Public Member Functions
	TabPrinter (ParamsPanel *parent)
	~TabPrinter ()
void	build () override
void	build_fff ()
void	build_sla ()
void	reload_config () override
void	activate_selected_page (std::function< void()> throw_if_canceled) override
void	clear_pages () override
void	toggle_options () override
void	update () override
void	update_fff ()
void	update_sla ()
void	update_pages ()
void	on_gcode_flavor_changed ()
void	extruders_count_changed (size_t extruders_count)
PageShp	build_kinematics_page ()
void	build_unregular_pages (bool from_initial_build=false)
void	on_preset_loaded () override
void	init_options_list () override
void	msw_rescale () override
bool	supports_printer_technology (const PrinterTechnology) const override
void	set_extruder_volume_type (int extruder_id, NozzleVolumeType type)
void	on_value_change (const std::string &opt_key, const boost::any &value) override
wxSizer *	create_bed_shape_widget (wxWindow *parent)
void	cache_extruder_cnt (const DynamicPrintConfig *config=nullptr)
bool	apply_extruder_cnt_from_cache ()
void	refresh_printer_agent_dropdown () const
Page *	extruder_page () const
int	extruder_page_data_index (const std::string &field_id) const
int	extruder_variant_index (int extruder)
void	sync_extruders_count ()
void	activate_option (const std::string &opt_key, const wxString &category) override
wxWindow *	parent () const
wxString	title () const
std::string	name () const
Preset::Type	type () const
bool	completed () const
void	create_preset_tab ()
void	add_scaled_button (wxWindow *parent, ScalableButton **btn, const std::string &icon_name, const wxString &label=wxEmptyString, long style=wxBU_EXACTFIT|wxNO_BORDER)
void	add_scaled_bitmap (wxWindow *parent, ScalableBitmap &btn, const std::string &icon_name)
void	update_ui_items_related_on_parent_preset (const Preset *selected_preset_parent)
void	load_current_preset ()
void	reactive_preset_combo_box ()
void	rebuild_page_tree ()
void	update_btns_enabling ()
void	update_preset_choice ()
bool	select_preset (std::string preset_name="", bool delete_current=false, const std::string &last_selected_ph_printer_name="", bool force_select=false, bool force_no_transfer=false)
bool	may_discard_current_dirty_preset (PresetCollection *presets=nullptr, const std::string &new_printer_name="", bool no_transfer=false, bool no_transfer_variant=false)
virtual void	update_description_lines ()
void	OnTreeSelChange (wxCommandEvent &event)
void	OnKeyDown (wxKeyEvent &event)
void	compare_preset ()
void	transfer_options (const std::string &name_from, const std::string &name_to, std::vector< std::string > options)
void	save_preset (std::string name=std::string(), bool detach=false, bool save_to_project=false, bool from_input=false, std::string input_name="")
void	delete_preset ()
void	toggle_show_hide_incompatible ()
void	update_show_hide_incompatible_button ()
void	update_ui_from_settings ()
void	update_label_colours ()
void	decorate ()
void	update_changed_ui ()
void	get_sys_and_mod_flags (const std::string &opt_key, bool &sys_page, bool &modified_page)
void	update_changed_tree_ui ()
void	update_undo_buttons ()
void	update_extruder_switch_colors ()
bool	variant_switch_active () const
bool	is_printer_extruder_page (const Page *page) const
void	update_variant_sizer_visibility ()
void	update_all_extruder_options_status ()
void	check_extruder_options_status (int index, bool &sys_extruder, bool &modified_extruder, const std::vector< PageShp > &pages_to_check)
void	on_roll_back_value (const bool to_sys=false)
PageShp	add_options_page (const wxString &title, const std::string &icon, bool is_extruder_pages=false)
virtual void	OnActivate ()
std::string	options_list_storage_key (const std::string &opt_key) const
void	load_initial_data ()
void	update_dirty ()
void	update_tab_ui (bool update_plater_presets=false)
void	load_config (const DynamicPrintConfig &config)
void	apply_preset_config_value (const std::string &opt_key, const std::string &value)
void	apply_preset_config_values (const std::vector< std::pair< std::string, std::string > > &values)
void	update_mode ()
void	update_visibility ()
virtual void	sys_color_changed ()
Field *	get_field (const t_config_option_key &opt_key, int opt_index=-1) const
Field *	get_field (const t_config_option_key &opt_key, Page **selected_page, int opt_index=-1)
Line *	get_line (const t_config_option_key &opt_key)
std::pair< OG_CustomCtrl *, bool * >	get_custom_ctrl_with_blinking_ptr (const t_config_option_key &opt_key, int opt_index=-1)
void	toggle_option (const std::string &opt_key, bool toggle, int opt_index=-1)
void	toggle_line (const std::string &opt_key, bool toggle, int opt_index=-1)
void	set_option_label (const std::string &opt_key, const wxString &label, int opt_index=-1)
SettingRowState	setting_row_state (const std::string &opt_id) const
wxSizer *	description_line_widget (wxWindow *parent, ogStaticText **StaticText, wxString text=wxEmptyString)
bool	current_preset_is_dirty () const
bool	saved_preset_is_dirty () const
void	update_saved_preset_from_current_preset ()
void	update_pages_with_multi_variant ()
DynamicPrintConfig *	get_config ()
PresetCollection *	get_presets ()
TabPresetComboBox *	get_combo_box ()
void	update_wiping_button_visibility ()
void	apply_searcher ()
void	cache_config_diff (const std::vector< std::string > &selected_options, const DynamicPrintConfig *config=nullptr)
void	apply_config_from_cache ()
void	show_timelapse_warning_dialog ()
const std::map< wxString, std::string > &	get_category_icon_map ()
bool	update_current_page_in_background (int &item)
void	unselect_tree_item ()
void	set_expanded (bool value)
void	restore_last_select_item ()
bool	page_build_pending () const
bool	page_build_step ()
bool	validate_custom_gcodes ()
bool	validate_filament_temperature_pairs ()
void	set_just_edit (bool just_edit)
void	edit_custom_gcode (const t_config_option_key &opt_key)
virtual const std::string &	get_custom_gcode (const t_config_option_key &opt_key)
virtual void	set_custom_gcode (const t_config_option_key &opt_key, const std::string &value)
void	update_extruder_variants (int extruder_id=-1, bool reload=true)
	Call from: 1: on_value_change "nozzle_volume_type" 2: on_preset_loaded (extruder_id = -1).
void	switch_excluder (int extruder_id=-1, bool reload=true)
void	sync_excluder ()
void	parse_extruder_selection (int selection, int &extruder_id, NozzleVolumeType &nozzle_type)
int	calculate_selection_index_for_extruder (int extruder_id, NozzleVolumeType nozzle_type)
bool	get_extruder_sync_enable_state (int extruder_id)
int	get_current_active_extruder ()
std::vector< wxString >	generate_extruder_options ()
NozzleVolumeType	get_actual_nozzle_volume_type (int extruder_id)

Static Public Member Functions
static wxString	translate_category (const wxString &title, Preset::Type preset_type, bool translate=true)
static bool	validate_custom_gcode (const wxString &title, const std::string &gcode)

Public Attributes
ScalableButton *	m_reset_to_filament_color = nullptr
size_t	m_extruders_count
size_t	m_extruders_count_old = 0
size_t	m_initial_extruders_count
size_t	m_sys_extruders_count
size_t	m_cache_extruder_count = 0
std::vector< std::string >	m_extruder_variant_list
std::string	m_base_preset_name
PrinterTechnology	m_printer_technology = ptFFF
PresetBundle *	m_preset_bundle
bool	m_show_btn_incompatible_presets = false
PresetCollection *	m_presets = nullptr
DynamicPrintConfig *	m_config
ogStaticText *	m_parent_preset_description_line = nullptr
ScalableButton *	m_detach_preset_btn = nullptr
std::map< std::string, wxColour >	m_colored_Label_colors
int	m_update_cnt = 0
ModeSwitchButton *	m_mode_view = nullptr
ScalableButton *	m_mode_icon = nullptr
wxSizer *	m_variant_sizer = nullptr
MultiSwitchButton *	m_extruder_switch = nullptr
MultiSwitchButton *	m_variant_combo = nullptr
ScalableButton *	m_extruder_sync = nullptr
wxPanel *	m_extruder_sync_box = nullptr
bool	m_extruder_switch_variants = false
std::vector< NozzleVolumeType >	m_actual_nozzle_volumes
bool	validate_custom_gcodes_was_shown { false }

Protected Types
enum	OptStatus { osSystemValue = 1 , osInitValue = 2 }

Protected Member Functions
void	update_custom_dirty (std::vector< std::string > &dirty_options, std::vector< std::string > &nonsys_options) override
void	set_type ()
void	create_line_with_widget (ConfigOptionsGroup *optgroup, const std::string &opt_key, const std::string &path, widget_t widget)
wxSizer *	compatible_widget_create (wxWindow *parent, PresetDependencies &deps)
void	compatible_widget_reload (PresetDependencies &deps)
void	load_key_value (const std::string &opt_key, const boost::any &value, bool saved_value=false)
bool	commit_preset_config_value (const std::string &opt_key)
bool	tree_sel_change_delayed (wxCommandEvent &event)
void	on_presets_changed ()
void	update_printer_agent_if_needed ()
void	build_preset_description_line (ConfigOptionsGroup *optgroup)
void	update_preset_description_line ()
void	update_frequently_changed_parameters ()
void	set_tooltips_text ()
void	filter_diff_option (std::vector< std::string > &options)
ConfigManipulation	get_config_manipulation ()

Protected Attributes
ParamsPanel *	m_parent
Preset::Type	m_type
std::string	m_name
const wxString	m_title
TabPresetComboBox *	m_presets_choice { nullptr }
wxPanel *	m_top_panel
wxBoxSizer *	m_main_sizer
wxBoxSizer *	m_top_sizer
wxBoxSizer *	m_top_left_sizer
wxGridSizer *	m_top_right_sizer
wxBoxSizer *	m_select_sizer
wxBoxSizer *	m_tree_sizer
ScalableButton *	m_btn_compare_preset
ScalableButton *	m_btn_save_preset
ScalableButton *	m_btn_delete_preset
TabCtrl *	m_tabctrl
wxImageList *	m_icons
wxScrolledWindow *	m_page_view {nullptr}
PresetDependencies	m_compatible_printers
PresetDependencies	m_compatible_prints
bool	m_is_default_preset {false}
bool	m_just_edit {false}
ScalableButton *	m_undo_btn
ScalableButton *	m_undo_to_sys_btn
ScalableButton *	m_btn_search
StaticBox *	m_search_item
TextInput *	m_search_input
ScalableBitmap	m_bmp_show_incompatible_presets
ScalableBitmap	m_bmp_hide_incompatible_presets
ScalableBitmap	m_bmp_value_lock
ScalableBitmap	m_bmp_value_unlock
ScalableBitmap	m_bmp_white_bullet
ScalableBitmap *	m_bmp_non_system
ScalableBitmap	m_bmp_value_revert
ScalableBitmap	m_bmp_edit_value
std::vector< ScalableButton * >	m_scaled_buttons = {}
std::vector< ScalableBitmap * >	m_scaled_bitmaps = {}
std::vector< ScalableBitmap >	m_scaled_icons_list = {}
wxColour	m_sys_label_clr
wxColour	m_modified_label_clr
wxColour	m_default_text_clr
wxString	m_ttg_value_lock
wxString	m_ttg_value_unlock
wxString	m_ttg_white_bullet_ns
wxString *	m_ttg_non_system
wxString	m_ttg_white_bullet
wxString	m_ttg_value_revert
wxString	m_tt_value_lock
wxString	m_tt_value_unlock
wxString *	m_tt_non_system
wxString	m_tt_white_bullet
wxString	m_tt_value_revert
int	m_icon_count
std::map< std::string, size_t >	m_icon_index
std::map< wxString, std::string >	m_category_icon
std::vector< PageShp >	m_pages
Page *	m_active_page {nullptr}
bool	m_disable_tree_sel_changed_event {false}
bool	m_show_incompatible_presets
int	m_last_select_item = -1
std::vector< Preset::Type >	m_dependent_tabs
std::map< std::string, int >	m_options_list
std::map< std::string, int >	m_all_extruder_options_status
int	m_opt_status_value = 0
bool	m_is_modified_values { false }
bool	m_is_nonsys_values { true }
bool	m_postpone_update_ui {false}
int	m_em_unit
bool	m_completed { false }
ConfigOptionMode	m_mode = comAdvanced
struct Slic3r::GUI::Tab::Highlighter	m_highlighter
DynamicPrintConfig	m_cache_config
std::vector< std::string >	m_cache_options
bool	m_page_switch_running = false
bool	m_page_switch_planned = false
bool	m_is_timelapse_wipe_tower_already_prompted = false
ConfigManipulation	m_config_manipulation
std::string	m_last_sparse_infill_rotate_template_value

Private Member Functions
void	append_option_line (ConfigOptionsGroupShp optgroup, const std::string opt_key, const std::string &label_path="")
void	update_input_shaper_menu (GCodeFlavor flavor)

Private Attributes
bool	m_was_belt_printer = false
double	m_belt_synced_tilt_x = 0.
double	m_belt_synced_tilt_y = 0.
std::vector< PageShp >	m_pages_fff
std::vector< PageShp >	m_pages_sla
IMEXModesCtrl *	m_imex_modes_ctrl {nullptr}

Detailed Description

Member Enumeration Documentation

OptStatus

enum Slic3r::GUI::Tab::OptStatus

protectedinherited

Enumerator
osSystemValue
osInitValue

{ osSystemValue = 1, osInitValue = 2 };

Constructor & Destructor Documentation

TabPrinter()

Slic3r::GUI::TabPrinter::TabPrinter ( ParamsPanel * parent )

inline

                                    :
        Tab(parent, _L("Machine"), Slic3r::Preset::TYPE_PRINTER) {}

References Slic3r::GUI::Tab::Tab(), _L, and Slic3r::GUI::Tab::parent().

Here is the call graph for this function:

~TabPrinter()

Slic3r::GUI::TabPrinter::~TabPrinter ( )

inline

{}

Member Function Documentation

activate_option()

void Slic3r::GUI::TabPrinter::activate_option ( const std::string & opt_key, const wxString & category )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    wxString number;
    long     n = 0;
    const bool numbered = category.StartsWith("Extruder ", &number) && number.ToLong(&n);
    if (extruder_page() == nullptr || (!numbered && category != "Extruder")) {
        Tab::activate_option(opt_key, category);
        return;
    }
 
    // Selecting fires the switch's event, which re-targets the page (switch_excluder()).
    const int extruder_idx = (n >= 1 && n <= long(m_extruders_count)) ? int(n - 1) : 0;
    if (m_extruder_switch && m_extruder_switch->IsThisEnabled() && extruder_idx != get_current_active_extruder())
        m_extruder_switch->SetSelection(calculate_selection_index_for_extruder(extruder_idx, get_actual_nozzle_volume_type(extruder_idx)));
 
    // The page's controls are created for index 0.
    const auto pos = opt_key.find('#');
    Tab::activate_option(pos == std::string::npos ? opt_key : opt_key.substr(0, pos) + "#0", "Extruder");
}

References Slic3r::GUI::Tab::activate_option(), activate_option(), Slic3r::GUI::Tab::calculate_selection_index_for_extruder(), extruder_page(), Slic3r::GUI::Tab::get_actual_nozzle_volume_type(), Slic3r::GUI::Tab::get_current_active_extruder(), Slic3r::GUI::Tab::m_extruder_switch, and m_extruders_count.

Referenced by activate_option().

Here is the call graph for this function:

Here is the caller graph for this function:

activate_selected_page()

void Slic3r::GUI::TabPrinter::activate_selected_page ( std::function< void()> throw_if_canceled )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::activate_selected_page(throw_if_canceled);
 
    // "extruders_count" doesn't update from the update_config(),
    // so update it implicitly
    if (m_active_page && m_active_page->title() == "Multimaterial")
        m_active_page->set_value("extruders_count", int(m_extruders_count));
 
}

References Slic3r::GUI::Tab::activate_selected_page(), activate_selected_page(), Slic3r::GUI::Tab::m_active_page, and m_extruders_count.

Referenced by activate_selected_page().

Here is the call graph for this function:

Here is the caller graph for this function:

add_options_page()

Slic3r::GUI::PageShp Slic3r::GUI::Tab::add_options_page ( const wxString & title, const std::string & icon, bool is_extruder_pages = false )

inherited

{
    // Index of icon in an icon list $self->{icons}.
    auto icon_idx = 0;
    if (!icon.empty()) {
        icon_idx = (m_icon_index.find(icon) == m_icon_index.end()) ? -1 : m_icon_index.at(icon);
        if (icon_idx == -1) {
            // Add a new icon to the icon list.
            m_scaled_icons_list.push_back(ScalableBitmap(this, icon, 32, false, true));
            //m_icons->Add(m_scaled_icons_list.back().bmp());
            icon_idx = ++m_icon_count;
            m_icon_index[icon] = icon_idx;
        }
 
        if (m_category_icon.find(title) == m_category_icon.end()) {
            // Add new category to the category_to_icon list.
            m_category_icon[title] = icon;
        }
    }
    // Initialize the page.
    //BBS: GUI refactor
    PageShp page = std::make_shared<Page>(m_page_view, title, icon_idx, this);
//  page->SetBackgroundStyle(wxBG_STYLE_SYSTEM);
#ifdef __WINDOWS__
//  page->SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    if (dynamic_cast<TabPrint*>(this)) {
        page->m_split_multi_line = true;
        page->m_option_label_at_right = true;
    }
 
    if (!is_extruder_pages)
        m_pages.push_back(page);
 
    page->set_config(m_config);
    return page;
}

References m_category_icon, m_config, m_icon_count, m_icon_index, m_page_view, m_pages, m_scaled_icons_list, and title().

Referenced by Slic3r::GUI::TabFilament::add_filament_overrides_page(), Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), Slic3r::GUI::TabPrintModel::build(), Slic3r::GUI::TabPrintPlate::build(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::build_kinematics_page(), and Slic3r::GUI::TabPrinter::build_unregular_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

add_scaled_bitmap()

void Slic3r::GUI::Tab::add_scaled_bitmap ( wxWindow * parent, ScalableBitmap & btn, const std::string & icon_name )

inherited

{
    bmp = ScalableBitmap(parent, icon_name);
    m_scaled_bitmaps.push_back(&bmp);
}

References m_scaled_bitmaps, and parent().

Referenced by create_preset_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

add_scaled_button()

void Slic3r::GUI::Tab::add_scaled_button ( wxWindow * parent, ScalableButton ** btn, const std::string & icon_name, const wxString & label = wxEmptyString, long style = wxBU_EXACTFIT | wxNO_BORDER )

inherited

{
    *btn = new ScalableButton(parent, wxID_ANY, icon_name, label, wxDefaultSize, wxDefaultPosition, style, true);
    (*btn)->SetBackgroundColour(parent->GetBackgroundColour());
    m_scaled_buttons.push_back(*btn);
}

References m_scaled_buttons, parent(), and style.

Referenced by create_preset_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

append_option_line()

void Slic3r::GUI::TabPrinter::append_option_line ( ConfigOptionsGroupShp optgroup, const std::string opt_key, const std::string & label_path = "" )

private

{
    auto option = optgroup->get_option(opt_key, 0);
    auto line = Line{ option.opt.full_label, "" };
    line.label_path = label_path;
    line.append_option(option);
    if (m_printer_technology == ptSLA) // just for first build, if SLA printer preset is selected
        line.append_option(optgroup->get_option(opt_key, 1));
    optgroup->append_line(line);
}

References append_option_line(), Slic3r::GUI::Line::label_path, m_printer_technology, and Slic3r::ptSLA.

Referenced by append_option_line(), and build_kinematics_page().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_config_from_cache()

void Slic3r::GUI::Tab::apply_config_from_cache ( )

inherited

{
    bool was_applied = false;
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": enter");
    // check and apply extruders count for printer preset
    if (m_type == Preset::TYPE_PRINTER)
        was_applied = static_cast<TabPrinter*>(this)->apply_extruder_cnt_from_cache();
 
    if (!m_cache_config.empty()) {
        m_presets->get_edited_preset().config.apply_only(m_cache_config, m_cache_options);
        m_cache_config.clear();
        m_cache_options.clear();
 
        was_applied = true;
    }
 
    if (was_applied)
        update_dirty();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": exit, was_applied=%1%")%was_applied;
}

References apply_config_from_cache(), m_cache_config, m_cache_options, m_presets, m_type, Slic3r::Preset::TYPE_PRINTER, and update_dirty().

Referenced by apply_config_from_cache(), on_presets_changed(), select_preset(), and transfer_options().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_extruder_cnt_from_cache()

bool Slic3r::GUI::TabPrinter::apply_extruder_cnt_from_cache

(

)

{
    if (m_presets->get_edited_preset().printer_technology() == ptSLA)
        return false;
 
    if (m_cache_extruder_count > 0) {
        m_presets->get_edited_preset().set_num_extruders(m_cache_extruder_count);
        m_cache_extruder_count = 0;
        return true;
    }
    return false;
}

References apply_extruder_cnt_from_cache(), m_cache_extruder_count, Slic3r::GUI::Tab::m_presets, and Slic3r::ptSLA.

Referenced by apply_extruder_cnt_from_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_preset_config_value()

void Slic3r::GUI::Tab::apply_preset_config_value ( const std::string & opt_key, const std::string & value )

inherited

{
    apply_preset_config_values({{opt_key, value}});
}

References apply_preset_config_value(), and apply_preset_config_values().

Referenced by apply_preset_config_value().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_preset_config_values()

void Slic3r::GUI::Tab::apply_preset_config_values ( const std::vector< std::pair< std::string, std::string > > & values )

inherited

{
    if (m_config == nullptr)
        throw std::runtime_error("The preset configuration is not available");
    if (wxGetApp().plater() == nullptr)
        throw std::runtime_error("OrcaSlicer main window is not available");
 
    if (values.empty())
        return;
 
    const std::vector<std::string>& options = preset_type_options(m_type);
 
    // Preparation: reject every batch that cannot be applied before touching the edited preset, so a
    // bad key or value fails without a partial write. The key must belong to this preset type, it must
    // not repeat, and each value is strict-parsed into a scratch copy (the strict deserializer can
    // already have mutated an option when it rejects a bad value, so the check has to run somewhere
    // the edited preset is not affected). Callback failures cannot be prepared this way: a setting's
    // on_change callback is a GUI method, not a pure function of the config, so whether it throws is
    // only known by running it. That residual case is handled by the rollback below.
    std::set<std::string>   seen;
    DynamicPrintConfig      scratch(*m_config);
    for (const auto& kv : values) {
        const std::string& opt_key = kv.first;
        if (std::find(options.begin(), options.end(), opt_key) == options.end())
            throw std::invalid_argument(format("Unknown %1% preset setting \"%2%\"", preset_type_name(m_type), opt_key));
        if (!seen.insert(opt_key).second)
            throw std::invalid_argument(format("%1% preset setting \"%2%\" is set more than once in the same update",
                                               preset_type_name(m_type), opt_key));
        try {
            scratch.set_deserialize_strict(opt_key, kv.second);
        } catch (const ConfigurationError& err) {
            throw std::invalid_argument(err.what());
        }
    }
 
    // Rollback boundary: snapshot the whole edited config, not just the keys the batch names, because a
    // key-specific callback can adjust related settings of the edited preset (mutually exclusive
    // options, compatibility, and so on). A failure restores this config and then recomputes the state
    // derived from it.
    DynamicPrintConfig before(*m_config);
    try {
        for (const auto& kv : values) {
            m_config->set_deserialize_strict(kv.first, kv.second);
            if (!commit_preset_config_value(kv.first))
                // The GUI edits this setting through a custom widget rather than a group (e.g.
                // compatible_printers), so take the same shared no-field commit path the widget uses.
                // The value was written above, so saved mode skips the write and keeps the path's
                // compatibility recompute, dirty flag, preset-combo and plater updates.
                load_key_value(kv.first, boost::any(), /*saved_value=*/true);
        }
    } catch (...) {
        *m_config = before;
        // A callback can rewrite state derived from the config (compatibility marks, the preset
        // selector, dependent tabs, the Plater and, on the printer tab, the printer agent) before it
        // throws. Recompute that derived state from the restored config so none of it is left
        // reflecting the failed batch. Effects that are not a function of the config (a dialog the
        // user already accepted, an undo snapshot, a command already sent to a device, the target
        // selection) cannot be reversed here; see the header.
        m_preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
        reload_config();
        update_dirty();
        update();
        throw;
    }
 
    // Apply the batch's final state once. The commit paths above already maintained the dirty flag,
    // preset combo and, on the printer tab, the printer-agent switch; this reloads the visible page
    // and pushes the config to the Plater.
    reload_config();
    update_dirty();
    update();
}

References apply_preset_config_values(), commit_preset_config_value(), Slic3r::format(), load_key_value(), m_config, m_preset_bundle, m_type, Slic3r::Never, Slic3r::GUI::plater(), Slic3r::GUI::preset_type_name(), Slic3r::GUI::preset_type_options(), reload_config(), Slic3r::ConfigBase::set_deserialize_strict(), update(), and update_dirty().

Referenced by apply_preset_config_value(), apply_preset_config_values(), and Slic3r::anonymous_namespace{PluginHostPresets.cpp}::PresetTransaction::commit().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_searcher()

void Slic3r::GUI::Tab::apply_searcher ( )

inherited

{
    wxGetApp().sidebar().get_searcher().apply(m_config, m_type, m_mode);
}

References apply_searcher(), m_config, m_mode, and m_type.

Referenced by apply_searcher(), and Slic3r::GUI::TabPrinter::build_unregular_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

build()

void Slic3r::GUI::TabPrinter::build ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    m_presets = &m_preset_bundle->printers;
    m_printer_technology = m_presets->get_selected_preset().printer_technology();
 
    // For DiffPresetDialog we use options list which is saved in Searcher class.
    // Options for the Searcher is added in the moment of pages creation.
    // So, build first of all printer pages for non-selected printer technology...
    //std::string def_preset_name = "- default " + std::string(m_printer_technology == ptSLA ? "FFF" : "SLA") + " -";
    std::string def_preset_name = "Default Printer";
    m_config = &m_presets->find_preset(def_preset_name)->config;
    m_printer_technology == ptSLA ? build_fff() : build_sla();
    if (m_printer_technology == ptSLA)
        m_extruders_count_old = 0;// revert this value
 
    // ... and than for selected printer technology
    load_initial_data();
    m_printer_technology == ptSLA ? build_sla() : build_fff();
}

References build(), build_fff(), build_sla(), Slic3r::GUI::Tab::load_initial_data(), Slic3r::GUI::Tab::m_config, m_extruders_count_old, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_presets, m_printer_technology, and Slic3r::ptSLA.

Referenced by build().

Here is the call graph for this function:

Here is the caller graph for this function:

build_fff()

void Slic3r::GUI::TabPrinter::build_fff

(

)

{
    if (!m_pages.empty())
        m_pages.resize(0);
    // to avoid redundant memory allocation / deallocation during extruders count changing
    m_pages.reserve(30);
 
    auto   *nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(m_config->option("nozzle_diameter"));
    m_initial_extruders_count = m_extruders_count = nozzle_diameter->values.size();
    m_extruder_variant_list = m_config->option<ConfigOptionStrings>("printer_extruder_variant")->values;
    // BBS
    //wxGetApp().obj_list()->update_objects_list_filament_column(m_initial_extruders_count);
 
    const Preset* parent_preset = m_printer_technology == ptSLA ? nullptr // just for first build, if SLA printer preset is selected
                                  : m_presets->get_selected_preset_parent();
    m_sys_extruders_count = parent_preset == nullptr ? 0 :
            static_cast<const ConfigOptionFloats*>(parent_preset->config.option("nozzle_diameter"))->values.size();
 
    auto page = add_options_page(L("Basic information"), "custom-gcode_object-info"); // ORCA: icon only visible on placeholders
    auto optgroup = page->new_optgroup(L("Printable space"), "param_printable_space");
 
        create_line_with_widget(optgroup.get(), "printable_area", "custom-svg-and-png-bed-textures_124612", [this](wxWindow* parent) {
           return   create_bed_shape_widget(parent);
        });
        optgroup->append_single_option_line("parallel_printheads_count");
        Option option = optgroup->get_option("bed_exclude_area");
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "printer_basic_information_printable_space#excluded-bed-area");
 
        option = optgroup->get_option("bed_exclude_volumes");
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "printer_basic_information_printable_space#toolhead-collision-volumes");
        optgroup->append_single_option_line("bed_exclude_volume_mode", "printer_basic_information_printable_space#toolhead-collision-volumes");
 
        optgroup->append_single_option_line("printable_height", "printer_basic_information_printable_space#printable-height");
        optgroup->append_single_option_line("support_multi_bed_types", "printer_basic_information_printable_space#support-multi-bed-types");
        optgroup->append_single_option_line("best_object_pos", "printer_basic_information_printable_space#best-object-position");
        optgroup->append_single_option_line("z_offset", "printer_basic_information_printable_space#z-offset");
        optgroup->append_single_option_line("preferred_orientation", "printer_basic_information_printable_space#preferred-orientation");
 
        optgroup = page->new_optgroup(L("Advanced"), L"param_advanced");
 
        optgroup->append_single_option_line("printer_structure", "printer_basic_information_advanced#printer-structure");
        optgroup->append_single_option_line("gcode_flavor", "printer_basic_information_advanced#g-code-flavor");
        optgroup->append_single_option_line("gcode_skip_config_block", "printer_basic_information_advanced#skip-g-code-config-block");
        optgroup->append_single_option_line("pellet_modded_printer", "printer_basic_information_advanced#pellet-modded-printer");
        optgroup->append_single_option_line("bbl_use_printhost", "printer_basic_information_advanced#use-3rd-party-print-host");
 
        // "Printer Agent" dropdown - printer_agent is a coString; gui_type routes it to
        // PrinterAgentChoice instead of a TextCtrl. Rows and values come from the live agent
        // registry, and the value is stored as the agent-id string.
        if (wxGetApp().getAgent() != nullptr)
        {
            auto registered_printer_agents = NetworkAgentFactory::get_registered_printer_agents();
            if (!registered_printer_agents.empty())
            {
                option = optgroup->get_option("printer_agent");
                option.opt.gui_type = ConfigOptionDef::GUIType::printer_agent_select;
                option.opt.width = Field::def_width_wider();
                option.opt.tooltip = L("Select the network agent implementation for printer communication. "
                    "Available agents are registered at startup.");
                optgroup->append_single_option_line(option, "printer_basic_information_advanced#printer-agent");
            }
        }
 
        optgroup->append_single_option_line("use_3mf");
        optgroup->append_single_option_line("scan_first_layer" , "printer_basic_information_advanced#scan-first-layer");
        optgroup->append_single_option_line("enable_power_loss_recovery", "printer_basic_information_advanced#power-loss-recovery");
        //option  = optgroup->get_option("wrapping_exclude_area");
        //option.opt.full_width = true;
        //optgroup->append_single_option_line(option);
        optgroup->append_single_option_line("disable_m73", "printer_basic_information_advanced#disable-set-remaining-print-time");
 
        // Belt printer: dedicated section. Everything except the "Enable belt printing"
        // checkbox is hidden when belt_printer is off (see TabPrinter::toggle_options).
        auto belt_og = page->new_optgroup(L("Belt printer"), L"param_advanced");
        belt_og->append_single_option_line("belt_printer", "printer_basic_information_belt_printer#enable-belt-printing");
        belt_og->append_single_option_line("belt_printer_infinite_y", "printer_basic_information_belt_printer#infinite-y-axis");
        // Belt tilt: the sole mesh-side transform and the single source of truth for
        // the physical tilt (drives bed rendering and support gravity tilt too).
        // Isometric rotation, no distortion; the back-transform inverts it before the
        // machine-frame remap.  The angle is what a user checks against the machine;
        // the axis is a profile-level kinematics choice, so it is Develop-only.  They
        // are separate rows because a shared line is shown by its first option's mode.
        belt_og->append_single_option_line("belt_slice_rotation_angle", "printer_basic_information_belt_printer#tilt-angle");
        belt_og->append_single_option_line("belt_slice_rotation", "printer_basic_information_belt_printer#tilt-axis");
        belt_og->append_single_option_line("belt_support_floor_offset", "printer_basic_information_belt_printer#support-floor-z-offset");
 
        // Machine-frame transform: the shear (cot) + scale (1/sin) that map
        // Cartesian G-code into the printer's physical machine frame are derived
        // from the belt tilt angle.  Only the post-slice axis remap and the expert
        // decouple override are exposed here, one option per row.
        {
            auto mf = page->new_optgroup(L("Machine frame transforms"), L"param_advanced");
            mf->append_single_option_line("gcode_remap_x", "printer_basic_information_machine_frame_transforms#g-code-axis-remap");
            mf->append_single_option_line("gcode_remap_y", "printer_basic_information_machine_frame_transforms#g-code-axis-remap");
            mf->append_single_option_line("gcode_remap_z", "printer_basic_information_machine_frame_transforms#g-code-axis-remap");
            mf->append_single_option_line("belt_frame_tilt_decouple", "printer_basic_information_machine_frame_transforms#machine-frame-tilt");
            mf->append_single_option_line("belt_frame_tilt_angle", "printer_basic_information_machine_frame_transforms#machine-frame-tilt");
        }
 
        option = optgroup->get_option("thumbnails");
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "printer_basic_information_advanced#g-code-thumbnails");
        // optgroup->append_single_option_line("thumbnails_format");
        optgroup->m_on_change = [this](t_config_option_key opt_key, boost::any value) {
            wxTheApp->CallAfter([this, opt_key, value]() {
                if (opt_key == "thumbnails" && m_config->has("thumbnails_format")) {
                    // to backward compatibility we need to update "thumbnails_format" from new "thumbnails"
                    const std::string val = boost::any_cast<std::string>(value);
                    if (!value.empty()) {
                        auto [thumbnails_list, errors] = GCodeThumbnails::make_and_check_thumbnail_list(val);
 
                        if (errors != enum_bitmask<ThumbnailError>()) {
                            // TRN: The first argument is the parameter's name; the second argument is its value.
                            std::string error_str = format(_u8L("Invalid value provided for parameter %1%: %2%"), "thumbnails", val);
                            error_str += GCodeThumbnails::get_error_string(errors);
                            InfoDialog(parent(), _L("G-code flavor is switched"), from_u8(error_str)).ShowModal();
                        }
 
                        if (!thumbnails_list.empty()) {
                            GCodeThumbnailsFormat old_format = GCodeThumbnailsFormat(m_config->option("thumbnails_format")->getInt());
                            GCodeThumbnailsFormat new_format = thumbnails_list.begin()->first;
                            if (old_format != new_format) {
                                DynamicPrintConfig new_conf = *m_config;
 
                                auto* opt = m_config->option("thumbnails_format")->clone();
                                opt->setInt(int(new_format));
                                new_conf.set_key_value("thumbnails_format", opt);
 
                                load_config(new_conf);
                            }
                        }
                    }
                }
 
                update_dirty();
                on_value_change(opt_key, value);
            });
        };
 
        optgroup->append_single_option_line("use_relative_e_distances", "printer_basic_information_advanced#use-relative-e-distances");
        optgroup->append_single_option_line("use_firmware_retraction", "printer_basic_information_advanced#use-firmware-retraction");
        // optgroup->append_single_option_line("spaghetti_detector");
        optgroup->append_single_option_line("time_cost", "printer_basic_information_advanced#time-cost");
        optgroup->append_single_option_line("build_plate_tilt_x", "printer_basic_information_advanced#build-plate-tilt");
        optgroup->append_single_option_line("build_plate_tilt_y", "printer_basic_information_advanced#build-plate-tilt");
 
        optgroup = page->new_optgroup(L("Plugin Configuration"), L"param_gcode");
        optgroup->append_single_option_line("printer_plugin_config_overrides");
 
        optgroup  = page->new_optgroup(L("Cooling Fan"), "param_cooling_fan");
        Line line = Line{ L("Fan speed-up time"), optgroup->get_option("fan_speedup_time").opt.tooltip };
        line.label_path = "printer_basic_information_cooling_fan#fan-speed-up-time";
        line.append_option(optgroup->get_option("fan_speedup_time"));
        line.append_option(optgroup->get_option("fan_speedup_overhangs"));
        optgroup->append_line(line);
        optgroup->append_single_option_line("fan_kickstart", "printer_basic_information_cooling_fan#fan-kick-start-time");
        // ORCA: PWM floor for fans that won't spool at low duty cycles.
        optgroup->append_single_option_line("part_cooling_fan_min_pwm", "printer_basic_information_cooling_fan#minimum-non-zero-part-cooling-fan-speed");
 
        optgroup = page->new_optgroup(L("Extruder Clearance"), "param_extruder_clearance");
        optgroup->append_single_option_line("extruder_clearance_radius", "printer_basic_information_extruder_clearance#radius");
        optgroup->append_single_option_line("extruder_clearance_dist_to_rod", "printer_basic_information_extruder_clearance#distance-to-rod");
        optgroup->append_single_option_line("extruder_clearance_height_to_rod", "printer_basic_information_extruder_clearance#height-to-rod");
        optgroup->append_single_option_line("extruder_clearance_height_to_lid", "printer_basic_information_extruder_clearance#height-to-lid");
 
        optgroup = page->new_optgroup(L("Adaptive bed mesh"), "param_adaptive_mesh");
        optgroup->append_single_option_line("bed_mesh_min", "printer_basic_information_adaptive_bed_mesh#bed-mesh");
        optgroup->append_single_option_line("bed_mesh_max", "printer_basic_information_adaptive_bed_mesh#bed-mesh");
        optgroup->append_single_option_line("bed_mesh_probe_distance", "printer_basic_information_adaptive_bed_mesh#probe-point-distance");
        optgroup->append_single_option_line("adaptive_bed_mesh_margin", "printer_basic_information_adaptive_bed_mesh#mesh-margin");
 
        optgroup = page->new_optgroup(L("Accessory"), "param_accessory");
        optgroup->append_single_option_line("nozzle_hrc", "printer_basic_information_accessory#nozzle-hrc");
        optgroup->append_single_option_line("auxiliary_fan", "printer_basic_information_accessory#auxiliary-part-cooling-fan");
        optgroup->append_single_option_line("fan_direction");
        optgroup->append_single_option_line("support_chamber_temp_control", "printer_basic_information_accessory#support-controlling-chamber-temperature");
        optgroup->append_single_option_line("support_air_filtration", "printer_basic_information_accessory#support-air-filtration");
        optgroup->append_single_option_line("cooling_filter_enabled");
 
        auto edit_custom_gcode_fn = [this](const t_config_option_key& opt_key) { edit_custom_gcode(opt_key); };
 
    const int gcode_field_height = 15; // 150
    const int notes_field_height = 25; // 250
    page = add_options_page(L("Machine G-code"), "custom-gcode_gcode"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("File header G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("file_start_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = 8;
        optgroup->append_single_option_line(option);
 
        optgroup = page->new_optgroup(L("Machine start G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("machine_start_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#machine-start-g-code");
 
        optgroup = page->new_optgroup(L("Machine end G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("machine_end_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#machine-end-g-code");
 
        optgroup              = page->new_optgroup(L("Printing by object G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, optgroup](const t_config_option_key &opt_key, const boost::any &value) {
            validate_custom_gcode_cb(this, optgroup, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option                = optgroup->get_option("printing_by_object_gcode");
        option.opt.full_width = true;
        option.opt.is_code    = true;
        option.opt.height     = gcode_field_height; // 150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#printing-by-object-g-code");
 
 
        optgroup = page->new_optgroup(L("Before layer change G-code"),"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("before_layer_change_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#before-layer-change-g-code");
 
        optgroup = page->new_optgroup(L("Layer change G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("layer_change_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#layer-change-g-code");
 
        optgroup = page->new_optgroup(L("Timelapse G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("time_lapse_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#timelapse-g-code");
 
        optgroup              = page->new_optgroup(L("Clumping Detection G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, optgroup](const t_config_option_key &opt_key, const boost::any &value) {
            validate_custom_gcode_cb(this, optgroup, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option                = optgroup->get_option("wrapping_detection_gcode");
        option.opt.full_width = true;
        option.opt.is_code    = true;
        option.opt.height     = gcode_field_height; // 150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#clumping-detection-g-code");
 
        optgroup = page->new_optgroup(L("Change filament G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("change_filament_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#change-filament-g-code");
 
        optgroup = page->new_optgroup(L("Change extrusion role G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key &opt_key, const boost::any &value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("change_extrusion_role_gcode");
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#change-extrusion-role-g-code");
 
        optgroup = page->new_optgroup(L("Pause G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("machine_pause_gcode");
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#pause-g-code");
 
        optgroup = page->new_optgroup(L("Template Custom G-code"), L"param_gcode", 0);
        optgroup->m_on_change = [this, &optgroup_title = optgroup->title](const t_config_option_key& opt_key, const boost::any& value) {
            validate_custom_gcode_cb(this, optgroup_title, opt_key, value);
        };
        optgroup->edit_custom_gcode = edit_custom_gcode_fn;
        option = optgroup->get_option("template_custom_gcode");
        option.opt.is_code = true;
        option.opt.height = gcode_field_height;//150;
        optgroup->append_single_option_line(option, "printer_machine_gcode#template-custom-g-code");
 
    page = add_options_page(L("Notes"), "custom-gcode_note"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("Notes"), "note", 0);
        option = optgroup->get_option("printer_notes");
        option.opt.full_width = true;
        option.opt.height = notes_field_height;//250;
        optgroup->append_single_option_line(option);
#if 0
    //page = add_options_page(L("Dependencies"), "advanced");
    //    optgroup = page->new_optgroup(L("Profile dependencies"));
 
    //    build_preset_description_line(optgroup.get());
#endif
    build_unregular_pages(true);
}

References _L, _u8L, Slic3r::GUI::Tab::add_options_page(), Slic3r::GUI::Line::append_option(), build_fff(), build_unregular_pages(), Slic3r::GUI::Tab::create_line_with_widget(), Slic3r::GUI::Field::def_width_wider(), Slic3r::GUI::Tab::edit_custom_gcode(), Slic3r::format(), Slic3r::from_u8(), Slic3r::ConfigOptionDef::full_width, Slic3r::GCodeThumbnails::get_error_string(), Slic3r::NetworkAgentFactory::get_registered_printer_agents(), Slic3r::ConfigOptionDef::gui_type, Slic3r::ConfigOptionDef::height, Slic3r::ConfigOptionDef::is_code, L, Slic3r::GUI::Line::label_path, Slic3r::load_config(), Slic3r::GUI::Tab::m_config, m_extruder_variant_list, m_extruders_count, m_initial_extruders_count, Slic3r::GUI::Tab::m_pages, Slic3r::GUI::Tab::m_presets, m_printer_technology, m_sys_extruders_count, Slic3r::GCodeThumbnails::make_and_check_thumbnail_list(), Slic3r::nozzle_diameter(), on_value_change(), Slic3r::GUI::Option::opt, Slic3r::GUI::Tab::parent(), Slic3r::ConfigOptionDef::printer_agent_select, Slic3r::ptSLA, Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::ConfigOptionDef::tooltip, Slic3r::GUI::Tab::update_dirty(), Slic3r::GUI::validate_custom_gcode_cb(), and Slic3r::ConfigOptionDef::width.

Referenced by build(), build_fff(), and update_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

build_kinematics_page()

PageShp Slic3r::GUI::TabPrinter::build_kinematics_page

(

)

{
    auto page = add_options_page(L("Motion ability"), "custom-gcode_motion", true); // ORCA: icon only visible on placeholders
 
    auto optgroup = page->new_optgroup(L("Advanced"), "param_advanced");
    optgroup->append_single_option_line("emit_machine_limits_to_gcode", "printer_motion_ability#emit-limits-to-g-code");
 
    // resonance avoidance ported over from qidi slicer
    optgroup = page->new_optgroup(L("Resonance Compensation"), "param_resonance_avoidance");
    optgroup->append_single_option_line("resonance_avoidance", "printer_motion_ability#resonance-avoidance");
    // Resonance‑avoidance speed inputs
    {
        Line resonance_line = {L("Resonance Avoidance Speed"), L""};
        resonance_line.label_path = "printer_motion_ability#resonance-avoidance";
        resonance_line.append_option(optgroup->get_option("min_resonance_avoidance_speed"));
        resonance_line.append_option(optgroup->get_option("max_resonance_avoidance_speed"));
        optgroup->append_line(resonance_line);
    }
    optgroup->append_single_option_line("input_shaping_emit", "printer_motion_ability#input-shaping");
    optgroup->append_single_option_line("input_shaping_type", "printer_motion_ability#input-shaping-type");
    {
        Line freq_line = {L("Frequency"), L("The frequency of the anti-vibration signal will correspond to the natural frequency of the frame.")};
        freq_line.label_path = "printer_motion_ability#input-shaping";
        freq_line.append_option(optgroup->get_option("input_shaping_freq_x"));
        freq_line.append_option(optgroup->get_option("input_shaping_freq_y"));
        optgroup->append_line(freq_line);
    }
    {
        Line damping_line = {L("Damping"), L("Damping ratio for the input shaping filter.")};
        damping_line.label_path = "printer_motion_ability#input-shaping";
        damping_line.append_option(optgroup->get_option("input_shaping_damp_x"));
        damping_line.append_option(optgroup->get_option("input_shaping_damp_y"));
        optgroup->append_line(damping_line);
    }
 
    const std::vector<std::string> speed_axes{
        "machine_max_speed_x",
        "machine_max_speed_y",
        "machine_max_speed_z",
        "machine_max_speed_e"
    };
    optgroup = page->new_optgroup(L("Speed limitation"), "param_speed");
        for (const std::string &speed_axis : speed_axes)  {
            append_option_line(optgroup, speed_axis, "printer_motion_ability#speed-limitation");
        }
 
    const std::vector<std::string> axes{ "x", "y", "z", "e" };
    optgroup = page->new_optgroup(L("Acceleration limitation"), "param_acceleration");
        for (const std::string &axis : axes)  {
            append_option_line(optgroup, "machine_max_acceleration_" + axis, "printer_motion_ability#acceleration-limitation");
        }
        append_option_line(optgroup, "machine_max_acceleration_extruding", "printer_motion_ability#acceleration-limitation");
        append_option_line(optgroup, "machine_max_acceleration_retracting", "printer_motion_ability#acceleration-limitation");
        append_option_line(optgroup, "machine_max_acceleration_travel", "printer_motion_ability#acceleration-limitation");
 
        optgroup = page->new_optgroup(L("Jerk limitation"), "param_jerk");
        // machine max junction deviation
        append_option_line(optgroup, "machine_max_junction_deviation", "printer_motion_ability#maximum-junction-deviation");
        for (const std::string &axis : axes)  {
            append_option_line(optgroup, "machine_max_jerk_" + axis, "printer_motion_ability#maximum-jerk");
        }
 
    //optgroup = page->new_optgroup(L("Minimum feedrates"));
    //    append_option_line(optgroup, "machine_min_extruding_rate");
    //    append_option_line(optgroup, "machine_min_travel_rate");
 
    return page;
}

References Slic3r::GUI::Tab::add_options_page(), Slic3r::GUI::Line::append_option(), append_option_line(), build_kinematics_page(), L, and Slic3r::GUI::Line::label_path.

Referenced by build_kinematics_page(), and build_unregular_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

build_preset_description_line()

void Slic3r::GUI::Tab::build_preset_description_line ( ConfigOptionsGroup * optgroup )

protectedinherited

{
    auto description_line = [this](wxWindow* parent) {
        return description_line_widget(parent, &m_parent_preset_description_line);
    };
 
    auto detach_preset_btn = [this](wxWindow* parent) {
        m_detach_preset_btn = new ScalableButton(parent, wxID_ANY, "lock_normal", "",
                                                 wxDefaultSize, wxDefaultPosition, wxBU_LEFT | wxBU_EXACTFIT, true);
        ScalableButton* btn = m_detach_preset_btn;
        btn->SetFont(Slic3r::GUI::wxGetApp().normal_font());
 
        auto sizer = new wxBoxSizer(wxHORIZONTAL);
        sizer->Add(btn);
 
        btn->Bind(wxEVT_BUTTON, [this, parent](wxCommandEvent&)
        {
          bool system = m_presets->get_edited_preset().is_system;
          bool dirty  = m_presets->get_edited_preset().is_dirty;
            wxString msg_text = system ?
              _(L("A copy of the current system preset will be created, which will be detached from the system preset.")) :
                _(L("The current custom preset will be detached from the parent system preset."));
            if (dirty) {
              msg_text += "\n\n";
              msg_text += _(L("Modifications to the current profile will be saved."));
            }
            msg_text += "\n\n";
            msg_text += _(L("This action is not revertible.\nDo you want to proceed?"));
 
            //wxMessageDialog dialog(parent, msg_text, _(L("Detach preset")), wxICON_WARNING | wxYES_NO | wxCANCEL);
            MessageDialog dialog(parent, msg_text, _(L("Detach preset")), wxICON_WARNING | wxYES_NO | wxCANCEL);
            if (dialog.ShowModal() == wxID_YES)
                save_preset(m_presets->get_edited_preset().is_system ? std::string() : m_presets->get_edited_preset().name, true);
        });
 
        btn->Hide();
 
        return sizer;
    };
 
    Line line = Line{ "", "" };
    line.full_width = 1;
 
    line.append_widget(description_line);
    line.append_widget(detach_preset_btn);
    optgroup->append_line(line);
}

References _, Slic3r::GUI::OptionsGroup::append_line(), Slic3r::GUI::Line::append_widget(), build_preset_description_line(), description_line_widget(), Slic3r::GUI::Line::full_width, L, m_detach_preset_btn, m_parent_preset_description_line, m_presets, parent(), save_preset(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by build_preset_description_line().

Here is the call graph for this function:

Here is the caller graph for this function:

build_sla()

void Slic3r::GUI::TabPrinter::build_sla

(

)

{
    //if (!m_pages.empty())
    //    m_pages.resize(0);
    //auto page = add_options_page(L("General"), "printer");
    //auto optgroup = page->new_optgroup(L("Size and coordinates"));
 
    //create_line_with_widget(optgroup.get(), "printable_area", "custom-svg-and-png-bed-textures_124612", [this](wxWindow* parent) {
    //    return  create_bed_shape_widget(parent);
    //});
    //optgroup->append_single_option_line("printable_height");
 
    //optgroup = page->new_optgroup(L("Display"));
    //optgroup->append_single_option_line("display_width");
    //optgroup->append_single_option_line("display_height");
 
    //auto option = optgroup->get_option("display_pixels_x");
    //Line line = { option.opt.full_label, "" };
    //line.append_option(option);
    //line.append_option(optgroup->get_option("display_pixels_y"));
    //optgroup->append_line(line);
    //optgroup->append_single_option_line("display_orientation");

    //optgroup->append_single_option_line("display_mirror_x");
    //optgroup->append_single_option_line("display_mirror_y");
 
    //optgroup = page->new_optgroup(L("Tilt"));
    //line = { L("Tilt time"), "" };
    //line.append_option(optgroup->get_option("fast_tilt_time"));
    //line.append_option(optgroup->get_option("slow_tilt_time"));
    //optgroup->append_line(line);
    //optgroup->append_single_option_line("area_fill");
 
    //optgroup = page->new_optgroup(L("Corrections"));
    //line = Line{ m_config->def()->get("relative_correction")->full_label, "" };
    //for (auto& axis : { "X", "Y", "Z" }) {
    //    auto opt = optgroup->get_option(std::string("relative_correction_") + char(std::tolower(axis[0])));
    //    opt.opt.label = axis;
    //    line.append_option(opt);
    //}
    //optgroup->append_line(line);
    //optgroup->append_single_option_line("absolute_correction");
    //optgroup->append_single_option_line("elefant_foot_compensation");
    //optgroup->append_single_option_line("elefant_foot_min_width");
    //optgroup->append_single_option_line("gamma_correction");
    //
    //optgroup = page->new_optgroup(L("Exposure"));
    //optgroup->append_single_option_line("min_exposure_time");
    //optgroup->append_single_option_line("max_exposure_time");
    //optgroup->append_single_option_line("min_initial_exposure_time");
    //optgroup->append_single_option_line("max_initial_exposure_time");
 
    //page = add_options_page(L("Dependencies"), "wrench.png");
    //optgroup = page->new_optgroup(L("Profile dependencies"));
 
    //build_preset_description_line(optgroup.get());
}

References build_sla().

Referenced by build(), build_sla(), and update_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

build_unregular_pages()

void Slic3r::GUI::TabPrinter::build_unregular_pages

(

bool

from_initial_build = false

)

{
    size_t    n_before_extruders = 2;     //  Count of pages before Extruder pages
    auto        flavor = m_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor")->value;
    bool    is_marlin_flavor = (flavor == gcfMarlinLegacy || flavor == gcfMarlinFirmware || flavor == gcfKlipper || flavor == gcfRepRapFirmware || flavor == gcfRepetier);
 
    /* ! Freeze/Thaw in this function is needed to avoid call OnPaint() for erased pages
     * and be cause of application crash, when try to change Preset in moment,
     * when one of unregular pages is selected.
     *  */
    Freeze();
 
    // Add/delete Kinematics page according to is_marlin_flavor
    size_t existed_page = 0;
    for (size_t i = n_before_extruders; i < m_pages.size(); ++i) // first make sure it's not there already
        if (m_pages[i]->title().find(L("Motion ability")) != std::string::npos) {
            existed_page = i;
            break;
        }
 
    if (existed_page < n_before_extruders && (is_marlin_flavor || from_initial_build)) {
        auto page = build_kinematics_page();
        if (from_initial_build && !is_marlin_flavor)
            page->clear();
        else
            m_pages.insert(m_pages.begin() + n_before_extruders, page);
    }
 
if (is_marlin_flavor)
    n_before_extruders++;
    size_t    n_after_single_extruder_MM = 2; //  Count of pages after single_extruder_multi_material page
 
    if (from_initial_build) {
        // create a page, but pretend it's an extruder page, so we can add it to m_pages ourselves
        auto page     = add_options_page(L("Multimaterial"), "custom-gcode_multi_material", true); // ORCA: icon only visible on placeholders
        auto optgroup = page->new_optgroup(L("Single extruder multi-material setup"), "param_multi_material");
        optgroup->append_single_option_line("single_extruder_multi_material", "printer_multimaterial_setup#single-extruder-multi-material");
        ConfigOptionDef def;
        def.type    = coInt, def.set_default_value(new ConfigOptionInt((int) m_extruders_count));
        def.label   = L("Extruders");
        def.tooltip = L("Number of extruders of the printer.");
        def.min     = 1;
        def.max     = MAXIMUM_EXTRUDER_NUMBER;
        def.mode    = comAdvanced;
        Option option(def, "extruders_count");
        optgroup->append_single_option_line(option, "printer_multimaterial_setup#extruders");
 
        // Orca: rebuild missed extruder pages
        optgroup->m_on_change = [this, optgroup_wk = ConfigOptionsGroupWkp(optgroup)](t_config_option_key opt_key, boost::any value) {
            auto optgroup_sh = optgroup_wk.lock();
            if (!optgroup_sh)
                return;
 
            // optgroup->get_value() return int for def.type == coInt,
            // Thus, there should be boost::any_cast<int> !
            // Otherwise, boost::any_cast<size_t> causes an "unhandled unknown exception"
            const auto v = optgroup_sh->get_value("extruders_count");
            if (v.empty()) return;
            size_t extruders_count = size_t(boost::any_cast<int>(v));
            wxTheApp->CallAfter([this, opt_key, value, extruders_count]() {
                if (opt_key == "extruders_count" || opt_key == "single_extruder_multi_material") {
                    const size_t old_extruders_count = m_extruders_count;
                    extruders_count_changed(extruders_count);
                    init_options_list(); // m_options_list should be updated before UI updating
                    update_dirty();
                    // Orca: the variant switches (here, Process in the sidebar, ...) list one option per extruder.
                    if (m_extruders_count != old_extruders_count)
                        update_all_extruder_variants();
                    if (opt_key == "single_extruder_multi_material") { // the single_extruder_multimaterial was added to force pages
                        on_value_change(opt_key, value);                      // rebuild - let's make sure the on_value_change is not skipped
 
                        if (boost::any_cast<bool>(value) && m_extruders_count > 1) {
                            SuppressBackgroundProcessingUpdate sbpu;
 
// Orca: we use a different logic here. If SEMM is enabled, we set extruder count to 1.
#if 1
                            extruders_count_changed(1);
                            update_all_extruder_variants();
#else
 
                            std::vector<double> nozzle_diameters =
                                static_cast<const ConfigOptionFloats*>(m_config->option("nozzle_diameter"))->values;
                            const double frst_diam = nozzle_diameters[0];
 
                            for (auto cur_diam : nozzle_diameters) {
                                // if value is differs from first nozzle diameter value
                                if (fabs(cur_diam - frst_diam) > EPSILON) {
                                    const wxString msg_text = _(
                                        L("Single Extruder Multi Material is selected,\n"
                                          "and all extruders must have the same diameter.\n"
                                          "Do you want to change the diameter for all extruders to first extruder nozzle diameter value?"));
                                    MessageDialog dialog(parent(), msg_text, _(L("Nozzle diameter")), wxICON_WARNING | wxYES_NO);
 
                                    DynamicPrintConfig new_conf = *m_config;
                                    if (dialog.ShowModal() == wxID_YES) {
                                        for (size_t i = 1; i < nozzle_diameters.size(); i++)
                                            nozzle_diameters[i] = frst_diam;
 
                                        new_conf.set_key_value("nozzle_diameter", new ConfigOptionFloats(nozzle_diameters));
                                    } else
                                        new_conf.set_key_value("single_extruder_multi_material", new ConfigOptionBool(false));
 
                                    load_config(new_conf);
                                    break;
                                }
                            }
#endif
                        }
 
                        m_preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
                        // Upadte related comboboxes on Sidebar and Tabs
                        Sidebar& sidebar = wxGetApp().plater()->sidebar();
                        for (const Preset::Type& type : {Preset::TYPE_PRINT, Preset::TYPE_FILAMENT}) {
                            sidebar.update_presets(type);
                            wxGetApp().get_tab(type)->update_tab_ui();
                        }
                    }
                }
                else {
                    update_dirty();
                    on_value_change(opt_key, value);
                }
            });
        };
        optgroup->append_single_option_line("manual_filament_change", "printer_multimaterial_setup#manual-filament-change");
        optgroup->append_single_option_line("bed_temperature_formula", "printer_basic_information_advanced#bed-temperature-type");
 
        optgroup = page->new_optgroup(L("Wipe tower"), "param_tower");
        optgroup->append_single_option_line("wipe_tower_type", "printer_multimaterial_wipe_tower");
        optgroup->append_single_option_line("purge_in_prime_tower", "printer_multimaterial_wipe_tower#purge-in-prime-tower");
        optgroup->append_single_option_line("enable_filament_ramming", "printer_multimaterial_wipe_tower#enable-filament-ramming");
        optgroup->append_single_option_line("tool_change_on_wipe_tower", "printer_multimaterial_wipe_tower#tool-change-on-wipe-tower");
        optgroup->append_single_option_line("wait_for_temp_on_wipe_tower", "printer_multimaterial_wipe_tower#wait-for-temperature-on-wipe-tower");
 
        // Orca-Belt: belt printers replace the classic wipe tower with an
        // auto-generated purge prism; this is its enable (gated to belt printers
        // in toggle_options()).
        optgroup = page->new_optgroup(L("Belt purge tower"), "param_tower");
        optgroup->append_single_option_line("enable_belt_purge_tower", "printer_multimaterial_wipe_tower#belt-purge-tower");
 
 
        optgroup = page->new_optgroup(L("Single extruder multi-material parameters"), "param_settings");
        optgroup->append_single_option_line("cooling_tube_retraction", "printer_multimaterial_semm_parameters#cooling-tube-position");
        optgroup->append_single_option_line("cooling_tube_length", "printer_multimaterial_semm_parameters#cooling-tube-length");
        optgroup->append_single_option_line("parking_pos_retraction", "printer_multimaterial_semm_parameters#filament-parking-position");
        optgroup->append_single_option_line("extra_loading_move", "printer_multimaterial_semm_parameters#extra-loading-distance");
        optgroup->append_single_option_line("high_current_on_filament_swap", "printer_multimaterial_semm_parameters#high-extruder-current-on-filament-swap");
 
        optgroup = page->new_optgroup(L("Advanced"), L"param_advanced");
        optgroup->append_single_option_line("machine_load_filament_time", "printer_multimaterial_advanced#filament-load-time");
        optgroup->append_single_option_line("machine_unload_filament_time", "printer_multimaterial_advanced#filament-unload-time");
        optgroup->append_single_option_line("machine_tool_change_time", "printer_multimaterial_advanced#tool-change-time");
 
        // IDEX/IQEX (IMEX) parallel printing configuration
        optgroup = page->new_optgroup(L("IDEX/IQEX Configuration"), L"param_advanced");
        optgroup->append_single_option_line("is_imex", "printer_multimaterial_idex_iqex#idexiqex-printer");
        optgroup->append_single_option_line("imex_firmware_managed_zones", "printer_multimaterial_idex_iqex#firmware-managed-zones");
        optgroup->append_single_option_line("imex_gantry_count", "printer_multimaterial_idex_iqex#gantry-count");
        optgroup->append_single_option_line("imex_tools_per_gantry", "printer_multimaterial_idex_iqex#tools-per-gantry");
        optgroup->append_single_option_line("imex_tool_layout", "printer_multimaterial_idex_iqex#tool-0-position");
        optgroup->append_single_option_line("imex_nozzle_clearance_x", "printer_multimaterial_idex_iqex#nozzle-clearance-x");
        optgroup->append_single_option_line("imex_nozzle_clearance_y", "printer_multimaterial_idex_iqex#nozzle-clearance-y");
        optgroup->append_single_option_line("imex_carriage_margin", "printer_multimaterial_idex_iqex#safety-margin");
        {
            // Toggle for pre-slice IMEX safety warnings (stored in app_config, not printer profile).
            // We avoid full_width=1 here because that path uses different sizer math from the
            // rest of the optgroup — it left-pads with 15px instead of aligning to the label
            // column, which made this row look out-of-place vs. the option lines above. Instead
            // we register a placeholder Option so option_set.front() (the empty-vector access
            // that crashes Windows release builds) is satisfied, and let the standard line path
            // render the label + custom widget with the same column geometry as everything else.
            // No Field is built for the placeholder because line.widget != nullptr causes
            // activate_line to return early before build_field.
            ConfigOptionDef placeholder_def;
            placeholder_def.label   = L("Pre-slice warnings");
            placeholder_def.mode    = comAdvanced;
            placeholder_def.tooltip = L("Show a warning dialog before slicing if IDEX/IQEX parallel mode "
                                        "concerns are detected (bed temperature conflicts, filament type "
                                        "mismatches, multi-material conflicts). Can be suppressed from the "
                                        "dialog itself. Re-enable here if suppressed accidentally.");
            auto line = Line{ placeholder_def.label, placeholder_def.tooltip };
            line.label_path = "printer_multimaterial_idex_iqex#pre-slice-warnings";
            line.append_option(Option{ placeholder_def, "imex_pre_slice_warnings" });
            line.widget = [](wxWindow* parent) -> wxSizer* {
                auto* cb = new ::CheckBox(parent);
                const bool enabled = wxGetApp().app_config->get("imex_pre_slice_warnings") != "false";
                cb->SetValue(enabled);
                cb->Bind(wxEVT_TOGGLEBUTTON, [cb](wxCommandEvent& e) {
                    wxGetApp().app_config->set("imex_pre_slice_warnings", cb->GetValue() ? "true" : "false");
                    e.Skip(); // CheckBox's own handler redraws the tick
                });
                auto* s = new wxBoxSizer(wxHORIZONTAL);
                s->Add(cb, 0, wxALIGN_CENTER_VERTICAL);
                return s;
            };
            optgroup->append_line(line);
        }
        optgroup->append_single_option_line("imex_viz_theme", "printer_multimaterial_idex_iqex#visualization-theme");
        {
            // In the configuration group rather than a group of its own: a full-width widget line
            // records no mode, so a group holding only this line would show in every mode.
            auto line = Line{ L("Modes"), "" };
            line.full_width = 1;
            line.widget = [this](wxWindow* parent) -> wxSizer* {
                int n_cols = 0, n_rows = 0, layout = 0;
                imex_grid_shape(m_config, n_cols, n_rows, layout);
                m_imex_modes_ctrl = new IMEXModesCtrl(parent, n_cols, n_rows, layout);
                // Lazy lookup pointing at the *saved* state of the currently-selected
                // preset (not the parent). Per-row reset means "discard in-session
                // edits to this row" — matches the page-level reset semantic and works
                // on any preset, including ones whose parent has no IMEX modes at all.
                m_imex_modes_ctrl->set_parent_config_lookup([this]() -> const DynamicPrintConfig* {
                    return m_presets ? &m_presets->get_selected_preset().config : nullptr;
                });
                m_imex_modes_ctrl->load_from_config(*m_config);
                m_imex_modes_ctrl->on_change = [this]() {
                    auto [names, tools, gcodes] = m_imex_modes_ctrl->get_mode_data();
                    m_config->set_key_value("imex_mode_names",        new ConfigOptionStrings(names));
                    m_config->set_key_value("imex_mode_active_tools", new ConfigOptionStrings(tools));
                    m_config->set_key_value("imex_mode_gcodes",       new ConfigOptionStrings(gcodes));
                    update_dirty();
                    on_value_change("imex_mode_names", std::string(""));
                };
                // A plate stores its IMEX mode as the mode's *name*, resolved against this
                // table at slice time, so deleting a row strands every plate that was using
                // it. Those plates print as Primary either way -- GCode.cpp falls back when
                // the name resolves to no row -- but until they are reset they keep claiming
                // a mode that no longer exists: the plate button still shows the old label,
                // the mode is written back out to the 3MF, and re-adding a different mode at
                // the same position would not revive it. Resetting them here is what makes
                // "deleting a mode resets the plates using it to Primary" true.
                //
                // Deletion only. Renaming is deliberately not funnelled through here: the
                // name field notifies on every keystroke, so an in-progress rename would
                // orphan and reset the plate on the first character typed.
                //
                // Because of that, a row can be renamed and only then deleted, and the plate
                // is still holding the name it was set from. The control therefore reports
                // every name the deleted row was known by -- its build-time name and its name
                // at delete time -- already filtered of anything a surviving row still
                // carries, so matching any of them is safe.
                m_imex_modes_ctrl->on_mode_removed = [](const std::vector<std::string>& removed_modes) {
                    Plater* plater = wxGetApp().plater();
                    if (!plater || removed_modes.empty())
                        return;
                    PartPlateList&          plates = plater->get_partplate_list();
                    std::vector<PartPlate*> affected;
                    for (int i = 0; i < plates.get_plate_count(); ++i) {
                        PartPlate* plate = plates.get_plate(i);
                        if (!plate)
                            continue;
                        const std::string mode = plate->get_imex_mode();
                        if (mode.empty() || mode == kImexPrimaryMode)
                            continue;
                        if (std::find(removed_modes.begin(), removed_modes.end(), mode) != removed_modes.end())
                            affected.push_back(plate);
                    }
                    if (affected.empty())
                        return;
                    // One snapshot for the whole batch, so a single undo restores every plate.
                    // Same sequence the plate's own mode button runs (Plater::select_plate_by_hover_id,
                    // PLATE_IMEX_MODE_ID) -- reset_imex_mode() already invalidates each plate's
                    // slice result and its zone / ghost caches.
                    plater->take_snapshot("reset imex mode");
                    for (PartPlate* plate : affected)
                        plate->reset_imex_mode();
                    plater->update_project_dirty_from_presets();
                    plater->set_plater_dirty(true);
                    plater->update();
                };
                auto* sizer = new wxBoxSizer(wxHORIZONTAL);
                // Align the left edge with the option-line labels above. A full-width line's
                // widget is inset by 15 (OptionsGroup::activate_line), while an ordinary line's
                // custom control is inset by 10 and then paints its label further in again, so
                // the two do not line up without this. One number, tuned against the settings
                // page. Unscaled on purpose: the 15 and 10 it compensates for are raw pixels too,
                // so a DIP-scaled correction here would drift apart from them on a HiDPI display.
                sizer->Add(m_imex_modes_ctrl, 1, wxEXPAND | wxLEFT, 8);
                return sizer;
            };
            optgroup->append_line(line);
        }
 
        m_pages.insert(m_pages.end() - n_after_single_extruder_MM, page);
    }
 
    // Orca: a single "Extruder" page serves all extruders. Its controls are created once for extruder 0;
    // switch_excluder() re-targets them to the extruder selected on the variant switch (m_extruder_switch),
    // which the printer tab shows on this page too.
    if (extruder_page() == nullptr && m_extruders_count > 0) {
        const size_t extruder_idx = 0;
        auto page = add_options_page(L("Extruder"), "custom-gcode_extruder", true); // ORCA: icon only visible on placeholders
        m_pages.insert(m_pages.begin() + n_before_extruders, page);
 
        auto optgroup = page->new_optgroup(L("Basic information"), L"param_information", -1, true);
            optgroup->append_single_option_line("nozzle_diameter", "printer_extruder_basic_information#nozzle-diameter", extruder_idx);
            optgroup->append_single_option_line("nozzle_type", "printer_basic_information_accessory#nozzle-type", extruder_idx);
            //optgroup->append_single_option_line("nozzle_volume_type", "", extruder_idx);
 
            optgroup->append_single_option_line("nozzle_volume", "printer_extruder_basic_information#nozzle-volume", extruder_idx);
            optgroup->append_single_option_line("extruder_printable_height", "printer_extruder_basic_information#extruder-layer-height-limits", extruder_idx);
            Option option         = optgroup->get_option("extruder_printable_area", extruder_idx);
            option.opt.full_width = true;
            optgroup->append_single_option_line(option, "printer_extruder_basic_information#extruder-printable-area");
 
            Option exclusion_option = optgroup->get_option("extruder_bed_exclude_volumes", extruder_idx);
            exclusion_option.opt.full_width = true;
            optgroup->append_single_option_line(exclusion_option, "printer_basic_information_printable_space#toolhead-collision-volumes");
 
            optgroup->m_on_change = [this](const t_config_option_key& opt_key, boost::any value)
            {
                // The page edits the extruder selected on the variant switch.
                const size_t extruder_idx = size_t(get_current_active_extruder());
                bool is_SEMM = m_config->opt_bool("single_extruder_multi_material");
                bool independent_nozzles = m_preset_bundle && m_preset_bundle->is_bbl_vendor() && m_extruders_count > 1;
                if (is_SEMM && m_extruders_count > 1 && !independent_nozzles && boost::starts_with(opt_key, "nozzle_diameter"))
                {
                    SuppressBackgroundProcessingUpdate sbpu;
                    const double new_nd = boost::any_cast<double>(value);
                    std::vector<double> nozzle_diameters = static_cast<const ConfigOptionFloats*>(m_config->option("nozzle_diameter"))->values;
 
                    // if value was changed
                    if (fabs(nozzle_diameters[extruder_idx == 0 ? 1 : 0] - new_nd) > EPSILON)
                    {
                        const wxString msg_text = _(L("This is a single extruder multi-material printer, diameters of all extruders "
                            "will be set to the new value. Do you want to proceed?"));
                        //wxMessageDialog dialog(parent(), msg_text, _(L("Nozzle diameter")), wxICON_WARNING | wxYES_NO);
                        MessageDialog dialog(parent(), msg_text, _(L("Nozzle diameter")), wxICON_WARNING | wxYES_NO);
 
                        DynamicPrintConfig new_conf = *m_config;
                        if (dialog.ShowModal() == wxID_YES) {
                            for (size_t i = 0; i < nozzle_diameters.size(); i++) {
                                if (i == extruder_idx)
                                    continue;
                                nozzle_diameters[i] = new_nd;
                            }
                        }
                        else
                            nozzle_diameters[extruder_idx] = nozzle_diameters[extruder_idx == 0 ? 1 : 0];
 
                        new_conf.set_key_value("nozzle_diameter", new ConfigOptionFloats(nozzle_diameters));
                        load_config(new_conf);
                    }
                }
 
                update_dirty();
                on_value_change(opt_key, value);
                update();
            };
 
            optgroup = page->new_optgroup(L("Layer height limits"), L"param_layer_height");
            optgroup->append_single_option_line("min_layer_height", "printer_extruder_basic_information#extruder-layer-height-limits", extruder_idx);
            optgroup->append_single_option_line("max_layer_height", "printer_extruder_basic_information#extruder-layer-height-limits", extruder_idx);
 
            optgroup = page->new_optgroup(L("Position"), L"param_position");
            optgroup->append_single_option_line("extruder_offset", "printer_extruder_basic_information#extruder-offset-position", extruder_idx);
 
            //BBS: don't show retract related config menu in machine page
            // These optgroups are built from publishable_printer_retraction/z_hop_options() so the
            // published-3MF printer allowlist (their union in libslic3r/PublishSettings.hpp) can
            // never drift from what the machine page actually shows.
            optgroup = page->new_optgroup(L("Retraction"), L"param_retraction");
            for (const PublishablePrinterOption& opt : publishable_printer_retraction_options())
                optgroup->append_single_option_line(opt.key, opt.icon, extruder_idx);
 
            optgroup = page->new_optgroup(L("Z-Hop"), L"param_extruder_lift_enforcement");
            for (const PublishablePrinterOption& opt : publishable_printer_z_hop_options())
                optgroup->append_single_option_line(opt.key, opt.icon, extruder_idx);
 
            optgroup = page->new_optgroup(L("Retraction when switching material"), L"param_retraction_material_change");
            optgroup->append_single_option_line("retract_length_toolchange", "printer_extruder_retraction#retraction-when-switching-materials", extruder_idx);
            optgroup->append_single_option_line("retract_restart_extra_toolchange", "printer_extruder_retraction#retraction-when-switching-materials", extruder_idx);
            // do not display this params now
            optgroup->append_single_option_line("long_retractions_when_cut", "printer_extruder_retraction#long-retraction-when-cut-beta", extruder_idx);
            optgroup->append_single_option_line("retraction_distances_when_cut", "printer_extruder_retraction#long-retraction-when-cut-beta", extruder_idx);
#if 0
            //optgroup = page->new_optgroup(L("Preview"), -1, true);
 
            //auto reset_to_filament_color = [this, extruder_idx](wxWindow* parent) {
            //    m_reset_to_filament_color = new ScalableButton(parent, wxID_ANY, "undo", _L("Reset to Filament Color"),
            //                                                   wxDefaultSize, wxDefaultPosition, wxBU_LEFT | wxBU_EXACTFIT, true);
            //    ScalableButton* btn = m_reset_to_filament_color;
            //    btn->SetFont(Slic3r::GUI::wxGetApp().normal_font());
            //    btn->SetSize(btn->GetBestSize());
            //    auto sizer = new wxBoxSizer(wxHORIZONTAL);
            //    sizer->Add(btn);
 
            //    btn->Bind(wxEVT_BUTTON, [this, extruder_idx](wxCommandEvent& e)
            //    {
            //        std::vector<std::string> colors = static_cast<const ConfigOptionStrings*>(m_config->option("extruder_colour"))->values;
            //        colors[extruder_idx] = "";
 
            //        DynamicPrintConfig new_conf = *m_config;
            //        new_conf.set_key_value("extruder_colour", new ConfigOptionStrings(colors));
            //        load_config(new_conf);
 
            //        update_dirty();
            //        update();
            //    });
 
            //    return sizer;
            //};
            //Line line = optgroup->create_single_option_line("extruder_colour", "", extruder_idx);
            //line.append_widget(reset_to_filament_color);
            //optgroup->append_line(line);
#endif
    }
 
    // The page holds only the "#0" controls, so register every extruder's options with the search
    // index under "Extruder N"; a search hit selects that extruder (TabPrinter::activate_option()).
    if (Page *page = extruder_page()) {
        auto &index = wxGetApp().sidebar().settings_index();
        for (auto &group : page->m_optgroups) {
            group->set_config_category_and_type(page->title(), m_type);
            for (auto &opt : group->opt_map()) {
                if (opt.second.second < 0)
                    continue;
                for (size_t i = 0; i < m_extruders_count; ++i) {
                    const wxString category = m_extruders_count > 1 ? wxString::Format("Extruder %d", int(i + 1)) : wxString("Extruder");
                    index.add_key(opt.second.first + "#" + std::to_string(i), m_type, group->title, category, group->icon);
                }
            }
        }
    }
 
    Thaw();
 
    m_extruders_count_old = m_extruders_count;
 
    if (from_initial_build && m_printer_technology == ptSLA)
        return; // next part of code is no needed to execute at this moment
 
    rebuild_page_tree();
 
    // Reload preset pages with current configuration values
    reload_config();
 
    // apply searcher with current configuration
    apply_searcher();
}

References _, Slic3r::GUI::Tab::add_options_page(), Slic3r::GUI::Tab::apply_searcher(), build_kinematics_page(), build_unregular_pages(), Slic3r::coInt, Slic3r::comAdvanced, EPSILON, extruder_page(), extruders_count_changed(), Slic3r::ConfigOptionDef::full_width, Slic3r::GUI::Line::full_width, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepetier, Slic3r::gcfRepRapFirmware, Slic3r::GUI::Tab::get_current_active_extruder(), Slic3r::GUI::PartPlate::get_imex_mode(), Slic3r::GUI::PartPlateList::get_plate(), Slic3r::GUI::PartPlateList::get_plate_count(), Slic3r::GUI::imex_grid_shape(), init_options_list(), Slic3r::kImexPrimaryMode, L, Slic3r::ConfigOptionDef::label, Slic3r::GUI::Line::label_path, Slic3r::load_config(), Slic3r::GUI::Tab::m_config, m_extruders_count, m_extruders_count_old, m_imex_modes_ctrl, Slic3r::GUI::Tab::m_pages, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_presets, m_printer_technology, Slic3r::GUI::Tab::m_type, Slic3r::ConfigOptionDef::max, MAXIMUM_EXTRUDER_NUMBER, Slic3r::ConfigOptionDef::min, Slic3r::ConfigOptionDef::mode, Slic3r::Never, on_value_change(), Slic3r::GUI::Option::opt, Slic3r::GUI::Tab::parent(), Slic3r::GUI::plater(), Slic3r::ptSLA, Slic3r::publishable_printer_retraction_options(), Slic3r::publishable_printer_z_hop_options(), Slic3r::GUI::Tab::rebuild_page_tree(), reload_config(), Slic3r::ConfigOptionDef::set_default_value(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::Tab::title(), Slic3r::ConfigOptionDef::tooltip, Slic3r::ConfigOptionDef::type, Slic3r::GUI::Tab::type(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, update(), Slic3r::GUI::update_all_extruder_variants(), Slic3r::GUI::Tab::update_dirty(), and Slic3r::GUI::Sidebar::update_presets().

Referenced by build_fff(), build_unregular_pages(), and extruders_count_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

cache_config_diff()

void Slic3r::GUI::Tab::cache_config_diff ( const std::vector< std::string > & selected_options, const DynamicPrintConfig * config = nullptr )

inherited

{
    m_cache_options = selected_options;
    m_cache_config.apply_only(config ? *config : m_presets->get_edited_preset().config, selected_options);
}

References cache_config_diff(), m_cache_config, m_cache_options, and m_presets.

Referenced by cache_config_diff(), Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes(), may_discard_current_dirty_preset(), and transfer_options().

Here is the call graph for this function:

Here is the caller graph for this function:

cache_extruder_cnt()

void Slic3r::GUI::TabPrinter::cache_extruder_cnt

(

const DynamicPrintConfig *

config = nullptr

)

{
    const DynamicPrintConfig& cached_config = config ? *config : m_presets->get_edited_preset().config;
    if (Preset::printer_technology(cached_config) == ptSLA)
        return;
 
    // get extruders count
    auto* nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(cached_config.option("nozzle_diameter"));
    m_cache_extruder_count = nozzle_diameter->values.size(); //m_extruders_count;
}

References cache_extruder_cnt(), m_cache_extruder_count, Slic3r::GUI::Tab::m_presets, Slic3r::nozzle_diameter(), Slic3r::ConfigBase::option(), Slic3r::Preset::printer_technology(), and Slic3r::ptSLA.

Referenced by cache_extruder_cnt().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_selection_index_for_extruder()

int Slic3r::GUI::Tab::calculate_selection_index_for_extruder ( int extruder_id, NozzleVolumeType nozzle_type )

inherited

{
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    int  extruder_nums  = m_preset_bundle->get_printer_extruder_count();
 
    int index = 0;
 
    for (int i = 0; i < extruder_nums; ++i) {
        if (i == extruder_id) {
            NozzleVolumeType volume_type = NozzleVolumeType(nozzle_volumes->values[i]);
            if (volume_type == NozzleVolumeType::nvtHybrid) {
                return nozzle_type == NozzleVolumeType::nvtHighFlow ? index + 1 : index;
            } else {
                return index;
            }
        }
 
        NozzleVolumeType volume_type = NozzleVolumeType(nozzle_volumes->values[i]);
        index += (volume_type == NozzleVolumeType::nvtHybrid) ? 2 : 1;
    }
 
    return 0;
}

References m_preset_bundle, Slic3r::nozzle_type(), Slic3r::nvtHighFlow, and Slic3r::nvtHybrid.

Referenced by Slic3r::GUI::TabPrinter::activate_option(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

check_extruder_options_status()

void Slic3r::GUI::Tab::check_extruder_options_status ( int index, bool & sys_extruder, bool & modified_extruder, const std::vector< PageShp > & pages_to_check )

inherited

{
    int config_index = index;
    int extruder_id  = index;
    if (m_type == Preset::TYPE_PRINT || m_type == Preset::TYPE_PRINTER || m_type == Preset::TYPE_MODEL) {
        NozzleVolumeType nozzle_type;
        parse_extruder_selection(index, extruder_id, nozzle_type);
 
        auto extruders = m_preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnumsGeneric>("extruder_type");
        auto variant_keys = extruder_variant_keys[m_type >= Preset::TYPE_COUNT ? Preset::TYPE_PRINT : m_type];
        config_index = m_config->get_index_for_extruder(
            extruder_id + 1,
            variant_keys.first,
            ExtruderType(extruders->values[extruder_id]),
            nozzle_type,
            variant_keys.second
        );
    }
 
    for (auto page : pages_to_check) {
        /*if (page->title() != "Speed" && page->title() != "Motion ability" && page->title() != "Filament" && page->title() != "Setting Overrides" && page->title() != "Multimaterial") {
            continue;
        }*/
        for (auto group : page->m_optgroups) {
            for (const auto &kvp : group->opt_map()) {
                std::string base_opt_key = kvp.second.first;
                // For filament tab, common options will not change color when edited
                if (m_type == Preset::TYPE_FILAMENT && kvp.second.second == -1) {
                    continue;
                }
 
                unsigned int stride = 1;
                if (printer_options_with_variant_2.count(base_opt_key) > 0) {
                    stride = 2;
                }
 
                std::string target_opt_key = base_opt_key + "#" + std::to_string(config_index * stride);
                // Orca: on the printer's Extruder page only per-variant options use the variant column,
                // the others (nozzle_diameter, extruder_offset, ...) are indexed by the extruder.
                if (is_printer_extruder_page(page.get()) && printer_options_with_variant_1.count(base_opt_key) == 0)
                    target_opt_key = base_opt_key + "#" + std::to_string(extruder_id);
 
                auto status_iter = m_all_extruder_options_status.find(target_opt_key);
                if (status_iter != m_all_extruder_options_status.end()) {
                    bool found_modified_for_this_config = false;
                    const bool deep_compare = (m_type == Preset::TYPE_PRINTER || m_type == Preset::TYPE_PRINT || m_type == Preset::TYPE_FILAMENT || m_type == Preset::TYPE_SLA_MATERIAL ||
                                   m_type == Preset::TYPE_MODEL);
                    auto original_dirty_options = m_presets->current_dirty_options(deep_compare);
                    for (const std::string &orig_opt : original_dirty_options) {
                        if (orig_opt == target_opt_key) {
                            found_modified_for_this_config = true;
                            break;
                        }
                    }
 
                    if (found_modified_for_this_config) {
                        sys_extruder = (status_iter->second & osSystemValue) != 0;
                        modified_extruder |= (status_iter->second & osInitValue) == 0;
 
                        if (!sys_extruder && modified_extruder) { return; }
                    }
                }
            }
        }
    }
}

References check_extruder_options_status(), Slic3r::GUI::extruder_variant_keys, is_printer_extruder_page(), m_all_extruder_options_status, m_config, m_preset_bundle, m_presets, m_type, Slic3r::nozzle_type(), osInitValue, osSystemValue, parse_extruder_selection(), Slic3r::printer_options_with_variant_1, Slic3r::printer_options_with_variant_2, Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_MODEL, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::GUI::variant_keys().

Referenced by check_extruder_options_status(), update_changed_tree_ui(), and update_extruder_switch_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_pages()

void Slic3r::GUI::TabPrinter::clear_pages ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::clear_pages();
    m_reset_to_filament_color = nullptr;
    m_imex_modes_ctrl   = nullptr;
}

References Slic3r::GUI::Tab::clear_pages(), clear_pages(), m_imex_modes_ctrl, and m_reset_to_filament_color.

Referenced by clear_pages(), and update_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

commit_preset_config_value()

bool Slic3r::GUI::Tab::commit_preset_config_value ( const std::string & opt_key )

protectedinherited

{
    if (Page* field_page = nullptr; Field* field = get_field(opt_key, &field_page)) {
        field_page->reload_config();
        field->field_changed();
        return true;
    }
    for (const PageShp& page : m_pages)
        for (const ConfigOptionsGroupShp& group : page->m_optgroups)
            if (group->commit_config_value(opt_key))
                return true;
    return false;
}

References commit_preset_config_value(), Slic3r::GUI::Field::field_changed(), get_field(), and m_pages.

Referenced by apply_preset_config_values(), and commit_preset_config_value().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_preset()

void Slic3r::GUI::Tab::compare_preset ( )

inherited

{
    DiffPresetDialog::ensure()->show(m_type);
}

References compare_preset(), Slic3r::GUI::LazyInstance< DiffPresetDialog >::ensure(), and m_type.

Referenced by compare_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

compatible_widget_create()

wxSizer * Slic3r::GUI::Tab::compatible_widget_create ( wxWindow * parent, PresetDependencies & deps )

protectedinherited

{
    deps.checkbox = new ::CheckBox(parent, wxID_ANY);
    wxGetApp().UpdateDarkUI(deps.checkbox, false, true);
 
    deps.checkbox_title = new wxStaticText(parent, wxID_ANY, _L("All"));
    deps.checkbox_title->SetFont(Label::Body_14);
    deps.checkbox_title->SetForegroundColour(wxColour("#363636"));
    wxGetApp().UpdateDarkUI(deps.checkbox_title, false, true);
 
    // ORCA modernize button style
    Button* btn = new Button(parent, _(L("Set")) + " " + dots);
    btn->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
    deps.btn = btn;
 
    auto sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add((deps.checkbox), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add((deps.checkbox_title), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(new wxStaticText(parent, wxID_ANY, "  ")); // weirdly didnt apply AddSpacer or wxRIGHT border
    sizer->Add((deps.btn), 0, wxALIGN_CENTER_VERTICAL);
 
    auto on_toggle = [this, &deps](const bool &state){
        deps.checkbox->SetValue(state);
        deps.btn->Enable(!state);
        // All printers have been made compatible with this preset.
        if (state)
            this->load_key_value(deps.key_list, std::vector<std::string> {});
        this->get_field(deps.key_condition)->toggle(state);
        this->update_changed_ui();
    };
 
    deps.checkbox_title->Bind(wxEVT_LEFT_DOWN,([&deps, on_toggle](wxMouseEvent& e) {
        if (e.GetEventType() == wxEVT_LEFT_DCLICK) return;
        on_toggle(!deps.checkbox->GetValue());
        e.Skip();
    }));
 
    deps.checkbox_title->Bind(wxEVT_LEFT_DCLICK,([&deps, on_toggle](wxMouseEvent& e) {
        on_toggle(!deps.checkbox->GetValue());
        e.Skip();
    }));
 
    deps.checkbox->Bind(wxEVT_TOGGLEBUTTON, ([on_toggle](wxCommandEvent& e) {
        on_toggle(e.IsChecked());
        e.Skip();
    }), deps.checkbox->GetId());
 
    if (deps.checkbox){
        bool is_empty = m_config->option<ConfigOptionStrings>(deps.key_list)->values.empty();
        deps.checkbox->SetValue(is_empty);
        deps.btn->Enable(!is_empty);
    }
 
    /*
    if (m_compatible_printers.checkbox) {
        bool is_empty = m_config->option<ConfigOptionStrings>("compatible_printers")->values.empty();
        m_compatible_printers.checkbox->SetValue(is_empty);
        is_empty ? m_compatible_printers.btn->Disable() : m_compatible_printers.btn->Enable();
    }
 
    if (m_compatible_prints.checkbox) {
        bool is_empty = m_config->option<ConfigOptionStrings>("compatible_prints")->values.empty();
        m_compatible_prints.checkbox->SetValue(is_empty);
        is_empty ? m_compatible_prints.btn->Disable() : m_compatible_prints.btn->Enable();
    }
    */
 
    deps.btn->Bind(wxEVT_BUTTON, ([this, parent, &deps](wxCommandEvent& e)
    {
        // Collect names of non-default non-external profiles.
        PrinterTechnology printer_technology = m_preset_bundle->printers.get_edited_preset().printer_technology();
        PresetCollection &depending_presets  = (deps.type == Preset::TYPE_PRINTER) ? m_preset_bundle->printers :
                (printer_technology == ptFFF) ? m_preset_bundle->prints : m_preset_bundle->sla_prints;
        wxArrayString presets;
        for (size_t idx = 0; idx < depending_presets.size(); ++ idx)
        {
            Preset& preset = depending_presets.preset(idx);
            //BBS: add project embedded preset logic and refine is_external
            bool add = ! preset.is_default;
            //bool add = ! preset.is_default && ! preset.is_external;
            if (add && deps.type == Preset::TYPE_PRINTER)
                // Only add printers with the same technology as the active printer.
                add &= preset.printer_technology() == printer_technology;
            if (add)
                presets.Add(from_u8(preset.name));
        }
 
        if(deps.type == Preset::TYPE_PRINTER){
            deps.dialog_title = _L("Compatible printers");
            deps.dialog_label = _L("Select printers");
        }else{
            deps.dialog_title = _L("Compatible process profiles");
            deps.dialog_label = _L("Select profiles");
        }
 
        MultiChoiceDialog dlg(parent, deps.dialog_label, deps.dialog_title, presets);
        wxGetApp().UpdateDlgDarkUI(&dlg);
        // Collect and set indices of depending_presets marked as compatible.
        wxArrayInt selections;
        auto *compatible_printers = dynamic_cast<const ConfigOptionStrings*>(m_config->option(deps.key_list));
        if (compatible_printers != nullptr && !compatible_printers->values.empty())
            for (auto preset_name : compatible_printers->values)
                for (size_t idx = 0; idx < presets.GetCount(); ++idx)
                    if (presets[idx] == from_u8(preset_name)) {
                        selections.Add(idx);
                        break;
                    }
        dlg.SetSelections(selections);
        dlg.SetSize(FromDIP(wxSize(360, 480)));
        std::vector<std::string> value;
        // Show the dialog.
        if (dlg.ShowModal() == wxID_OK) {
            selections.Clear();
            selections = dlg.GetSelections();
            // leave list empty if all items checked. this will check "All" checkbox automatically. also fixes unnecessary config change
            if(selections.GetCount() != presets.GetCount())
                for (auto idx : selections)
                    value.push_back(presets[idx].ToUTF8().data());
            if (value.empty()) {
                deps.checkbox->SetValue(1);
                deps.btn->Disable();
            }
            // All depending_presets have been made compatible with this preset.
            this->load_key_value(deps.key_list, value);
            this->update_changed_ui();
        }
    }));
 
    return sizer;
}

References _, _L, Label::Body_14, Slic3r::GUI::Tab::PresetDependencies::btn, Slic3r::GUI::Tab::PresetDependencies::checkbox, Slic3r::GUI::Tab::PresetDependencies::checkbox_title, compatible_widget_create(), Slic3r::GUI::Tab::PresetDependencies::dialog_label, Slic3r::GUI::Tab::PresetDependencies::dialog_title, Slic3r::GUI::dots(), Slic3r::ConfigOptionVector< T >::empty(), Button::Enable(), Slic3r::from_u8(), get_field(), Slic3r::GUI::MultiChoiceDialog::GetSelections(), Slic3r::Preset::is_default, Slic3r::GUI::Tab::PresetDependencies::key_condition, Slic3r::GUI::Tab::PresetDependencies::key_list, L, load_key_value(), m_config, m_preset_bundle, Slic3r::Preset::name, Parameter, parent(), Slic3r::PresetCollection::preset(), Slic3r::GUI::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Regular, Slic3r::GUI::MultiChoiceDialog::SetSelections(), Button::SetStyle(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::PresetCollection::size(), Slic3r::GUI::Tab::PresetDependencies::type, Slic3r::Preset::TYPE_PRINTER, update_changed_ui(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Referenced by compatible_widget_create().

Here is the call graph for this function:

Here is the caller graph for this function:

compatible_widget_reload()

void Slic3r::GUI::Tab::compatible_widget_reload ( PresetDependencies & deps )

protectedinherited

{
    Field* field = this->get_field(deps.key_condition);
    if (!field)
        return;
 
    bool has_any = ! m_config->option<ConfigOptionStrings>(deps.key_list)->values.empty();
    has_any ? deps.btn->Enable() : deps.btn->Disable();
    deps.checkbox->SetValue(! has_any);
 
    field->toggle(! has_any);
}

References Slic3r::GUI::Tab::PresetDependencies::btn, Slic3r::GUI::Tab::PresetDependencies::checkbox, compatible_widget_reload(), Slic3r::ConfigOptionVector< T >::empty(), Button::Enable(), get_field(), Slic3r::GUI::Tab::PresetDependencies::key_condition, Slic3r::GUI::Tab::PresetDependencies::key_list, m_config, and Slic3r::GUI::Field::toggle().

Referenced by compatible_widget_reload(), on_value_change(), Slic3r::GUI::TabFilament::reload_config(), Slic3r::GUI::TabPrint::reload_config(), Slic3r::GUI::TabSLAMaterial::reload_config(), and Slic3r::GUI::TabSLAPrint::reload_config().

Here is the call graph for this function:

Here is the caller graph for this function:

completed()

bool Slic3r::GUI::Tab::completed ( ) const

inlineinherited

{ return m_completed; }

References m_completed.

create_bed_shape_widget()

wxSizer * Slic3r::GUI::TabPrinter::create_bed_shape_widget

(

wxWindow *

parent

)

{
    // ORCA modernize button style
    Button* btn = new Button(parent, _(L("Set")) + " " + dots);
    btn->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
 
    auto sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(btn, 0, wxALIGN_CENTER_VERTICAL);
 
    btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent& e) {
            bool  is_configed_by_BBL = PresetUtils::system_printer_bed_model(m_preset_bundle->printers.get_edited_preset()).size() > 0;
            BedShapeDialog dlg(this);
            dlg.build_dialog(m_config->option<ConfigOptionPoints>("printable_area")->values,
                *m_config->option<ConfigOptionString>("bed_custom_texture"),
                *m_config->option<ConfigOptionString>("bed_custom_model"));
            if (dlg.ShowModal() == wxID_OK) {
                const std::vector<Vec2d>& shape = dlg.get_shape();
                const std::string& custom_texture = dlg.get_custom_texture();
                const std::string& custom_model = dlg.get_custom_model();
                if (!shape.empty())
                {
                    load_key_value("printable_area", shape);
                    load_key_value("bed_custom_texture", custom_texture);
                    load_key_value("bed_custom_model", custom_model);
                    update_changed_ui();
                }
            on_presets_changed();
 
            }
        }));
 
    {
        Search::SettingsIndex& index = wxGetApp().sidebar().settings_index();
        const Search::GroupAndCategory& gc = index.get_group_and_category("printable_area");
        index.add_key("bed_custom_texture", m_type, gc.group, gc.category, gc.icon);
        index.add_key("bed_custom_model", m_type, gc.group, gc.category, gc.icon);
    }
 
    return sizer;
}

References _, Slic3r::Search::SettingsIndex::add_key(), Slic3r::GUI::BedShapeDialog::build_dialog(), Slic3r::Search::GroupAndCategory::category, create_bed_shape_widget(), Slic3r::GUI::dots(), Slic3r::GUI::BedShapeDialog::get_custom_model(), Slic3r::GUI::BedShapeDialog::get_custom_texture(), Slic3r::Search::SettingsIndex::get_group_and_category(), Slic3r::GUI::BedShapeDialog::get_shape(), Slic3r::Search::GroupAndCategory::group, Slic3r::Search::GroupAndCategory::icon, L, Slic3r::GUI::Tab::load_key_value(), Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_type, Slic3r::GUI::Tab::on_presets_changed(), Parameter, Slic3r::GUI::Tab::parent(), Regular, Button::SetStyle(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::PresetUtils::system_printer_bed_model(), Slic3r::GUI::Tab::update_changed_ui(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by create_bed_shape_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

create_line_with_widget()

void Slic3r::GUI::Tab::create_line_with_widget ( ConfigOptionsGroup * optgroup, const std::string & opt_key, const std::string & path, widget_t widget )

protectedinherited

{
    Line line = optgroup->create_single_option_line(opt_key);
    line.widget = widget;
    line.label_path = path;
 
    // set default undo ui
    line.set_undo_bitmap(&m_bmp_white_bullet);
    line.set_undo_to_sys_bitmap(&m_bmp_white_bullet);
    line.set_undo_tooltip(&m_tt_white_bullet);
    line.set_undo_to_sys_tooltip(&m_tt_white_bullet);
    line.set_label_colour(&m_default_text_clr);
 
    optgroup->append_line(line);
}

References Slic3r::GUI::OptionsGroup::append_line(), create_line_with_widget(), Slic3r::GUI::ConfigOptionsGroup::create_single_option_line(), Slic3r::GUI::Line::label_path, m_bmp_white_bullet, m_default_text_clr, m_tt_white_bullet, Slic3r::GUI::UndoValueUIManager::set_label_colour(), Slic3r::GUI::UndoValueUIManager::set_undo_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_tooltip(), Slic3r::GUI::UndoValueUIManager::set_undo_tooltip(), and Slic3r::GUI::Line::widget.

Referenced by Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrinter::build_fff(), and create_line_with_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

create_preset_tab()

void Slic3r::GUI::Tab::create_preset_tab ( )

inherited

{
//move to ParamsPanel
/*#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__*/
    auto panel = this;
 
    m_preset_bundle = wxGetApp().preset_bundle;
 
    // Vertical sizer to hold the choice menu and the rest of the page.
/*#ifdef __WXOSX__
    auto  *main_sizer = new wxBoxSizer(wxVERTICAL);
    main_sizer->SetSizeHints(this);
    this->SetSizer(main_sizer);
 
    // Create additional panel to Fit() it from OnActivate()
    // It's needed for tooltip showing on OSX
    m_tmp_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL);
    auto panel = m_tmp_panel;
    auto  sizer = new wxBoxSizer(wxVERTICAL);
    m_tmp_panel->SetSizer(sizer);
    m_tmp_panel->Layout();
 
    main_sizer->Add(m_tmp_panel, 1, wxEXPAND | wxALL, 0);
#else
    Tab *panel = this;
    auto  *sizer = new wxBoxSizer(wxVERTICAL);
    sizer->SetSizeHints(panel);
    panel->SetSizer(sizer);
#endif //__WXOSX__*/
 
    // BBS: model config
    if (m_type < Preset::TYPE_COUNT) {
        // preset chooser
        m_presets_choice = new TabPresetComboBox(panel, m_type);
        // m_presets_choice->SetFont(Label::Body_10); // BBS
        m_presets_choice->set_selection_changed_function([this](int selection) {
            if (!m_presets_choice->selection_is_changed_according_to_physical_printers())
            {
                if (m_type == Preset::TYPE_PRINTER && !m_presets_choice->is_selected_physical_printer())
                    m_preset_bundle->physical_printers.unselect_printer();
 
                // select preset — prefer stored internal name to avoid alias collisions
                wxString stored_name = m_presets_choice->GetItemAlias(selection);
                std::string preset_name;
                if (!stored_name.empty()) {
                    preset_name = Preset::remove_suffix_modified(stored_name.ToUTF8().data());
                } else {
                    std::string selected_label = Preset::remove_suffix_modified(
                        m_presets_choice->GetString(selection).ToUTF8().data());
                    preset_name = m_preset_bundle->get_preset_name_by_alias(m_type, selected_label);
                }
                select_preset(preset_name);
            }
        });
    }
 
    auto color = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
 
    //buttons
    m_scaled_buttons.reserve(6);
    m_scaled_bitmaps.reserve(4);
 
    m_top_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    // BBS: open this tab by select first
    m_top_panel->SetBackgroundColour(*wxWHITE);
    m_top_panel->Bind(wxEVT_LEFT_UP, [this](auto & e) {
        restore_last_select_item();
    });
 
    //add_scaled_button(panel, &m_btn_compare_preset, "compare");
    add_scaled_button(m_top_panel, &m_btn_save_preset, "save");
    add_scaled_button(m_top_panel, &m_btn_delete_preset, "cross");
    //if (m_type == Preset::Type::TYPE_PRINTER)
    //    add_scaled_button(panel, &m_btn_edit_ph_printer, "cog");
 
    m_show_incompatible_presets = false;
    add_scaled_bitmap(this, m_bmp_show_incompatible_presets, "flag_red");
    add_scaled_bitmap(this, m_bmp_hide_incompatible_presets, "flag_green");
 
    //add_scaled_button(panel, &m_btn_hide_incompatible_presets, m_bmp_hide_incompatible_presets.name());
 
    //m_btn_compare_preset->SetToolTip(_L("Compare presets"));
    // TRN "Save current Settings"
    m_btn_save_preset->SetToolTip(wxString::Format(_L("Save current %s"), m_title));
    m_btn_delete_preset->SetToolTip(_(L("Delete this preset")));
    m_btn_delete_preset->Hide();
 
    /*add_scaled_button(panel, &m_question_btn, "question");
    m_question_btn->SetToolTip(_(L("Hover the cursor over buttons to find more information\n"
                                   "or click this button.")));
 
    add_scaled_button(panel, &m_search_btn, "search");
    m_search_btn->SetToolTip(format_wxstr(_L("Search in settings [%1%]"), _L("Ctrl+") + "F"));*/
 
    // Bitmaps to be shown on the "Revert to system" aka "Lock to system" button next to each input field.
    add_scaled_bitmap(this, m_bmp_value_lock  , "unlock_normal");
    add_scaled_bitmap(this, m_bmp_value_unlock, "lock_normal");
    m_bmp_non_system = &m_bmp_white_bullet;
    // Bitmaps to be shown on the "Undo user changes" button next to each input field.
    add_scaled_bitmap(this, m_bmp_value_revert, "undo");
    add_scaled_bitmap(this, m_bmp_white_bullet, "dot");
    // Bitmap to be shown on the "edit" button before to each editable input field.
    add_scaled_bitmap(this, m_bmp_edit_value, "edit");
 
    set_tooltips_text();
 
    add_scaled_button(m_top_panel, &m_undo_btn,        m_bmp_white_bullet.name());
    //add_scaled_button(m_top_panel, &m_undo_to_sys_btn, m_bmp_white_bullet.name());
    add_scaled_button(m_top_panel, &m_btn_search,      "search");
    m_btn_search->SetToolTip(_L("Search in preset"));
 
    //search input
    m_search_item = new StaticBox(m_top_panel);
    StateColor box_colour(std::pair<wxColour, int>(*wxWHITE, StateColor::Normal));
    StateColor box_border_colour(std::pair<wxColour, int>(wxColour("#009688"), StateColor::Normal)); // ORCA match border color with other input/combo boxes
 
    m_search_item->SetBackgroundColor(box_colour);
    m_search_item->SetBorderColor(box_border_colour);
    m_search_item->SetCornerRadius(5);
 
 
    //StateColor::darkModeColorFor(wxColour(238, 238, 238)), wxDefaultPosition, wxSize(m_top_panel->GetSize().GetWidth(), 3 * wxGetApp().em_unit()), 8);
    auto search_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_search_input = new TextInput(m_search_item, wxEmptyString, wxEmptyString, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 | wxBORDER_NONE);
    m_search_input->SetBackgroundColour(wxColour(238, 238, 238));
    m_search_input->SetForegroundColour(wxColour(43, 52, 54));
    m_search_input->SetFont(wxGetApp().bold_font());
    m_search_input->SetIcon(*BitmapCache().load_svg("search", FromDIP(16), FromDIP(16)));
    m_search_input->GetTextCtrl()->SetHint(_L("Search in preset") + dots);
    search_sizer->Add(new wxWindow(m_search_item, wxID_ANY, wxDefaultPosition, wxSize(0, 0)), 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(2));
    search_sizer->Add(m_search_input, 1, wxEXPAND | wxALL, FromDIP(2));
    //bbl for linux
    //search_sizer->Add(new wxWindow(m_search_input, wxID_ANY, wxDefaultPosition, wxSize(0, 0)), 0, wxEXPAND | wxLEFT, 16);
 
 
     m_search_item->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &e) {
        m_search_input->SetFocus();
    });
 
    m_search_input->Bind(wxCUSTOMEVT_EXIT_SEARCH, [this](wxCommandEvent &) {
         Freeze();
        if (m_presets_choice) m_presets_choice->Show();
 
        m_btn_save_preset->Show();
        m_btn_delete_preset->Show(); // ORCA: fixes delete preset button visible while search box focused
        m_undo_btn->Show();          // ORCA: fixes revert preset button visible while search box focused
        m_btn_search->Show();
        m_search_item->Hide();
 
        m_search_item->Refresh();
        m_search_item->Update();
        m_search_item->Layout();
 
        this->GetParent()->Refresh();
        this->GetParent()->Update();
        this->GetParent()->Layout();
        Thaw();
    });
 
    m_search_item->SetSizer(search_sizer);
    m_search_item->Layout();
    search_sizer->Fit(m_search_item);
 
    m_search_item->Hide();
    //m_btn_search->SetId(wxID_FIND_PROCESS);
 
    m_btn_search->Bind(
        wxEVT_BUTTON,
        [this](wxCommandEvent &) {
         Freeze();
         if (m_presets_choice)
             m_presets_choice->Hide();
 
         m_btn_save_preset->Hide();
         m_btn_delete_preset->Hide(); // ORCA: fixes delete preset button visible while search box focused
         m_undo_btn->Hide();          // ORCA: fixes revert preset button visible while search box focused
         m_btn_search->Hide();
         m_search_item->Show();
 
         this->GetParent()->Refresh();
         this->GetParent()->Update();
         this->GetParent()->Layout();
 
         wxGetApp().plater()->search(false, m_type, m_top_panel->GetParent(), m_search_input, m_btn_search);
         Thaw();
 
        });
 
    m_undo_btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent&) { on_roll_back_value(); }));
    //m_undo_to_sys_btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent&) { on_roll_back_value(true); }));
    /* m_search_btn->Bind(wxEVT_BUTTON, [](wxCommandEvent&) { wxGetApp().plater()->search(false); });*/
 
    // Colors for ui "decoration"
    m_sys_label_clr     = wxGetApp().get_label_clr_sys();
    m_modified_label_clr  = wxGetApp().get_label_clr_modified();
    m_default_text_clr      = wxGetApp().get_label_clr_default();
 
    m_main_sizer = new wxBoxSizer( wxVERTICAL );
    m_top_sizer = new wxBoxSizer( wxHORIZONTAL );
 
    m_top_sizer->Add(m_undo_btn, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(SidebarProps::ContentMargin()));
    // BBS: model config
    if (m_presets_choice) {
        m_presets_choice->Reparent(m_top_panel);
        m_top_sizer->Add(m_presets_choice, 1, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(SidebarProps::ElementSpacing()));
    } else {
        m_top_sizer->AddSpacer(FromDIP(SidebarProps::ElementSpacing()));
        m_top_sizer->AddStretchSpacer(1);
    }
 
    const float scale_factor = /*wxGetApp().*/em_unit(this)*0.1;// GetContentScaleFactor();
#ifndef DISABLE_UNDO_SYS
    m_top_sizer->Add(m_undo_to_sys_btn, 0, wxALIGN_CENTER_VERTICAL);
    m_top_sizer->AddSpacer(FromDIP(SidebarProps::IconSpacing()));
#endif
    m_top_sizer->Add(m_btn_save_preset  , 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
    m_top_sizer->Add(m_btn_delete_preset, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
    m_top_sizer->Add(m_btn_search       , 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::WideSpacing()));
    m_top_sizer->Add(m_search_item      , 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::ContentMargin()));
 
    if (dynamic_cast<TabPrint*>(this) == nullptr) {
        m_mode_icon = new ScalableButton(m_top_panel, wxID_ANY, "advanced"); // ORCA
        m_mode_icon->SetToolTip(_L("Cycle settings visibility"));
        m_mode_icon->Bind(wxEVT_BUTTON, [this](wxCommandEvent e) {
            if (wxGetApp().get_mode() == comDevelop || m_mode_view == nullptr)
                return; // prevent change on dev mode
 
            const int selection = m_mode_view->GetSelection();
            m_mode_view->SelectAndNotify((selection + 1) % 3);
        });
        m_top_sizer->Add(m_mode_icon, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::WideSpacing()));
        m_mode_view = new ModeSwitchButton(m_top_panel);
        if (wxGetApp().get_mode() == comDevelop) {
            m_mode_view->SetSelection(mode_to_selection(comExpert));
            m_mode_view->Enable(false);
        } else {
            m_mode_view->SetSelection(mode_to_selection(wxGetApp().get_saved_mode()));
        }
        m_top_sizer->AddSpacer(FromDIP(SidebarProps::ElementSpacing()));
        m_top_sizer->Add( m_mode_view, 0, wxALIGN_CENTER_VERTICAL);
    }
 
    m_top_sizer->AddSpacer(FromDIP(SidebarProps::ContentMargin()));
 
    m_top_sizer->SetMinSize(-1, 3 * m_em_unit);
    m_top_panel->SetSizer(m_top_sizer);
    if (m_presets_choice)
        m_main_sizer->Add(m_top_panel, 0, wxEXPAND | wxUP | wxDOWN, FromDIP(SidebarProps::ContentMarginV()));
    else
        m_top_panel->Hide();
 
    // tree
    m_tabctrl = new TabCtrl(panel, wxID_ANY, wxDefaultPosition, wxSize(20 * m_em_unit, -1),
        wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_NONE | wxWANTS_CHARS | wxTR_FULL_ROW_HIGHLIGHT);
    m_tabctrl->Bind(wxEVT_RIGHT_DOWN, [](auto &e) {}); // disable right select
    m_tabctrl->SetFont(Label::Body_14);
    //m_left_sizer->Add(m_tabctrl, 1, wxEXPAND);
    const int img_sz = int(32 * scale_factor + 0.5f);
    m_icons = new wxImageList(img_sz, img_sz, false, 1);
    // Index of the last icon inserted into $self->{icons}.
    m_icon_count = -1;
    m_tabctrl->AssignImageList(m_icons);
    wxGetApp().UpdateDarkUI(m_tabctrl);
 
    // Delay processing of the following handler until the message queue is flushed.
    // This helps to process all the cursor key events on Windows in the tree control,
    // so that the cursor jumps to the last item.
    // BBS: bold selection
    m_tabctrl->Bind(wxEVT_TAB_SEL_CHANGING, [this](wxCommandEvent& event) {
        const auto sel_item = m_tabctrl->GetSelection();
        m_tabctrl->SetItemBold(sel_item, false);
        });
    m_tabctrl->Bind(wxEVT_TAB_SEL_CHANGED, [this](wxCommandEvent& event) {
#ifdef __linux__
        // Events queue is opposite On Linux. wxEVT_SET_FOCUS invokes after wxEVT_TAB_SEL_CHANGED,
        // and a result wxEVT_KILL_FOCUS doesn't invoke for the TextCtrls.
        // So, call SetFocus explicitly for this control before changing of the selection
        m_tabctrl->SetFocus();
#endif
            if (!m_disable_tree_sel_changed_event && !m_pages.empty()) {
                if (m_page_switch_running)
                    m_page_switch_planned = true;
                else {
                    m_page_switch_running = true;
                    do {
                        m_page_switch_planned = false;
                        m_tabctrl->Update();
                    } while (this->tree_sel_change_delayed(event));
                    m_page_switch_running = false;
                }
            }
        });
 
    m_tabctrl->Bind(wxEVT_KEY_DOWN, &Tab::OnKeyDown, this);
 
    m_main_sizer->Add(m_tabctrl, 0, wxEXPAND | wxALL, 0 );
 
    if (dynamic_cast<TabPrinter *>(this) || dynamic_cast<TabPrint *>(this)) {
        m_extruder_switch = new MultiSwitchButton(panel);
        m_extruder_switch->SetFont(Label::Body_11);
        m_extruder_switch->SetFitToOptions();
        m_extruder_switch->Bind(wxCUSTOMEVT_MULTISWITCH_SELECTION, [this](auto &evt) {
            evt.Skip();
            int selection = evt.GetInt();
 
            int extruder_id;
            NozzleVolumeType nozzle_type;
            parse_extruder_selection(selection, extruder_id, nozzle_type);
            int extruder_count = m_preset_bundle->get_printer_extruder_count();
            m_actual_nozzle_volumes.resize(extruder_count, NozzleVolumeType::nvtStandard);
            if (extruder_id >= 0 && extruder_id < m_preset_bundle->get_printer_extruder_count())
                m_actual_nozzle_volumes[extruder_id] = nozzle_type;
 
            switch_excluder(extruder_id);
        });
        m_extruder_sync_box = new wxPanel(panel, wxID_ANY);
        m_extruder_sync_box->SetBackgroundColour(panel->GetBackgroundColour());
        m_extruder_sync_box->SetToolTip(_L("Synchronization of different extruder drives or nozzle volume types is not supported."));
        m_extruder_sync = nullptr;
        add_scaled_button(m_extruder_sync_box, &m_extruder_sync, "extruder_sync");
        m_extruder_sync->SetToolTip(_L("Synchronize the modification of parameters to the corresponding parameters of another extruder."));
        m_extruder_sync->Bind(wxEVT_BUTTON, [this](auto &evt) {
            evt.Skip();
            sync_excluder();
        });
 
        ScalableButton* icon = nullptr;
        add_scaled_button(panel, &icon, "multi_extruder");
        icon->SetToolTip(_L("Parameters with this icon can be configured per nozzle."));
 
        auto sync_box_sizer = new wxBoxSizer(wxHORIZONTAL);
        sync_box_sizer->Add(m_extruder_sync, 1, wxEXPAND);
        m_extruder_sync_box->SetSizer(sync_box_sizer);
 
        m_variant_sizer  = new wxBoxSizer(wxHORIZONTAL);
        auto right_sizer = new wxBoxSizer(wxHORIZONTAL);
        auto left_sizer  = new wxBoxSizer(wxHORIZONTAL);
 
        m_variant_sizer->Add(left_sizer, 0, wxALIGN_CENTER);
        m_variant_sizer->AddStretchSpacer(1);
        // Orca: proportion 1 lets a narrow row squeeze the switch, which then scrolls its buttons.
        m_variant_sizer->Add(m_extruder_switch, 1, wxALIGN_CENTER, 0);
        m_variant_sizer->AddStretchSpacer(1);
        m_variant_sizer->Add(right_sizer, 0, wxALIGN_CENTER);
        left_sizer->Add(icon               , 0, wxALIGN_CENTER | wxLEFT , m_em_unit);
        right_sizer->Add(m_extruder_sync_box, 0, wxALIGN_CENTER | wxRIGHT, m_em_unit);
 
        m_main_sizer->Add(m_variant_sizer, 0, wxEXPAND | wxTOP, m_em_unit);
    } else if (dynamic_cast<TabFilament *>(this)) {
        m_variant_combo = new MultiSwitchButton(panel);
        m_variant_combo->SetFont(Label::Body_11);
        m_variant_combo->Bind(wxCUSTOMEVT_MULTISWITCH_SELECTION, [this](auto &evt) {
            evt.Skip();
            switch_excluder(evt.GetInt());
            reload_config();
            update_changed_ui();
            toggle_options();
            if (m_active_page)
                m_active_page->update_visibility(m_mode, true);
            m_page_view->GetParent()->Layout();
        });
 
        ScalableButton* icon = nullptr;
        add_scaled_button(panel, &icon, "multi_extruder");
        icon->SetToolTip(_L("Parameters with this icon can be configured per nozzle."));
 
        wxBoxSizer *top_sizer = new wxBoxSizer(wxHORIZONTAL);
        top_sizer->Add(icon,            0, wxALIGN_CENTER_VERTICAL);
        top_sizer->Add(m_variant_combo, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
 
        m_variant_sizer = new wxBoxSizer(wxVERTICAL);
        m_variant_sizer->Add(top_sizer, 0, wxEXPAND | wxLEFT, m_em_unit);
 
        m_main_sizer->Add(m_variant_sizer, 0, wxEXPAND | wxTOP, m_em_unit);
    }
 
    this->SetSizer(m_main_sizer);
    //this->Layout();
    m_page_view = m_parent->get_paged_view();
 
    // Initialize the page.
/*#ifdef __WXOSX__
    auto page_parent = m_tmp_panel;
#else
    auto page_parent = this;
#endif
 
    m_page_view = new wxScrolledWindow(page_parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_page_sizer = new wxBoxSizer(wxVERTICAL);
    m_page_view->SetSizer(m_page_sizer);
    m_page_view->SetScrollbars(1, 20, 1, 2);
    m_hsizer->Add(m_page_view, 1, wxEXPAND | wxLEFT, 5);*/
 
    //m_btn_compare_preset->Bind(wxEVT_BUTTON, ([this](wxCommandEvent e) { compare_preset(); }));
    m_btn_save_preset->Bind(wxEVT_BUTTON, ([this](wxCommandEvent& e) { save_preset(); }));
    m_btn_delete_preset->Bind(wxEVT_BUTTON, ([this](wxCommandEvent& e) { delete_preset(); }));
    /*m_btn_hide_incompatible_presets->Bind(wxEVT_BUTTON, ([this](wxCommandEvent e) {
        toggle_show_hide_incompatible();
    }));
 
    if (m_btn_edit_ph_printer)
        m_btn_edit_ph_printer->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
            if (m_preset_bundle->physical_printers.has_selection())
                m_presets_choice->edit_physical_printer();
            else
                m_presets_choice->add_physical_printer();
        });*/
 
    // Initialize the DynamicPrintConfig by default keys/values.
    build();
 
    // ys_FIXME: Following should not be needed, the function will be called later
    // (update_mode->update_visibility->rebuild_page_tree). This does not work, during the
    // second call of rebuild_page_tree m_tabctrl->GetFirstVisibleItem(); returns zero
    // for some unknown reason (and the page is not refreshed until user does a selection).
    rebuild_page_tree();
 
    m_completed = true;
}

References _, _L, add_scaled_bitmap(), add_scaled_button(), Label::Body_11, Label::Body_14, build(), Slic3r::comDevelop, Slic3r::comExpert, Slic3r::GUI::SidebarProps::ContentMargin(), Slic3r::GUI::SidebarProps::ContentMarginV(), delete_preset(), Slic3r::GUI::dots(), Slic3r::GUI::SidebarProps::ElementSpacing(), em_unit(), Slic3r::GUI::SidebarProps::IconSpacing(), L, Slic3r::load_svg(), m_active_page, m_actual_nozzle_volumes, m_bmp_edit_value, m_bmp_hide_incompatible_presets, m_bmp_non_system, m_bmp_show_incompatible_presets, m_bmp_value_lock, m_bmp_value_revert, m_bmp_value_unlock, m_bmp_white_bullet, m_btn_delete_preset, m_btn_save_preset, m_btn_search, m_completed, m_default_text_clr, m_disable_tree_sel_changed_event, m_em_unit, m_extruder_switch, m_extruder_sync, m_extruder_sync_box, m_icon_count, m_icons, m_main_sizer, m_mode, m_mode_icon, m_mode_view, m_modified_label_clr, m_page_switch_planned, m_page_switch_running, m_page_view, m_pages, m_parent, m_preset_bundle, m_presets_choice, m_scaled_bitmaps, m_scaled_buttons, m_search_input, m_search_item, m_show_incompatible_presets, m_sys_label_clr, m_tabctrl, m_title, m_top_panel, m_top_sizer, m_type, m_undo_btn, m_undo_to_sys_btn, m_variant_combo, m_variant_sizer, StateColor::Normal, Slic3r::nozzle_type(), Slic3r::nvtStandard, on_roll_back_value(), OnKeyDown(), parse_extruder_selection(), rebuild_page_tree(), reload_config(), Slic3r::Preset::remove_suffix_modified(), restore_last_select_item(), save_preset(), select_preset(), set_tooltips_text(), switch_excluder(), sync_excluder(), toggle_options(), tree_sel_change_delayed(), Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_PRINTER, update_changed_ui(), Slic3r::GUI::SidebarProps::WideSpacing(), and Slic3r::GUI::wxMouseEvent.

Referenced by Slic3r::GUI::MainFrame::add_created_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

current_preset_is_dirty()

bool Slic3r::GUI::Tab::current_preset_is_dirty ( ) const

inherited

{ return m_presets->current_is_dirty(); }

References current_preset_is_dirty(), and m_presets.

Referenced by current_preset_is_dirty(), and Slic3r::GUI::PresetComboBox::get_tooltip().

Here is the call graph for this function:

Here is the caller graph for this function:

decorate()

void Slic3r::GUI::Tab::decorate ( )

inherited

{
    for (const auto& opt : m_options_list)
    {
        Field*      field = nullptr;
        bool        option_without_field = false;
 
        if (opt.first == "printable_area" ||
            opt.first == "compatible_prints" || opt.first == "compatible_printers")
            option_without_field = true;
 
        if (!option_without_field) {
            field = get_field(opt.first);
            if (!field)
                continue;
        }
 
        bool is_nonsys_value = false;
        bool is_modified_value = true;
        const ScalableBitmap* sys_icon  = &m_bmp_value_lock;
        const ScalableBitmap* icon      = &m_bmp_value_revert;
 
        const wxColour* color = m_is_default_preset ? &m_default_text_clr : &m_sys_label_clr;
 
        const wxString* sys_tt  = &m_tt_value_lock;
        const wxString* tt      = &m_tt_value_revert;
 
        // value isn't equal to system value
        if ((opt.second & osSystemValue) == 0) {
            is_nonsys_value = true;
            sys_icon = m_bmp_non_system;
            sys_tt = m_tt_non_system;
            // value is equal to last saved
            if ((opt.second & osInitValue) != 0)
                color = &m_default_text_clr;
            // value is modified
            else
                color = &m_modified_label_clr;
        }
        if ((opt.second & osInitValue) != 0)
        {
            is_modified_value = false;
            icon = &m_bmp_white_bullet;
            tt = &m_tt_white_bullet;
        }
 
        if (opt.first == "compatible_prints" || opt.first == "compatible_printers") {
            bool sys_page      = true;
            bool modified_page = false;
            if (m_type == Slic3r::Preset::TYPE_PRINTER) {
                sys_page      = m_presets->get_selected_preset_parent() != nullptr;
                modified_page = false;
            } else {
                if (opt.first == "compatible_prints") {
                    get_sys_and_mod_flags("compatible_prints", sys_page, modified_page);
                    // Don't call for "compatible_printers"
                } else if (opt.first == "compatible_printers") {
                    get_sys_and_mod_flags("compatible_printers", sys_page, modified_page);
                    if (m_type == Slic3r::Preset::TYPE_FILAMENT || m_type == Slic3r::Preset::TYPE_SLA_MATERIAL) {
                        get_sys_and_mod_flags("compatible_prints", sys_page, modified_page);
                    }
                }
            }
            if (!sys_page) {
                is_nonsys_value = true;
                sys_icon        = m_bmp_non_system;
                sys_tt          = m_tt_non_system;
 
                if (!modified_page)
                    color = &m_default_text_clr;
                else
                    color = &m_modified_label_clr;
            }
 
            if (!modified_page) {
                is_modified_value = false;
                icon              = &m_bmp_white_bullet;
                tt                = &m_tt_white_bullet;
            }
 
        }
 
        if (option_without_field) {
            if (Line* line = get_line(opt.first)) {
                line->set_undo_bitmap(icon);
                line->set_undo_to_sys_bitmap(sys_icon);
                line->set_undo_tooltip(tt);
                line->set_undo_to_sys_tooltip(sys_tt);
                line->set_label_colour(color);
            }
            continue;
        }
 
        field->m_is_nonsys_value = is_nonsys_value;
        field->m_is_modified_value = is_modified_value;
        field->set_undo_bitmap(icon);
        //BBS: GUI refactor
        field->set_undo_to_sys_bitmap(sys_icon);
        field->set_undo_tooltip(tt);
        field->set_undo_to_sys_tooltip(sys_tt);
        field->set_label_colour(color);
 
        if (field->has_edit_ui())
            field->set_edit_bitmap(&m_bmp_edit_value);
 
    }
 
    if (m_active_page)
        m_active_page->refresh();
}

References get_field(), get_line(), get_sys_and_mod_flags(), Slic3r::GUI::UndoValueUIManager::has_edit_ui(), m_active_page, m_bmp_edit_value, m_bmp_non_system, m_bmp_value_lock, m_bmp_value_revert, m_bmp_white_bullet, m_default_text_clr, m_is_default_preset, Slic3r::GUI::Field::m_is_modified_value, Slic3r::GUI::Field::m_is_nonsys_value, m_modified_label_clr, m_options_list, m_presets, m_sys_label_clr, m_tt_non_system, m_tt_value_lock, m_tt_value_revert, m_tt_white_bullet, m_type, osInitValue, osSystemValue, Slic3r::GUI::UndoValueUIManager::set_edit_bitmap(), Slic3r::GUI::UndoValueUIManager::set_label_colour(), Slic3r::GUI::UndoValueUIManager::set_undo_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_bitmap(), Slic3r::GUI::UndoValueUIManager::set_undo_to_sys_tooltip(), Slic3r::GUI::UndoValueUIManager::set_undo_tooltip(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::TYPE_SLA_MATERIAL.

Referenced by update_changed_ui(), and update_label_colours().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_preset()

void Slic3r::GUI::Tab::delete_preset ( )

inherited

{
    auto current_preset = m_presets->get_selected_preset();
    // Don't let the user delete the ' - default - ' configuration.
    //BBS: add project embedded preset logic and refine is_external
    wxString msg;
    bool     confirm_delete_third_party_printer = false;
    bool     is_base_preset                 = false;
    if (m_presets->get_preset_base(current_preset) == &current_preset) { //root preset
        is_base_preset = true;
        if (current_preset.type == Preset::Type::TYPE_PRINTER && !current_preset.is_system) { //Customize third-party printers
            Preset &current_preset = m_presets->get_selected_preset();
            int filament_preset_num    = 0;
            int process_preset_num     = 0;
            for (const Preset &preset : m_preset_bundle->filaments.get_presets()) {
                if (preset.is_compatible && !preset.is_default) { filament_preset_num++; }
            }
            for (const Preset &preset : m_preset_bundle->prints.get_presets()) {
                if (preset.is_compatible && !preset.is_default) { process_preset_num++; }
            }
 
            DeleteConfirmDialog
                dlg(parent(), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Delete"),
                    // TRN %1% is "N filament preset(s)", %2% is "N process preset(s)".
                    format_wxstr(_L("%1% and %2% are attached to this printer. Those presets would be deleted if the printer is deleted."),
                                 wxString::Format(_L_PLURAL("%d filament preset", "%d filament presets", filament_preset_num), filament_preset_num),
                                 wxString::Format(_L_PLURAL("%d process preset", "%d process presets", process_preset_num), process_preset_num)));
            int res = dlg.ShowModal();
            if (res != wxID_OK) return;
            confirm_delete_third_party_printer = true;
        }
        int count = 0;
        wxString presets;
        for (auto &preset2 : *m_presets)
            if (preset2.inherits() == current_preset.name) {
                ++count;
                presets += "\n - " + from_u8(preset2.name);
            }
        if (count > 0) {
            msg = _L("Presets inherited by other presets cannot be deleted!");
            msg += "\n";
            msg += _L_PLURAL("The following preset inherits this preset.",
                            "The following presets inherit this preset.", count);
            wxString title = _L("Delete Preset");
            MessageDialog(parent(), msg + presets, title, wxOK | wxICON_ERROR).ShowModal();
            return;
        }
    }
 
    BOOST_LOG_TRIVIAL(info) << boost::format("delete preset %1%, setting_id %2%, user_id %3%, base_id %4%, sync_info %5%, type %6%")
        %current_preset.name%current_preset.setting_id%current_preset.user_id%current_preset.base_id%current_preset.sync_info
        %Preset::get_type_string(m_type);
    PhysicalPrinterCollection& physical_printers = m_preset_bundle->physical_printers;
 
    if (m_type == Preset::TYPE_PRINTER && !physical_printers.empty())
    {
        // Check preset for delete in physical printers
        // Ask a customer about next action, if there is a printer with just one preset and this preset is equal to delete
        std::vector<std::string> ph_printers        = physical_printers.get_printers_with_preset(current_preset.name);
        std::vector<std::string> ph_printers_only   = physical_printers.get_printers_with_only_preset(current_preset.name);
 
        //if (!ph_printers.empty()) {
        //    msg += _L_PLURAL("The physical printer below is based on the preset, you are going to delete.",
        //                        "The physical printers below are based on the preset, you are going to delete.", ph_printers.size());
        //    for (const std::string& printer : ph_printers)
        //        msg += "\n    \"" + from_u8(printer) + "\",";
        //    msg.RemoveLast();
        //    msg += "\n" + _L_PLURAL("Note, that the selected preset will be deleted from this printer too.",
        //                            "Note, that the selected preset will be deleted from these printers too.", ph_printers.size()) + "\n\n";
        //}
 
        //if (!ph_printers_only.empty()) {
        //    msg += _L_PLURAL("The physical printer below is based only on the preset, you are going to delete.",
        //                        "The physical printers below are based only on the preset, you are going to delete.", ph_printers_only.size());
        //    for (const std::string& printer : ph_printers_only)
        //        msg += "\n    \"" + from_u8(printer) + "\",";
        //    msg.RemoveLast();
        //    msg += "\n" + _L_PLURAL("Note, that this printer will be deleted after deleting the selected preset.",
        //                            "Note, that these printers will be deleted after deleting the selected preset.", ph_printers_only.size()) + "\n\n";
        //}
        if (!ph_printers.empty() || !ph_printers_only.empty()) {
            msg += _L_PLURAL("The following preset will be deleted too:", "The following presets will be deleted too:", ph_printers.size() + ph_printers_only.size());
            for (const std::string &printer : ph_printers) msg += "\n    \"" + from_u8(printer) + "\",";
            for (const std::string &printer : ph_printers_only) msg += "\n    \"" + from_u8(printer) + "\",";
            msg.RemoveLast();
            // msg += "\n" + _L_PLURAL("Note, that the selected preset will be deleted from this printer too.",
            //                        "Note, that the selected preset will be deleted from these printers too.", ph_printers.size()) + "\n\n";
        }
    }
 
    if (is_base_preset && (current_preset.type == Preset::Type::TYPE_FILAMENT)) {
        msg += from_u8(_u8L("Are you sure to delete the selected preset?\nIf the preset corresponds to a filament currently in use on your printer, please reset the filament information for that slot."));
    } else {
        msg += _L("Are you sure you want to delete the selected preset?");
    }
 
    wxString title = _L("Delete Preset");
    if (current_preset.is_default || !(confirm_delete_third_party_printer ||
        //wxID_YES != wxMessageDialog(parent(), msg, title, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION).ShowModal())
        wxID_YES == MessageDialog(parent(), msg, title, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION).ShowModal()))
        return;
 
    // if we just delete preset from the physical printer
    if (m_presets_choice->is_selected_physical_printer()) {
        PhysicalPrinter& printer = physical_printers.get_selected_printer();
 
        // just delete this preset from the current physical printer
        printer.delete_preset(m_presets->get_edited_preset().name);
        // select first from the possible presets for this printer
        physical_printers.select_printer(printer);
 
        this->select_preset(physical_printers.get_selected_printer_preset_name());
        return;
    }
 
    // delete selected preset from printers and printer, if it's needed
    if (m_type == Preset::TYPE_PRINTER && !physical_printers.empty())
        physical_printers.delete_preset_from_printers(current_preset.name);
 
    // Select will handle of the preset dependencies, of saving & closing the depending profiles, and
    // finally of deleting the preset.
    this->select_preset("", true);
 
    BOOST_LOG_TRIVIAL(info) << boost::format("delete preset finished");
}

References _L, _L_PLURAL, _u8L, count, delete_preset(), Slic3r::PhysicalPrinter::delete_preset(), Slic3r::PhysicalPrinterCollection::delete_preset_from_printers(), Slic3r::PhysicalPrinterCollection::empty(), Slic3r::GUI::format_wxstr(), Slic3r::from_u8(), Slic3r::PhysicalPrinterCollection::get_printers_with_only_preset(), Slic3r::PhysicalPrinterCollection::get_printers_with_preset(), Slic3r::PhysicalPrinterCollection::get_selected_printer(), Slic3r::PhysicalPrinterCollection::get_selected_printer_preset_name(), Slic3r::Preset::get_type_string(), m_preset_bundle, m_presets, m_presets_choice, m_type, parent(), select_preset(), Slic3r::PhysicalPrinterCollection::select_printer(), Slic3r::GUI::DPIAware< P >::ShowModal(), SLIC3R_APP_FULL_NAME, title(), Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by create_preset_tab(), and delete_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

description_line_widget()

wxSizer * Slic3r::GUI::Tab::description_line_widget ( wxWindow * parent, ogStaticText ** StaticText, wxString text = wxEmptyString )

inherited

{
    *StaticText = new ogStaticText(parent, text);
 
//  auto font = (new wxSystemSettings)->GetFont(wxSYS_DEFAULT_GUI_FONT);
    (*StaticText)->SetFont(wxGetApp().normal_font());
 
    auto sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(*StaticText, 1, wxEXPAND|wxALL, 0);
    return sizer;
}

References description_line_widget(), and parent().

Referenced by build_preset_description_line(), and description_line_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

edit_custom_gcode()

void Slic3r::GUI::Tab::edit_custom_gcode ( const t_config_option_key & opt_key )

inherited

{
    EditGCodeDialog dlg = EditGCodeDialog(this, opt_key, get_custom_gcode(opt_key));
    if (dlg.ShowModal() == wxID_OK) {
        const std::string edited_gcode = dlg.get_edited_gcode();
        // Orca: this dialog writes the value straight into the config, bypassing the field's change
        // handler, so the reserved keyword check has to run here as it does when editing in place.
        validate_custom_gcodes_was_shown = !validate_custom_gcode(custom_gcode_group_title(m_active_page, opt_key), edited_gcode);
        set_custom_gcode(opt_key, edited_gcode);
        update_dirty();
        update();
    }
}

References Slic3r::GUI::custom_gcode_group_title(), EditGCodeDialog, get_custom_gcode(), Slic3r::GUI::EditGCodeDialog::get_edited_gcode(), m_active_page, set_custom_gcode(), Slic3r::GUI::DPIAware< P >::ShowModal(), update(), update_dirty(), validate_custom_gcode(), and validate_custom_gcodes_was_shown.

Referenced by Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), and Slic3r::GUI::TabPrinter::build_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

extruder_page()

Page * Slic3r::GUI::TabPrinter::extruder_page

(

)

const

{
    for (const PageShp &page : m_pages)
        if (page->title() == "Extruder")
            return page.get();
    return nullptr;
}

References extruder_page(), and Slic3r::GUI::Tab::m_pages.

Referenced by activate_option(), build_unregular_pages(), extruder_page(), and extruder_page_data_index().

Here is the call graph for this function:

Here is the caller graph for this function:

extruder_page_data_index()

int Slic3r::GUI::TabPrinter::extruder_page_data_index

(

const std::string &

field_id

)

const

{
    if (Page *page = extruder_page())
        for (const auto &group : page->m_optgroups)
            if (auto it = group->opt_map().find(field_id); it != group->opt_map().end())
                return it->second.second;
    return -1;
}

References extruder_page(), and extruder_page_data_index().

Referenced by extruder_page_data_index(), and on_value_change().

Here is the call graph for this function:

Here is the caller graph for this function:

extruder_variant_index()

int Slic3r::GUI::TabPrinter::extruder_variant_index

(

int

extruder

)

{
    const auto *extruders = m_config->option<ConfigOptionEnumsGeneric>("extruder_type");
    const int   index     = extruder < int(extruders->size()) ?
                                m_config->get_index_for_extruder(extruder + 1, "printer_extruder_id", ExtruderType(extruders->values[extruder]),
                                                                 get_actual_nozzle_volume_type(extruder), "printer_extruder_variant") :
                                -1;
    return index < 0 ? extruder : index;
}

References extruder_variant_index(), Slic3r::GUI::Tab::get_actual_nozzle_volume_type(), and Slic3r::GUI::Tab::m_config.

Referenced by extruder_variant_index(), and toggle_options().

Here is the call graph for this function:

Here is the caller graph for this function:

extruders_count_changed()

void Slic3r::GUI::TabPrinter::extruders_count_changed

(

size_t

extruders_count

)

{
    bool is_count_changed = false;
    if (m_extruders_count != extruders_count) {
        m_extruders_count = extruders_count;
        m_preset_bundle->on_extruders_count_changed(extruders_count);
        is_count_changed = true;
 
        wxGetApp().plater()->get_partplate_list().on_extruder_count_changed((int)m_extruders_count);
    }
    // Orca: support multi tool
    else if (m_extruders_count == 1 &&
             m_preset_bundle->project_config.option<ConfigOptionFloats>("flush_volumes_matrix")->values.size()>1)
        m_preset_bundle->update_multi_material_filament_presets();
 
    /* This function should be call in any case because of correct updating/rebuilding
     * of unregular pages of a Printer Settings
     */
    build_unregular_pages();
 
    if (is_count_changed) {
        on_value_change("extruders_count", extruders_count);
        // BBS
        //wxGetApp().obj_list()->update_objects_list_filament_column(extruders_count);
    }
}

References build_unregular_pages(), extruders_count_changed(), m_extruders_count, Slic3r::GUI::Tab::m_preset_bundle, and on_value_change().

Referenced by build_unregular_pages(), extruders_count_changed(), on_preset_loaded(), and sync_extruders_count().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_diff_option()

void Slic3r::GUI::Tab::filter_diff_option ( std::vector< std::string > & options )

protectedinherited

{
    for (auto &opt : options) {
        const auto hash_pos = opt.find_last_of('#');
        if (hash_pos == std::string::npos) continue;
        bool found = false;
        for (auto page : m_pages) {
            if (auto iter = page->m_opt_id_map.find(opt); iter != page->m_opt_id_map.end()) {
                opt = iter->second;
                found = true;
                break;
            }
        }
        if (!found) opt = opt.substr(0, hash_pos);
    }
    options.erase(std::remove(options.begin(), options.end(), ""), options.end());
}

References m_pages.

Referenced by Slic3r::GUI::TabPrintModel::activate_selected_page(), Slic3r::GUI::TabPrintModel::reload_config(), update_changed_ui(), and Slic3r::GUI::TabPrintModel::update_model_config().

Here is the caller graph for this function:

generate_extruder_options()

std::vector< wxString > Slic3r::GUI::Tab::generate_extruder_options ( )

inherited

{
    std::vector<wxString> options;
    if (m_type == Preset::TYPE_FILAMENT) {
        auto variants = m_config->option<ConfigOptionStrings>("filament_extruder_variant");
        if (!variants)
            return options;
 
        for (auto &v : variants->values) {
            std::string drive, nozzle;
 
            static std::vector<std::string> known_nozzle_types;
            if (known_nozzle_types.empty()) {
                for (auto nvt : get_valid_nozzle_volume_type()) {
                    known_nozzle_types.push_back(get_nozzle_volume_type_string(nvt));
                }
                std::sort(known_nozzle_types.begin(), known_nozzle_types.end(),
                    [](const std::string& a, const std::string& b) { return a.size() > b.size(); });
            }
            bool found = false;
            for (const auto& nozzle_type : known_nozzle_types) {
                if (v.size() > nozzle_type.size() &&
                    v.substr(v.size() - nozzle_type.size()) == nozzle_type &&
                    v[v.size() - nozzle_type.size() - 1] == ' ') {
                    drive = v.substr(0, v.size() - nozzle_type.size() - 1);
                    nozzle = nozzle_type;
                    found = true;
                    break;
                }
            }
            if (!found) {
                size_t pos = v.rfind(' ');
                if (pos != std::string::npos) {
                    drive = v.substr(0, pos);
                    nozzle = v.substr(pos + 1);
                } else {
                    drive = v;
                    nozzle = "";
                }
            }
            options.push_back(wxString::Format("%s %s", _L(drive), short_nozzle_volume_name(nozzle)));
        }
        return options;
    }
 
    auto nozzle_volumes     = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    auto nozzle_volumes_def = m_preset_bundle->project_config.def()->get("nozzle_volume_type");
    int  extruder_nums      = m_preset_bundle->get_printer_extruder_count();
 
    if (!nozzle_volumes || extruder_nums <= 0) {
        return options;
    }
 
    // Orca: the printer tab has one tag per extruder, named as its former "Extruder N" pages were.
    // parse_extruder_selection() counts a hybrid extruder as two tags; that still lines up because
    // only the last extruder can be hybrid.
    if (m_type == Preset::TYPE_PRINTER) {
        for (int i = 0; i < extruder_nums; ++i)
            options.push_back(translate_category(wxString::Format("Extruder %d", i + 1), m_type));
        return options;
    }
 
    std::string pt = m_preset_bundle->printers.get_edited_preset().get_printer_type(m_preset_bundle);
    // Orca: the main/deputy toolhead names describe a Bambu dual-nozzle printer, where extruder 0 is
    // the left (deputy) and extruder 1 the right (main) nozzle. Other printers number their tools.
    const bool toolhead_names = extruder_nums == 2 && m_preset_bundle->is_bbl_vendor();
    for (int i = 0; i < extruder_nums; ++i) {
        wxString extruder_name = !toolhead_names ? wxString::Format("T%d", i + 1) :
                                                     _L(DevPrinterConfigUtil::get_toolhead_display_name(
                                                         pt, (i == 0) ? DEPUTY_EXTRUDER_ID : MAIN_EXTRUDER_ID,
                                                         ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase, true));
        NozzleVolumeType volume_type = NozzleVolumeType(nozzle_volumes->values[i]);
 
        if (volume_type == NozzleVolumeType::nvtHybrid) {
            options.push_back(wxString::Format("%s %s", extruder_name, short_nozzle_volume_name(get_nozzle_volume_type_string(NozzleVolumeType::nvtStandard))));
            options.push_back(wxString::Format("%s %s", extruder_name, short_nozzle_volume_name(get_nozzle_volume_type_string(NozzleVolumeType::nvtHighFlow))));
        } else {
            options.push_back(wxString::Format("%s %s", extruder_name,
                                               short_nozzle_volume_name(get_nozzle_volume_type_string(volume_type))));
        }
    }
    return options;
}

References _L, DEPUTY_EXTRUDER_ID, generate_extruder_options(), Slic3r::get_nozzle_volume_type_string(), Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), Slic3r::get_valid_nozzle_volume_type(), m_config, m_preset_bundle, m_type, MAIN_EXTRUDER_ID, Slic3r::Nozzle, Slic3r::nozzle_type(), Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::GUI::short_nozzle_volume_name(), Slic3r::TitleCase, translate_category(), Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by generate_extruder_options(), update_changed_tree_ui(), update_extruder_switch_colors(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

get_actual_nozzle_volume_type()

NozzleVolumeType Slic3r::GUI::Tab::get_actual_nozzle_volume_type ( int extruder_id )

inherited

{
    int extruder_count = m_preset_bundle->get_printer_extruder_count();
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    if (extruder_count == 1) {
        if (extruder_id < 0)
            return NozzleVolumeType::nvtStandard;
 
        return NozzleVolumeType(nozzle_volumes->values[extruder_id]);
    }
 
    if (extruder_id < 0 || extruder_id >= extruder_count)
        return NozzleVolumeType::nvtStandard;
 
    if (m_actual_nozzle_volumes.size() != static_cast<size_t>(extruder_count))
        m_actual_nozzle_volumes.resize(extruder_count, NozzleVolumeType::nvtStandard);
 
    return m_actual_nozzle_volumes[extruder_id];
}

References get_actual_nozzle_volume_type(), m_actual_nozzle_volumes, m_preset_bundle, and Slic3r::nvtStandard.

Referenced by Slic3r::GUI::TabPrinter::activate_option(), Slic3r::GUI::TabPrinter::extruder_variant_index(), get_actual_nozzle_volume_type(), get_extruder_sync_enable_state(), switch_excluder(), sync_excluder(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

get_category_icon_map()

const std::map< wxString, std::string > & Slic3r::GUI::Tab::get_category_icon_map ( )

inlineinherited

{ return m_category_icon; }

References m_category_icon.

Referenced by Slic3r::GUI::ActionRegistry::materialize_setting_actions().

Here is the caller graph for this function:

get_combo_box()

TabPresetComboBox * Slic3r::GUI::Tab::get_combo_box ( )

inlineinherited

{ return m_presets_choice; }

References m_presets_choice.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target(), and Slic3r::GUI::Sidebar::update_presets().

Here is the caller graph for this function:

get_config()

DynamicPrintConfig * Slic3r::GUI::Tab::get_config ( )

inlineinherited

{ return m_config; }

References m_config.

Referenced by Slic3r::GUI::ObjectList::add_settings_item(), and Slic3r::GUI::PresetComboBox::get_tooltip().

Here is the caller graph for this function:

get_config_manipulation()

ConfigManipulation Slic3r::GUI::Tab::get_config_manipulation ( )

protectedinherited

{
    auto load_config = [this]()
    {
        update_dirty();
        // Initialize UI components with the config values.
        reload_config();
        update();
    };
 
    auto cb_toggle_field = [this](const t_config_option_key& opt_key, bool toggle, int opt_index) {
        return toggle_option(opt_key, toggle, opt_index >= 0 ? opt_index + 256 : opt_index);
    };
 
    auto cb_toggle_line = [this](const t_config_option_key &opt_key, bool toggle, int opt_index) {
        return toggle_line(opt_key, toggle, opt_index >= 0 ? opt_index + 256 : opt_index);
    };
 
    auto cb_set_option_label = [this](const t_config_option_key &opt_key, const wxString &label, int opt_index) {
        return set_option_label(opt_key, label, opt_index >= 0 ? opt_index + 256 : opt_index);
    };
 
    auto cb_value_change = [this](const std::string& opt_key, const boost::any& value) {
        return on_value_change(opt_key, value);
    };
 
    return ConfigManipulation(load_config, cb_toggle_field, cb_toggle_line, cb_value_change, nullptr, this, cb_set_option_label);
}

References load_config(), on_value_change(), reload_config(), set_option_label(), toggle_line(), toggle_option(), update(), and update_dirty().

Referenced by Tab().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_active_extruder()

int Slic3r::GUI::Tab::get_current_active_extruder ( )

inherited

{
    if (m_extruder_switch && m_extruder_switch->IsThisEnabled()) {
        int selection = m_extruder_switch->GetSelection();
        int extruder_id;
        NozzleVolumeType nozzle_type;
        parse_extruder_selection(selection, extruder_id, nozzle_type);
        return extruder_id;
    }
    return 0;
}

References m_extruder_switch, Slic3r::nozzle_type(), and parse_extruder_selection().

Referenced by Slic3r::GUI::TabPrinter::activate_option(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::TabPrinter::on_value_change(), switch_excluder(), sync_excluder(), Slic3r::GUI::TabPrinter::toggle_options(), and update_variant_sizer_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

get_custom_ctrl_with_blinking_ptr()

std::pair< OG_CustomCtrl *, bool * > Slic3r::GUI::Tab::get_custom_ctrl_with_blinking_ptr ( const t_config_option_key & opt_key, int opt_index = -1 )

inherited

{
    if (!m_active_page)
        return {nullptr, nullptr};
 
    std::pair<OG_CustomCtrl*, bool*> ret = {nullptr, nullptr};
 
    for (auto opt_group : m_active_page->m_optgroups) {
        ret = opt_group->get_custom_ctrl_with_blinking_ptr(opt_key, opt_index);
        if (ret.first && ret.second)
            break;
    }
    return ret;
}

References get_custom_ctrl_with_blinking_ptr(), and m_active_page.

Referenced by activate_option(), and get_custom_ctrl_with_blinking_ptr().

Here is the call graph for this function:

Here is the caller graph for this function:

get_custom_gcode()

const std::string & Slic3r::GUI::Tab::get_custom_gcode ( const t_config_option_key & opt_key )

virtualinherited

Reimplemented in Slic3r::GUI::TabFilament.

{
    return m_config->opt_string(opt_key);
}

References m_config.

Referenced by edit_custom_gcode().

Here is the caller graph for this function:

get_extruder_sync_enable_state()

bool Slic3r::GUI::Tab::get_extruder_sync_enable_state ( int extruder_id )

inherited

{
    Preset& printer_preset = m_preset_bundle->printers.get_edited_preset();
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    auto extruders = printer_preset.config.option<ConfigOptionEnumsGeneric>("extruder_type");
    // Orca: every rule below describes the two toolheads of a dual-nozzle printer as left/right.
    // A printer with any other extruder count has no single counterpart to copy to, so it gets no
    // sync button (a toolchanger would need a target to be chosen).
    if (nozzle_volumes->values.size() != 2 || extruders->values.size() != 2) {
        return false;
    }
 
    NozzleVolumeType left_nozzle    = NozzleVolumeType(nozzle_volumes->values[0]);
    NozzleVolumeType right_nozzle   = NozzleVolumeType(nozzle_volumes->values[1]);
    ExtruderType     left_extruder  = ExtruderType(extruders->values[0]);
    ExtruderType     right_extruder = ExtruderType(extruders->values[1]);
 
    if (left_extruder != right_extruder) {
        return false;
    }
 
    if (left_nozzle == right_nozzle) {
        return true;
    }
 
    if (left_nozzle != NozzleVolumeType::nvtHybrid && right_nozzle != NozzleVolumeType::nvtHybrid) {
        return false;
    }
 
    if (left_nozzle == NozzleVolumeType::nvtHybrid && right_nozzle == NozzleVolumeType::nvtHybrid) {
        return true;
    }
 
    // Hybrid rules
    auto current_nozzle = get_actual_nozzle_volume_type(extruder_id);
    if (left_nozzle != NozzleVolumeType::nvtHybrid) {
        if (extruder_id == 0) {
            return true;
        }
        if (extruder_id == 1 && current_nozzle == left_nozzle) {
            return true;
        }
        return false;
    }
    if (right_nozzle != NozzleVolumeType::nvtHybrid) {
        if (extruder_id == 1) {
            return true;
        }
        if (extruder_id == 0 && current_nozzle == right_nozzle) {
            return true;
        }
        return false;
    }
    return false;
}

References Slic3r::Preset::config, get_actual_nozzle_volume_type(), get_extruder_sync_enable_state(), m_preset_bundle, Slic3r::nvtHybrid, Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by get_extruder_sync_enable_state(), switch_excluder(), sync_excluder(), and update_variant_sizer_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

get_field() [1/2]

Field * Slic3r::GUI::Tab::get_field ( const t_config_option_key & opt_key, int opt_index = -1 ) const

inherited

{
    return m_active_page ? m_active_page->get_field(opt_key, opt_index) : nullptr;
}

References get_field(), and m_active_page.

Referenced by activate_option(), commit_preset_config_value(), compatible_widget_create(), compatible_widget_reload(), decorate(), get_field(), get_field(), on_value_change(), Slic3r::GUI::TabPrinter::refresh_printer_agent_dropdown(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::TabPrinter::update_input_shaper_menu(), and update_label_colours().

Here is the call graph for this function:

Here is the caller graph for this function:

get_field() [2/2]

Field * Slic3r::GUI::Tab::get_field ( const t_config_option_key & opt_key, Page ** selected_page, int opt_index = -1 )

inherited

{
    Field* field = nullptr;
    for (auto page : m_pages) {
        field = page->get_field(opt_key, opt_index);
        if (field != nullptr) {
            *selected_page = page.get();
            return field;
        }
    }
    return field;
}

References get_field(), and m_pages.

Here is the call graph for this function:

get_line()

Line * Slic3r::GUI::Tab::get_line ( const t_config_option_key & opt_key )

inherited

{
    return m_active_page ? m_active_page->get_line(opt_key) : nullptr;
}

References get_line(), and m_active_page.

Referenced by decorate(), get_line(), and update_label_colours().

Here is the call graph for this function:

Here is the caller graph for this function:

get_presets()

PresetCollection * Slic3r::GUI::Tab::get_presets ( )

inlineinherited

{ return m_presets; }

References m_presets.

Referenced by Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), and Slic3r::GUI::PresetComboBox::get_tooltip().

Here is the caller graph for this function:

get_sys_and_mod_flags()

void Slic3r::GUI::Tab::get_sys_and_mod_flags ( const std::string & opt_key, bool & sys_page, bool & modified_page )

inherited

{
    auto opt = m_options_list.find(opt_key);
    if (opt == m_options_list.end())
        return;
    // If the value is empty, clear the system flag
    if (opt_key == "compatible_printers" || opt_key == "compatible_prints") {
        auto* compatible_values = m_config->option<ConfigOptionStrings>(opt_key);
        if (compatible_values && compatible_values->values.empty()) {
            sys_page = false; // Empty value should NOT be treated as a system value
        }
    } else if (sys_page) {
        sys_page = (opt->second & osSystemValue) != 0;
    }
 
    modified_page |= (opt->second & osInitValue) == 0;
 
    //if (sys_page) sys_page = (opt->second & osSystemValue) != 0;
    //modified_page |= (opt->second & osInitValue) == 0;
}

References get_sys_and_mod_flags(), m_config, m_options_list, osInitValue, and osSystemValue.

Referenced by decorate(), get_sys_and_mod_flags(), and update_changed_tree_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

init_options_list()

void Slic3r::GUI::TabPrinter::init_options_list ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::init_options_list();
    if (m_printer_technology == ptFFF)
        m_options_list.emplace("extruders_count", m_opt_status_value);
}

References Slic3r::GUI::Tab::init_options_list(), init_options_list(), Slic3r::GUI::Tab::m_opt_status_value, Slic3r::GUI::Tab::m_options_list, m_printer_technology, and Slic3r::ptFFF.

Referenced by build_unregular_pages(), init_options_list(), and sync_extruders_count().

Here is the call graph for this function:

Here is the caller graph for this function:

is_printer_extruder_page()

bool Slic3r::GUI::Tab::is_printer_extruder_page ( const Page * page ) const

inlineinherited

{ return m_type == Preset::TYPE_PRINTER && page && page->title() == "Extruder"; }

References m_type, Slic3r::GUI::Page::title(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by check_extruder_options_status(), switch_excluder(), update_changed_tree_ui(), update_extruder_switch_colors(), and update_variant_sizer_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

load_config()

void Slic3r::GUI::Tab::load_config ( const DynamicPrintConfig & config )

inherited

{
    bool modified = 0;
    for(auto opt_key : m_config->diff(config)) {
        m_config->set_key_value(opt_key, config.option(opt_key)->clone());
        modified = 1;
    }
    if (modified) {
        update_dirty();
        //# Initialize UI components with the config values.
        reload_config();
        update();
    }
}

References Slic3r::ConfigOption::clone(), load_config(), m_config, Slic3r::ConfigBase::option(), reload_config(), update(), and update_dirty().

Referenced by get_config_manipulation(), Slic3r::GUI::MainFrame::load_config(), load_config(), set_custom_gcode(), Slic3r::GUI::TabFilament::set_custom_gcode(), and Slic3r::GUI::Sidebar::priv::switch_diameter().

Here is the call graph for this function:

Here is the caller graph for this function:

load_current_preset()

void Slic3r::GUI::Tab::load_current_preset ( )

inherited

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": enter, m_type %1%")%Preset::get_type_string(m_type);
    const Preset& preset = m_presets->get_edited_preset();
    std::vector<std::string> prev_variant_list;
    int prev_extruder_count = 0;
 
    update_btns_enabling();
 
    if (m_type == Slic3r::Preset::TYPE_PRINTER) {
        // For the printer profile, generate the extruder pages.
        if (preset.printer_technology() == ptFFF) {
            prev_variant_list = static_cast<TabPrinter*>(this)->m_extruder_variant_list;
            prev_extruder_count = static_cast<TabPrinter*>(this)->m_extruders_count;
            on_preset_loaded();
        }
        else
            wxGetApp().obj_list()->update_objects_list_filament_column(1);
    }
    if (m_type == Preset::TYPE_PRINT) {
        if (auto tab = wxGetApp().plate_tab) {
            tab->m_config->apply(*m_config);
            tab->update_extruder_variants();
        }
        for (auto tab : wxGetApp().model_tabs_list) {
            tab->m_config->apply(*m_config);
            tab->update_extruder_variants();
        }
    }
    update();
 
    // Reload preset pages with the new configuration values.
    update_extruder_variants(-1, false);
    reload_config();
 
    update_ui_items_related_on_parent_preset(m_presets->get_selected_preset_parent());
 
//  m_undo_to_sys_btn->Enable(!preset.is_default);
 
#if 0
    // use CallAfter because some field triggers schedule on_change calls using CallAfter,
    // and we don't want them to be called after this update_dirty() as they would mark the
    // preset dirty again
    // (not sure this is true anymore now that update_dirty is idempotent)
    wxTheApp->CallAfter([this]
#endif
    {
        // checking out if this Tab exists till this moment
        if (!wxGetApp().checked_tab(this))
            return;
        update_tab_ui();
 
        // update show/hide tabs
        if (m_type == Slic3r::Preset::TYPE_PRINTER) {
            const PrinterTechnology printer_technology = m_presets->get_edited_preset().printer_technology();
            if (printer_technology != static_cast<TabPrinter*>(this)->m_printer_technology)
            {
                // The change of the technology requires to remove some of unrelated Tabs
                // During this action, wxNoteBook::RemovePage invoke wxEVT_NOTEBOOK_PAGE_CHANGED
                // and as a result a function select_active_page() is called fron Tab::OnActive()
                // But we don't need it. So, to avoid activation of the page, set m_active_page to NULL
                // till unusable Tabs will be deleted
                Page* tmp_page = m_active_page;
                m_active_page = nullptr;
                for (auto tab : wxGetApp().tabs_list) {
                    if (tab->type() == Preset::TYPE_PRINTER) { // Printer tab is shown every time
                        int cur_selection = wxGetApp().tab_panel()->GetSelection();
                        if (cur_selection != 0)
                            wxGetApp().tab_panel()->SetSelection(wxGetApp().tab_panel()->GetPageCount() - 1);
                        continue;
                    }
                    if (tab->supports_printer_technology(printer_technology))
                    {
#ifdef _MSW_DARK_MODE
                        if (!wxGetApp().tabs_as_menu()) {
                            std::string bmp_name = tab->type() == Slic3r::Preset::TYPE_FILAMENT      ? "spool" :
                                                   tab->type() == Slic3r::Preset::TYPE_SLA_MATERIAL  ? "" : "cog";
                            tab->Hide(); // #ys_WORKAROUND : Hide tab before inserting to avoid unwanted rendering of the tab
                            dynamic_cast<Notebook*>(wxGetApp().tab_panel())->InsertPage(wxGetApp().tab_panel()->FindPage(this), wxString(), tab, tab->title(), bmp_name);
                        }
                        else
#endif
                            wxGetApp().tab_panel()->InsertPage(wxGetApp().tab_panel()->FindPage(this), tab, tab->title(), "");
                        #ifdef __linux__ // the tabs apparently need to be explicitly shown on Linux (pull request #1563)
                            int page_id = wxGetApp().tab_panel()->FindPage(tab);
                            wxGetApp().tab_panel()->GetPage(page_id)->Show(true);
                        #endif // __linux__
                    }
                    else {
                        int page_id = wxGetApp().tab_panel()->FindPage(tab);
                        wxGetApp().tab_panel()->GetPage(page_id)->Show(false);
                        wxGetApp().tab_panel()->RemovePage(page_id);
                    }
                }
                static_cast<TabPrinter*>(this)->m_printer_technology = printer_technology;
                m_active_page = tmp_page;
#ifdef _MSW_DARK_MODE
                if (!wxGetApp().tabs_as_menu())
                    dynamic_cast<Notebook*>(wxGetApp().tab_panel())->SetPageImage(wxGetApp().tab_panel()->FindPage(this), printer_technology == ptFFF ? "printer" : "sla_printer");
#endif
            }
            //update the object config due to extruder count change
            DynamicPrintConfig& new_print_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
            std::vector<std::string> new_variant_list = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionStrings>("printer_extruder_variant")->values;
            int new_extruder_count = wxGetApp().preset_bundle->get_printer_extruder_count();
            if (prev_extruder_count != new_extruder_count || prev_variant_list.size() != new_variant_list.size())
            {
                //process the object params here
                Model& model = wxGetApp().plater()->model();
                size_t num_objects = model.objects.size();
                for (int i = 0; i < num_objects; ++i) {
                    ModelObject* object = model.objects[i];
                    DynamicPrintConfig object_config = object->config.get();
                    if (!object_config.empty()) {
                        object_config.update_values_from_multi_to_multi_2(prev_variant_list, new_variant_list, new_print_config, print_options_with_variant);
                        object->config.assign_config(std::move(object_config));
                    }
                    for (ModelVolume* v : object->volumes) {
                        if (v->is_model_part() || v->is_modifier()) {
                            DynamicPrintConfig volume_config = v->config.get();
                            if (!volume_config.empty()) {
                                volume_config.update_values_from_multi_to_multi_2(prev_variant_list,new_variant_list,new_print_config, print_options_with_variant);
                                v->config.assign_config(std::move(volume_config));
                            }
                        }
                    }
 
                    for (auto &layer_config_it : object->layer_config_ranges) {
                        ModelConfig& layer_model_config = layer_config_it.second;
                        DynamicPrintConfig layer_config = layer_model_config.get();
                        if (!layer_config.empty()) {
                            layer_config.update_values_from_multi_to_multi_2(prev_variant_list,new_variant_list,new_print_config, print_options_with_variant);
                            layer_model_config.assign_config(std::move(layer_config));
                       }
                    }
                }
            }
 
            on_presets_changed();
            if (printer_technology == ptFFF) {
                static_cast<TabPrinter*>(this)->m_initial_extruders_count = static_cast<const ConfigOptionFloats*>(m_presets->get_selected_preset().config.option("nozzle_diameter"))->values.size(); //static_cast<TabPrinter*>(this)->m_extruders_count;
                const Preset* parent_preset = m_presets->get_selected_preset_parent();
                static_cast<TabPrinter*>(this)->m_sys_extruders_count = parent_preset == nullptr ? 0 :
                    static_cast<const ConfigOptionFloats*>(parent_preset->config.option("nozzle_diameter"))->values.size();
            }
        }
        else {
            on_presets_changed();
            if (m_type == Preset::TYPE_SLA_PRINT || m_type == Preset::TYPE_PRINT)
                update_frequently_changed_parameters();
        }
        m_opt_status_value = (m_presets->get_selected_preset_parent() ? osSystemValue : 0) | osInitValue;
        init_options_list();
        if (m_type == Preset::TYPE_PRINT) {
            for (auto tab : wxGetApp().model_tabs_list) {
                tab->init_options_list();
            }
        }
        update_visibility();
        update_changed_ui();
    }
#if 0
    );
#endif
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__<<boost::format(": exit");
}

References Slic3r::ModelConfig::assign_config(), Slic3r::ModelVolume::config, Slic3r::Preset::config, Slic3r::DynamicConfig::empty(), Slic3r::ModelConfig::get(), Slic3r::Preset::get_type_string(), init_options_list(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::is_modifier(), Slic3r::ModelObject::layer_config_ranges, load_current_preset(), m_active_page, m_config, m_opt_status_value, m_presets, m_type, Slic3r::Model::objects, on_preset_loaded(), on_presets_changed(), Slic3r::ConfigBase::option(), osInitValue, osSystemValue, Slic3r::print_options_with_variant, Slic3r::GUI::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, reload_config(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, Slic3r::Preset::TYPE_SLA_PRINT, update(), update_btns_enabling(), update_changed_ui(), update_extruder_variants(), update_frequently_changed_parameters(), update_tab_ui(), update_ui_items_related_on_parent_preset(), Slic3r::DynamicPrintConfig::update_values_from_multi_to_multi_2(), update_visibility(), and Slic3r::ModelObject::volumes.

Referenced by load_current_preset(), on_presets_changed(), select_preset(), and transfer_options().

Here is the call graph for this function:

Here is the caller graph for this function:

load_initial_data()

void Slic3r::GUI::Tab::load_initial_data ( )

inherited

{
    m_config = &m_presets->get_edited_preset().config;
    bool has_parent = m_presets->get_selected_preset_parent() != nullptr;
    m_bmp_non_system = has_parent ? &m_bmp_value_unlock : &m_bmp_white_bullet;
    m_ttg_non_system = has_parent ? &m_ttg_value_unlock : &m_ttg_white_bullet_ns;
    m_tt_non_system  = has_parent ? &m_tt_value_unlock  : &m_ttg_white_bullet_ns;
}

References m_bmp_non_system, m_bmp_value_unlock, m_bmp_white_bullet, m_config, m_presets, m_tt_non_system, m_tt_value_unlock, m_ttg_non_system, m_ttg_value_unlock, and m_ttg_white_bullet_ns.

Referenced by Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), Slic3r::GUI::TabPrinter::build(), Slic3r::GUI::TabPrintPlate::build(), Slic3r::GUI::TabSLAMaterial::build(), and Slic3r::GUI::TabSLAPrint::build().

Here is the caller graph for this function:

load_key_value()

void Slic3r::GUI::Tab::load_key_value ( const std::string & opt_key, const boost::any & value, bool saved_value = false )

protectedinherited

{
    if (!saved_value) change_opt_value(*m_config, opt_key, value);
    // Mark the print & filament enabled if they are compatible with the currently selected preset.
    if (opt_key == "compatible_printers" || opt_key == "compatible_prints") {
        // Don't select another profile if this profile happens to become incompatible.
        m_preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
    }
    if (m_presets_choice)
        m_presets_choice->update_dirty();
    on_presets_changed();
    update();
}

References Slic3r::GUI::change_opt_value(), load_key_value(), m_config, m_preset_bundle, m_presets_choice, Slic3r::Never, on_presets_changed(), and update().

Referenced by apply_preset_config_values(), compatible_widget_create(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), load_key_value(), and on_roll_back_value().

Here is the call graph for this function:

Here is the caller graph for this function:

may_discard_current_dirty_preset()

bool Slic3r::GUI::Tab::may_discard_current_dirty_preset ( PresetCollection * presets = nullptr, const std::string & new_printer_name = "", bool no_transfer = false, bool no_transfer_variant = false )

inherited

{
    if (presets == nullptr) presets = m_presets;
 
    UnsavedChangesDialog dlg(m_type, presets, new_printer_name, no_transfer);
    if (dlg.ShowModal() == wxID_CANCEL)
        return false;
 
    if (dlg.save_preset())  // save selected changes
    {
        const std::vector<std::string>& unselected_options = dlg.get_unselected_options(presets->type());
        const std::string& name = dlg.get_preset_name();
        //BBS: add project embedded preset relate logic
        bool save_to_project = dlg.get_save_to_project_option();
 
        if (m_type == presets->type()) // save changes for the current preset from this tab
        {
            // revert unselected options to the old values
            presets->get_edited_preset().config.apply_only(presets->get_selected_preset().config, unselected_options);
            //BBS: add project embedded preset relate logic
            save_preset(name, false, save_to_project);
            //save_preset(name);
        }
        else
        {
            //BBS: add project embedded preset relate logic
            m_preset_bundle->save_changes_for_preset(name, presets->type(), unselected_options, save_to_project);
            //m_preset_bundle->save_changes_for_preset(name, presets->type(), unselected_options);
 
            // If filament preset is saved for multi-material printer preset,
            // there are cases when filament comboboxs are updated for old (non-modified) colors,
            // but in full_config a filament_colors option aren't.
            if (presets->type() == Preset::TYPE_FILAMENT && wxGetApp().extruders_edited_cnt() > 1)
                wxGetApp().plater()->force_filament_colors_update();
        }
    }
    else if (dlg.transfer_changes()) // move selected changes
    {
        std::vector<std::string> selected_options = dlg.get_selected_options();
        if (!no_transfer && no_transfer_variant) {
            auto & options_list = wxGetApp().get_tab(presets->type())->m_options_list;
            bool has_variants = false;
            for (auto &opt : selected_options) {
                if (auto n = opt.find('#'); n != std::string::npos) {
                    auto iter = options_list.lower_bound(opt.substr(0, n));
                    if (iter == options_list.end() || opt.compare(0, n, iter->first)) {
                        has_variants = true;
                        opt.clear();
                    }
                }
            }
            if (has_variants) {
                auto msg = _L("Switching to a printer with different extruder types or numbers will discard or reset changes to extruder or multi-nozzle-related parameters.");
                MessageDialog(wxGetApp().plater(), msg, _L("Use Modified Value"), wxOK | wxICON_WARNING).ShowModal();
                selected_options.erase(std::remove(selected_options.begin(), selected_options.end(), ""), selected_options.end());
            }
        }
 
        if (m_type == presets->type()) // move changes for the current preset from this tab
        {
            if (m_type == Preset::TYPE_PRINTER) {
                auto it = std::find(selected_options.begin(), selected_options.end(), "extruders_count");
                if (it != selected_options.end()) {
                    // erase "extruders_count" option from the list
                    selected_options.erase(it);
                    // cache the extruders count
                    static_cast<TabPrinter*>(this)->cache_extruder_cnt();
                }
            }
 
            // copy selected options to the cache from edited preset
            cache_config_diff(selected_options);
        }
        else
            wxGetApp().get_tab(presets->type())->cache_config_diff(selected_options);
    }
 
    return true;
}

References _L, Slic3r::ConfigBase::apply_only(), cache_config_diff(), Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::UnsavedChangesDialog::get_preset_name(), Slic3r::GUI::UnsavedChangesDialog::get_save_to_project_option(), Slic3r::GUI::UnsavedChangesDialog::get_selected_options(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::GUI::UnsavedChangesDialog::get_unselected_options(), m_preset_bundle, m_presets, m_type, may_discard_current_dirty_preset(), name(), Slic3r::GUI::plater(), save_preset(), Slic3r::GUI::UnsavedChangesDialog::save_preset(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::UnsavedChangesDialog::ShowModal(), Slic3r::GUI::UnsavedChangesDialog::transfer_changes(), Slic3r::PresetCollection::type(), Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by may_discard_current_dirty_preset(), and select_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::TabPrinter::msw_rescale ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::msw_rescale();
 
    if (m_reset_to_filament_color)
        m_reset_to_filament_color->msw_rescale();
 
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
}

References Slic3r::GUI::Tab::m_parent, m_reset_to_filament_color, Slic3r::GUI::Tab::msw_rescale(), and msw_rescale().

Referenced by msw_rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

name()

std::string Slic3r::GUI::Tab::name ( ) const

inlineinherited

{ return m_presets->name(); }

References m_presets.

Referenced by may_discard_current_dirty_preset(), OnTreeSelChange(), save_preset(), and update_preset_description_line().

Here is the caller graph for this function:

on_gcode_flavor_changed()

void Slic3r::GUI::TabPrinter::on_gcode_flavor_changed

(

)

{
    auto* flavor_option = m_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor");
    if (!flavor_option)
        return;
    update_input_shaper_menu(flavor_option->value);
}

References Slic3r::GUI::Tab::m_config, on_gcode_flavor_changed(), and update_input_shaper_menu().

Referenced by on_gcode_flavor_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_preset_loaded()

void Slic3r::GUI::TabPrinter::on_preset_loaded ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    // R8: reset the belt-tilt transition tracking to reflect the freshly loaded preset WITHOUT
    // running update_fff()'s reset logic. on_preset_loaded() is called from Tab::load_current_preset()
    // on every printer preset load, right before update()->update_fff(). Seeding m_was_belt_printer
    // from the loaded preset's belt_printer flag means a preset switch (belt preset -> non-belt preset)
    // enters update_fff() with m_was_belt_printer==false, so the belt->off clear branch is skipped and
    // the newly loaded preset's manual tilt is preserved. An in-place belt toggle does NOT go through
    // here (only through on_value_change->update), so m_was_belt_printer stays true there and the clear
    // still fires. Seed m_belt_synced_tilt from the loaded tilt as a safeguard.
    m_was_belt_printer   = m_config->opt_bool("belt_printer");
    m_belt_synced_tilt_x = m_config->opt_float("build_plate_tilt_x");
    m_belt_synced_tilt_y = m_config->opt_float("build_plate_tilt_y");
 
    // Orca
    //update nozzle_volume_type
    const Preset& current_printer = m_preset_bundle->printers.get_selected_preset();
    const Preset* base_printer = m_preset_bundle->printers.get_preset_base(current_printer);
    if (!base_printer)
        base_printer = &current_printer;
    std::string base_name = base_printer->name;
    // update the extruders count field
    auto   *nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(m_config->option("nozzle_diameter"));
    size_t extruders_count = nozzle_diameter->values.size();
    // update the GUI field according to the number of nozzle diameters supplied
    if (m_extruders_count != extruders_count)
        extruders_count_changed(extruders_count);
 
    m_extruder_variant_list = m_config->option<ConfigOptionStrings>("printer_extruder_variant")->values;
 
    if (base_name != m_base_preset_name) {
        bool use_default_nozzle_volume_type = true;
        m_base_preset_name = base_name;
        std::string prev_nozzle_volume_type = wxGetApp().app_config->get_nozzle_volume_types_from_config(base_name);
        if (!prev_nozzle_volume_type.empty()) {
            ConfigOptionEnumsGeneric* nozzle_volume_type_option = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
            if (nozzle_volume_type_option->deserialize(prev_nozzle_volume_type)) {
                use_default_nozzle_volume_type = false;
            }
        }
        if (use_default_nozzle_volume_type) {
            m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values = current_printer.config.option<ConfigOptionEnumsGeneric>("default_nozzle_volume_type")->values;
        }
 
        // Changing printer model drops any Filament Track Switch context from the previous
        // printer; clear both device-derived flags so a switch-less printer never inherits a
        // stale installed/active state (re-derived by device sync when a printer is connected).
        if (auto* has_switcher = m_preset_bundle->project_config.opt<ConfigOptionBool>("has_filament_switcher"))
            has_switcher->value = false;
        if (auto* dynamic_map = m_preset_bundle->project_config.opt<ConfigOptionBool>("enable_filament_dynamic_map"))
            dynamic_map->value = false;
        // Orca: also clear the sidebar switcher status icon on printer-model change (mirrors BBS's
        // reset_fila_switch on machine change); it re-derives from device sync once a printer connects.
        if (wxGetApp().plater())
            wxGetApp().plater()->sidebar().reset_fila_switch();
    }
 
    // Purge mode selection is only meaningful for printers with multiple sub-nozzles per
    // extruder (prime saving) or fast-purge support; reset stale project values that the
    // current printer cannot honor and toggle the sidebar button accordingly.
    auto extruder_max_nozzle_count = current_printer.config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    bool has_multiple_nozzle = extruder_max_nozzle_count &&
        std::any_of(extruder_max_nozzle_count->values.begin(), extruder_max_nozzle_count->values.end(),
                    [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); });
    auto support_fast_purge_opt = current_printer.config.option<ConfigOptionBool>("support_fast_purge_mode");
    bool support_fast_purge     = support_fast_purge_opt ? support_fast_purge_opt->value : false;
    bool show_purge_mode        = has_multiple_nozzle || support_fast_purge;
    if (auto *prime_volume_mode = m_preset_bundle->project_config.option<ConfigOptionEnum<PrimeVolumeMode>>("prime_volume_mode")) {
        if (!show_purge_mode)
            prime_volume_mode->value = PrimeVolumeMode::pvmDefault;
        else if (!has_multiple_nozzle && prime_volume_mode->value == PrimeVolumeMode::pvmSaving)
            prime_volume_mode->value = PrimeVolumeMode::pvmDefault;
        else if (!support_fast_purge && prime_volume_mode->value == PrimeVolumeMode::pvmFast)
            prime_volume_mode->value = PrimeVolumeMode::pvmDefault;
    }
    if (wxGetApp().plater())
        wxGetApp().plater()->sidebar().enable_purge_mode_btn(show_purge_mode);
 
    // Sidebar nozzle-count badge on the extruder cards. The `extruder_nozzle_stats` key is session-only —
    // saved presets never carry it, so any preset switch rebuilds the edited config without it — so
    // re-baseline it whenever it is missing (each extruder gets extruder_max_nozzle_count nozzles of its
    // selected volume type), then refresh the badges. Idempotent, so run on every preset load.
    if (wxGetApp().plater())
        wxGetApp().plater()->sidebar().enable_nozzle_count_edit(has_multiple_nozzle);
    const auto *nozzle_stats = m_preset_bundle->printers.get_edited_preset().config.option<ConfigOptionStrings>("extruder_nozzle_stats");
    if (nozzle_stats == nullptr || nozzle_stats->values.empty())
        seedExtruderNozzleStats(m_preset_bundle);
    if (auto *nozzle_volume_type = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type"))
        for (size_t idx = 0; idx < nozzle_volume_type->values.size(); ++idx)
            updateNozzleCountDisplay(m_preset_bundle, idx, NozzleVolumeType(nozzle_volume_type->values[idx]));
}

References Slic3r::Preset::config, Slic3r::ConfigOptionEnumsGenericTempl< NULLABLE >::deserialize(), Slic3r::extruder_max_nozzle_count(), extruders_count_changed(), m_base_preset_name, m_belt_synced_tilt_x, m_belt_synced_tilt_y, Slic3r::GUI::Tab::m_config, m_extruder_variant_list, m_extruders_count, Slic3r::GUI::Tab::m_preset_bundle, m_was_belt_printer, Slic3r::Preset::name, Slic3r::nozzle_diameter(), Slic3r::nozzle_volume_type(), on_preset_loaded(), Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), Slic3r::pvmDefault, Slic3r::pvmFast, Slic3r::pvmSaving, Slic3r::GUI::seedExtruderNozzleStats(), Slic3r::GUI::updateNozzleCountDisplay(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by on_preset_loaded().

Here is the call graph for this function:

Here is the caller graph for this function:

on_presets_changed()

void Slic3r::GUI::Tab::on_presets_changed ( )

protectedinherited

{
    if (wxGetApp().plater() == nullptr)
        return;
 
    // Instead of PostEvent (EVT_TAB_PRESETS_CHANGED) just call update_presets
    wxGetApp().plater()->sidebar().update_presets(m_type);
 
    // Check if printer agent needs switching
    if (m_type == Preset::TYPE_PRINTER) {
        wxGetApp().switch_printer_agent();
 
        // Trigger per-vendor preset update check
        const Preset& printer_preset = m_preset_bundle->printers.get_edited_preset();
        if (printer_preset.vendor) {
            wxGetApp().get_preset_updater()->check_vendor_update(printer_preset.vendor->id);
        }
    }
 
    bool is_bbl_vendor_preset = m_preset_bundle->is_bbl_vendor();
    if (is_bbl_vendor_preset) {
        wxGetApp().plater()->get_partplate_list().set_render_option(true, true);
        if (m_preset_bundle->printers.get_edited_preset().has_cali_lines(wxGetApp().preset_bundle)) {
            wxGetApp().plater()->get_partplate_list().set_render_cali(true);
        } else {
            wxGetApp().plater()->get_partplate_list().set_render_cali(false);
        }
    } else {
        wxGetApp().plater()->get_partplate_list().set_render_option(false, true);
        wxGetApp().plater()->get_partplate_list().set_render_cali(false);
    }
 
    // Printer selected at the Printer tab, update "compatible" marks at the print and filament selectors.
    for (auto t: m_dependent_tabs)
    {
        Tab* tab = wxGetApp().get_tab(t);
        // If the printer tells us that the print or filament/sla_material preset has been switched or invalidated,
        // refresh the print or filament/sla_material tab page.
        // But if there are options, moved from the previously selected preset, update them to edited preset
        tab->apply_config_from_cache();
        tab->load_current_preset();
    }
    // clear m_dependent_tabs after first update from select_preset()
    // to avoid needless preset loading from update() function
    m_dependent_tabs.clear();
 
    wxGetApp().plater()->update_project_dirty_from_presets();
 
    // ORCA also update states of plates for plates toolbar. same method exist on Plater::priv::on_select_preset()
    auto& plate_list = wxGetApp().plater()->get_partplate_list();
    for (auto plate : plate_list.get_plate_list())
        plate->update_slice_result_valid_state(false);
}

References Tab(), apply_config_from_cache(), Slic3r::VendorProfile::id, load_current_preset(), m_dependent_tabs, m_preset_bundle, m_type, on_presets_changed(), Slic3r::GUI::plater(), Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::vendor.

Referenced by Slic3r::GUI::TabPrinter::create_bed_shape_widget(), load_current_preset(), load_key_value(), on_presets_changed(), on_value_change(), save_preset(), select_preset(), update_dirty(), and update_tab_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

on_roll_back_value()

void Slic3r::GUI::Tab::on_roll_back_value ( const bool to_sys = false )

inherited

{
    // BBS: restore all pages in preset
    // if (!m_active_page) return;
 
    int os;
    if (to_sys) {
        if (!m_is_nonsys_values) return;
        os = osSystemValue;
    }
    else {
        // BBS: restore all pages in preset
        if (!m_presets->get_edited_preset().is_dirty) return;
        os = osInitValue;
    }
 
    m_postpone_update_ui = true;
 
    // BBS: restore all preset
    for (auto page : m_pages)
    for (auto group : page->m_optgroups) {
        if (group->title == "Capabilities") {
            if ((m_options_list["extruders_count"] & os) == 0)
                to_sys ? group->back_to_sys_value("extruders_count") : group->back_to_initial_value("extruders_count");
        }
        if (group->title == "Size and coordinates") {
            if ((m_options_list["printable_area"] & os) == 0) {
                to_sys ? group->back_to_sys_value("printable_area") : group->back_to_initial_value("printable_area");
                load_key_value("printable_area", true/*some value*/, true);
            }
        }
        if (group->title == "Profile dependencies") {
            if (m_type != Preset::TYPE_PRINTER && (m_options_list["compatible_printers"] & os) == 0) {
                to_sys ? group->back_to_sys_value("compatible_printers") : group->back_to_initial_value("compatible_printers");
                load_key_value("compatible_printers", true/*some value*/, true);
            }
            if ((m_type == Preset::TYPE_FILAMENT || m_type == Preset::TYPE_SLA_MATERIAL) && (m_options_list["compatible_prints"] & os) == 0) {
                to_sys ? group->back_to_sys_value("compatible_prints") : group->back_to_initial_value("compatible_prints");
                load_key_value("compatible_prints", true/*some value*/, true);
            }
        }
        for (const auto &kvp : group->opt_map()) {
            const std::string &opt_key = kvp.first;
            auto iter = m_options_list.find(opt_key);
            if (iter != m_options_list.end() && (iter->second & os) == 0)
                to_sys ? group->back_to_sys_value(opt_key) : group->back_to_initial_value(opt_key);
        }
    }
 
    // BBS: restore all pages in preset
    m_presets->discard_current_changes();
 
    m_postpone_update_ui = false;
 
    // Orca: the restored config may have another extruder count than the tab shows.
    if (auto printer_tab = dynamic_cast<TabPrinter *>(this))
        printer_tab->sync_extruders_count();
 
    // When all values are rolled, then we have to update whole tab in respect to the reverted values
    update();
    if (m_active_page)
        m_active_page->update_visibility(m_mode, true);
 
    // BBS: restore all pages in preset, update_dirty also update combobox
    update_dirty();
 
    if (m_compatible_printers.checkbox) {
        bool is_empty = m_config->option<ConfigOptionStrings>("compatible_printers")->values.empty();
        m_compatible_printers.checkbox->SetValue(is_empty);
        is_empty ? m_compatible_printers.btn->Disable() : m_compatible_printers.btn->Enable();
    }
    if (m_compatible_prints.checkbox) {
        bool is_empty = m_config->option<ConfigOptionStrings>("compatible_prints")->values.empty();
        m_compatible_prints.checkbox->SetValue(is_empty);
        is_empty ? m_compatible_prints.btn->Disable() : m_compatible_prints.btn->Enable();
    }
 
    m_page_view->GetParent()->Layout();
}

References Slic3r::ConfigOptionVector< T >::empty(), load_key_value(), m_active_page, m_compatible_printers, m_compatible_prints, m_config, m_is_nonsys_values, m_mode, m_options_list, m_page_view, m_pages, m_postpone_update_ui, m_presets, m_type, on_roll_back_value(), osInitValue, osSystemValue, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, update(), and update_dirty().

Referenced by create_preset_tab(), and on_roll_back_value().

Here is the call graph for this function:

Here is the caller graph for this function:

on_value_change()

void Slic3r::GUI::TabPrinter::on_value_change ( const std::string & opt_key, const boost::any & value )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    if (wxGetApp().plater() == nullptr || m_config_manipulation.is_applying())
        return;
 
    const int pos = opt_key.find("#");
    // Orca: fields of the single Extruder page keep index 0 but edit the selected extruder.
    const int data_idx = pos > 0 ? extruder_page_data_index(opt_key) : -1;
 
    if (pos > 0) {
        std::string temp_str = opt_key;
        boost::erase_head(temp_str, pos + 1);
        int orig_opt_idx = static_cast<size_t>(atoi(temp_str.c_str()));
        int opt_idx = orig_opt_idx >= 0 ? orig_opt_idx : 0;
        if (data_idx >= 0)
            opt_idx = data_idx;
 
        std::string opt_key_pure = opt_key;
        boost::erase_tail(opt_key_pure, opt_key_pure.size() - pos);
 
        if (opt_key_pure == "retract_after_wipe" || opt_key_pure == "retract_before_wipe") {
            auto percent_value_clamp = [](double percent_value) { return std::clamp(percent_value, 0., 100.); };
            double dvalue = boost::any_cast<double>(value);
 
            double retract_before_wipe = percent_value_clamp(opt_key_pure == "retract_before_wipe"
                ? dvalue : m_config->option<ConfigOptionPercents>("retract_before_wipe")->get_at(opt_idx));
 
            double retract_after_wipe = percent_value_clamp(opt_key_pure == "retract_after_wipe"
                ? dvalue : m_config->option<ConfigOptionPercents>("retract_after_wipe")->get_at(opt_idx));
 
            bool need_to_reload_config = false;
 
            if (percent_value_clamp(dvalue) != dvalue) {
                change_opt_value(*m_config, opt_key_pure, percent_value_clamp(dvalue), opt_idx);
                need_to_reload_config = true;
            }
 
            if (retract_after_wipe > 100. - retract_before_wipe) {
                change_opt_value(*m_config, "retract_after_wipe", 100. - retract_before_wipe, opt_idx);
                need_to_reload_config = true;
            }
 
            if (need_to_reload_config && !m_postpone_update_ui) {
                update_dirty();
                reload_config();
                update_tab_ui();
            }
        }
    }
 
    // Orca: report Extruder page changes as "key#<extruder>", as the former "Extruder N" pages did,
    // so per-extruder handling in Tab::on_value_change() sees the extruder that was edited.
    if (data_idx >= 0)
        Tab::on_value_change(opt_key.substr(0, pos) + "#" + std::to_string(get_current_active_extruder()), value);
    else
        Tab::on_value_change(opt_key, value);
}

References Slic3r::GUI::change_opt_value(), extruder_page_data_index(), Slic3r::GUI::Tab::get_current_active_extruder(), Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_config_manipulation, Slic3r::GUI::Tab::m_postpone_update_ui, Slic3r::GUI::Tab::on_value_change(), on_value_change(), Slic3r::GUI::plater(), reload_config(), Slic3r::retract_after_wipe(), Slic3r::GUI::Tab::update_dirty(), and Slic3r::GUI::Tab::update_tab_ui().

Referenced by build_fff(), build_unregular_pages(), extruders_count_changed(), on_value_change(), set_extruder_volume_type(), and update_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

OnActivate()

void Slic3r::GUI::Tab::OnActivate ( )

virtualinherited

{
    //BBS: GUI refactor
    //noUpdates seems not working
    //wxWindowUpdateLocker noUpdates(this);
/*#ifdef __WXOSX__
//    wxWindowUpdateLocker noUpdates(this);
    auto size = GetSizer()->GetSize();
    m_tmp_panel->GetSizer()->SetMinSize(size.x + m_size_move, size.y);
    Fit();
    m_size_move *= -1;
#endif // __WXOSX__*/
 
#ifdef __WXMSW__
    // Workaround for tooltips over Tree Controls displayed over excessively long
    // tree control items, stealing the window focus.
    //
    // In case the Tab was reparented from the MainFrame to the floating dialog,
    // the tooltip created by the Tree Control before reparenting is not reparented,
    // but it still points to the MainFrame. If the tooltip pops up, the MainFrame
    // is incorrectly focussed, stealing focus from the floating dialog.
    //
    // The workaround is to delete the tooltip control.
    // Vojtech tried to reparent the tooltip control, but it did not work,
    // and if the Tab was later reparented back to MainFrame, the tooltip was displayed
    // at an incorrect position, therefore it is safer to just discard the tooltip control
    // altogether.
    HWND hwnd_tt = TreeView_GetToolTips(m_tabctrl->GetHandle());
    if (hwnd_tt) {
      HWND hwnd_toplevel  = find_toplevel_parent(m_tabctrl)->GetHandle();
      HWND hwnd_parent  = ::GetParent(hwnd_tt);
      if (hwnd_parent != hwnd_toplevel) {
        ::DestroyWindow(hwnd_tt);
      TreeView_SetToolTips(m_tabctrl->GetHandle(), nullptr);
      }
    }
#endif
 
    // The OnActivate() that shows the tab builds the page.
    if (wxGetApp().mainframe != nullptr && !wxGetApp().mainframe->is_active_and_shown_tab(m_parent))
        return;
 
    // BBS: select on first active
    if (!m_active_page)
        restore_last_select_item();
 
    //BBS: GUI refactor
    m_page_view->Freeze();
 
    // create controls on active page
    activate_selected_page([](){});
    //BBS: GUI refactor
    //m_main_sizer->Layout();
    m_parent->Layout();
 
#ifdef _MSW_DARK_MODE
    // Because of DarkMode we use our own Notebook (inherited from wxSiplebook) instead of wxNotebook
    // And it looks like first Layout of the page doesn't update a size of the m_presets_choice
    // So we have to set correct size explicitely
   /* if (wxSize ok_sz = wxSize(35 * m_em_unit, m_presets_choice->GetBestSize().y);
        ok_sz != m_presets_choice->GetSize()) {
        m_presets_choice->SetMinSize(ok_sz);
        m_presets_choice->SetSize(ok_sz);
        GetSizer()->GetItem(size_t(0))->GetSizer()->Layout();
        if (wxGetApp().tabs_as_menu())
            m_presets_choice->update();
    }*/
#endif // _MSW_DARK_MODE
    Refresh();
 
    //BBS: GUI refactor
    m_page_view->Thaw();
}

References activate_selected_page(), Slic3r::GUI::find_toplevel_parent(), m_active_page, m_page_view, m_parent, m_tabctrl, and restore_last_select_item().

Referenced by Slic3r::GUI::ParamsPanel::OnActivate(), Slic3r::GUI::MainFrame::select_tab(), Slic3r::GUI::PlaterPresetComboBox::switch_to_tab(), and tree_sel_change_delayed().

Here is the call graph for this function:

Here is the caller graph for this function:

OnKeyDown()

void Slic3r::GUI::Tab::OnKeyDown ( wxKeyEvent & event )

inherited

{
    if (event.GetKeyCode() == WXK_TAB)
        m_tabctrl->Navigate(event.ShiftDown() ? wxNavigationKeyEvent::IsBackward : wxNavigationKeyEvent::IsForward);
    else
        event.Skip();
}

References m_tabctrl, and OnKeyDown().

Referenced by create_preset_tab(), and OnKeyDown().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTreeSelChange()

void Slic3r::GUI::Tab::OnTreeSelChange ( wxCommandEvent & event )

inherited

References name().

Here is the call graph for this function:

options_list_storage_key()

std::string Slic3r::GUI::Tab::options_list_storage_key ( const std::string & opt_key ) const

inherited

{
    if (opt_key == "printable_area" || opt_key == "bed_exclude_area" || opt_key == "compatible_prints" ||
        opt_key == "compatible_printers" || opt_key == "thumbnails" || opt_key == "wrapping_exclude_area")
        return opt_key;
 
    if (m_config == nullptr || !m_config->has(opt_key))
        return opt_key;
 
    const ConfigOption* option = m_config->option(opt_key);
    if (option == nullptr || !option->is_vector())
        return opt_key;
 
    const ConfigOptionDef* def = m_config->def()->get(opt_key);
    if (def == nullptr)
        return opt_key;
 
    const bool serialized = def->gui_flags == "serialized";
    const bool is_plugin_field = def->gui_type == ConfigOptionDef::GUIType::plugin_picker;
    return (serialized || is_plugin_field) ? opt_key : opt_key + "#0";
}

References Slic3r::ConfigOptionDef::gui_flags, Slic3r::ConfigOptionDef::gui_type, Slic3r::ConfigOption::is_vector(), m_config, and Slic3r::ConfigOptionDef::plugin_picker.

Referenced by init_options_list().

Here is the call graph for this function:

Here is the caller graph for this function:

page_build_pending()

bool Slic3r::GUI::Tab::page_build_pending ( ) const

inherited

{
    return m_active_page != nullptr && (m_active_page->build_pending() || m_active_page->visibility_pending());
}

References m_active_page, and page_build_pending().

Referenced by Slic3r::GUI::ParamsPanel::SettingsPagePrebuild::built(), page_build_pending(), and page_build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

page_build_step()

bool Slic3r::GUI::Tab::page_build_step ( )

inherited

{
    if (m_active_page == nullptr)
        return false;
    if (m_active_page->build_pending())
        m_active_page->build_step(m_mode);
    else
        m_active_page->update_visibility(m_mode, true);
    return page_build_pending();
}

References m_active_page, m_mode, page_build_pending(), and page_build_step().

Referenced by Slic3r::GUI::ParamsPanel::SettingsPagePrebuild::build_step(), and page_build_step().

Here is the call graph for this function:

Here is the caller graph for this function:

parent()

wxWindow * Slic3r::GUI::Tab::parent ( ) const

inlineinherited

{ return m_parent; }

References m_parent.

Referenced by Tab(), Slic3r::GUI::TabFilament::TabFilament(), Slic3r::GUI::TabPrint::TabPrint(), Slic3r::GUI::TabPrinter::TabPrinter(), Slic3r::GUI::TabPrintLayer::TabPrintLayer(), Slic3r::GUI::TabPrintModel::TabPrintModel(), Slic3r::GUI::TabPrintObject::TabPrintObject(), Slic3r::GUI::TabPrintPart::TabPrintPart(), Slic3r::GUI::TabPrintPlate::TabPrintPlate(), Slic3r::GUI::TabSLAMaterial::TabSLAMaterial(), Slic3r::GUI::TabSLAPrint::TabSLAPrint(), Slic3r::GUI::TabFilament::add_filament_overrides_page(), add_scaled_bitmap(), add_scaled_button(), Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrinter::build_fff(), build_preset_description_line(), Slic3r::GUI::TabPrinter::build_unregular_pages(), compatible_widget_create(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), delete_preset(), description_line_widget(), supports_printer_technology(), Slic3r::GUI::TabPrinter::toggle_options(), update_changed_ui(), update_preset_description_line(), and validate_filament_temperature_pairs().

Here is the caller graph for this function:

parse_extruder_selection()

void Slic3r::GUI::Tab::parse_extruder_selection ( int selection, int & extruder_id, NozzleVolumeType & nozzle_type )

inherited

{
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    int  extruder_nums  = m_preset_bundle->get_printer_extruder_count();
 
    int current_index = 0;
 
    for (int i = 0; i < extruder_nums; ++i) {
        NozzleVolumeType volume_type = NozzleVolumeType(nozzle_volumes->values[i]);
 
        if (volume_type == NozzleVolumeType::nvtHybrid) {
            if (selection == current_index) {
                extruder_id = i;
                nozzle_type = NozzleVolumeType::nvtStandard;
                return;
            } else if (selection == current_index + 1) {
                extruder_id = i;
                nozzle_type = NozzleVolumeType::nvtHighFlow;
                return;
            }
            current_index += 2;
        } else {
            if (selection == current_index) {
                extruder_id = i;
                nozzle_type = volume_type;
                return;
            }
            current_index += 1;
        }
    }
 
    extruder_id = 0;
    nozzle_type = NozzleVolumeType::nvtStandard;
}

References m_preset_bundle, Slic3r::nozzle_type(), Slic3r::nvtHighFlow, Slic3r::nvtHybrid, and Slic3r::nvtStandard.

Referenced by check_extruder_options_status(), create_preset_tab(), and get_current_active_extruder().

Here is the call graph for this function:

Here is the caller graph for this function:

reactive_preset_combo_box()

void Slic3r::GUI::Tab::reactive_preset_combo_box ( )

inherited

{
    if (!m_presets_choice) return;
    //BBS: add workaround to fix the issue caused by wxwidget 3.15 upgrading
    m_presets_choice->Enable(false);
    m_presets_choice->Enable(true);
}

References m_presets_choice, and reactive_preset_combo_box().

Referenced by reactive_preset_combo_box().

Here is the call graph for this function:

Here is the caller graph for this function:

rebuild_page_tree()

void Slic3r::GUI::Tab::rebuild_page_tree ( )

inherited

{
    // get label of the currently selected item
    auto sel_item = m_tabctrl->GetSelection();
    // BBS: fix new layout, record last select
    if (sel_item < 0)
        sel_item = m_last_select_item;
    const auto selected = sel_item >= 0 ? m_tabctrl->GetItemText(sel_item) : "";
 
    int item = -1;
 
    // Delete/Append events invoke wxEVT_TAB_SEL_CHANGED event.
    // To avoid redundant clear/activate functions call
    // suppress activate page before page_tree rebuilding
    m_disable_tree_sel_changed_event = true;
 
    int curr_item = 0;
    for (auto p : m_pages)
    {
        if (!p->get_show())
            continue;
        if (m_tabctrl->GetCount() <= curr_item) {
            m_tabctrl->AppendItem(translate_category(p->title(), m_type), p->iconID());
        } else {
            m_tabctrl->SetItemText(curr_item, translate_category(p->title(), m_type));
        }
        m_tabctrl->SetItemTextColour(curr_item, p->get_item_colour() == m_modified_label_clr ? p->get_item_colour() : StateColor(
                        std::make_pair(0x6B6B6C, (int) StateColor::NotChecked),
                        std::make_pair(p->get_item_colour(), (int) StateColor::Normal)));
        if (translate_category(p->title(), m_type) == selected)
            item = curr_item;
        curr_item++;
    }
    while (m_tabctrl->GetCount() > curr_item) {
        m_tabctrl->DeleteItem(m_tabctrl->GetCount() - 1);
    }
 
    // BBS: on mac, root is selected, this fix it
    m_tabctrl->Unselect();
    // BBS: not select on hide tab
    if (item == -1 && m_parent->is_active_and_shown_tab(this)) {
        // this is triggered on first load, so we don't disable the sel change event
        item = m_tabctrl->GetFirstVisibleItem();
    }
    // BBS: fix new layout, record last select
    if (sel_item == m_last_select_item)
        m_last_select_item = item;
    else
        m_last_select_item = 0;
 
    // allow activate page before selection of a page_tree item
    m_disable_tree_sel_changed_event = false;
    //BBS: GUI refactor
    if (item >= 0)
    {
        bool ret = update_current_page_in_background(item);
        //if m_active_page is changed in update_current_page_in_background
        //will just update the selected item of the treectrl
         if (m_parent->is_active_and_shown_tab(this)) // FIX: modify state not update
            m_tabctrl->SelectItem(item);
    }
}

References m_disable_tree_sel_changed_event, m_last_select_item, m_modified_label_clr, m_pages, m_parent, m_tabctrl, m_type, StateColor::Normal, StateColor::NotChecked, rebuild_page_tree(), translate_category(), and update_current_page_in_background().

Referenced by Slic3r::GUI::TabPrinter::build_unregular_pages(), create_preset_tab(), rebuild_page_tree(), Slic3r::GUI::TabPrinter::update_pages(), and update_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_printer_agent_dropdown()

void Slic3r::GUI::TabPrinter::refresh_printer_agent_dropdown

(

)

const

{
    auto* choice = dynamic_cast<PrinterAgentChoice*>(get_field("printer_agent"));
    if (!choice || !choice->getWindow())
        return;
 
    const auto agents = NetworkAgentFactory::get_registered_printer_agents();
    if (agents.empty())
        return;
 
    // why: rows live on PrinterAgentChoice now; rebuild them from the live registry and re-select the stored id.
    const std::string selected_agent = wxGetApp().preset_bundle->printers.get_edited_preset()
                                                 .config.opt_string("printer_agent");
    choice->reload_rows();
    choice->set_value(selected_agent, false);
    this->GetParent()->Layout();
}

References Slic3r::GUI::Tab::get_field(), Slic3r::NetworkAgentFactory::get_registered_printer_agents(), and refresh_printer_agent_dropdown().

Referenced by refresh_printer_agent_dropdown().

Here is the call graph for this function:

Here is the caller graph for this function:

reload_config()

void Slic3r::GUI::TabPrinter::reload_config ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::reload_config();
 
    // "extruders_count" doesn't update from the update_config(),
    // so update it implicitly
    if (m_active_page && m_active_page->title() == "Multimaterial")
        m_active_page->set_value("extruders_count", int(m_extruders_count));
 
    if (m_config) {
        // imex_tool_layout / imex_viz_theme are now real enum options handled by
        // standard Choice fields; only the modes grid still needs explicit re-sync
        // because it spans three options at once and isn't a Field.
        if (m_imex_modes_ctrl) {
            int n_cols = 0, n_rows = 0, layout = 0;
            imex_grid_shape(m_config, n_cols, n_rows, layout);
            m_imex_modes_ctrl->set_grid_size(n_cols, n_rows, layout);
            m_imex_modes_ctrl->load_from_config(*m_config);
        }
    }
}

References Slic3r::GUI::imex_grid_shape(), Slic3r::GUI::Tab::m_active_page, Slic3r::GUI::Tab::m_config, m_extruders_count, m_imex_modes_ctrl, Slic3r::GUI::Tab::reload_config(), and reload_config().

Referenced by build_unregular_pages(), on_value_change(), and reload_config().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_last_select_item()

void Slic3r::GUI::Tab::restore_last_select_item ( )

inherited

{
    auto item = m_last_select_item;
    if (item == -1)
        item = m_tabctrl->GetFirstVisibleItem();
    m_tabctrl->SelectItem(item);
}

References m_last_select_item, m_tabctrl, and restore_last_select_item().

Referenced by create_preset_tab(), Slic3r::GUI::Plater::priv::on_modify_filament(), OnActivate(), restore_last_select_item(), Slic3r::GUI::ParamsPanel::set_active_tab(), and Slic3r::GUI::PlaterPresetComboBox::switch_to_tab().

Here is the call graph for this function:

Here is the caller graph for this function:

save_preset()

void Slic3r::GUI::Tab::save_preset ( std::string name = std::string(), bool detach = false, bool save_to_project = false, bool from_input = false, std::string input_name = "" )

inherited

m_tabctrl->OnSetFocus();

{
    // ORCA: Validate before opening any save-name UI for filament presets.
    if (!validate_filament_temperature_pairs())
        return;
 
    // since buttons(and choices too) don't get focus on Mac, we set focus manually
    // to the treectrl so that the EVT_* events are fired for the input field having
    // focus currently.is there anything better than this ?
    if (from_input) {
        SavePresetDialog dlg(m_parent, m_type, m_mode, detach ? _u8L("Detached") : "");
        dlg.Show(false);
        dlg.input_name_from_other(input_name);
        wxCommandEvent evt(wxEVT_TEXT, GetId());
        dlg.GetEventHandler()->ProcessEvent(evt);
        dlg.confirm_from_other();
        name = input_name;
        detach = dlg.get_detach_value(m_type);
    }
 
    if (name.empty()) {
        SavePresetDialog dlg(m_parent, m_type, m_mode, detach ? _u8L("Detached") : "");
        if (!m_just_edit) {
            if (dlg.ShowModal() != wxID_OK)
                return;
        }
        name = dlg.get_name();
        //BBS: add project embedded preset relate logic
        save_to_project = dlg.get_save_to_project_selection(m_type);
        detach          = dlg.get_detach_value(m_type);
    }
 
    //BBS record current preset name
    Preset& edited_preset = m_presets->get_edited_preset();
    std::string curr_preset_name = edited_preset.name;
 
    bool exist_preset = false;
    Preset* new_preset = m_presets->find_preset(name, false);
    if (new_preset) {
        exist_preset = true;
    }
 
    // Orca: check if compatible_printers exists and is not empty, set it to the current printer if it is empty
    // Ensures that custom filaments based on system are not accidentally allowed for all printers
    // Can still be set for all after creation
    if (m_presets->type() == Preset::TYPE_FILAMENT && !exist_preset && edited_preset.is_system) {
        Preset* _curr_printer = const_cast<Preset*>(&wxGetApp().preset_bundle->printers.get_selected_preset_base());
        ConfigOptionStrings* compatible_printers = m_config->option<ConfigOptionStrings>("compatible_printers");
        if (nullptr != _curr_printer && compatible_printers && compatible_printers->values.empty())
            compatible_printers->values.push_back(_curr_printer->name);
    }
    // Save the preset into Slic3r::data_dir / presets / section_name / preset_name.json
    m_presets->save_current_preset(name, detach, save_to_project, nullptr);
 
    //BBS create new settings
    new_preset = m_presets->find_preset(name, false, true);
    //Preset* preset = &m_presets.preset(it - m_presets.begin(), true);
    if (!new_preset) {
        BOOST_LOG_TRIVIAL(info) << "create new preset failed";
        return;
    }
 
    // set sync_info for sync service
    if (exist_preset) {
        new_preset->sync_info = "update";
        BOOST_LOG_TRIVIAL(info) << "sync_preset: update preset = " << new_preset->name;
    }
    else {
        new_preset->sync_info = "create";
        if (wxGetApp().is_user_login())
            new_preset->user_id = wxGetApp().getAgent()->get_user_id();
        BOOST_LOG_TRIVIAL(info) << "sync_preset: create preset = " << new_preset->name;
    }
    new_preset->save_info();
 
    // Mark the print & filament enabled if they are compatible with the currently selected preset.
    // If saving the preset changes compatibility with other presets, keep the now incompatible dependent presets selected, however with a "red flag" icon showing that they are no more compatible.
    m_preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
    // Add the new item into the UI component, remove dirty flags and activate the saved item.
    update_tab_ui();
 
    // Update the selection boxes at the plater.
    on_presets_changed();
 
    //BBS if create a new prset name, preset changed from preset name to new preset name
    if (!exist_preset) {
        wxGetApp().plater()->sidebar().update_presets_from_to(m_type, curr_preset_name, new_preset->name);
    }
 
    // If current profile is saved, "delete preset" button have to be enabled
    m_btn_delete_preset->Show();
    m_btn_delete_preset->GetParent()->Layout();
 
    if (m_type == Preset::TYPE_PRINTER)
        static_cast<TabPrinter*>(this)->m_initial_extruders_count = static_cast<TabPrinter*>(this)->m_extruders_count;
 
    // Parent preset is "default" after detaching, so we should to update UI values, related on parent preset
    if (detach)
        update_ui_items_related_on_parent_preset(m_presets->get_selected_preset_parent());
 
    update_changed_ui();
 
    /* If filament preset is saved for multi-material printer preset,
     * there are cases when filament comboboxs are updated for old (non-modified) colors,
     * but in full_config a filament_colors option aren't.*/
    if (m_type == Preset::TYPE_FILAMENT && wxGetApp().extruders_edited_cnt() > 1)
        wxGetApp().plater()->force_filament_colors_update();
 
    {
        // Profile compatiblity is updated first when the profile is saved.
        // Update profile selection combo boxes at the depending tabs to reflect modifications in profile compatibility.
        std::vector<Preset::Type> dependent;
        switch (m_type) {
        case Preset::TYPE_PRINT:
            dependent = { Preset::TYPE_FILAMENT };
            break;
        case Preset::TYPE_SLA_PRINT:
            dependent = { Preset::TYPE_SLA_MATERIAL };
            break;
        case Preset::TYPE_PRINTER:
            if (static_cast<const TabPrinter*>(this)->m_printer_technology == ptFFF)
                dependent = { Preset::TYPE_PRINT, Preset::TYPE_FILAMENT };
            else
                dependent = { Preset::TYPE_SLA_PRINT, Preset::TYPE_SLA_MATERIAL };
            break;
        default:
            break;
        }
        for (Preset::Type preset_type : dependent)
            wxGetApp().get_tab(preset_type)->update_tab_ui();
    }
 
    // show() reloads the presets, so only a visible Compare dialog needs updating.
    DiffPresetDialog* diff_dialog = DiffPresetDialog::if_built();
    if (diff_dialog != nullptr && diff_dialog->IsShown())
        diff_dialog->update_presets(m_type);
}

References _u8L, Slic3r::GUI::SavePresetDialog::confirm_from_other(), Slic3r::GUI::SavePresetDialog::get_detach_value(), Slic3r::GUI::SavePresetDialog::get_name(), Slic3r::GUI::SavePresetDialog::get_save_to_project_selection(), Slic3r::GUI::LazyInstance< DiffPresetDialog >::if_built(), Slic3r::GUI::SavePresetDialog::input_name_from_other(), Slic3r::Preset::is_system, m_btn_delete_preset, m_config, Slic3r::GUI::TabPrinter::m_extruders_count, m_just_edit, m_mode, m_parent, m_preset_bundle, m_presets, m_type, name(), Slic3r::Preset::name, Slic3r::Never, on_presets_changed(), Slic3r::ptFFF, Slic3r::Preset::save_info(), save_preset(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::Preset::sync_info, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, Slic3r::Preset::TYPE_SLA_PRINT, update_changed_ui(), Slic3r::GUI::DiffPresetDialog::update_presets(), update_tab_ui(), update_ui_items_related_on_parent_preset(), Slic3r::Preset::user_id, validate_filament_temperature_pairs(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by build_preset_description_line(), create_preset_tab(), may_discard_current_dirty_preset(), and save_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

saved_preset_is_dirty()

bool Slic3r::GUI::Tab::saved_preset_is_dirty ( ) const

inherited

{ return m_presets->saved_is_dirty(); }

References m_presets, and saved_preset_is_dirty().

Referenced by saved_preset_is_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

select_preset()

bool Slic3r::GUI::Tab::select_preset ( std::string preset_name = "", bool delete_current = false, const std::string & last_selected_ph_printer_name = "", bool force_select = false, bool force_no_transfer = false )

inherited

{
    BOOST_LOG_TRIVIAL(info) << boost::format("select preset, name %1%, delete_current %2%")
        %preset_name %delete_current;
    if (preset_name.empty()) {
        if (delete_current) {
            // Find an alternate preset to be selected after the current preset is deleted.
            const std::deque<Preset> &presets     = m_presets->get_presets();
            size_t              idx_current   = m_presets->get_idx_selected();
            // Find the next visible preset.
            preset_name = presets[idx_current].inherits();
            if (preset_name.empty()) {
                size_t              idx_new       = idx_current + 1;
                if (idx_new < presets.size())
                    for (; idx_new < presets.size() && ! presets[idx_new].is_visible; ++ idx_new) ;
                if (idx_new == presets.size())
                    for (idx_new = idx_current - 1; idx_new > 0 && ! presets[idx_new].is_visible; -- idx_new);
                preset_name = presets[idx_new].name;
                BOOST_LOG_TRIVIAL(info) << boost::format("cause by delete current ,choose the next visible, idx %1%, name %2%")
                                            %idx_new %preset_name;
            } else {
                BOOST_LOG_TRIVIAL(info) << boost::format("cause by delete current ,choose base, name %1%") % preset_name;
            }
        } else {
            //BBS select first visible item first
            const std::deque<Preset> &presets     = this->m_presets->get_presets();
            size_t              idx_new = 0;
            if (idx_new < presets.size())
                for (; idx_new < presets.size() && ! presets[idx_new].is_visible; ++ idx_new) ;
            preset_name = presets[idx_new].name;
            if (idx_new == presets.size()) {
                // If no name is provided, select the "-- default --" preset.
                preset_name = m_presets->default_preset().name;
            }
            BOOST_LOG_TRIVIAL(info) << boost::format("not cause by delete current ,choose the first visible, idx %1%, name %2%")
                                        %idx_new %preset_name;
        }
    }
    //BBS: add project embedded preset logic and refine is_external
    assert(! delete_current || (m_presets->get_edited_preset().name != preset_name && (m_presets->get_edited_preset().is_user() || m_presets->get_edited_preset().is_project_embedded)));
    //assert(! delete_current || (m_presets->get_edited_preset().name != preset_name && m_presets->get_edited_preset().is_user()));
    bool current_dirty = ! delete_current && m_presets->current_is_dirty();
    bool print_tab     = m_presets->type() == Preset::TYPE_PRINT || m_presets->type() == Preset::TYPE_SLA_PRINT;
    bool printer_tab   = m_presets->type() == Preset::TYPE_PRINTER;
    bool canceled      = false;
    bool no_transfer = false;
    bool technology_changed = false;
    m_dependent_tabs.clear();
    if ((m_presets->type() == Preset::TYPE_FILAMENT) && !preset_name.empty())
    {
        Preset *to_be_selected = m_presets->find_preset(preset_name, false, true);
        if (to_be_selected) {
            std::string current_type, to_select_type;
            ConfigOptionStrings* cur_opt = dynamic_cast <ConfigOptionStrings *>(m_presets->get_edited_preset().config.option("filament_type"));
            ConfigOptionStrings* to_select_opt = dynamic_cast <ConfigOptionStrings *>(to_be_selected->config.option("filament_type"));
            if (cur_opt && (cur_opt->values.size() > 0)) {
                current_type =  cur_opt->values[0];
            }
            if (to_select_opt && (to_select_opt->values.size() > 0)) {
                to_select_type =  to_select_opt->values[0];
            }
            if (current_type != to_select_type)
                no_transfer = true;
        }
    }
    else if (printer_tab)
        no_transfer = true;
 
    if (force_no_transfer) {
        no_transfer = true;
    }
    if (current_dirty && ! may_discard_current_dirty_preset(nullptr, preset_name, no_transfer) && !force_select) {
        canceled = true;
        BOOST_LOG_TRIVIAL(info) << boost::format("current dirty and cancelled");
    } else if (print_tab) {
        // Before switching the print profile to a new one, verify, whether the currently active filament or SLA material
        // are compatible with the new print.
        // If it is not compatible and the current filament or SLA material are dirty, let user decide
        // whether to discard the changes or keep the current print selection.
        PresetWithVendorProfile printer_profile = m_preset_bundle->printers.get_edited_preset_with_vendor_profile();
        PrinterTechnology  printer_technology = printer_profile.preset.printer_technology();
        PresetCollection  &dependent = (printer_technology == ptFFF) ? m_preset_bundle->filaments : m_preset_bundle->sla_materials;
        bool         old_preset_dirty = dependent.current_is_dirty();
        bool         new_preset_compatible = is_compatible_with_print(dependent.get_edited_preset_with_vendor_profile(),
          m_presets->get_preset_with_vendor_profile(*m_presets->find_preset(preset_name, true)), printer_profile);
        if (! canceled)
            canceled = old_preset_dirty && ! may_discard_current_dirty_preset(&dependent, preset_name) && ! new_preset_compatible && !force_select;
        if (! canceled) {
            // The preset will be switched to a different, compatible preset, or the '-- default --'.
            m_dependent_tabs.emplace_back((printer_technology == ptFFF) ? Preset::Type::TYPE_FILAMENT : Preset::Type::TYPE_SLA_MATERIAL);
            if (old_preset_dirty && ! new_preset_compatible)
                dependent.discard_current_changes();
        }
        BOOST_LOG_TRIVIAL(info) << boost::format("select process, new_preset_compatible %1%, old_preset_dirty %2%, cancelled %3%")
            %new_preset_compatible %old_preset_dirty % canceled;
    } else if (printer_tab) {
        // Before switching the printer to a new one, verify, whether the currently active print and filament
        // are compatible with the new printer.
        // If they are not compatible and the current print or filament are dirty, let user decide
        // whether to discard the changes or keep the current printer selection.
        //
        // With the introduction of the SLA printer types, we need to support switching between
        // the FFF and SLA printers.
        const Preset    &new_printer_preset     = *m_presets->find_preset(preset_name, true);
    const PresetWithVendorProfile new_printer_preset_with_vendor_profile = m_presets->get_preset_with_vendor_profile(new_printer_preset);
        PrinterTechnology    old_printer_technology = m_presets->get_edited_preset().printer_technology();
        PrinterTechnology    new_printer_technology = new_printer_preset.printer_technology();
        if (new_printer_technology == ptSLA && old_printer_technology == ptFFF && !wxGetApp().may_switch_to_SLA_preset(_omitL("New printer preset selected")))
            canceled = true;
        else {
            struct PresetUpdate {
                Preset::Type         tab_type;
                PresetCollection  *presets;
                PrinterTechnology    technology;
                bool               old_preset_dirty;
                bool               new_preset_compatible;
            };
            std::vector<PresetUpdate> updates = {
                { Preset::Type::TYPE_PRINT,         &m_preset_bundle->prints,       ptFFF },
                //{ Preset::Type::TYPE_SLA_PRINT,     &m_preset_bundle->sla_prints,   ptSLA },
                { Preset::Type::TYPE_FILAMENT,      &m_preset_bundle->filaments,    ptFFF },
                //{ Preset::Type::TYPE_SLA_MATERIAL,  &m_preset_bundle->sla_materials,ptSLA }
            };
            Preset *to_be_selected = m_presets->find_preset(preset_name, false, true);
            ConfigOptionStrings* cur_opt2 = dynamic_cast <ConfigOptionStrings *>(m_presets->get_edited_preset().config.option("printer_extruder_variant"));
            ConfigOptionStrings* to_select_opt2 = dynamic_cast <ConfigOptionStrings *>(to_be_selected->config.option("printer_extruder_variant"));
            bool no_transfer_variant = cur_opt2->values != to_select_opt2->values;
            for (PresetUpdate &pu : updates) {
                pu.old_preset_dirty = (old_printer_technology == pu.technology) && pu.presets->current_is_dirty();
                pu.new_preset_compatible = (new_printer_technology == pu.technology) && is_compatible_with_printer(pu.presets->get_edited_preset_with_vendor_profile(), new_printer_preset_with_vendor_profile);
                if (!canceled)
                    canceled = pu.old_preset_dirty && !may_discard_current_dirty_preset(pu.presets, preset_name, false, no_transfer_variant) && !pu.new_preset_compatible && !force_select;
            }
            if (!canceled) {
                for (PresetUpdate &pu : updates) {
                    // The preset will be switched to a different, compatible preset, or the '-- default --'.
                    if (pu.technology == new_printer_technology)
                        m_dependent_tabs.emplace_back(pu.tab_type);
                    if (pu.old_preset_dirty && !pu.new_preset_compatible)
                        pu.presets->discard_current_changes();
                }
            }
        }
        if (! canceled)
          technology_changed = old_printer_technology != new_printer_technology;
 
        BOOST_LOG_TRIVIAL(info) << boost::format("select machine, technology_changed %1%, canceled %2%")
                %technology_changed  % canceled;
    }
 
    BOOST_LOG_TRIVIAL(info) << boost::format("before delete action, canceled %1%, delete_current %2%") %canceled %delete_current;
    bool        delete_third_printer = false;
    std::deque<Preset> filament_presets;
    std::deque<Preset> process_presets;
    if (! canceled && delete_current) {
        // Delete the file and select some other reasonable preset.
        // It does not matter which preset will be made active as the preset will be re-selected from the preset_name variable.
        // The 'external' presets will only be removed from the preset list, their files will not be deleted.
        try {
            //BBS delete preset
            Preset &current_preset = m_presets->get_selected_preset();
 
            // Obtain compatible filament and process presets for printers
            if (m_preset_bundle && m_presets->get_preset_base(current_preset) == &current_preset && printer_tab && !current_preset.is_system && !current_preset.is_from_bundle()) {
                delete_third_printer = true;
                for (const Preset &preset : m_preset_bundle->filaments.get_presets()) {
                    if (preset.is_compatible && !preset.is_default) {
                        if (preset.inherits() != "")
                            filament_presets.push_front(preset);
                        else
                            filament_presets.push_back(preset);
                    }
                }
                for (const Preset &preset : m_preset_bundle->prints.get_presets()) {
                    if (preset.is_compatible && !preset.is_default) {
                        if (preset.inherits() != "")
                            process_presets.push_front(preset);
                        else
                            process_presets.push_back(preset);
                    }
                }
            }
            if (!current_preset.setting_id.empty()) {
                wxGetApp().delete_preset_from_cloud(current_preset.setting_id, current_preset.file);
            }
            BOOST_LOG_TRIVIAL(info) << "delete preset = " << current_preset.name << ", setting_id = " << current_preset.setting_id;
            BOOST_LOG_TRIVIAL(info) << boost::format("will delete current preset...");
            m_presets->delete_current_preset();
        } catch (const std::exception & ex) {
            //FIXME add some error reporting!
            canceled = true;
            BOOST_LOG_TRIVIAL(info) << boost::format("found exception when delete: %1%") %ex.what();
        }
    }
 
    if (canceled) {
        BOOST_LOG_TRIVIAL(info) << boost::format("canceled delete, update ui...");
        if (m_type == Preset::TYPE_PRINTER) {
            if (!last_selected_ph_printer_name.empty() &&
                m_presets->get_edited_preset().name == PhysicalPrinter::get_preset_name(last_selected_ph_printer_name)) {
                // If preset selection was canceled and previously was selected physical printer, we should select it back
                m_preset_bundle->physical_printers.select_printer(last_selected_ph_printer_name);
            }
            if (m_preset_bundle->physical_printers.has_selection()) {
                // If preset selection was canceled and physical printer was selected
                // we must disable selection marker for the physical printers
                m_preset_bundle->physical_printers.unselect_printer();
            }
        }
 
        update_tab_ui();
 
        // Trigger the on_presets_changed event so that we also restore the previous value in the plater selector,
        // if this action was initiated from the plater.
        on_presets_changed();
    } else {
        BOOST_LOG_TRIVIAL(info) << boost::format("successfully delete, will update compatibility");
        if (current_dirty)
            m_presets->discard_current_changes();
 
        const bool is_selected = m_presets->select_preset_by_name(preset_name, false) || delete_current;
        assert(m_presets->get_edited_preset().name == preset_name || ! is_selected);
        // Mark the print & filament enabled if they are compatible with the currently selected preset.
        // The following method should not discard changes of current print or filament presets on change of a printer profile,
        // if they are compatible with the current printer.
        auto update_compatible_type = [delete_current](bool technology_changed, bool on_page, bool show_incompatible_presets) {
          return (delete_current || technology_changed) ? PresetSelectCompatibleType::Always :
                 on_page                                ? PresetSelectCompatibleType::Never  :
                 show_incompatible_presets              ? PresetSelectCompatibleType::OnlyIfWasCompatible : PresetSelectCompatibleType::Always;
        };
        if (current_dirty || delete_current || print_tab || printer_tab)
            m_preset_bundle->update_compatible(
              update_compatible_type(technology_changed, print_tab,   (print_tab ? this : wxGetApp().get_tab(Preset::TYPE_PRINT))->m_show_incompatible_presets),
              update_compatible_type(technology_changed, false,     wxGetApp().get_tab(Preset::TYPE_FILAMENT)->m_show_incompatible_presets));
        // Initialize the UI from the current preset.
        if (printer_tab)
            static_cast<TabPrinter*>(this)->update_pages();
 
        if (! is_selected && printer_tab)
        {
            /* There is a case, when :
             * after Config Wizard applying we try to select previously selected preset, but
             * in a current configuration this one:
             *  1. doesn't exist now,
             *  2. have another printer_technology
             * So, it is necessary to update list of dependent tabs
             * to the corresponding printer_technology
             */
            const PrinterTechnology printer_technology = m_presets->get_edited_preset().printer_technology();
            if (printer_technology == ptFFF && m_dependent_tabs.front() != Preset::Type::TYPE_PRINT)
                m_dependent_tabs = { Preset::Type::TYPE_PRINT, Preset::Type::TYPE_FILAMENT };
            else if (printer_technology == ptSLA && m_dependent_tabs.front() != Preset::Type::TYPE_SLA_PRINT)
                m_dependent_tabs = { Preset::Type::TYPE_SLA_PRINT, Preset::Type::TYPE_SLA_MATERIAL };
        }
 
        // check if there is something in the cache to move to the new selected preset
        apply_config_from_cache();
 
        // Orca: update presets for the selected printer
        if (m_type == Preset::TYPE_PRINTER && wxGetApp().app_config->get_bool("remember_printer_config")) {
            m_preset_bundle->update_selections(*wxGetApp().app_config);
            wxGetApp().plater()->sidebar().on_filament_count_change(m_preset_bundle->filament_presets.size());
        }
        load_current_preset();
 
        // Wait for the settings dialog to close; its edits are still provisional.
        if (printer_tab && is_selected) {
            Plater *plater = wxGetApp().plater();
            ParamsDialog *dialog = wxGetApp().params_dialog();
            if (plater && !plater->is_loading_project() &&
                (!dialog || !dialog->IsShown()))
                plater->normalize_bed_types(false);
        }
 
        {
            Slic3r::LifecycleEventContext ctx;
            ctx.name = preset_name;
            ctx.code = Slic3r::LifecycleEvtCode::Ok;
            switch (m_type) {
            case Preset::TYPE_PRINT:        ctx.msg = "print"; break;
            case Preset::TYPE_SLA_PRINT:    ctx.msg = "sla_print"; break;
            case Preset::TYPE_FILAMENT:     ctx.msg = "filament"; break;
            case Preset::TYPE_SLA_MATERIAL: ctx.msg = "sla_material"; break;
            case Preset::TYPE_PRINTER:      ctx.msg = "printer"; break;
            default: break;
            }
            Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::PresetSelected, ctx);
        }
 
        if (delete_third_printer) {
            wxGetApp().CallAfter([filament_presets, process_presets]() {
                PresetBundle *preset_bundle     = wxGetApp().preset_bundle;
                std::string   old_filament_name = preset_bundle->filaments.get_edited_preset().name;
                std::string   old_process_name  = preset_bundle->prints.get_edited_preset().name;
 
                for (const Preset &preset : filament_presets) {
                    if (!preset.setting_id.empty()) {
                        wxGetApp().delete_preset_from_cloud(preset.setting_id, preset.file);
                    }
                    BOOST_LOG_TRIVIAL(info) << "delete filament preset = " << preset.name << ", setting_id = " << preset.setting_id;
                    preset_bundle->filaments.delete_preset(preset.name);
                }
 
                for (const Preset &preset : process_presets) {
                    if (!preset.setting_id.empty()) {
                        wxGetApp().delete_preset_from_cloud(preset.setting_id, preset.file);
                    }
                    BOOST_LOG_TRIVIAL(info) << "delete print preset = " << preset.name << ", setting_id = " << preset.setting_id;
                    preset_bundle->prints.delete_preset(preset.name);
                }
 
                preset_bundle->update_compatible(PresetSelectCompatibleType::Always);
                preset_bundle->filaments.select_preset_by_name(old_filament_name, true);
                preset_bundle->prints.select_preset_by_name(old_process_name, true);
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " old filament name is:" << old_filament_name << " old process name is: " << old_process_name;
 
            });
        }
 
    }
 
    if (technology_changed)
        wxGetApp().mainframe->technology_changed();
    BOOST_LOG_TRIVIAL(info) << boost::format("select preset, exit");
 
    return !canceled;
}

References _omitL, Slic3r::Always, apply_config_from_cache(), Slic3r::LifecycleEventContext::code, Slic3r::Preset::config, Slic3r::PresetCollection::current_is_dirty(), Slic3r::PresetCollection::delete_preset(), Slic3r::PresetCollection::discard_current_changes(), Slic3r::PresetBundle::filaments, Slic3r::Preset::file, Slic3r::fire_lifecycle_event(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_edited_preset_with_vendor_profile(), Slic3r::PhysicalPrinter::get_preset_name(), Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::Preset::is_from_bundle(), Slic3r::Preset::is_system, load_current_preset(), m_dependent_tabs, m_preset_bundle, m_presets, m_show_incompatible_presets, m_type, may_discard_current_dirty_preset(), Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Preset::name, Slic3r::Never, Slic3r::Ok, on_presets_changed(), Slic3r::OnlyIfWasCompatible, Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), Slic3r::PresetWithVendorProfile::preset, Slic3r::PresetSelected, Slic3r::GUI::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::PresetBundle::prints, Slic3r::ptFFF, Slic3r::ptSLA, select_preset(), Slic3r::PresetCollection::select_preset_by_name(), Slic3r::Preset::setting_id, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, Slic3r::Preset::TYPE_SLA_PRINT, Slic3r::PresetBundle::update_compatible(), update_tab_ui(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_preset_target(), create_preset_tab(), delete_preset(), Slic3r::GUI::Plater::priv::on_modify_filament(), select_preset(), Slic3r::GUI::PresetComboBox::selection_is_changed_according_to_physical_printers(), Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and transfer_options().

Here is the call graph for this function:

Here is the caller graph for this function:

set_custom_gcode()

void Slic3r::GUI::Tab::set_custom_gcode ( const t_config_option_key & opt_key, const std::string & value )

virtualinherited

Reimplemented in Slic3r::GUI::TabFilament.

{
    DynamicPrintConfig new_conf = *m_config;
    new_conf.set_key_value(opt_key, new ConfigOptionString(value));
    load_config(new_conf);
}

References Slic3r::ConfigOptionString, load_config(), m_config, and Slic3r::DynamicConfig::set_key_value().

Referenced by edit_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

set_expanded()

void Slic3r::GUI::Tab::set_expanded ( bool value )

inherited

{
    if (value) {
        if (m_presets_choice)
            m_main_sizer->Show(m_presets_choice);
        m_main_sizer->Show(m_tabctrl);
    }
    else {
        m_active_page = NULL;
        if (m_presets_choice)
            m_main_sizer->Hide(m_presets_choice);
        m_main_sizer->Hide(m_tabctrl);
    }
}

References m_active_page, m_main_sizer, m_presets_choice, m_tabctrl, and set_expanded().

Referenced by set_expanded().

Here is the call graph for this function:

Here is the caller graph for this function:

set_extruder_volume_type()

void Slic3r::GUI::TabPrinter::set_extruder_volume_type	(	int	extruder_id,
		NozzleVolumeType	type )

{
    // -1 means single extruder, so we should default use extruder id 0
    if (extruder_id == -1)
        extruder_id = 0;
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    assert(nozzle_volumes->values.size() > (size_t)extruder_id);
    nozzle_volumes->values[extruder_id] = type;
 
    // Carry the extruder's nozzle count over to the new flow type and refresh the sidebar badge.
    onNozzleVolumeTypeSwitch(m_preset_bundle, extruder_id, type);
    updateNozzleCountDisplay(m_preset_bundle, extruder_id, type);
 
    on_value_change((boost::format("nozzle_volume_type#%1%") % extruder_id).str(), int(type));
 
    //save to app config
    if (!m_base_preset_name.empty()) {
        // do not save hybrid flow status to config: it depends on the nozzles currently installed
        // on the connected printer, so it must not be restored in a later session
        ConfigOptionEnumsGeneric nozzle_volume_type_option = *m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
        for (size_t i = 0; i < nozzle_volume_type_option.values.size(); i++) {
            if (nozzle_volume_type_option.values[i] == (int) nvtHybrid)
                nozzle_volume_type_option.values[i] = (int) nvtStandard;
        }
        std::string nozzle_volume_type_str = nozzle_volume_type_option.serialize();
        wxGetApp().app_config->save_nozzle_volume_types_to_config(m_base_preset_name, nozzle_volume_type_str);
    }
 
}

References m_base_preset_name, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::nvtHybrid, Slic3r::nvtStandard, on_value_change(), Slic3r::GUI::onNozzleVolumeTypeSwitch(), Slic3r::ConfigOptionEnumsGenericTempl< NULLABLE >::serialize(), set_extruder_volume_type(), Slic3r::GUI::Tab::type(), Slic3r::GUI::updateNozzleCountDisplay(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by set_extruder_volume_type().

Here is the call graph for this function:

Here is the caller graph for this function:

set_just_edit()

void Slic3r::GUI::Tab::set_just_edit ( bool just_edit )

inherited

{
    m_just_edit = just_edit;
    if (just_edit) {
        m_presets_choice->Disable();
        m_btn_delete_preset->Disable();
    } else {
        m_presets_choice->Enable();
        m_btn_delete_preset->Enable();
    }
}

References m_btn_delete_preset, m_just_edit, m_presets_choice, and set_just_edit().

Referenced by Slic3r::GUI::Plater::priv::on_modify_filament(), Slic3r::GUI::ParamsDialog::Popup(), and set_just_edit().

Here is the call graph for this function:

Here is the caller graph for this function:

set_option_label()

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

inherited

{
    // Same as toggle_line: a runtime rename (brim_width -> "Brim ear radius") must reach every page
    // so the Speed Dial titles the setting before the page has been shown.
    for (const PageShp& page : m_pages) {
        if (!page) continue;
        if (Line *line = page->get_line(opt_key, opt_index))
            line->set_label(label);
    }
}

References m_pages, and set_option_label().

Referenced by get_config_manipulation(), and set_option_label().

Here is the call graph for this function:

Here is the caller graph for this function:

set_tooltips_text()

void Slic3r::GUI::Tab::set_tooltips_text ( )

protectedinherited

{
    // --- Tooltip text for reset buttons (for whole options group)
    // Text to be shown on the "Revert to system" aka "Lock to system" button next to each input field.
    //m_ttg_value_lock =    _(L("LOCKED LOCK icon indicates that the settings are the same as the system (or default) values "
    //                            "for the current option group"));
    //m_ttg_value_unlock =  _(L("UNLOCKED LOCK icon indicates that some settings were changed and are not equal "
    //                            "to the system (or default) values for the current option group.\n"
    //                            "Click to reset all settings for current option group to the system (or default) values."));
    //m_ttg_white_bullet_ns = _(L("WHITE BULLET icon indicates a non system (or non default) preset."));
    //m_ttg_non_system =    &m_ttg_white_bullet_ns;
    // Text to be shown on the "Undo user changes" button next to each input field.
    //m_ttg_white_bullet =  _(L("WHITE BULLET icon indicates that the settings are the same as in the last saved "
    //                            "preset for the current option group."));
    //m_ttg_value_revert =  _(L("BACK ARROW icon indicates that the settings were changed and are not equal to "
    //                            "the last saved preset for the current option group.\n"
    //                            "Click to reset all settings for the current option group to the last saved preset."));
 
    // --- Tooltip text for reset buttons (for each option in group)
    // Text to be shown on the "Revert to system" aka "Lock to system" button next to each input field.
    //m_tt_value_lock =   _(L("LOCKED LOCK icon indicates that the value is the same as the system (or default) value."));
    m_tt_value_unlock =   _(L("Click to reset current value and attach to the global value."));
    //  m_tt_white_bullet_ns= _(L("WHITE BULLET icon indicates a non system preset."));
    //m_tt_non_system =   &m_ttg_white_bullet_ns;
    // Text to be shown on the "Undo user changes" button next to each input field.
    //m_tt_white_bullet =   _(L("WHITE BULLET icon indicates that the value is the same as in the last saved preset."));
    m_tt_value_revert =   _(L("Click to drop current modifications and reset to saved value."));
}

References _, L, m_tt_value_revert, m_tt_value_unlock, and set_tooltips_text().

Referenced by create_preset_tab(), and set_tooltips_text().

Here is the call graph for this function:

Here is the caller graph for this function:

set_type()

void Slic3r::GUI::Tab::set_type ( )

protectedinherited

{
    if (m_name == PRESET_PRINT_NAME)              { m_type = Slic3r::Preset::TYPE_PRINT; }
    else if (m_name == "sla_print")     { m_type = Slic3r::Preset::TYPE_SLA_PRINT; }
    else if (m_name == PRESET_FILAMENT_NAME)      { m_type = Slic3r::Preset::TYPE_FILAMENT; }
    else if (m_name == "sla_material")  { m_type = Slic3r::Preset::TYPE_SLA_MATERIAL; }
    else if (m_name == PRESET_PRINTER_NAME)       { m_type = Slic3r::Preset::TYPE_PRINTER; }
    else                                { m_type = Slic3r::Preset::TYPE_INVALID; assert(false); }
}

References m_name, m_type, PRESET_FILAMENT_NAME, PRESET_PRINT_NAME, PRESET_PRINTER_NAME, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_INVALID, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and Slic3r::Preset::TYPE_SLA_PRINT.

setting_row_state()

Tab::SettingRowState Slic3r::GUI::Tab::setting_row_state ( const std::string & opt_id ) const

inherited

{
    bool found = false;
    for (const PageShp& page : m_pages) {
        if (!page) continue;
        for (const ConfigOptionsGroupShp& group : page->m_optgroups) {
            if (!group) continue;
            for (const Line& line : group->get_lines()) {
                for (const Option& opt : line.get_options()) {
                    if (opt.opt_id != opt_id)
                        continue;
                    if (line.toggle_visible) // shown on any owning page is enough
                        return {true, line.label, line.label_en, line.get_options().size() > 1};
                    found = true;
                }
            }
        }
    }
    // Never registered on a page -> visible, but with no row label to contribute.
    return {!found, wxString(), wxString(), false};
}

References m_pages, and setting_row_state().

Referenced by Slic3r::GUI::ActionRegistry::materialize_setting_actions(), and setting_row_state().

Here is the call graph for this function:

Here is the caller graph for this function:

show_timelapse_warning_dialog()

void Slic3r::GUI::Tab::show_timelapse_warning_dialog ( )

inherited

                                        {
    if (!m_is_timelapse_wipe_tower_already_prompted) {
        wxString      msg_text = _(L("When recording timelapse without toolhead, it is recommended to add a \"Timelapse Wipe Tower\" \n"
                                "by right-click the empty position of build plate and choose \"Add Primitive\"->\"Timelapse Wipe Tower\"."));
        msg_text += "\n";
        MessageDialog dialog(nullptr, msg_text, "", wxICON_WARNING | wxOK);
        dialog.ShowModal();
        m_is_timelapse_wipe_tower_already_prompted = true;
    }
}

References _, L, m_is_timelapse_wipe_tower_already_prompted, show_timelapse_warning_dialog(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by show_timelapse_warning_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_printer_technology()

bool Slic3r::GUI::TabPrinter::supports_printer_technology ( const PrinterTechnology ) const

inlineoverridevirtual

Implements Slic3r::GUI::Tab.

{ return true; }

switch_excluder()

void Slic3r::GUI::Tab::switch_excluder ( int extruder_id = -1, bool reload = true )

inherited

{
    Preset & printer_preset = m_preset_bundle->printers.get_edited_preset();
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    auto extruders      = printer_preset.config.option<ConfigOptionEnumsGeneric>("extruder_type");
 
    // Orca: the printer tab re-targets its pages to the extruder selected on the switch. Resolved before
    // the range check below, which keeps the extruder_type read in get_index_for_extruder in range.
    if (m_type == Preset::TYPE_PRINTER && extruder_id == -1)
        extruder_id = get_current_active_extruder();
    if (!m_variant_combo && (extruder_id >= (int)nozzle_volumes->size() || extruder_id >= (int)extruders->size()))
        extruder_id = 0;
    if (m_extruder_switch) {
        int current_extruder = get_current_active_extruder();
        bool sync_enable = get_extruder_sync_enable_state(current_extruder);
        m_extruder_sync->Enable(m_extruder_switch_variants && sync_enable && !is_printer_extruder_page(m_active_page));
        m_extruder_sync->Show();
        if (m_type != Preset::TYPE_PRINTER) {
            if (extruder_id == -1)
                extruder_id = current_extruder;
            else if (extruder_id != current_extruder)
                return;
        }
    } else if (m_variant_combo) {
        int current_variant = m_variant_combo->GetSelection();
        if (current_variant < 0)
            current_variant = 0;
        if (extruder_id == -1)
            extruder_id = current_variant;
        else if (extruder_id != current_variant)
            return;
    }
    auto get_index_for_extruder =
            [this, &extruders, variant_keys = extruder_variant_keys[m_type >= Preset::TYPE_COUNT ? Preset::TYPE_PRINT : m_type]](int extruder_id, int stride = 1) {
        return m_config->get_index_for_extruder(extruder_id + 1, variant_keys.first,
            ExtruderType(extruders->values[extruder_id]), get_actual_nozzle_volume_type(extruder_id), variant_keys.second, stride);
    };
    auto index = m_variant_combo ? extruder_id : get_index_for_extruder(extruder_id == -1 ? 0 : extruder_id);
    if (index < 0)
        return;
    if (m_extruder_switch) m_extruder_switch->SetClientData(reinterpret_cast<void*>(static_cast<std::uintptr_t>(index)));
    if (m_variant_combo) m_variant_combo->SetClientData(reinterpret_cast<void *>(static_cast<std::uintptr_t>(index)));
    for (auto page : m_pages) {
        bool is_extruder = false;
        int  page_index  = index;
        if (m_type == Preset::TYPE_PRINTER) {
            if (page->title() == "Extruder")
                is_extruder = true;
            else if (page->title().StartsWith("Motion ability"))
                page_index = get_index_for_extruder(extruder_id == -1 ? 0 : extruder_id, 2);
        }
        page->m_opt_id_map.clear();
        for (auto group : page->m_optgroups) {
            for (auto &opt : group->opt_map()) {
                if (is_extruder && opt.second.second >= 0) {
                    // Per-variant options use the variant column, the others (nozzle_diameter,
                    // extruder_offset, ...) are sized by the extruder count and use the extruder.
                    const int idx = printer_options_with_variant_1.count(opt.second.first) > 0 ? page_index : extruder_id;
                    const_cast<int &>(opt.second.second) = idx;
                    page->m_opt_id_map.insert({opt.second.first + "#" + std::to_string(idx), opt.first});
                    continue;
                }
                auto iter = std::find(printer_extruder_options.begin(), printer_extruder_options.end(), opt.second.first);
                if (iter != printer_extruder_options.end()) {
                    page->m_opt_id_map.insert({opt.first, opt.first});
                    continue;
                }
 
                if (opt.second.second >= 0) {
                    const_cast<int &>(opt.second.second) = page_index;
                    page->m_opt_id_map.insert({opt.second.first + "#" + std::to_string(page_index), opt.first});
                    group->draw_multi_extruder = variant_switch_active();
                }
            }
        }
    }
    if (reload) {
        reload_config();
        update_changed_ui();
        toggle_options();
        if (m_active_page)
            m_active_page->update_visibility(m_mode, true);
        m_page_view->GetParent()->Layout();
    }
}

References Slic3r::Preset::config, Slic3r::GUI::extruder_variant_keys, get_actual_nozzle_volume_type(), get_current_active_extruder(), get_extruder_sync_enable_state(), is_printer_extruder_page(), m_active_page, m_config, m_extruder_switch, m_extruder_switch_variants, m_extruder_sync, m_mode, m_page_view, m_pages, m_preset_bundle, m_type, m_variant_combo, Slic3r::ConfigBase::option(), Slic3r::printer_extruder_options, Slic3r::printer_options_with_variant_1, reload_config(), Slic3r::ConfigOptionVector< int >::size(), switch_excluder(), toggle_options(), Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, update_changed_ui(), Slic3r::ConfigOptionVector< int >::values, Slic3r::GUI::variant_keys(), and variant_switch_active().

Referenced by create_preset_tab(), switch_excluder(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_excluder()

void Slic3r::GUI::Tab::sync_excluder ( )

inherited

{
    Preset & printer_preset = m_preset_bundle->printers.get_edited_preset();
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    auto extruders      = printer_preset.config.option<ConfigOptionEnumsGeneric>("extruder_type");
    // Motion ability options hold a (normal, silent) pair per variant, so switch_excluder indexes that page with stride 2.
    const int stride = m_active_page->title().StartsWith("Motion ability") ? 2 : 1;
    auto get_index_for_extruder =
            [this, &extruders, stride, variant_keys = extruder_variant_keys[m_type >= Preset::TYPE_COUNT ? Preset::TYPE_PRINT : m_type]](int extruder_id, NozzleVolumeType nozzle_type) {
        return m_config->get_index_for_extruder(extruder_id + 1, variant_keys.first,
            ExtruderType(extruders->values[extruder_id]), nozzle_type, variant_keys.second, stride);
    };
    int active_index = get_current_active_extruder();
    // The button copies to the other toolhead, so it is only offered when that other one exists;
    // without this the `1 - active_index` below would index an extruder that is not there.
    if (!get_extruder_sync_enable_state(active_index))
        return;
    auto active_nozzle = get_actual_nozzle_volume_type(active_index);
    int from_index = get_index_for_extruder(active_index, active_nozzle);
    int dest_index = get_index_for_extruder(1 - active_index, active_nozzle);
    if (from_index < 0 || dest_index < 0) // no variant column for this nozzle on one of the extruders
        return;
    auto dirty_options = m_presets->current_dirty_options(true);
    DynamicConfig config_origin, config_to_apply;
    for (int i = 0; i < dirty_options.size(); ++i) {
        auto &opt = dirty_options[i];
        auto n= opt.find('#');
        if (n == std::string::npos)
            continue;
        auto field = m_active_page->get_field(opt.substr(0, n), from_index + 256);
        auto line  = m_active_page->get_line(opt.substr(0, n), from_index + 256);
        if (field == nullptr || line == nullptr)
            continue;
        ++n;
        auto is_from_slot = [&](const std::string &dirty_opt) {
            int slot = std::atoi(dirty_opt.c_str() + n);
            return slot >= from_index && slot < from_index + stride;
        };
        bool dirty = is_from_slot(opt);
        while (i + 1 < dirty_options.size() && dirty_options[i + 1].compare(0, n, opt, 0, n) == 0) {
            dirty |= is_from_slot(dirty_options[i + 1]);
            ++i;
        }
        if (dirty) {
            auto key = opt.substr(0, n - 1);
            auto option = dynamic_cast<ConfigOptionVectorBase*>(m_config->option(key));
            auto option2 = dynamic_cast<ConfigOptionVectorBase*>(option->clone());
            for (int s = 0; s < stride; ++s)
                option2->set_at(option, dest_index + s, from_index + s);
            if (*option == *option2) {
                delete option2;
                continue;
            }
            config_origin.set_key_value(key, option->clone());
            config_to_apply.set_key_value(key, option2);
        }
    }
    if (config_to_apply.empty()) {
        MessageDialog md(wxGetApp().plater(), _L("No modifications need to be copied."), _L("Copy parameters"), wxICON_INFORMATION | wxOK);
        md.ShowModal();
        return;
    }
 
    std::string pt = m_preset_bundle->printers.get_edited_preset().get_printer_type(m_preset_bundle);
    std::string active_nozzle_name = DevPrinterConfigUtil::get_toolhead_display_name(pt, active_index, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase);
    std::string other_nozzle_name  = DevPrinterConfigUtil::get_toolhead_display_name(pt, 1 - active_index, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase);
    wxString title  = wxString::Format(_L("Modify parameters of %s"), _L(active_nozzle_name));
    wxString header = wxString::Format(_L("Do you want to modify the following parameters of the %s to that of the %s?"),
                                       _L(active_nozzle_name), _L(other_nozzle_name));
    UnsavedChangesDialog dlg(title, header, &config_origin, from_index, dest_index, active_index == 0, active_nozzle);
    dlg.ShowModal();
    if (dlg.transfer_changes()) {
        m_config->apply(config_to_apply);
        auto &applying_keys = const_cast<t_config_option_keys&>(m_config_manipulation.applying_keys());
        if (m_type > Preset::TYPE_COUNT)
            applying_keys = config_to_apply.keys();
        reload_config();
        if (m_type > Preset::TYPE_COUNT)
            applying_keys.clear();
        update_changed_ui();
        update();
        if (m_active_page)
            m_active_page->update_visibility(m_mode, true);
        m_page_view->GetParent()->Layout();
    }
}

References _L, Slic3r::Preset::config, Slic3r::DynamicConfig::empty(), Slic3r::GUI::extruder_variant_keys, get_actual_nozzle_volume_type(), get_current_active_extruder(), get_extruder_sync_enable_state(), Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), Slic3r::DynamicConfig::keys(), Slic3r::LowerCase, m_active_page, m_config, m_config_manipulation, m_mode, m_page_view, m_preset_bundle, m_presets, m_type, Slic3r::Nozzle, Slic3r::nozzle_type(), Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), reload_config(), Slic3r::ConfigOptionVectorBase::set_at(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::UnsavedChangesDialog::ShowModal(), sync_excluder(), title(), Slic3r::GUI::UnsavedChangesDialog::transfer_changes(), Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_PRINT, update(), update_changed_ui(), Slic3r::ConfigOptionVector< int >::values, and Slic3r::GUI::variant_keys().

Referenced by create_preset_tab(), and sync_excluder().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_extruders_count()

void Slic3r::GUI::TabPrinter::sync_extruders_count

(

)

{
    if (m_printer_technology != ptFFF)
        return;
    const auto *nozzle_diameter = m_config->option<ConfigOptionFloats>("nozzle_diameter");
    if (nozzle_diameter == nullptr || nozzle_diameter->size() == m_extruders_count)
        return;
    extruders_count_changed(nozzle_diameter->size());
    init_options_list();
    update_all_extruder_variants();
}

References extruders_count_changed(), init_options_list(), Slic3r::GUI::Tab::m_config, m_extruders_count, m_printer_technology, Slic3r::nozzle_diameter(), Slic3r::ptFFF, sync_extruders_count(), and Slic3r::GUI::update_all_extruder_variants().

Referenced by sync_extruders_count().

Here is the call graph for this function:

Here is the caller graph for this function:

sys_color_changed()

void Slic3r::GUI::Tab::sys_color_changed ( )

virtualinherited

{
    if (m_presets_choice)
        m_presets_choice->sys_color_changed();
 
    // update buttons and cached bitmaps
    for (const auto btn : m_scaled_buttons)
        btn->msw_rescale();
    for (const auto bmp : m_scaled_bitmaps)
        bmp->msw_rescale();
    if (m_detach_preset_btn)
        m_detach_preset_btn->msw_rescale();
 
    // update icons for tree_ctrl
    for (ScalableBitmap& bmp : m_scaled_icons_list)
        bmp.msw_rescale();
    // recreate and set new ImageList for tree_ctrl
    m_icons->RemoveAll();
    m_icons = new wxImageList(m_scaled_icons_list.front().bmp().GetWidth(), m_scaled_icons_list.front().bmp().GetHeight(), false);
    for (ScalableBitmap& bmp : m_scaled_icons_list)
        //m_icons->Add(bmp.bmp());
    m_tabctrl->AssignImageList(m_icons);
 
    // Colors for ui "decoration"
    update_label_colours();
#ifdef _WIN32
    wxWindowUpdateLocker noUpdates(this);
    //BBS: GUI refactor
    //if (m_mode_sizer)
    //    m_mode_sizer->msw_rescale();
    wxGetApp().UpdateDarkUI(this);
    wxGetApp().UpdateDarkUI(m_tabctrl);
#endif
    update_changed_tree_ui();
 
    // update options_groups
    if (m_active_page)
        m_active_page->sys_color_changed();
    if (m_extruder_switch)
        m_extruder_switch->Rescale();
    if (m_variant_combo)
        m_variant_combo->Rescale();
 
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
}

References m_active_page, m_detach_preset_btn, m_extruder_switch, m_icons, m_parent, m_presets_choice, m_scaled_bitmaps, m_scaled_buttons, m_scaled_icons_list, m_tabctrl, m_variant_combo, sys_color_changed(), update_changed_tree_ui(), and update_label_colours().

Referenced by sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

title()

wxString Slic3r::GUI::Tab::title ( ) const

inlineinherited

{ return m_title; }

References m_title.

Referenced by Slic3r::GUI::SavePresetDialog::Item::Item(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Tab(), activate_option(), add_options_page(), Slic3r::GUI::TabPrinter::build_unregular_pages(), delete_preset(), sync_excluder(), translate_category(), update_changed_tree_ui(), update_label_colours(), and validate_custom_gcode().

Here is the caller graph for this function:

toggle_line()

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

inherited

{
    // Apply to every page that owns the option, not just m_active_page. ConfigManipulation runs while
    // each tab updates at preset load, so the Speed Dial sees the same visibility regardless of page.
    for (const PageShp& page : m_pages) {
        if (!page) continue;
        if (Line *line = page->get_line(opt_key, opt_index))
            line->toggle_visible = toggle;
    }
};

References m_pages, and toggle_line().

Referenced by get_config_manipulation(), toggle_line(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::TabPrinter::toggle_options(), and Slic3r::GUI::TabFilament::update_filament_overrides_page().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_option()

void Slic3r::GUI::Tab::toggle_option ( const std::string & opt_key, bool toggle, int opt_index = -1 )

inherited

{
    if (!m_active_page)
        return;
    Field* field = m_active_page->get_field(opt_key, opt_index);
    if (field)
        field->toggle(toggle);
}

References m_active_page, Slic3r::GUI::Field::toggle(), and toggle_option().

Referenced by get_config_manipulation(), toggle_option(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::TabPrint::toggle_options(), Slic3r::GUI::TabPrinter::toggle_options(), and Slic3r::GUI::TabPrintPlate::update_mixed_filament_seq_state().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_options()

void Slic3r::GUI::TabPrinter::toggle_options ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    if (!m_active_page || m_presets->get_edited_preset().printer_technology() == ptSLA)
        return;
 
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
    //BBS: whether the preset is Bambu Lab printer
    bool is_BBL_printer = false;
    if (m_preset_bundle) {
       is_BBL_printer = wxGetApp().preset_bundle->is_bbl_vendor();
    }
 
    bool have_multiple_extruders = true;
    //m_extruders_count > 1;
    //if (m_active_page->title() == "Custom G-code") {
    //    toggle_option("change_filament_gcode", have_multiple_extruders);
    //}
    if (m_active_page->title() == L("Basic information")) {
        const auto &printer_cfg = m_preset_bundle->printers.get_edited_preset().config;
 
        // SoftFever: hide BBL specific settings
        for (auto el : {"scan_first_layer", "bbl_calib_mark_logo", "bbl_use_printhost"})
            toggle_line(el, is_BBL_printer);
 
        // SoftFever: hide non-BBL settings
        for (auto el : {"use_firmware_retraction", "use_relative_e_distances", "support_multi_bed_types", "pellet_modded_printer", "bed_mesh_max", "bed_mesh_min", "bed_mesh_probe_distance", "adaptive_bed_mesh_margin", "thumbnails"})
          toggle_line(el, !is_BBL_printer);
 
        bool gcf_is_marlin_firmware = m_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor")->value == GCodeFlavor::gcfMarlinFirmware;
        toggle_line("enable_power_loss_recovery", is_BBL_printer || gcf_is_marlin_firmware);
 
        // Belt printer: show belt-specific settings only when belt_printer is enabled.
        bool is_belt = m_config->opt_bool("belt_printer");
        // update_fff() derives build_plate_tilt_{x,y} from the belt tilt on a belt
        // printer, so an edit here would be overwritten; keep them read-only there.
        toggle_option("build_plate_tilt_x", !is_belt);
        toggle_option("build_plate_tilt_y", !is_belt);
        bool expert_or_above = (m_mode >= comExpert);
        toggle_line("belt_printer_infinite_y", is_belt);
        // Belt tilt: the sole mesh-side belt transform (visible by default in belt mode).
        toggle_line("belt_slice_rotation_angle", is_belt);
        toggle_line("belt_slice_rotation", is_belt);
 
        // Remap, back-transform, and global mesh-transforms toggles are gated by belt
        // mode here; finer mode-based visibility is handled by each option's
        // ConfigOptionMode in PrintConfig.cpp. The axis remap is Develop-only: a
        // printer profile sets it once for its kinematics, and a wrong value sends
        // the gantry outside the machine.
        for (auto el : {"gcode_remap_x", "gcode_remap_y", "gcode_remap_z"})
            toggle_line(el, is_belt);
 
        // Rotation is the only mesh-side belt transform.  Gray out its angle when no
        // rotation axis is selected.
        auto rot_axis = m_config->option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation")->value;
        toggle_option("belt_slice_rotation_angle",  is_belt && rot_axis != BeltRotationAxis::None);
 
        // Machine-frame transform: derived from the belt tilt.  Only the expert
        // decouple override is exposed; its angle is shown only when decoupled.
        toggle_line("belt_frame_tilt_decouple", is_belt && expert_or_above);
        toggle_line("belt_frame_tilt_angle",
                    is_belt && expert_or_above && m_config->opt_bool("belt_frame_tilt_decouple"));
 
 
        toggle_line("belt_support_floor_offset", is_belt);
        const bool support_parallel_printheads = printer_cfg.opt_bool("support_parallel_printheads");
        toggle_line("parallel_printheads_count", support_parallel_printheads);
 
        const size_t exclusion_extruder_count = m_preset_bundle->get_printer_extruder_count();
        // UI visibility follows the selected mode even before any volumes are
        // entered. The runtime resolver still ignores empty configurations.
        const BedExcludeVolumeMode exclusion_mode = m_config->opt_enum<BedExcludeVolumeMode>("bed_exclude_volume_mode");
        // Legacy areas and collision volumes are additive. Keep the established
        // material keep-out editable while the opt-in motion constraints exist.
        toggle_option("bed_exclude_area", true);
        toggle_line("bed_exclude_volume_mode", exclusion_extruder_count > 1);
        toggle_line("bed_exclude_volumes", exclusion_extruder_count <= 1 || exclusion_mode != BedExcludeVolumeMode::PerExtruder);
 
        toggle_line("fan_direction", m_config->opt_bool("auxiliary_fan"));
 
        // The cooling filter and air filtration are alternative accessories: show only the one the printer supports.
        toggle_line("support_air_filtration", !m_config->opt_bool("support_cooling_filter"));
        toggle_line("cooling_filter_enabled", m_config->opt_bool("support_cooling_filter"));
    }
 
 
    if (m_active_page->title() == L("Machine G-code")) {
        PresetBundle *preset_bundle = wxGetApp().preset_bundle;
        std::string   printer_type  = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
        toggle_line("wrapping_detection_gcode", DevPrinterConfigUtil::support_wrapping_detection(printer_type));
    }
 
    if (m_active_page->title() == L("Multimaterial")) {
        // Orca-Belt: belt printers use the belt purge tower instead of the classic
        // wipe tower — show its enable only on belt printers, and hide the classic
        // wipe-tower fields there (the classic tower's G-code bypasses the belt transform).
        const bool is_belt_printer = m_config->opt_bool("belt_printer");
        toggle_line("enable_belt_purge_tower", is_belt_printer);
 
        const bool supports_wipe_tower_2 = !is_BBL_printer && m_config->opt_enum<WipeTowerType>("wipe_tower_type") == WipeTowerType::Type2;
        toggle_line("wipe_tower_type", !is_BBL_printer && !is_belt_printer);
        // SoftFever: hide specific settings for BBL printer
        for (auto el : {
                 "enable_filament_ramming",
                 "cooling_tube_retraction",
                 "cooling_tube_length",
                 "parking_pos_retraction",
                 "extra_loading_move",
                 "high_current_on_filament_swap",
             })
            toggle_option(el, supports_wipe_tower_2);
 
        auto bSEMM = m_config->opt_bool("single_extruder_multi_material");
        if (!bSEMM && m_config->opt_bool("manual_filament_change")) {
            DynamicPrintConfig new_conf = *m_config;
            new_conf.set_key_value("manual_filament_change", new ConfigOptionBool(false));
            load_config(new_conf);
        }
        toggle_option("extruders_count", !bSEMM);
        toggle_option("manual_filament_change", bSEMM);
        toggle_option("purge_in_prime_tower", bSEMM && supports_wipe_tower_2);
 
        // IDEX/IQEX: show carriage config options only when is_imex is enabled
        bool is_imex = m_config->opt_bool("is_imex");
        for (auto el : {"imex_gantry_count", "imex_tools_per_gantry",
                        "imex_nozzle_clearance_x", "imex_nozzle_clearance_y",
                        "imex_carriage_margin"})
            toggle_option(el, is_imex);
        toggle_option("imex_tool_layout", is_imex);
        toggle_option("imex_viz_theme",   is_imex);
        toggle_option("imex_firmware_managed_zones", is_imex);
        if (m_imex_modes_ctrl) m_imex_modes_ctrl->set_applicable(is_imex);
 
        // IDEX/IQEX: the tool_layout dropdown carries 4 corner values
        // (front-left / front-right / rear-left / rear-right) in storage, but front/rear
        // is meaningless on single-gantry setups. Collapse the dropdown to just two
        // items ("Left" / "Right") when imex_gantry_count == 1 — mapped to front-left
        // and front-right internally — and normalize any stored rear-* selection to its
        // front-* equivalent so the displayed selection always matches the stored value.
        if (is_imex) {
            if (Field* layout_field = get_field("imex_tool_layout"); layout_field) {
                if (auto* choice = dynamic_cast<Choice*>(layout_field); choice) {
                    const int gantry_count = std::max(1, imex_cfg_int(*m_config, "imex_gantry_count"));
                    // Not const: the rear-* -> front-* normalization below reassigns it.
                    int current_val =
                        static_cast<int>(imex_cfg_enum<ImexToolLayout>(*m_config, "imex_tool_layout"));
 
                    // Normalize rear-* → front-* when collapsing to 1 gantry.
                    if (gantry_count == 1 && (current_val == static_cast<int>(ImexToolLayout::RearLeft)
                                           || current_val == static_cast<int>(ImexToolLayout::RearRight))) {
                        ImexToolLayout normalized = (current_val == static_cast<int>(ImexToolLayout::RearLeft))
                                                  ? ImexToolLayout::FrontLeft
                                                  : ImexToolLayout::FrontRight;
                        DynamicPrintConfig new_conf = *m_config;
                        new_conf.set_key_value("imex_tool_layout",
                                               new ConfigOptionEnum<ImexToolLayout>(normalized));
                        load_config(new_conf);
                        current_val = static_cast<int>(normalized);
                    }
 
                    wxArrayString items;
                    if (gantry_count >= 2) {
                        items.Add(_L("Front-left"));
                        items.Add(_L("Front-right"));
                        items.Add(_L("Rear-left"));
                        items.Add(_L("Rear-right"));
                    } else {
                        items.Add(_L("Left"));
                        items.Add(_L("Right"));
                    }
                    choice->set_values(items);
                    choice->set_value(boost::any(current_val), false);
                }
            }
        }
 
        // Orca: "Tool change on wipe tower" only makes sense for multi-extruder (multi-toolhead) printers
        // using a Type 2 wipe tower. SEMM already always travels to the tower as part of the purge,
        // so the option is irrelevant there.
        const size_t extruders_count = m_config->option<ConfigOptionFloats>("nozzle_diameter")->size();
        toggle_option("tool_change_on_wipe_tower", !bSEMM && supports_wipe_tower_2 && extruders_count > 1);
        toggle_option("wait_for_temp_on_wipe_tower", !bSEMM && supports_wipe_tower_2 && extruders_count > 1);
    }
    if (m_active_page->title() == L("Extruder") && m_extruders_count > 0)
    {
        // Orca: the single Extruder page edits the extruder selected on the variant switch; its
        // controls carry field index 0 (i), the values are read for `extruder`.
        const size_t i        = 0;
        const size_t extruder = std::min<size_t>(size_t(get_current_active_extruder()), m_extruders_count - 1);
        const int    variant_index = extruder_variant_index(int(extruder));
        bool have_retract_length = m_config->opt_float("retraction_length", variant_index) > 0;
 
        toggle_option("extruder_printable_area", false, i);          // disable
        toggle_line("extruder_printable_area", m_preset_bundle->get_printer_extruder_count() == 2, i);  //hide
        const bool per_extruder_exclusions =
            m_config->opt_enum<BedExcludeVolumeMode>("bed_exclude_volume_mode") == BedExcludeVolumeMode::PerExtruder;
        toggle_line("extruder_bed_exclude_volumes", m_preset_bundle->get_printer_extruder_count() > 1 && per_extruder_exclusions, i);
        toggle_option("extruder_printable_height", false, i);
        toggle_line("extruder_printable_height", m_preset_bundle->get_printer_extruder_count() == 2, i);
 
        // when using firmware retraction, firmware decides retraction length
        bool use_firmware_retraction = m_config->opt_bool("use_firmware_retraction");
        toggle_option("retract_length", !use_firmware_retraction, i);
 
        // user can customize travel length if we have retraction length or we"re using
        // firmware retraction
        toggle_option("retraction_minimum_travel", have_retract_length || use_firmware_retraction, i);
 
        // user can customize other retraction options if retraction is enabled
        //BBS
        bool retraction = have_retract_length || use_firmware_retraction;
        std::vector<std::string> vec = {"z_hop", "retract_when_changing_layer"};
        for (auto el : vec)
            toggle_option(el, retraction, i);
 
        // retract lift above / below + enforce only applies if using retract lift
        vec.resize(0);
        vec = {"retract_lift_above", "retract_lift_below", "retract_lift_enforce"};
        for (auto el : vec)
          toggle_option(el, retraction && (m_config->opt_float("z_hop", variant_index) > 0), i);
 
        // some options only apply when not using firmware retraction
        vec.resize(0);
        vec = {"retraction_speed", "deretraction_speed", "retract_before_wipe", "retract_after_wipe",
               "retract_length", "retract_restart_extra", "wipe_distance"};
        for (auto el : vec)
            //BBS
            toggle_option(el, retraction && !use_firmware_retraction, i);
 
        bool wipe = retraction && m_config->opt_bool("wipe", variant_index);
 
        // Orca:
        double retract_before_wipe = m_config->option<ConfigOptionPercents>("retract_before_wipe")->get_at(variant_index);
        double retract_after_wipe  = m_config->option<ConfigOptionPercents>("retract_after_wipe")->get_at(variant_index);
 
        toggle_option("retract_before_wipe", wipe && !is_approx(retract_after_wipe, 100.), i);
        toggle_option("retract_after_wipe", wipe && !is_approx(retract_before_wipe, 100.), i);
 
        if (use_firmware_retraction && wipe && retract_before_wipe < 100.0) {
            //wxMessageDialog dialog(parent(),
            MessageDialog dialog(parent(),
                _(L("The Retract before wipe option could be only 100% when using the Firmware Retraction mode.\n"
                    "\nShall I set it to 100% in order to enable Firmware Retraction?")),
                _(L("Firmware Retraction")), wxICON_WARNING | wxYES | wxNO);
 
            DynamicPrintConfig new_conf = *m_config;
            if (dialog.ShowModal() == wxID_YES) {
                auto wipe = static_cast<ConfigOptionBools*>(m_config->option("wipe")->clone());
                auto retract_before_wipe = static_cast<ConfigOptionPercents*>(m_config->option("retract_before_wipe")->clone());
                for (size_t w = 0; w < wipe->values.size(); w++) {
                    wipe->values[w] = false;
                    retract_before_wipe->values[w] = 100.0;
                }
                new_conf.set_key_value("wipe", wipe);
                new_conf.set_key_value("retract_before_wipe", retract_before_wipe);
            }
            else {
                new_conf.set_key_value("use_firmware_retraction", new ConfigOptionBool(false));
            }
            load_config(new_conf);
        }
        // BBS
        toggle_option("wipe_distance", wipe, i);
 
        toggle_option("retract_length_toolchange", have_multiple_extruders, i);
 
        bool toolchange_retraction = m_config->opt_float("retract_length_toolchange", variant_index) > 0;
        toggle_option("retract_restart_extra_toolchange", have_multiple_extruders && toolchange_retraction, i);
 
        toggle_option("long_retractions_when_cut", !use_firmware_retraction && m_config->opt_int("enable_long_retraction_when_cut"), i);
        toggle_line("retraction_distances_when_cut", m_config->opt_bool("long_retractions_when_cut", variant_index), i);
 
        toggle_option("travel_slope", m_config->opt_enum("z_hop_types", variant_index) != ZHopType::zhtNormal, i);
    }
 
    if (m_active_page->title() == L("Motion ability")) {
        auto gcf = m_config->option<ConfigOptionEnum<GCodeFlavor>>("gcode_flavor")->value;
        update_input_shaper_menu(gcf);
 
        // Orca: use booleans to avoid repeated comparisons with enum values
        const bool gcf_is_marlin_legacy = gcf == GCodeFlavor::gcfMarlinLegacy;
        const bool gcf_is_marlin_firmware = gcf == GCodeFlavor::gcfMarlinFirmware;
        const bool gcf_is_klipper = gcf == GCodeFlavor::gcfKlipper;
        const bool gcf_is_reprap_firmware = gcf == GCodeFlavor::gcfRepRapFirmware;
 
        toggle_option("machine_max_acceleration_travel", !gcf_is_marlin_legacy && !gcf_is_klipper, 0);
        toggle_line("machine_max_acceleration_travel", !gcf_is_marlin_legacy && !gcf_is_klipper);
        toggle_option("machine_max_junction_deviation", gcf_is_marlin_firmware, 0);
        toggle_line("machine_max_junction_deviation", gcf_is_marlin_firmware);
 
        // Check if junction deviation value is non-zero and firmware is Marlin
        bool enable_jerk = !gcf_is_marlin_firmware;
        if (gcf_is_marlin_firmware) {
            const auto *junction_deviation = m_config->option<ConfigOptionFloats>("machine_max_junction_deviation");
            if (junction_deviation != nullptr) {
                const auto &values = junction_deviation->values;
                enable_jerk = std::all_of(values.begin(), values.end(), [](double val) { return val == 0.0; });
            } else {
                enable_jerk = true;
            }
        }
        toggle_option("machine_max_jerk_x", enable_jerk, 0);
        toggle_option("machine_max_jerk_y", enable_jerk, 0);
        toggle_option("machine_max_jerk_z", enable_jerk, 0);
        toggle_option("machine_max_jerk_e", enable_jerk, 0);
 
        bool emittable_limits = gcf_is_marlin_legacy || gcf_is_marlin_firmware || gcf_is_reprap_firmware;
        toggle_option("emit_machine_limits_to_gcode", emittable_limits);
 
        bool resonance_avoidance = m_config->opt_bool("resonance_avoidance");
        toggle_option("min_resonance_avoidance_speed", resonance_avoidance);
        toggle_option("max_resonance_avoidance_speed", resonance_avoidance);
 
        bool input_shaping_compatible = gcf_is_marlin_firmware || gcf_is_reprap_firmware;
 
        for (auto is : {"input_shaping_emit", "input_shaping_type", "input_shaping_freq_x", "input_shaping_freq_y",
                            "input_shaping_damp_x", "input_shaping_damp_y"})
                toggle_line(is, input_shaping_compatible);
 
        if (input_shaping_compatible) {
            bool emit_machine_limits_to_gcode = m_config->opt_bool("emit_machine_limits_to_gcode");
            toggle_option("input_shaping_emit", emit_machine_limits_to_gcode);
            bool input_shaping_emit = emit_machine_limits_to_gcode && m_config->opt_bool("input_shaping_emit");
            toggle_option("input_shaping_type", input_shaping_emit);
            toggle_option("input_shaping_freq_x", input_shaping_emit);
            toggle_option("input_shaping_freq_y", input_shaping_emit && !gcf_is_reprap_firmware);
            toggle_option("input_shaping_damp_x", input_shaping_emit);
            toggle_option("input_shaping_damp_y", input_shaping_emit && !gcf_is_reprap_firmware);
        }
 
    }
}

References _, _L, Slic3r::comExpert, extruder_variant_index(), Slic3r::FrontLeft, Slic3r::FrontRight, Slic3r::gcfKlipper, Slic3r::gcfMarlinFirmware, Slic3r::gcfMarlinLegacy, Slic3r::gcfRepRapFirmware, Slic3r::GUI::Tab::get_current_active_extruder(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::Tab::get_field(), Slic3r::Preset::get_printer_type(), Slic3r::imex_cfg_enum(), Slic3r::imex_cfg_int(), Slic3r::is_approx(), Slic3r::is_imex(), L, Slic3r::load_config(), Slic3r::GUI::Tab::m_active_page, Slic3r::GUI::Tab::m_config, m_extruders_count, m_imex_modes_ctrl, Slic3r::GUI::Tab::m_mode, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_presets, Slic3r::None, Slic3r::GUI::Tab::parent(), Slic3r::PerExtruder, Slic3r::PresetBundle::printers, Slic3r::ptSLA, Slic3r::RearLeft, Slic3r::RearRight, Slic3r::retract_after_wipe(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::support_parallel_printheads(), Slic3r::DevPrinterConfigUtil::support_wrapping_detection(), Slic3r::GUI::Tab::toggle_line(), Slic3r::GUI::Tab::toggle_option(), toggle_options(), Slic3r::Type2, update_input_shaper_menu(), Slic3r::use_firmware_retraction(), Slic3r::wipe(), and Slic3r::zhtNormal.

Referenced by toggle_options(), and update_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_show_hide_incompatible()

void Slic3r::GUI::Tab::toggle_show_hide_incompatible ( )

inherited

{
    m_show_incompatible_presets = !m_show_incompatible_presets;
    if (m_presets_choice)
        m_presets_choice->set_show_incompatible_presets(m_show_incompatible_presets);
    update_show_hide_incompatible_button();
    update_tab_ui();
}

References m_presets_choice, m_show_incompatible_presets, toggle_show_hide_incompatible(), update_show_hide_incompatible_button(), and update_tab_ui().

Referenced by toggle_show_hide_incompatible().

Here is the call graph for this function:

Here is the caller graph for this function:

transfer_options()

void Slic3r::GUI::Tab::transfer_options ( const std::string & name_from, const std::string & name_to, std::vector< std::string > options )

inherited

{
    if (options.empty())
        return;
 
    Preset* preset_from = m_presets->find_preset(name_from);
    Preset* preset_to = m_presets->find_preset(name_to);
 
    if (m_type == Preset::TYPE_PRINTER) {
         auto it = std::find(options.begin(), options.end(), "extruders_count");
         if (it != options.end()) {
             // erase "extruders_count" option from the list
             options.erase(it);
             // cache the extruders count
             static_cast<TabPrinter*>(this)->cache_extruder_cnt(&preset_from->config);
         }
    }
    cache_config_diff(options, &preset_from->config);
 
    if (name_to != m_presets->get_edited_preset().name )
        select_preset(preset_to->name);
 
    apply_config_from_cache();
    load_current_preset();
}

References apply_config_from_cache(), cache_config_diff(), Slic3r::Preset::config, load_current_preset(), m_presets, m_type, Slic3r::Preset::name, select_preset(), transfer_options(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by transfer_options().

Here is the call graph for this function:

Here is the caller graph for this function:

translate_category()

wxString Slic3r::GUI::Tab::translate_category ( const wxString & title, Preset::Type preset_type, bool translate = true )

staticinherited

{
    auto tr = [translate](const wxString& s) { return translate ? _(s) : s; };
    if (preset_type == Preset::TYPE_PRINTER && title.Contains("Extruder ")) {
        auto preset = wxGetApp().preset_bundle;
        if (preset && preset->is_bbl_vendor()) {
            if (title == "Extruder 1") return tr(L("Left Extruder"));
            if (title == "Extruder 2") return tr(L("Right Extruder"));
        }
        return tr(L("Extruder")) + title.SubString(8, title.Last());
    }
    // Orca: one "Extruder" page serves all extruders; name it "Extruders" when there are several.
    if (preset_type == Preset::TYPE_PRINTER && title == "Extruder") {
        auto preset = wxGetApp().preset_bundle;
        if (preset && preset->get_printer_extruder_count() > 1)
            return tr(L("Extruders"));
    }
    return tr(title);
}

References _, L, title(), Slic3r::translate(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by activate_option(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), generate_extruder_options(), Slic3r::Search::make_option(), Slic3r::GUI::ActionRegistry::materialize_setting_actions(), rebuild_page_tree(), tree_sel_change_delayed(), update_changed_tree_ui(), update_current_page_in_background(), update_label_colours(), Slic3r::GUI::UnsavedChangesDialog::update_tree(), and Slic3r::GUI::UnsavedChangesDialog::update_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

tree_sel_change_delayed()

bool Slic3r::GUI::Tab::tree_sel_change_delayed ( wxCommandEvent & event )

protectedinherited

{
    // The issue apparently manifests when Show()ing a window with overlay scrollbars while the UI is frozen. For this reason,
    // we will Thaw the UI prematurely on Linux. This means destroing the no_updates object prematurely.
#ifdef __linux__
    std::unique_ptr<wxWindowUpdateLocker> no_updates(new wxWindowUpdateLocker(this));
#else
    /* On Windows we use DoubleBuffering during rendering,
     * so on Window is no needed to call a Freeze/Thaw functions.
     * But under OSX (builds compiled with MacOSX10.14.sdk) wxStaticBitmap rendering is broken without Freeze/Thaw call.
     */
//#ifdef __WXOSX__  // Use Freeze/Thaw to avoid flickering during clear/activate new page
//    wxWindowUpdateLocker noUpdates(this);
//#endif
#endif
 
    //BBS: GUI refactor
    Page* page = nullptr;
    const auto sel_item = m_tabctrl->GetSelection();
    // BBS: bold selection
    //OutputDebugStringA("tree_sel_change_delayed ");
    //OutputDebugStringA(m_title.c_str());
    m_tabctrl->SetItemBold(sel_item, true);
    const auto selection = sel_item >= 0 ? m_tabctrl->GetItemText(sel_item) : "";
    //OutputDebugString(selection);
    //OutputDebugStringA("\n");
    for (auto p : m_pages)
        if (translate_category(p->title(), m_type) == selection)
        {
            page = p.get();
            m_is_nonsys_values = page->m_is_nonsys_values;
            m_is_modified_values = page->m_is_modified_values;
            break;
        }
 
    //BBS: GUI refactor
    if (page == nullptr)
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << boost::format("can not find page with current selection %1%\n") % selection;
        return false;
    }
    void* item_data = m_tabctrl->GetItemData(sel_item);
    if (item_data)
    {
        //from update_current_page_in_background in not active tab
        m_tabctrl->SetItemData(sel_item, NULL);
        return false;
    }
 
    if (!m_parent->is_active_and_shown_tab((wxPanel*)this))
    {
        Tab* current_tab = dynamic_cast<Tab*>(m_parent->get_current_tab());
 
        m_page_view->Freeze();
 
        if (current_tab)
        {
            current_tab->clear_pages();
            current_tab->unselect_tree_item();
        }
        m_active_page = page;
        // BBS: not changed
        // update_undo_buttons();
        this->OnActivate();
        m_parent->set_active_tab(this);
        update_variant_sizer_visibility();
 
        m_page_view->Thaw();
        return false;
    }
 
    //process logic in the same tab when select treeCtrlItem
    if (m_active_page == page)
        return false;
 
    m_active_page = page;
    update_variant_sizer_visibility();
 
    auto throw_if_canceled = std::function<void()>([this](){
#ifdef WIN32
            //BBS: GUI refactor
            //TODO: remove this call currently, after refactor, there is Paint event in the queue
            //this call will cause OnPaint immediately, which will cause crash
            //wxCheckForInterrupt(m_tabctrl);
            if (m_page_switch_planned)
                throw UIBuildCanceled();
#else // WIN32
            (void)this; // silence warning
#endif
        });
 
    try {
        m_page_view->Freeze();
        // clear pages from the controls
        clear_pages();
        throw_if_canceled();
 
        //BBS: GUI refactor
        if (wxGetApp().mainframe!=nullptr && wxGetApp().mainframe->is_active_and_shown_tab(m_parent))
            activate_selected_page(throw_if_canceled);
 
        #ifdef __linux__
            no_updates.reset(nullptr);
        #endif
 
        // BBS: not changed
        // update_undo_buttons();
        throw_if_canceled();
 
        //BBS: GUI refactor
        //m_hsizer->Layout();
        m_parent->Layout();
        throw_if_canceled();
        // Refresh();
 
        m_page_view->Thaw();
    } catch (const UIBuildCanceled&) {
      if (m_active_page)
        m_active_page->clear();
        m_page_view->Thaw();
        return true;
    }
 
    return false;
}

References Tab(), activate_selected_page(), clear_pages(), m_active_page, Slic3r::GUI::Page::m_is_modified_values, m_is_modified_values, Slic3r::GUI::Page::m_is_nonsys_values, m_is_nonsys_values, m_page_switch_planned, m_page_view, m_pages, m_parent, m_tabctrl, m_type, OnActivate(), translate_category(), tree_sel_change_delayed(), unselect_tree_item(), and update_variant_sizer_visibility().

Referenced by create_preset_tab(), and tree_sel_change_delayed().

Here is the call graph for this function:

Here is the caller graph for this function:

type()

Preset::Type Slic3r::GUI::Tab::type ( ) const

inlineinherited

{ return m_type; }

References m_type.

Referenced by Tab(), Slic3r::GUI::TabPrint::TabPrint(), Slic3r::GUI::MainFrame::add_created_tab(), Slic3r::GUI::TabPrinter::build_unregular_pages(), Slic3r::GUI::ParamsPanel::set_active_tab(), Slic3r::GUI::TabPrinter::set_extruder_volume_type(), and Slic3r::GUI::TabPrinter::update_input_shaper_menu().

Here is the caller graph for this function:

unselect_tree_item()

void Slic3r::GUI::Tab::unselect_tree_item ( )

inherited

{
    // BBS: bold selection
    const auto sel_item = m_tabctrl->GetSelection();
    m_last_select_item = sel_item;
    m_tabctrl->SetItemBold(sel_item, false);
    m_tabctrl->Unselect();
    m_active_page = nullptr;
}

References m_active_page, m_last_select_item, m_tabctrl, and unselect_tree_item().

Referenced by tree_sel_change_delayed(), and unselect_tree_item().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void Slic3r::GUI::TabPrinter::update ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    m_update_cnt++;
    m_presets->get_edited_preset().printer_technology() == ptFFF ? update_fff() : update_sla();
    m_update_cnt--;
 
    update_description_lines();
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
 
    if (m_update_cnt == 0)
        wxGetApp().mainframe->on_config_changed(m_config);
}

References Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_parent, Slic3r::GUI::Tab::m_presets, Slic3r::GUI::Tab::m_update_cnt, Slic3r::ptFFF, update(), Slic3r::GUI::Tab::update_description_lines(), update_fff(), and update_sla().

Referenced by build_unregular_pages(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_all_extruder_options_status()

void Slic3r::GUI::Tab::update_all_extruder_options_status ( )

inherited

{
    if (!m_extruder_switch && !m_variant_combo) {
        return;
    }
    m_all_extruder_options_status.clear();
 
    int extruder_count = m_preset_bundle->get_printer_extruder_count();
    auto extruders = m_preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnumsGeneric>("extruder_type");
    auto nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
    std::set<int> all_config_indices;
    for (int extruder_id = 0; extruder_id < extruder_count; ++extruder_id) {
        for (auto nozzle_type : get_valid_nozzle_volume_type()) {
            auto variant_keys = extruder_variant_keys[m_type >= Preset::TYPE_COUNT ? Preset::TYPE_PRINT : m_type];
            int config_index = m_config->get_index_for_extruder(
                extruder_id + 1,
                variant_keys.first,
                ExtruderType(extruders->values[extruder_id]),
                nozzle_type,
                variant_keys.second
            );
            if (config_index >= 0) {
                all_config_indices.insert(config_index);
            }
        }
    }
 
    auto dirty_options = m_presets->current_dirty_options(true);
    auto nonsys_options = m_presets->current_different_from_parent_options(true);
    if (m_type == Preset::TYPE_PRINTER)
        update_custom_dirty(dirty_options, nonsys_options);
    auto filter_extruder_options = [](const std::vector<std::string>& options) {
        std::vector<std::string> filtered_options;
        for (const auto& opt : options) {
            if (opt.find('#') != std::string::npos) {
                filtered_options.push_back(opt);
            }
        }
        return filtered_options;
    };
 
    auto filtered_dirty_options = filter_extruder_options(dirty_options);
    auto filtered_nonsys_options = filter_extruder_options(nonsys_options);
 
    for (int config_index : all_config_indices) {
        int status_value = m_opt_status_value;
        for (const auto &opt_key : filtered_dirty_options) {
              m_all_extruder_options_status[opt_key] = status_value & ~osInitValue;
        }
        for (const auto &opt_key : filtered_nonsys_options) {
            auto iter = m_all_extruder_options_status.find(opt_key);
            if (iter != m_all_extruder_options_status.end()) {
                iter->second &= ~osSystemValue;
            } else {
                m_all_extruder_options_status[opt_key] = status_value & ~osSystemValue;
            }
        }
    }
}

References Slic3r::GUI::extruder_variant_keys, Slic3r::get_valid_nozzle_volume_type(), m_all_extruder_options_status, m_config, m_extruder_switch, m_opt_status_value, m_preset_bundle, m_presets, m_type, m_variant_combo, Slic3r::nozzle_type(), osInitValue, osSystemValue, Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, update_all_extruder_options_status(), update_custom_dirty(), and Slic3r::GUI::variant_keys().

Referenced by update_all_extruder_options_status(), and update_changed_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

update_btns_enabling()

void Slic3r::GUI::Tab::update_btns_enabling ( )

inherited

{
    // we can delete any preset from the physical printer
    // and any user preset
    const Preset& preset = m_presets->get_edited_preset();
    m_btn_delete_preset->Show((m_type == Preset::TYPE_PRINTER && m_preset_bundle->physical_printers.has_selection())
                              || preset.can_overwrite());
 
    //if (m_btn_edit_ph_printer)
    //    m_btn_edit_ph_printer->SetToolTip( m_preset_bundle->physical_printers.has_selection() ?
    //                                       _L("Edit physical printer") : _L("Add physical printer"));
}

References Slic3r::Preset::can_overwrite(), m_btn_delete_preset, m_preset_bundle, m_presets, m_type, Slic3r::Preset::TYPE_PRINTER, and update_btns_enabling().

Referenced by load_current_preset(), update_btns_enabling(), and update_preset_choice().

Here is the call graph for this function:

Here is the caller graph for this function:

update_changed_tree_ui()

void Slic3r::GUI::Tab::update_changed_tree_ui ( )

inherited

{
    if (m_options_list.empty()) {
        if (m_type == Preset::Type::TYPE_PLATE) {
            for (auto page : m_pages) {
                page->m_is_nonsys_values = false;
            }
        }
        return;
    }
    auto cur_item = m_tabctrl->GetFirstVisibleItem();
    if (cur_item < 0 || !m_tabctrl->IsVisible(cur_item))
        return;
 
    auto selected_item = m_tabctrl->GetSelection();
    auto selection = selected_item >= 0 ? m_tabctrl->GetItemText(selected_item) : "";
 
    while (cur_item >= 0) {
        auto title = m_tabctrl->GetItemText(cur_item);
        for (auto page : m_pages)
        {
            if (translate_category(page->title(), m_type) != title)
                continue;
            bool sys_page = true;
            bool modified_page = false;
            if (page->title() == "General") {
                std::initializer_list<const char*> optional_keys{ "extruders_count", "printable_area" };
                for (auto &opt_key : optional_keys) {
                    get_sys_and_mod_flags(opt_key, sys_page, modified_page);
                }
            }
            if (page->title() == "Dependencies") {
                if (m_type == Slic3r::Preset::TYPE_PRINTER) {
                    sys_page = m_presets->get_selected_preset_parent() != nullptr;
                    modified_page = false;
                } else {
                    if (m_type == Slic3r::Preset::TYPE_FILAMENT || m_type == Slic3r::Preset::TYPE_SLA_MATERIAL)
                        get_sys_and_mod_flags("compatible_prints", sys_page, modified_page);
                    get_sys_and_mod_flags("compatible_printers", sys_page, modified_page);
                }
            }
            if (page->title() == "Speed" || page->title() == "Motion ability" || page->title() == "Filament" || page->title() == "Setting Overrides" || page->title() == "Multimaterial" || is_printer_extruder_page(page.get())) {
                auto options = generate_extruder_options();
                for (size_t switch_index = 0; switch_index < options.size(); ++switch_index) {
                    std::vector<PageShp> pages_to_check = { page };
                    check_extruder_options_status(switch_index, sys_page, modified_page, pages_to_check);
                }
            }
            for (auto group : page->m_optgroups)
            {
                if (!sys_page && modified_page)
                    break;
                for (const auto &kvp : group->opt_map()) {
                    const std::string &opt_key = kvp.first;
                    get_sys_and_mod_flags(opt_key, sys_page, modified_page);
                }
            }
 
            const wxColor *clr = sys_page ? (m_is_default_preset ? &m_default_text_clr : &m_sys_label_clr) :
                                 (modified_page || m_type >= Preset::TYPE_COUNT) ? &m_modified_label_clr : &m_default_text_clr;
 
            if (page->set_item_colour(clr))
                m_tabctrl->SetItemTextColour(cur_item, clr == &m_modified_label_clr ? *clr : StateColor(
                        std::make_pair(0x6B6B6C, (int) StateColor::NotChecked),
                        std::make_pair(*clr, (int) StateColor::Normal)));
 
            page->m_is_nonsys_values = !sys_page;
            page->m_is_modified_values = modified_page;
 
            if (selection == title) {
                m_is_nonsys_values = page->m_is_nonsys_values;
                m_is_modified_values = page->m_is_modified_values;
            }
            break;
        }
        auto next_item = m_tabctrl->GetNextVisible(cur_item);
        cur_item = next_item;
    }
}

References check_extruder_options_status(), generate_extruder_options(), get_sys_and_mod_flags(), is_printer_extruder_page(), m_default_text_clr, m_is_default_preset, m_is_modified_values, m_is_nonsys_values, m_modified_label_clr, m_options_list, m_pages, m_presets, m_sys_label_clr, m_tabctrl, m_type, StateColor::Normal, StateColor::NotChecked, Slic3r::optional_keys, title(), translate_category(), Slic3r::Preset::TYPE_COUNT, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PLATE, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, and update_changed_tree_ui().

Referenced by sys_color_changed(), update_changed_tree_ui(), update_changed_ui(), and update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

update_changed_ui()

void Slic3r::GUI::Tab::update_changed_ui ( )

inherited

{
    if (m_postpone_update_ui)
        return;
 
    const bool deep_compare = (m_type == Preset::TYPE_PRINTER || m_type == Preset::TYPE_PRINT || m_type == Preset::TYPE_FILAMENT
            || m_type == Preset::TYPE_SLA_MATERIAL || m_type == Preset::TYPE_MODEL);
    auto dirty_options = m_presets->current_dirty_options(deep_compare);
    auto nonsys_options = m_presets->current_different_from_parent_options(deep_compare);
    if (m_type == Preset::TYPE_PRINTER && static_cast<TabPrinter*>(this)->m_printer_technology == ptFFF) {
        TabPrinter* tab = static_cast<TabPrinter*>(this);
        if (tab->m_initial_extruders_count != tab->m_extruders_count)
            dirty_options.emplace_back("extruders_count");
        if (tab->m_sys_extruders_count != tab->m_extruders_count)
            nonsys_options.emplace_back("extruders_count");
    }
 
    update_custom_dirty(dirty_options, nonsys_options);
    update_all_extruder_options_status();
 
    filter_diff_option(dirty_options);
    filter_diff_option(nonsys_options);
 
    for (auto& it : m_options_list)
        it.second = m_opt_status_value;
 
    for (auto opt_key : dirty_options) {
        auto iter = m_options_list.find(opt_key);
        if (iter != m_options_list.end())
            iter->second &= ~osInitValue;
    }
    for (auto opt_key : nonsys_options) {
        auto iter = m_options_list.find(opt_key);
        if (iter != m_options_list.end())
            iter->second &= ~osSystemValue;
    }
 
    decorate();
    update_extruder_switch_colors();
 
    wxTheApp->CallAfter([this]() {
        if (parent()) //To avoid a crash, parent should be exist for a moment of a tree updating
            update_changed_tree_ui();
    });
    // BBS:
    update_undo_buttons();
}

References decorate(), filter_diff_option(), Slic3r::GUI::TabPrinter::m_extruders_count, Slic3r::GUI::TabPrinter::m_initial_extruders_count, m_opt_status_value, m_options_list, m_postpone_update_ui, m_presets, Slic3r::GUI::TabPrinter::m_sys_extruders_count, m_type, osInitValue, osSystemValue, parent(), Slic3r::ptFFF, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_MODEL, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, update_all_extruder_options_status(), update_changed_tree_ui(), update_custom_dirty(), update_extruder_switch_colors(), and update_undo_buttons().

Referenced by activate_selected_page(), compatible_widget_create(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), create_preset_tab(), load_current_preset(), Slic3r::GUI::TabPrintModel::on_value_change(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), save_preset(), switch_excluder(), sync_excluder(), update_dirty(), and update_pages_with_multi_variant().

Here is the call graph for this function:

Here is the caller graph for this function:

update_current_page_in_background()

bool Slic3r::GUI::Tab::update_current_page_in_background ( int & item )

inherited

{
    Page* page = nullptr;
 
    const auto selection = item >= 0 ? m_tabctrl->GetItemText(item) : "";
    for (auto p : m_pages)
        if (translate_category(p->title(), m_type) == selection)
        {
            page = p.get();
            break;
        }
 
    if (page == nullptr || m_active_page == page)
        return false;
 
    bool active_tab = false;
    if (wxGetApp().mainframe != nullptr && wxGetApp().mainframe->is_active_and_shown_tab(m_parent))
        active_tab = true;
 
    if (!active_tab || (!m_parent->is_active_and_shown_tab((wxPanel*)this)))
    {
        m_is_nonsys_values = page->m_is_nonsys_values;
        m_is_modified_values = page->m_is_modified_values;
        // BBS: not need active
        // m_active_page = page;
 
        // invalidated highlighter, if any exists
        m_highlighter.invalidate();
 
        // clear pages from the controlls
        // BBS: fix after new layout, clear page in backgroud
        for (auto p : m_pages)
            p->clear();
        if (m_parent->is_active_and_shown_tab((wxPanel*)this))
            m_parent->clear_page();
 
        update_undo_buttons();
 
        // BBS: this is not used, because we not SelectItem in background
        //todo: update selected item of tree_ctrl
        // wxTreeItemData item_data;
        // m_tabctrl->SetItemData(item, &item_data);
 
        return false;
    }
 
    return true;
}

References m_active_page, m_highlighter, Slic3r::GUI::Page::m_is_modified_values, m_is_modified_values, Slic3r::GUI::Page::m_is_nonsys_values, m_is_nonsys_values, m_pages, m_parent, m_tabctrl, m_type, translate_category(), update_current_page_in_background(), and update_undo_buttons().

Referenced by rebuild_page_tree(), and update_current_page_in_background().

Here is the call graph for this function:

Here is the caller graph for this function:

update_custom_dirty()

void Slic3r::GUI::TabPrinter::update_custom_dirty ( std::vector< std::string > & dirty_options, std::vector< std::string > & nonsys_options )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::Tab.

{
    drop_unchanged_added_entries(dirty_options, *m_config, &m_presets->get_selected_preset());
    drop_unchanged_added_entries(nonsys_options, *m_config, m_presets->get_selected_preset_parent());
}

References Slic3r::GUI::drop_unchanged_added_entries(), Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_presets, and update_custom_dirty().

Referenced by update_custom_dirty().

Here is the call graph for this function:

Here is the caller graph for this function:

update_description_lines()

void Slic3r::GUI::Tab::update_description_lines ( )

virtualinherited

Reimplemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, and Slic3r::GUI::TabSLAPrint.

{
    if (m_active_page && m_active_page->title() == "Dependencies" && m_parent_preset_description_line)
        update_preset_description_line();
}

References m_active_page, m_parent_preset_description_line, update_description_lines(), and update_preset_description_line().

Referenced by activate_selected_page(), Slic3r::GUI::TabPrinter::update(), Slic3r::GUI::TabSLAMaterial::update(), update_description_lines(), Slic3r::GUI::TabFilament::update_description_lines(), Slic3r::GUI::TabPrint::update_description_lines(), Slic3r::GUI::TabSLAPrint::update_description_lines(), and update_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

update_dirty()

void Slic3r::GUI::Tab::update_dirty ( )

inherited

{
    if (m_postpone_update_ui)
        return;
 
    if (m_presets_choice) {
        m_presets_choice->update_dirty();
        on_presets_changed();
    } else {
        m_presets->update_dirty();
    }
    update_changed_ui();
}

References m_postpone_update_ui, m_presets, m_presets_choice, on_presets_changed(), update_changed_ui(), and update_dirty().

Referenced by apply_config_from_cache(), apply_preset_config_values(), Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::build_unregular_pages(), edit_custom_gcode(), get_config_manipulation(), load_config(), on_roll_back_value(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), Slic3r::GUI::TabFilament::toggle_options(), update_dirty(), Slic3r::GUI::TabPrintModel::update_model_config(), Slic3r::GUI::validate_custom_gcode_cb(), and Slic3r::GUI::validate_custom_gcode_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

update_extruder_switch_colors()

void Slic3r::GUI::Tab::update_extruder_switch_colors ( )

inherited

{
    if (!m_extruder_switch && !m_variant_combo) {
        return;
    }
 
    auto options = generate_extruder_options();
 
    std::vector<PageShp> pages_to_check;
    if (m_active_page) {
        const wxString t = m_active_page->title();
        if (t == "Speed" || t == "Motion ability" || t == "Filament" ||
            t == "Setting Overrides" || t == "Multimaterial" || is_printer_extruder_page(m_active_page)) {
            for (auto &p : m_pages){
                if (p.get() == m_active_page) {
                    pages_to_check.push_back(p);
                    break;
                }
            }
        }
    }
 
    for (size_t switch_index = 0; switch_index < options.size(); ++switch_index) {
        bool sys_extruder = true;
        bool modified_extruder = false;
        if (!pages_to_check.empty())
            check_extruder_options_status((int) switch_index, sys_extruder, modified_extruder, pages_to_check);
        // no matching page: clear the flag so the tag doesn't keep a stale color
 
        if (m_extruder_switch) m_extruder_switch->SetModified(switch_index, modified_extruder);
        if (m_variant_combo)   m_variant_combo->SetModified(switch_index, modified_extruder);
    }
}

References check_extruder_options_status(), generate_extruder_options(), is_printer_extruder_page(), m_active_page, m_extruder_switch, m_pages, m_variant_combo, and update_extruder_switch_colors().

Referenced by update_changed_ui(), update_extruder_switch_colors(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

update_extruder_variants()

void Slic3r::GUI::Tab::update_extruder_variants ( int extruder_id = -1, bool reload = true )

inherited

Call from: 1: on_value_change "nozzle_volume_type" 2: on_preset_loaded (extruder_id = -1).

Parameters

extruder_id

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << extruder_id;
    if (m_extruder_switch) {
        auto    nozzle_volumes = m_preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
        int extruder_nums = m_preset_bundle->get_printer_extruder_count();
        nozzle_volumes->values.resize(extruder_nums);
 
        // Orca: update `m_actual_nozzle_volumes` to current selected ones
        m_actual_nozzle_volumes.resize(extruder_nums, NozzleVolumeType::nvtStandard);
        for (int i = 0; i < extruder_nums; i++) m_actual_nozzle_volumes[i] = (NozzleVolumeType)nozzle_volumes->values[i];
 
        // Orca: when every extruder uses the same variant (e.g. a non-Bambu dual-nozzle printer), the
        // switch has no nozzle variants to select and nothing to sync. The printer tab still enables it
        // to choose the extruder its Extruder and Motion ability pages edit.
        m_extruder_switch_variants = extruder_nums >= 2 && m_preset_bundle->support_different_extruders();
        if (m_extruder_switch_variants || (m_type == Preset::TYPE_PRINTER && extruder_nums >= 2)) {
            auto options = generate_extruder_options();
            m_extruder_switch->SetOptions(options);
            int item_n = options.empty() ? 0 : options.size();
            if (m_type == Preset::TYPE_PRINTER){ // we are on printer settings dialog and larger padding can be used
                int h_pad  = item_n > 8 ? 6 : (item_n > 6 ? 9 : (item_n > 5 ? 12 : (item_n > 4 ? 18 : (item_n > 3 ? 24 : (item_n > 2 ? 36 : 48)))));
                m_extruder_switch->SetButtonPadding(wxSize(h_pad, 3));
            }
            else {
                int h_pad  = item_n > 6 ? 6 : (item_n > 4 ? 10 : (item_n > 2 ? 20 : 36));
                m_extruder_switch->SetButtonPadding(wxSize(h_pad, 3));
            }
 
            int selection_index;
            if (extruder_id >= 0) {
                NozzleVolumeType current_nozzle_type = get_actual_nozzle_volume_type(extruder_id);
                selection_index = calculate_selection_index_for_extruder(extruder_id, current_nozzle_type);
            } else {
                selection_index = m_extruder_switch->GetSelection();
                if (selection_index < 0) {
                    selection_index = 0;
                }
            }
 
            m_extruder_switch->SetSelection(selection_index);
            m_extruder_switch->Enable(true);
            m_extruder_sync->Enable(true);
        } else {
            m_extruder_switch->Enable(false);
            m_extruder_sync->Enable(false);
        }
    } else if (m_variant_combo) {
        if (extruder_id >= 0)
            return;
 
        const int selection = m_variant_combo->GetSelection();
        auto      options   = generate_extruder_options();
        m_variant_combo->SetOptions(options);
        int item_n = options.empty() ? 0 : options.size();
        int h_pad  = item_n > 6 ? 6 : (item_n > 4 ? 8 : (item_n > 2 ? 20 : 36));
        m_variant_combo->SetButtonPadding(wxSize(h_pad, 3));
 
        if (!options.empty())
            m_variant_combo->SetSelection(selection < 0 || selection >= (int) options.size() ? 0 : selection);
 
        m_variant_combo->Enable(options.size() > 1);
    }
    switch_excluder(extruder_id, reload);
    if (m_type == Preset::TYPE_PRINT) {
        update_pages_with_multi_variant();
    }
    update_extruder_switch_colors();
    update_variant_sizer_visibility();
}

References calculate_selection_index_for_extruder(), generate_extruder_options(), get_actual_nozzle_volume_type(), m_actual_nozzle_volumes, m_extruder_switch, m_extruder_switch_variants, m_extruder_sync, m_preset_bundle, m_type, m_variant_combo, Slic3r::nvtStandard, switch_excluder(), Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, update_extruder_switch_colors(), update_extruder_variants(), update_pages_with_multi_variant(), and update_variant_sizer_visibility().

Referenced by load_current_preset(), and update_extruder_variants().

Here is the call graph for this function:

Here is the caller graph for this function:

update_fff()

void Slic3r::GUI::TabPrinter::update_fff

(

)

{
    // Sync IDEX/IQEX tool grid whenever carriage configuration changes.
    // set_grid_size() is a no-op when dimensions and layout are unchanged.
    // load_from_config() is gated on matches_config() — without that guard,
    // every keystroke in a row's textbox would destroy and rebuild the widget
    // (because notify() writes config → update_fff() runs → load_from_config()
    // detaches the textbox the user is typing in). The page-level reset still
    // refreshes the rows because that path actually changes the config, which
    // matches_config() then detects.
    if (m_imex_modes_ctrl) {
        int n_cols = 0, n_rows = 0, layout = 0;
        imex_grid_shape(m_config, n_cols, n_rows, layout);
        m_imex_modes_ctrl->set_grid_size(n_cols, n_rows, layout);
        if (!m_imex_modes_ctrl->matches_config(*m_config))
            m_imex_modes_ctrl->load_from_config(*m_config);
    }
 
    // Belt printer: auto-sync build_plate_tilt_{x,y} (which drives support gravity tilt)
    // from the belt slicing rotation, the single source of truth for the physical tilt.
    // Tilt about X drives tilt_x, tilt about Y drives tilt_y.
    //
    // R8: value-guessing (zeroing any tilt matching the dormant belt-derived tilt) wiped a
    // legitimate manual build_plate_tilt on a non-belt tilted-bed printer, because the belt
    // defaults (rotation=X, angle=45) make a manual tilt of 45 look belt-derived. Instead we
    // track the belt->non-belt transition and the exact values belt-sync wrote, and clear the
    // tilt only on a genuine in-place belt-off toggle, and only if the value is still what
    // belt-sync last wrote. Preset switches reset the tracking in on_preset_loaded(), so they
    // never trip the reset.
    if (m_config->opt_bool("belt_printer")) {
        auto rot_axis = m_config->option<ConfigOptionEnum<BeltRotationAxis>>("belt_slice_rotation")->value;
        const auto tilt = BeltTransformPipeline::physical_tilt(
            rot_axis, m_config->opt_float("belt_slice_rotation_angle"));
        if (m_config->opt_float("build_plate_tilt_x") != tilt.tilt_x_deg)
            m_config->set_key_value("build_plate_tilt_x", new ConfigOptionFloat(tilt.tilt_x_deg));
        if (m_config->opt_float("build_plate_tilt_y") != tilt.tilt_y_deg)
            m_config->set_key_value("build_plate_tilt_y", new ConfigOptionFloat(tilt.tilt_y_deg));
        // Remember exactly what belt-sync wrote, so an in-place belt-off toggle can distinguish
        // a still-belt-derived tilt (safe to clear) from a since-edited manual one (keep).
        m_belt_synced_tilt_x = tilt.tilt_x_deg;
        m_belt_synced_tilt_y = tilt.tilt_y_deg;
    } else if (m_was_belt_printer) {
        // Genuine in-place belt->off toggle on the same preset (on_preset_loaded() was not called
        // since the last update, so m_was_belt_printer still reflects belt mode). Clear each axis
        // only if it still holds the value belt-sync last wrote; a manual override is preserved.
        if (m_config->opt_float("build_plate_tilt_x") == m_belt_synced_tilt_x)
            m_config->set_key_value("build_plate_tilt_x", new ConfigOptionFloat(0.));
        if (m_config->opt_float("build_plate_tilt_y") == m_belt_synced_tilt_y)
            m_config->set_key_value("build_plate_tilt_y", new ConfigOptionFloat(0.));
    }
    m_was_belt_printer = m_config->opt_bool("belt_printer");
 
    toggle_options();
}

References Slic3r::ConfigOptionFloat, Slic3r::GUI::imex_grid_shape(), m_belt_synced_tilt_x, m_belt_synced_tilt_y, Slic3r::GUI::Tab::m_config, m_imex_modes_ctrl, m_was_belt_printer, Slic3r::BeltTransformPipeline::physical_tilt(), toggle_options(), and update_fff().

Referenced by update(), and update_fff().

Here is the call graph for this function:

Here is the caller graph for this function:

update_frequently_changed_parameters()

void Slic3r::GUI::Tab::update_frequently_changed_parameters ( )

protectedinherited

{
    const bool is_fff = supports_printer_technology(ptFFF);
    auto og_freq_chng_params = wxGetApp().sidebar().og_freq_chng_params(is_fff);
    if (!og_freq_chng_params) return;
 
    og_freq_chng_params->set_value("support", support_combo_value_for_config(*m_config, is_fff));
    if (! is_fff)
        og_freq_chng_params->set_value("pad", pad_combo_value_for_config(*m_config));
 
    const std::string updated_value_key = is_fff ? "sparse_infill_density" : "pad_enable";
 
    const boost::any val = og_freq_chng_params->get_config_value(*m_config, updated_value_key);
    og_freq_chng_params->set_value(updated_value_key, val);
 
    if (is_fff)
    {
        og_freq_chng_params->set_value("brim", bool(m_config->opt_float("brim_width") > 0.0));
        update_wiping_button_visibility();
    }
}

References m_config, Slic3r::GUI::pad_combo_value_for_config(), Slic3r::ptFFF, Slic3r::GUI::support_combo_value_for_config(), supports_printer_technology(), update_frequently_changed_parameters(), and update_wiping_button_visibility().

Referenced by load_current_preset(), and update_frequently_changed_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

update_input_shaper_menu()

void Slic3r::GUI::TabPrinter::update_input_shaper_menu ( GCodeFlavor flavor )

private

{
    if (m_presets->get_edited_preset().printer_technology() != ptFFF)
        return;
 
    const std::vector<InputShaperType> allowed = input_shaper_types_for_flavor(flavor);
    if (allowed.empty())
        return;
 
    const InputShaperType current = m_config->opt_enum<InputShaperType>("input_shaping_type");
    const bool needs_reset = std::find(allowed.begin(), allowed.end(), current) == allowed.end();
    const InputShaperType desired = needs_reset ? allowed.front() : current;
 
    if (needs_reset && current != desired) {
        DynamicPrintConfig new_conf = *m_config;
        new_conf.set_key_value("input_shaping_type", new ConfigOptionEnum<InputShaperType>(desired));
        m_config_manipulation.apply(m_config, &new_conf);
    }
 
    Page* owning_page = nullptr;
    Field* field = get_field("input_shaping_type", &owning_page);
    if (field == nullptr)
        return;
 
    auto choice_field = dynamic_cast<Choice*>(field);
    if (choice_field == nullptr)
        return;
 
    auto combo = dynamic_cast<ComboBox*>(choice_field->getWindow());
    if (combo == nullptr)
        return;
 
    const ConfigOptionDef* def = m_config->def()->get("input_shaping_type");
    if (def == nullptr)
        return;
 
    const auto& labels = def->enum_labels;
    const auto& values = def->enum_values;
 
    wxWindowUpdateLocker locker(combo);
    combo->Clear();
 
    for (InputShaperType type : allowed) {
        const size_t idx = static_cast<size_t>(type);
        wxString label;
        if (idx < labels.size() && !labels[idx].empty())
            label = _(labels[idx]);
        else if (idx < values.size())
            label = wxString::FromUTF8(values[idx].c_str());
        else
            label = wxString::Format("%d", static_cast<int>(type));
 
        combo->Append(label, wxNullBitmap,
            reinterpret_cast<void*>(static_cast<uintptr_t>(static_cast<int>(type))));
    }
 
    if (combo->GetCount() == 0)
        return;
 
    choice_field->set_value(static_cast<int>(desired), false);
}

References _, Slic3r::ConfigOptionDef::enum_labels, Slic3r::ConfigOptionDef::enum_values, Slic3r::GUI::Tab::get_field(), Slic3r::GUI::input_shaper_types_for_flavor(), Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_config_manipulation, Slic3r::GUI::Tab::m_presets, Slic3r::ptFFF, Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::Tab::type(), and update_input_shaper_menu().

Referenced by on_gcode_flavor_changed(), toggle_options(), and update_input_shaper_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

update_label_colours()

void Slic3r::GUI::Tab::update_label_colours ( )

inherited

{
    m_default_text_clr = wxGetApp().get_label_clr_default();
    if (m_sys_label_clr == wxGetApp().get_label_clr_sys() && m_modified_label_clr == wxGetApp().get_label_clr_modified())
        return;
    m_sys_label_clr = wxGetApp().get_label_clr_sys();
    m_modified_label_clr = wxGetApp().get_label_clr_modified();
 
    //update options "decoration"
    for (const auto& opt : m_options_list)
    {
        const wxColour *color = &m_sys_label_clr;
 
        // value isn't equal to system value
        if ((opt.second & osSystemValue) == 0) {
            // value is equal to last saved
            if ((opt.second & osInitValue) != 0)
                color = &m_default_text_clr;
            // value is modified
            else
                color = &m_modified_label_clr;
        }
        if (opt.first == "printable_area"            ||
            opt.first == "compatible_prints"    || opt.first == "compatible_printers"           ) {
            if (Line* line = get_line(opt.first))
                line->set_label_colour(color);
            continue;
        }
 
        Field* field = get_field(opt.first);
        if (field == nullptr) continue;
        field->set_label_colour(color);
    }
 
    auto cur_item = m_tabctrl->GetFirstVisibleItem();
    if (cur_item < 0 || !m_tabctrl->IsVisible(cur_item))
        return;
    while (cur_item >= 0) {
        auto title = m_tabctrl->GetItemText(cur_item);
        for (auto page : m_pages)
        {
            if (translate_category(page->title(), m_type) != title)
                continue;
 
            const wxColor *clr = !page->m_is_nonsys_values ? &m_sys_label_clr :
                page->m_is_modified_values ? &m_modified_label_clr :
                (m_type < Preset::TYPE_COUNT ? &m_default_text_clr : &m_modified_label_clr);
 
            m_tabctrl->SetItemTextColour(cur_item, clr == &m_modified_label_clr ? *clr : StateColor(
                        std::make_pair(0x6B6B6C, (int) StateColor::NotChecked),
                        std::make_pair(*clr, (int) StateColor::Normal)));
            break;
        }
        cur_item = m_tabctrl->GetNextVisible(cur_item);
    }
 
    decorate();
}

References decorate(), get_field(), get_line(), m_default_text_clr, m_modified_label_clr, m_options_list, m_pages, m_sys_label_clr, m_tabctrl, m_type, StateColor::Normal, StateColor::NotChecked, osInitValue, osSystemValue, Slic3r::GUI::UndoValueUIManager::set_label_colour(), title(), translate_category(), and Slic3r::Preset::TYPE_COUNT.

Referenced by sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

update_mode()

void Slic3r::GUI::Tab::update_mode ( )

inherited

{
    m_mode = wxGetApp().get_mode();
 
    // toggle_options reads m_mode to gate Lines whose contents are mode-mixed
    // (e.g., a multi-option row where some options are Advanced and some Expert):
    // when all of a Line's options would be hidden, we hide the Line itself.
    // Without refreshing here, the toggle_visible state stays stale across mode
    // switches and Lines stay hidden.
    toggle_options();
 
    update_visibility();
 
    update_changed_tree_ui();
}

References m_mode, toggle_options(), update_changed_tree_ui(), update_mode(), and update_visibility().

Referenced by update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

update_pages()

void Slic3r::GUI::TabPrinter::update_pages

(

)

{
    // update m_pages ONLY if printer technology is changed
    const PrinterTechnology new_printer_technology = m_presets->get_edited_preset().printer_technology();
    if (new_printer_technology == m_printer_technology)
        return;
 
    //clear all active pages before switching
    clear_pages();
 
    // set m_pages to m_pages_(technology before changing)
    m_printer_technology == ptFFF ? m_pages.swap(m_pages_fff) : m_pages.swap(m_pages_sla);
 
    // build Tab according to the technology, if it's not exist jet OR
    // set m_pages_(technology after changing) to m_pages
    // m_printer_technology will be set by Tab::load_current_preset()
    if (new_printer_technology == ptFFF)
    {
        if (m_pages_fff.empty())
        {
            build_fff();
            if (m_extruders_count > 1)
            {
                m_preset_bundle->update_multi_material_filament_presets();
                on_value_change("extruders_count", m_extruders_count);
            }
        }
        else
            m_pages.swap(m_pages_fff);
 
         wxGetApp().obj_list()->update_objects_list_filament_column(m_extruders_count);
    }
    else
        m_pages_sla.empty() ? build_sla() : m_pages.swap(m_pages_sla);
 
    rebuild_page_tree();
}

References build_fff(), build_sla(), clear_pages(), m_extruders_count, Slic3r::GUI::Tab::m_pages, m_pages_fff, m_pages_sla, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_presets, m_printer_technology, on_value_change(), Slic3r::ptFFF, Slic3r::GUI::Tab::rebuild_page_tree(), and update_pages().

Referenced by update_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

update_pages_with_multi_variant()

void Slic3r::GUI::Tab::update_pages_with_multi_variant ( )

inherited

{
    if (!m_active_page) {
        return;
    }
    // TODO: Orca: support multi variant field
    //for (auto optgroup : m_active_page->m_optgroups) {
    //    Field *multi_variant_field = nullptr;
    //    std::string opt_key;
 
    //    for (const auto& opt : multi_variant_text_ctrl_options) {
    //        Field* field = optgroup->get_fieldc(opt, 0);
    //        if (field) {
    //            auto *multi_variant = dynamic_cast<MultiVariantTextCtrl *>(field);
    //            if (multi_variant) {;
    //                multi_variant_field = field;
    //                opt_key = opt;
    //            }
    //            break;
    //        }
    //    }
    //    if (multi_variant_field) {
    //        auto * multi_variant_ctrl = dynamic_cast<MultiVariantTextCtrl*>(multi_variant_field);
    //        multi_variant_ctrl->refresh_text_ctrls_layout(optgroup->ctrl_parent());
    //        if (optgroup->custom_ctrl) {
    //            optgroup->custom_ctrl->update_line_height_for_field(opt_key);
    //        }
    //    }
    //    m_page_view->GetParent()->Layout();
    //    m_parent->Layout();
    //}
    update_changed_ui();
}

References m_active_page, update_changed_ui(), and update_pages_with_multi_variant().

Referenced by update_extruder_variants(), and update_pages_with_multi_variant().

Here is the call graph for this function:

Here is the caller graph for this function:

update_preset_choice()

void Slic3r::GUI::Tab::update_preset_choice ( )

inherited

{
    if (m_presets_choice)
        m_presets_choice->update();
    update_btns_enabling();
}

References m_presets_choice, update_btns_enabling(), and update_preset_choice().

Referenced by update_preset_choice().

Here is the call graph for this function:

Here is the caller graph for this function:

update_preset_description_line()

void Slic3r::GUI::Tab::update_preset_description_line ( )

protectedinherited

{
    const Preset* parent = m_presets->get_selected_preset_parent();
    const Preset& preset = m_presets->get_edited_preset();
 
    wxString description_line;
 
    if (preset.is_default) {
        description_line = _(L("This is a default preset."));
    } else if (preset.is_system) {
        description_line = _(L("This is a system preset."));
    } else if (parent == nullptr) {
        description_line = _(L("Current preset is inherited from the default preset."));
    } else {
        std::string name = parent->name;
        boost::replace_all(name, "&", "&&");
        description_line = _(L("Current preset is inherited from")) + ":\n\t" + from_u8(name);
    }
 
    if (preset.is_default || preset.is_system)
        description_line += "\n\t" + _(L("It can't be deleted or modified.")) +
                            "\n\t" + _(L("Any modifications should be saved as a new preset inherited from this one.")) +
                            "\n\t" + _(L("To do that please specify a new name for the preset."));
 
    if (parent && parent->vendor)
    {
        description_line += "\n\n" + _(L("Additional information:")) + "\n";
        description_line += "\t" + _(L("vendor")) + ": " + (m_type == Slic3r::Preset::TYPE_PRINTER ? "\n\t\t" : "") + parent->vendor->name +
                            // TRN Short for "version"
                            ", " + _L("ver") + ": " + parent->vendor->config_version.to_string();
        if (m_type == Slic3r::Preset::TYPE_PRINTER) {
            const std::string &printer_model = preset.config.opt_string("printer_model");
            if (! printer_model.empty())
                description_line += "\n\n\t" + _(L("printer model")) + ": \n\t\t" + printer_model;
            switch (preset.printer_technology()) {
            case ptFFF:
            {
                //FIXME add prefered_sla_material_profile for SLA
                const std::string              &default_print_profile = preset.config.opt_string("default_print_profile");
                const std::vector<std::string> &default_filament_profiles = preset.config.option<ConfigOptionStrings>("default_filament_profile")->values;
                if (!default_print_profile.empty())
                    description_line += "\n\n\t" + _(L("default print profile")) + ": \n\t\t" + default_print_profile;
                if (!default_filament_profiles.empty())
                {
                    description_line += "\n\n\t" + _(L("default filament profile")) + ": \n\t\t";
                    for (auto& profile : default_filament_profiles) {
                        if (&profile != &*default_filament_profiles.begin())
                            description_line += ", ";
                        description_line += profile;
                    }
                }
                break;
            }
            case ptSLA:
            {
                //FIXME add prefered_sla_material_profile for SLA
                const std::string &default_sla_material_profile = preset.config.opt_string("default_sla_material_profile");
                if (!default_sla_material_profile.empty())
                    description_line += "\n\n\t" + _(L("default SLA material profile")) + ": \n\t\t" + default_sla_material_profile;
 
                const std::string &default_sla_print_profile = preset.config.opt_string("default_sla_print_profile");
                if (!default_sla_print_profile.empty())
                    description_line += "\n\n\t" + _(L("default SLA print profile")) + ": \n\t\t" + default_sla_print_profile;
                break;
            }
            default: break;
            }
        }
        else if (!preset.alias.empty())
        {
            description_line += "\n\n\t" + _(L("full profile name"))     + ": \n\t\t" + preset.name;
            description_line += "\n\t"   + _(L("symbolic profile name")) + ": \n\t\t" + preset.alias;
        }
    }
 
    m_parent_preset_description_line->SetText(description_line, false);
 
    if (m_detach_preset_btn)
        m_detach_preset_btn->Show(parent && parent->is_system && !preset.is_default);
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
}

References _, _L, Slic3r::Preset::alias, Slic3r::Preset::config, Slic3r::from_u8(), Slic3r::Preset::is_default, Slic3r::Preset::is_system, L, m_detach_preset_btn, m_parent, m_parent_preset_description_line, m_presets, m_type, name(), Slic3r::Preset::name, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), parent(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::ptSLA, Slic3r::Preset::TYPE_PRINTER, and update_preset_description_line().

Referenced by update_description_lines(), and update_preset_description_line().

Here is the call graph for this function:

Here is the caller graph for this function:

update_printer_agent_if_needed()

void Slic3r::GUI::Tab::update_printer_agent_if_needed ( )

protectedinherited

update_saved_preset_from_current_preset()

void Slic3r::GUI::Tab::update_saved_preset_from_current_preset ( )

inherited

{ m_presets->update_saved_preset_from_current_preset(); }

References m_presets, and update_saved_preset_from_current_preset().

Referenced by update_saved_preset_from_current_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

update_show_hide_incompatible_button()

void Slic3r::GUI::Tab::update_show_hide_incompatible_button ( )

inherited

{
    //BBS: GUI refactor
    /*m_btn_hide_incompatible_presets->SetBitmap_(m_show_incompatible_presets ?
        m_bmp_show_incompatible_presets : m_bmp_hide_incompatible_presets);
    m_btn_hide_incompatible_presets->SetToolTip(m_show_incompatible_presets ?
        "Both compatible an incompatible presets are shown. Click to hide presets not compatible with the current printer." :
        "Only compatible presets are shown. Click to show both the presets compatible and not compatible with the current printer.");*/
}

References update_show_hide_incompatible_button().

Referenced by toggle_show_hide_incompatible(), update_show_hide_incompatible_button(), and update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_sla()

void Slic3r::GUI::TabPrinter::update_sla

(

)

{ ; }

References update_sla().

Referenced by update(), and update_sla().

Here is the call graph for this function:

Here is the caller graph for this function:

update_tab_ui()

void Slic3r::GUI::Tab::update_tab_ui ( bool update_plater_presets = false )

inherited

{
    if (m_presets_choice) {
        m_presets_choice->update();
        if (update_plater_presets)
            on_presets_changed();
    }
}

References m_presets_choice, on_presets_changed(), and update_tab_ui().

Referenced by load_current_preset(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), save_preset(), select_preset(), toggle_show_hide_incompatible(), update_tab_ui(), and update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_ui_from_settings()

void Slic3r::GUI::Tab::update_ui_from_settings ( )

inherited

{
    // Show the 'show / hide presets' button only for the print and filament tabs, and only if enabled
    // in application preferences.
    m_show_btn_incompatible_presets = true;
    bool show = m_show_btn_incompatible_presets && m_type != Slic3r::Preset::TYPE_PRINTER;
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
    //show ? m_btn_hide_incompatible_presets->Show() :  m_btn_hide_incompatible_presets->Hide();
    // If the 'show / hide presets' button is hidden, hide the incompatible presets.
    if (show) {
        update_show_hide_incompatible_button();
    }
    else {
        if (m_show_incompatible_presets) {
            m_show_incompatible_presets = false;
            update_tab_ui();
        }
    }
}

References m_parent, m_show_btn_incompatible_presets, m_show_incompatible_presets, m_type, Slic3r::Preset::TYPE_PRINTER, update_show_hide_incompatible_button(), update_tab_ui(), and update_ui_from_settings().

Referenced by update_ui_from_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_ui_items_related_on_parent_preset()

void Slic3r::GUI::Tab::update_ui_items_related_on_parent_preset ( const Preset * selected_preset_parent )

inherited

{
    m_is_default_preset = selected_preset_parent != nullptr && selected_preset_parent->is_default;
 
    m_bmp_non_system = selected_preset_parent ? &m_bmp_value_unlock : &m_bmp_white_bullet;
    m_ttg_non_system = selected_preset_parent ? &m_ttg_value_unlock : &m_ttg_white_bullet_ns;
    m_tt_non_system  = selected_preset_parent ? &m_tt_value_unlock  : &m_ttg_white_bullet_ns;
}

References Slic3r::Preset::is_default, m_bmp_non_system, m_bmp_value_unlock, m_bmp_white_bullet, m_is_default_preset, m_tt_non_system, m_tt_value_unlock, m_ttg_non_system, m_ttg_value_unlock, m_ttg_white_bullet_ns, and update_ui_items_related_on_parent_preset().

Referenced by load_current_preset(), save_preset(), and update_ui_items_related_on_parent_preset().

Here is the call graph for this function:

Here is the caller graph for this function:

update_undo_buttons()

void Slic3r::GUI::Tab::update_undo_buttons ( )

inherited

{
    // BBS: restore all pages in preset
    m_undo_btn->        SetBitmap_(m_presets->get_edited_preset().is_dirty ? m_bmp_value_revert: m_bmp_white_bullet);
    //m_undo_to_sys_btn-> SetBitmap_(m_is_nonsys_values   ? *m_bmp_non_system : m_bmp_value_lock);
 
    m_undo_btn->SetToolTip(m_presets->get_edited_preset().is_dirty ? _L("Click to reset all settings to the last saved preset.") : m_ttg_white_bullet);
    //m_undo_to_sys_btn->SetToolTip(m_is_nonsys_values ? *m_ttg_non_system : m_ttg_value_lock);
}

References _L, m_bmp_value_revert, m_bmp_white_bullet, m_presets, m_ttg_white_bullet, m_undo_btn, and update_undo_buttons().

Referenced by update_changed_ui(), update_current_page_in_background(), and update_undo_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

update_variant_sizer_visibility()

void Slic3r::GUI::Tab::update_variant_sizer_visibility ( )

inherited

{
    if (!m_variant_sizer)
        return;
    const bool show = variant_switch_active() && m_active_page && !m_active_page->m_opt_id_map.empty();
    m_main_sizer->Show(m_variant_sizer, show);
    if (m_extruder_sync) {
        m_extruder_sync->Show(show);
        // Orca: copying between extruders is offered only between nozzle variants, and not on the Extruder page.
        m_extruder_sync->Enable(m_extruder_switch_variants && !is_printer_extruder_page(m_active_page) &&
                                get_extruder_sync_enable_state(get_current_active_extruder()));
    }
    GetParent()->Layout();
}

References get_current_active_extruder(), get_extruder_sync_enable_state(), is_printer_extruder_page(), m_active_page, m_extruder_switch_variants, m_extruder_sync, m_main_sizer, m_variant_sizer, update_variant_sizer_visibility(), and variant_switch_active().

Referenced by tree_sel_change_delayed(), update_extruder_variants(), and update_variant_sizer_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

update_visibility()

void Slic3r::GUI::Tab::update_visibility ( )

inherited

{
    Freeze(); // There is needed Freeze/Thaw to avoid a flashing after Show/Layout
 
    for (auto page : m_pages)
        page->update_visibility(m_mode, page.get() == m_active_page);
    rebuild_page_tree();
 
    if (m_type == Preset::TYPE_SLA_PRINT)
        update_description_lines();
 
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
    Thaw();
}

References m_active_page, m_mode, m_pages, m_parent, m_type, rebuild_page_tree(), Slic3r::Preset::TYPE_SLA_PRINT, update_description_lines(), and update_visibility().

Referenced by load_current_preset(), update_mode(), and update_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

update_wiping_button_visibility()

void Slic3r::GUI::Tab::update_wiping_button_visibility ( )

inherited

                                          {
    if (m_preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
        return; // ys_FIXME
    // Orca: it's not used
    //
    // bool wipe_tower_enabled = dynamic_cast<ConfigOptionBool*>(  (m_preset_bundle->prints.get_edited_preset().config  ).option("enable_prime_tower"))->value;
    // bool multiple_extruders = dynamic_cast<ConfigOptionFloats*>((m_preset_bundle->printers.get_edited_preset().config).option("nozzle_diameter"))->values.size() > 1;
    // auto wiping_dialog_button = wxGetApp().sidebar().get_wiping_dialog_button();
    // if (wiping_dialog_button) {
    //     wiping_dialog_button->Show(wipe_tower_enabled && multiple_extruders);
    //     wiping_dialog_button->GetParent()->Layout();
    // }
 
}

References m_preset_bundle, Slic3r::ptSLA, and update_wiping_button_visibility().

Referenced by on_value_change(), update_frequently_changed_parameters(), and update_wiping_button_visibility().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_custom_gcode()

bool Slic3r::GUI::Tab::validate_custom_gcode ( const wxString & title, const std::string & gcode )

staticinherited

{
    std::vector<std::string> tags;
    bool invalid = GCodeProcessor::contains_reserved_tags(gcode, 5, tags, wxGetApp().preset_bundle->is_bbl_vendor());
    if (invalid) {
        std::string lines = ":\n";
        for (const std::string& keyword : tags)
            lines += ";" + keyword + "\n";
        wxString reports = format_wxstr(
            _L_PLURAL("Following line %s contains reserved keywords.\nPlease remove it, or G-code visualization and print time estimation will be broken.",
                      "Following lines %s contain reserved keywords.\nPlease remove them, or G-code visualization and print time estimation will be broken.",
                      tags.size()),
            lines);
        //wxMessageDialog dialog(wxGetApp().mainframe, reports, _L("Found reserved keywords in") + " " + _(title), wxICON_WARNING | wxOK);
        // TRN %1% is the name of the custom G-code setting, e.g. "Machine start G-code".
        MessageDialog dialog(wxGetApp().mainframe, reports, format_wxstr(_L("Reserved keywords found in %1%"), _(title)), wxICON_WARNING | wxOK);
        dialog.ShowModal();
    }
    return !invalid;
}

References _, _L, _L_PLURAL, Slic3r::GCodeProcessor::contains_reserved_tags(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::gcode(), Slic3r::GUI::DPIAware< P >::ShowModal(), and title().

Referenced by edit_custom_gcode(), Slic3r::GUI::validate_custom_gcode_cb(), Slic3r::GUI::validate_custom_gcode_cb(), and validate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_custom_gcodes()

bool Slic3r::GUI::Tab::validate_custom_gcodes ( )

inherited

{
    if (m_type != Preset::TYPE_FILAMENT &&
        (m_type != Preset::TYPE_PRINTER || static_cast<TabPrinter*>(this)->m_printer_technology != ptFFF))
        return true;
    if (m_active_page->title() != L("Custom G-code"))
        return true;
 
    // When we switch Settings tab after editing of the custom g-code, then warning message could ba already shown after KillFocus event
    // and then it's no need to show it again
    if (validate_custom_gcodes_was_shown) {
        validate_custom_gcodes_was_shown = false;
        return true;
    }
 
    bool valid = true;
    for (auto opt_group : m_active_page->m_optgroups) {
        assert(opt_group->opt_map().size() == 1);
        if (!opt_group->is_activated())
            break;
        std::string key = opt_group->opt_map().begin()->first;
        valid &= validate_custom_gcode(opt_group->title, boost::any_cast<std::string>(opt_group->get_value(key)));
        if (!valid)
            break;
    }
    return valid;
}

References L, m_active_page, m_type, Slic3r::ptFFF, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, validate_custom_gcode(), validate_custom_gcodes(), and validate_custom_gcodes_was_shown.

Referenced by validate_custom_gcodes().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_filament_temperature_pairs()

bool Slic3r::GUI::Tab::validate_filament_temperature_pairs ( )

inherited

{
    if (m_type != Preset::TYPE_FILAMENT || m_presets == nullptr)
        return true;
 
    // Warn only for newly edited state, not for unchanged presets.
    if (!m_presets->current_is_dirty())
        return true;
 
    Preset& edited_preset = m_presets->get_edited_preset();
    DynamicPrintConfig& config = edited_preset.config;
    const std::string suppress_key = edited_preset.name;
    // User opted out for this preset during current app session.
    if (!suppress_key.empty() && s_filament_temp_pair_warning_suppressed_for_session.count(suppress_key) > 0)
        return true;
 
    struct TempPairRule
    {
        wxString    label;
        std::string first_layer_key;
        std::string other_layer_key;
        int         max_delta;
    };
 
    std::vector<TempPairRule> temp_pair_rules;
    temp_pair_rules.push_back({_L("Nozzle"), "nozzle_temperature_initial_layer", "nozzle_temperature", 30});
 
    // Derive bed labels/keys from curr_bed_type metadata (BedType order excludes btDefault).
    if (const ConfigOptionDef* bed_type_def = print_config_def.get("curr_bed_type");
        bed_type_def != nullptr) {
        for (int bt = static_cast<int>(btPC); bt < static_cast<int>(btCount); ++bt) {
            const BedType     bed_type  = static_cast<BedType>(bt);
            const size_t      label_idx = static_cast<size_t>(bt - static_cast<int>(btPC));
            const std::string first_key = get_bed_temp_1st_layer_key(bed_type);
            const std::string other_key = get_bed_temp_key(bed_type);
            if (first_key.empty() || other_key.empty())
                continue;
 
            wxString label = _(bed_type_def->enum_labels[label_idx]);
            temp_pair_rules.push_back({label, first_key, other_key, 15});
        }
    }
 
    wxString invalid_pairs;
    int      invalid_count = 0;
 
    for (const TempPairRule& rule : temp_pair_rules) {
        if (!config.has(rule.first_layer_key) || !config.has(rule.other_layer_key))
            continue;
 
        const ConfigOptionInts* first_opt = config.option<ConfigOptionInts>(rule.first_layer_key);
        const ConfigOptionInts* other_opt = config.option<ConfigOptionInts>(rule.other_layer_key);
        if (first_opt == nullptr || other_opt == nullptr || first_opt->values.empty() || other_opt->values.empty())
            continue;
 
        const int first_temp = first_opt->get_at(0);
        const int other_temp = other_opt->get_at(0);
 
        // Keep existing semantics: 0 means unsupported/off for these temperatures.
        if (first_temp <= 0 || other_temp <= 0)
            continue;
 
        const int delta = std::abs(first_temp - other_temp);
        if (delta <= rule.max_delta)
            continue;
 
        const wxString deg_c   = wxString::FromUTF8(u8"\u2103" /* °C */);
        const wxString bullet  = wxString::FromUTF8("•");
        invalid_pairs += wxString::Format(_L(" - %s:\n    %s first layer %d %s, other layers %d %s\n    %s max delta %d %s, current delta %d %s\n"),
                                          rule.label, bullet, first_temp, deg_c, other_temp, deg_c, bullet, rule.max_delta, deg_c, delta, deg_c);
        ++invalid_count;
    }
 
    if (invalid_count == 0)
        return true;
 
    wxString msg_text = _L("Some first-layer and other-layer temperature pairs exceed safety limits.\n");
    msg_text += _L("\nInvalid pairs:\n");
    msg_text += invalid_pairs;
    msg_text += _L("\nYou can go back to edit values, or continue if this is intentional.");
    msg_text += _L("\n\nContinue anyway?");
 
    RichMessageDialog dialog(parent(), msg_text, _L("Temperature Safety Check"), wxYES | wxNO | wxICON_WARNING);
    dialog.SetButtonLabel(wxID_YES, _L("Continue"), true);
    dialog.SetButtonLabel(wxID_NO, _L_CONTEXT("Back", "Navigation"));
    dialog.ShowCheckBox(_L("Don't warn again for this preset"));
    const int answer = dialog.ShowModal();
    // Session-only suppression (does not modify/save filament preset data).
    if (dialog.IsCheckBoxChecked() && !suppress_key.empty())
        s_filament_temp_pair_warning_suppressed_for_session.insert(suppress_key);
 
    return answer == wxID_YES;
}

References _, _L, _L_CONTEXT, Slic3r::btCount, Slic3r::btPC, Slic3r::Preset::config, Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_1st_layer_key(), Slic3r::get_bed_temp_key(), Slic3r::ConfigOptionResolver::has(), Slic3r::GUI::RichMessageDialog::IsCheckBoxChecked(), m_presets, m_type, Slic3r::Preset::name, Slic3r::ConfigBase::option(), parent(), Slic3r::print_config_def, Slic3r::GUI::s_filament_temp_pair_warning_suppressed_for_session, Slic3r::GUI::MsgDialog::SetButtonLabel(), Slic3r::GUI::RichMessageDialog::ShowCheckBox(), Slic3r::GUI::RichMessageDialog::ShowModal(), Slic3r::Preset::TYPE_FILAMENT, validate_filament_temperature_pairs(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by save_preset(), and validate_filament_temperature_pairs().

Here is the call graph for this function:

Here is the caller graph for this function:

variant_switch_active()

bool Slic3r::GUI::Tab::variant_switch_active ( ) const

inherited

{
    if (m_extruder_switch)
        return m_extruder_switch->IsThisEnabled();
    return m_variant_combo && m_variant_combo->IsThisEnabled();
}

References m_extruder_switch, m_variant_combo, and variant_switch_active().

Referenced by switch_excluder(), update_variant_sizer_visibility(), and variant_switch_active().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_active_page

Page* Slic3r::GUI::Tab::m_active_page {nullptr}

protectedinherited

{nullptr};

Referenced by activate_selected_page(), Slic3r::GUI::TabPrinter::activate_selected_page(), Slic3r::GUI::TabPrintModel::activate_selected_page(), create_preset_tab(), decorate(), edit_custom_gcode(), get_custom_ctrl_with_blinking_ptr(), get_field(), get_line(), load_current_preset(), msw_rescale(), on_roll_back_value(), on_value_change(), Slic3r::GUI::TabPrintModel::on_value_change(), OnActivate(), page_build_pending(), page_build_step(), reload_config(), Slic3r::GUI::TabPrinter::reload_config(), Slic3r::GUI::TabPrintModel::reload_config(), set_expanded(), switch_excluder(), sync_excluder(), sys_color_changed(), toggle_option(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::TabPrint::toggle_options(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::TabSLAPrint::toggle_options(), tree_sel_change_delayed(), unselect_tree_item(), Slic3r::GUI::TabPrint::update(), update_current_page_in_background(), update_description_lines(), Slic3r::GUI::TabFilament::update_description_lines(), Slic3r::GUI::TabPrint::update_description_lines(), update_extruder_switch_colors(), Slic3r::GUI::TabFilament::update_filament_overrides_page(), Slic3r::GUI::TabPrintPlate::update_mixed_filament_seq_state(), Slic3r::GUI::TabPrintModel::update_model_config(), update_pages_with_multi_variant(), update_variant_sizer_visibility(), update_visibility(), and validate_custom_gcodes().

m_actual_nozzle_volumes

std::vector<NozzleVolumeType> Slic3r::GUI::Tab::m_actual_nozzle_volumes

inherited

Referenced by create_preset_tab(), get_actual_nozzle_volume_type(), and update_extruder_variants().

m_all_extruder_options_status

std::map<std::string, int> Slic3r::GUI::Tab::m_all_extruder_options_status

protectedinherited

Referenced by check_extruder_options_status(), and update_all_extruder_options_status().

m_base_preset_name

std::string Slic3r::GUI::TabPrinter::m_base_preset_name

Referenced by on_preset_loaded(), and set_extruder_volume_type().

m_belt_synced_tilt_x

double Slic3r::GUI::TabPrinter::m_belt_synced_tilt_x = 0.

private

Referenced by on_preset_loaded(), and update_fff().

m_belt_synced_tilt_y

double Slic3r::GUI::TabPrinter::m_belt_synced_tilt_y = 0.

private

Referenced by on_preset_loaded(), and update_fff().

m_bmp_edit_value

ScalableBitmap Slic3r::GUI::Tab::m_bmp_edit_value

protectedinherited

Referenced by create_preset_tab(), and decorate().

m_bmp_hide_incompatible_presets

ScalableBitmap Slic3r::GUI::Tab::m_bmp_hide_incompatible_presets

protectedinherited

Referenced by create_preset_tab().

m_bmp_non_system

ScalableBitmap* Slic3r::GUI::Tab::m_bmp_non_system

protectedinherited

Referenced by create_preset_tab(), decorate(), load_initial_data(), and update_ui_items_related_on_parent_preset().

m_bmp_show_incompatible_presets

ScalableBitmap Slic3r::GUI::Tab::m_bmp_show_incompatible_presets

protectedinherited

Referenced by create_preset_tab().

m_bmp_value_lock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_lock

protectedinherited

Referenced by create_preset_tab(), and decorate().

m_bmp_value_revert

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_revert

protectedinherited

Referenced by create_preset_tab(), decorate(), and update_undo_buttons().

m_bmp_value_unlock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_unlock

protectedinherited

Referenced by create_preset_tab(), load_initial_data(), and update_ui_items_related_on_parent_preset().

m_bmp_white_bullet

ScalableBitmap Slic3r::GUI::Tab::m_bmp_white_bullet

protectedinherited

Referenced by create_line_with_widget(), create_preset_tab(), decorate(), load_initial_data(), update_ui_items_related_on_parent_preset(), and update_undo_buttons().

m_btn_compare_preset

ScalableButton* Slic3r::GUI::Tab::m_btn_compare_preset

protectedinherited

m_btn_delete_preset

ScalableButton* Slic3r::GUI::Tab::m_btn_delete_preset

protectedinherited

Referenced by create_preset_tab(), save_preset(), set_just_edit(), and update_btns_enabling().

m_btn_save_preset

ScalableButton* Slic3r::GUI::Tab::m_btn_save_preset

protectedinherited

Referenced by create_preset_tab().

m_btn_search

ScalableButton* Slic3r::GUI::Tab::m_btn_search

protectedinherited

Referenced by create_preset_tab().

m_cache_config

DynamicPrintConfig Slic3r::GUI::Tab::m_cache_config

protectedinherited

Referenced by apply_config_from_cache(), and cache_config_diff().

m_cache_extruder_count

size_t Slic3r::GUI::TabPrinter::m_cache_extruder_count = 0

Referenced by apply_extruder_cnt_from_cache(), and cache_extruder_cnt().

m_cache_options

std::vector<std::string> Slic3r::GUI::Tab::m_cache_options

protectedinherited

Referenced by apply_config_from_cache(), and cache_config_diff().

m_category_icon

std::map<wxString, std::string> Slic3r::GUI::Tab::m_category_icon

protectedinherited

Referenced by add_options_page(), and get_category_icon_map().

m_colored_Label_colors

std::map<std::string, wxColour> Slic3r::GUI::Tab::m_colored_Label_colors

inherited

m_compatible_printers

PresetDependencies Slic3r::GUI::Tab::m_compatible_printers

protectedinherited

Referenced by Tab(), clear_pages(), on_roll_back_value(), on_value_change(), Slic3r::GUI::TabFilament::reload_config(), Slic3r::GUI::TabPrint::reload_config(), Slic3r::GUI::TabSLAMaterial::reload_config(), and Slic3r::GUI::TabSLAPrint::reload_config().

m_compatible_prints

PresetDependencies Slic3r::GUI::Tab::m_compatible_prints

protectedinherited

Referenced by Tab(), clear_pages(), on_roll_back_value(), on_value_change(), Slic3r::GUI::TabFilament::reload_config(), and Slic3r::GUI::TabSLAMaterial::reload_config().

m_completed

bool Slic3r::GUI::Tab::m_completed { false }

protectedinherited

{ false };

Referenced by completed(), and create_preset_tab().

m_config

DynamicPrintConfig* Slic3r::GUI::Tab::m_config

inherited

Referenced by Slic3r::GUI::TabFilament::add_filament_overrides_page(), add_options_page(), apply_preset_config_values(), apply_searcher(), Slic3r::GUI::TabPrinter::build(), Slic3r::GUI::TabPrintPlate::build(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::TabPrinter::build_unregular_pages(), check_extruder_options_status(), compatible_widget_create(), compatible_widget_reload(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), Slic3r::GUI::TabPrinter::extruder_variant_index(), generate_extruder_options(), get_config(), get_custom_gcode(), Slic3r::GUI::TabFilament::get_custom_gcode(), get_sys_and_mod_flags(), init_options_list(), Slic3r::GUI::TabFilament::init_options_list(), load_config(), load_current_preset(), load_initial_data(), load_key_value(), Slic3r::GUI::TabPrinter::on_gcode_flavor_changed(), Slic3r::GUI::TabPrinter::on_preset_loaded(), on_roll_back_value(), on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), Slic3r::GUI::TabPrintModel::on_value_change(), Slic3r::GUI::TabPrintPlate::on_value_change(), options_list_storage_key(), reload_config(), Slic3r::GUI::TabPrinter::reload_config(), Slic3r::GUI::TabPrintModel::reload_config(), Slic3r::GUI::TabPrintModel::reset_model_config(), Slic3r::GUI::TabPrintPlate::reset_model_config(), save_preset(), set_custom_gcode(), Slic3r::GUI::TabFilament::set_custom_gcode(), switch_excluder(), sync_excluder(), Slic3r::GUI::TabPrinter::sync_extruders_count(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::TabPrint::toggle_options(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::TabSLAPrint::toggle_options(), Slic3r::GUI::TabFilament::update(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabPrinter::update(), Slic3r::GUI::TabSLAMaterial::update(), Slic3r::GUI::TabSLAPrint::update(), update_all_extruder_options_status(), Slic3r::GUI::TabPrinter::update_custom_dirty(), Slic3r::GUI::TabPrintPlate::update_custom_dirty(), Slic3r::GUI::TabPrinter::update_fff(), Slic3r::GUI::TabFilament::update_filament_overrides_page(), update_frequently_changed_parameters(), Slic3r::GUI::TabPrinter::update_input_shaper_menu(), and Slic3r::GUI::TabPrintModel::update_model_config().

m_config_manipulation

ConfigManipulation Slic3r::GUI::Tab::m_config_manipulation

protectedinherited

Referenced by Tab(), Slic3r::GUI::TabFilament::build(), on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), Slic3r::GUI::TabPrintModel::on_value_change(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::GUI::TabPrintModel::reload_config(), Slic3r::GUI::TabPrintPlate::show_spiral_mode_settings_dialog(), sync_excluder(), Slic3r::GUI::TabPrint::toggle_options(), Slic3r::GUI::TabSLAMaterial::toggle_options(), Slic3r::GUI::TabSLAPrint::toggle_options(), Slic3r::GUI::TabFilament::update(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabSLAPrint::update(), Slic3r::GUI::TabPrinter::update_input_shaper_menu(), and Slic3r::GUI::TabPrintModel::update_model_config().

m_default_text_clr

wxColour Slic3r::GUI::Tab::m_default_text_clr

protectedinherited

Referenced by create_line_with_widget(), create_preset_tab(), decorate(), update_changed_tree_ui(), and update_label_colours().

m_dependent_tabs

std::vector<Preset::Type> Slic3r::GUI::Tab::m_dependent_tabs

protectedinherited

Referenced by on_presets_changed(), and select_preset().

m_detach_preset_btn

ScalableButton* Slic3r::GUI::Tab::m_detach_preset_btn = nullptr

inherited

Referenced by build_preset_description_line(), clear_pages(), msw_rescale(), sys_color_changed(), and update_preset_description_line().

m_disable_tree_sel_changed_event

bool Slic3r::GUI::Tab::m_disable_tree_sel_changed_event {false}

protectedinherited

{false};

Referenced by create_preset_tab(), and rebuild_page_tree().

m_em_unit

int Slic3r::GUI::Tab::m_em_unit

protectedinherited

Referenced by Tab(), create_preset_tab(), and msw_rescale().

m_extruder_switch

MultiSwitchButton* Slic3r::GUI::Tab::m_extruder_switch = nullptr

inherited

Referenced by Slic3r::GUI::TabPrinter::activate_option(), create_preset_tab(), get_current_active_extruder(), msw_rescale(), switch_excluder(), sys_color_changed(), Slic3r::GUI::TabPrint::toggle_options(), update_all_extruder_options_status(), update_extruder_switch_colors(), update_extruder_variants(), and variant_switch_active().

m_extruder_switch_variants

bool Slic3r::GUI::Tab::m_extruder_switch_variants = false

inherited

Referenced by switch_excluder(), update_extruder_variants(), and update_variant_sizer_visibility().

m_extruder_sync

ScalableButton* Slic3r::GUI::Tab::m_extruder_sync = nullptr

inherited

Referenced by create_preset_tab(), switch_excluder(), update_extruder_variants(), and update_variant_sizer_visibility().

m_extruder_sync_box

wxPanel* Slic3r::GUI::Tab::m_extruder_sync_box = nullptr

inherited

Referenced by create_preset_tab().

m_extruder_variant_list

std::vector<std::string> Slic3r::GUI::TabPrinter::m_extruder_variant_list

Referenced by build_fff(), and on_preset_loaded().

m_extruders_count

size_t Slic3r::GUI::TabPrinter::m_extruders_count

Referenced by activate_option(), activate_selected_page(), build_fff(), build_unregular_pages(), extruders_count_changed(), on_preset_loaded(), reload_config(), Slic3r::GUI::Tab::save_preset(), sync_extruders_count(), toggle_options(), Slic3r::GUI::Tab::update_changed_ui(), and update_pages().

m_extruders_count_old

size_t Slic3r::GUI::TabPrinter::m_extruders_count_old = 0

Referenced by build(), and build_unregular_pages().

m_highlighter

struct Slic3r::GUI::Tab::Highlighter Slic3r::GUI::Tab::m_highlighter

protectedinherited

Referenced by Tab(), activate_option(), clear_pages(), and update_current_page_in_background().

m_icon_count

int Slic3r::GUI::Tab::m_icon_count

protectedinherited

Referenced by add_options_page(), and create_preset_tab().

m_icon_index

std::map<std::string, size_t> Slic3r::GUI::Tab::m_icon_index

protectedinherited

Referenced by add_options_page().

m_icons

wxImageList* Slic3r::GUI::Tab::m_icons

protectedinherited

Referenced by create_preset_tab(), msw_rescale(), and sys_color_changed().

m_imex_modes_ctrl

IMEXModesCtrl* Slic3r::GUI::TabPrinter::m_imex_modes_ctrl {nullptr}

private

{nullptr};

Referenced by build_unregular_pages(), clear_pages(), reload_config(), toggle_options(), and update_fff().

m_initial_extruders_count

size_t Slic3r::GUI::TabPrinter::m_initial_extruders_count

Referenced by build_fff(), and Slic3r::GUI::Tab::update_changed_ui().

m_is_default_preset

bool Slic3r::GUI::Tab::m_is_default_preset {false}

protectedinherited

{false};

Referenced by Slic3r::GUI::TabPrintModel::TabPrintModel(), decorate(), update_changed_tree_ui(), and update_ui_items_related_on_parent_preset().

m_is_modified_values

bool Slic3r::GUI::Tab::m_is_modified_values { false }

protectedinherited

{ false };

Referenced by tree_sel_change_delayed(), update_changed_tree_ui(), and update_current_page_in_background().

m_is_nonsys_values

bool Slic3r::GUI::Tab::m_is_nonsys_values { true }

protectedinherited

{ true };

Referenced by on_roll_back_value(), tree_sel_change_delayed(), update_changed_tree_ui(), and update_current_page_in_background().

m_is_timelapse_wipe_tower_already_prompted

bool Slic3r::GUI::Tab::m_is_timelapse_wipe_tower_already_prompted = false

protectedinherited

Referenced by show_timelapse_warning_dialog().

m_just_edit

bool Slic3r::GUI::Tab::m_just_edit {false}

protectedinherited

{false};

Referenced by save_preset(), and set_just_edit().

m_last_select_item

int Slic3r::GUI::Tab::m_last_select_item = -1

protectedinherited

Referenced by rebuild_page_tree(), restore_last_select_item(), and unselect_tree_item().

m_last_sparse_infill_rotate_template_value

std::string Slic3r::GUI::Tab::m_last_sparse_infill_rotate_template_value

protectedinherited

Referenced by on_value_change(), and reload_config().

m_main_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_main_sizer

protectedinherited

Referenced by create_preset_tab(), set_expanded(), and update_variant_sizer_visibility().

m_mode

ConfigOptionMode Slic3r::GUI::Tab::m_mode = comAdvanced

protectedinherited

Referenced by activate_selected_page(), apply_searcher(), create_preset_tab(), on_roll_back_value(), on_value_change(), page_build_step(), save_preset(), switch_excluder(), sync_excluder(), Slic3r::GUI::TabPrinter::toggle_options(), update_mode(), Slic3r::GUI::TabPrintModel::update_model_config(), and update_visibility().

m_mode_icon

ScalableButton* Slic3r::GUI::Tab::m_mode_icon = nullptr

inherited

Referenced by create_preset_tab().

m_mode_view

ModeSwitchButton* Slic3r::GUI::Tab::m_mode_view = nullptr

inherited

Referenced by create_preset_tab(), and msw_rescale().

m_modified_label_clr

wxColour Slic3r::GUI::Tab::m_modified_label_clr

protectedinherited

Referenced by create_preset_tab(), decorate(), rebuild_page_tree(), update_changed_tree_ui(), and update_label_colours().

m_name

std::string Slic3r::GUI::Tab::m_name

protectedinherited

Referenced by set_type().

m_opt_status_value

int Slic3r::GUI::Tab::m_opt_status_value = 0

protectedinherited

Referenced by Slic3r::GUI::TabPrintModel::TabPrintModel(), init_options_list(), Slic3r::GUI::TabFilament::init_options_list(), Slic3r::GUI::TabPrinter::init_options_list(), load_current_preset(), update_all_extruder_options_status(), and update_changed_ui().

m_options_list

std::map<std::string, int> Slic3r::GUI::Tab::m_options_list

protectedinherited

Referenced by decorate(), get_sys_and_mod_flags(), init_options_list(), Slic3r::GUI::TabFilament::init_options_list(), Slic3r::GUI::TabPrinter::init_options_list(), on_roll_back_value(), update_changed_tree_ui(), update_changed_ui(), and update_label_colours().

m_page_switch_planned

bool Slic3r::GUI::Tab::m_page_switch_planned = false

protectedinherited

Referenced by create_preset_tab(), and tree_sel_change_delayed().

m_page_switch_running

bool Slic3r::GUI::Tab::m_page_switch_running = false

protectedinherited

Referenced by create_preset_tab().

m_page_view

wxScrolledWindow* Slic3r::GUI::Tab::m_page_view {nullptr}

protectedinherited

{nullptr};

Referenced by activate_option(), activate_selected_page(), add_options_page(), create_preset_tab(), on_roll_back_value(), on_value_change(), OnActivate(), switch_excluder(), sync_excluder(), and tree_sel_change_delayed().

m_pages

std::vector<PageShp> Slic3r::GUI::Tab::m_pages

protectedinherited

Referenced by activate_option(), add_options_page(), Slic3r::GUI::TabPrintModel::build(), Slic3r::GUI::TabPrinter::build_fff(), Slic3r::GUI::PublishSettingsDialog::build_option_model(), Slic3r::GUI::TabPrinter::build_unregular_pages(), clear_pages(), commit_preset_config_value(), create_preset_tab(), Slic3r::GUI::TabPrinter::extruder_page(), filter_diff_option(), get_field(), on_roll_back_value(), on_value_change(), rebuild_page_tree(), set_option_label(), setting_row_state(), switch_excluder(), toggle_line(), tree_sel_change_delayed(), update_changed_tree_ui(), update_current_page_in_background(), update_extruder_switch_colors(), update_label_colours(), Slic3r::GUI::TabPrinter::update_pages(), and update_visibility().

m_pages_fff

std::vector<PageShp> Slic3r::GUI::TabPrinter::m_pages_fff

private

Referenced by update_pages().

m_pages_sla

std::vector<PageShp> Slic3r::GUI::TabPrinter::m_pages_sla

private

Referenced by update_pages().

m_parent

ParamsPanel* Slic3r::GUI::Tab::m_parent

protectedinherited

Referenced by Tab(), activate_option(), clear_pages(), create_preset_tab(), msw_rescale(), Slic3r::GUI::TabPrinter::msw_rescale(), OnActivate(), parent(), rebuild_page_tree(), save_preset(), sys_color_changed(), tree_sel_change_delayed(), Slic3r::GUI::TabFilament::update(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabPrinter::update(), Slic3r::GUI::TabSLAPrint::update(), update_current_page_in_background(), update_preset_description_line(), update_ui_from_settings(), and update_visibility().

m_parent_preset_description_line

ogStaticText* Slic3r::GUI::Tab::m_parent_preset_description_line = nullptr

inherited

Referenced by build_preset_description_line(), clear_pages(), update_description_lines(), and update_preset_description_line().

m_postpone_update_ui

bool Slic3r::GUI::Tab::m_postpone_update_ui {false}

protectedinherited

{false};

Referenced by Slic3r::GUI::TabFilament::build(), on_roll_back_value(), on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), update_changed_ui(), and update_dirty().

m_preset_bundle

PresetBundle* Slic3r::GUI::Tab::m_preset_bundle

inherited

Referenced by Slic3r::GUI::TabFilament::add_filament_overrides_page(), apply_preset_config_values(), Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), Slic3r::GUI::TabPrinter::build(), Slic3r::GUI::TabPrintPlate::build(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabSLAPrint::build(), Slic3r::GUI::TabPrinter::build_unregular_pages(), calculate_selection_index_for_extruder(), check_extruder_options_status(), compatible_widget_create(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), create_preset_tab(), delete_preset(), Slic3r::GUI::TabPrinter::extruders_count_changed(), generate_extruder_options(), get_actual_nozzle_volume_type(), get_extruder_sync_enable_state(), load_key_value(), may_discard_current_dirty_preset(), Slic3r::GUI::TabPrinter::on_preset_loaded(), on_presets_changed(), on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), parse_extruder_selection(), Slic3r::GUI::TabFilament::reload_config(), save_preset(), select_preset(), Slic3r::GUI::TabPrinter::set_extruder_volume_type(), switch_excluder(), sync_excluder(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::TabPrint::toggle_options(), Slic3r::GUI::TabPrinter::toggle_options(), Slic3r::GUI::TabSLAMaterial::toggle_options(), Slic3r::GUI::TabFilament::update(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabSLAMaterial::update(), Slic3r::GUI::TabSLAPrint::update(), update_all_extruder_options_status(), update_btns_enabling(), Slic3r::GUI::TabPrintPlate::update_custom_dirty(), Slic3r::GUI::TabPrint::update_description_lines(), update_extruder_variants(), Slic3r::GUI::TabFilament::update_filament_overrides_page(), Slic3r::GUI::TabPrintPlate::update_mixed_filament_seq_state(), Slic3r::GUI::TabPrintModel::update_model_config(), Slic3r::GUI::TabPrinter::update_pages(), and update_wiping_button_visibility().

m_presets

PresetCollection* Slic3r::GUI::Tab::m_presets = nullptr

inherited

Referenced by apply_config_from_cache(), Slic3r::GUI::TabPrinter::apply_extruder_cnt_from_cache(), Slic3r::GUI::TabFilament::build(), Slic3r::GUI::TabPrint::build(), Slic3r::GUI::TabPrinter::build(), Slic3r::GUI::TabPrintModel::build(), Slic3r::GUI::TabPrintPlate::build(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabSLAPrint::build(), Slic3r::GUI::TabPrinter::build_fff(), build_preset_description_line(), Slic3r::GUI::TabPrinter::build_unregular_pages(), cache_config_diff(), Slic3r::GUI::TabPrinter::cache_extruder_cnt(), Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes(), check_extruder_options_status(), current_preset_is_dirty(), decorate(), delete_preset(), get_presets(), load_current_preset(), load_initial_data(), may_discard_current_dirty_preset(), name(), on_roll_back_value(), save_preset(), saved_preset_is_dirty(), select_preset(), sync_excluder(), Slic3r::GUI::TabPrinter::toggle_options(), transfer_options(), Slic3r::GUI::TabPrinter::update(), update_all_extruder_options_status(), update_btns_enabling(), update_changed_tree_ui(), update_changed_ui(), Slic3r::GUI::TabPrinter::update_custom_dirty(), Slic3r::GUI::TabFilament::update_description_lines(), update_dirty(), Slic3r::GUI::TabPrinter::update_input_shaper_menu(), Slic3r::GUI::TabPrinter::update_pages(), update_preset_description_line(), update_saved_preset_from_current_preset(), update_undo_buttons(), and validate_filament_temperature_pairs().

m_presets_choice

TabPresetComboBox* Slic3r::GUI::Tab::m_presets_choice { nullptr }

protectedinherited

{ nullptr };

Referenced by create_preset_tab(), delete_preset(), get_combo_box(), load_key_value(), msw_rescale(), reactive_preset_combo_box(), set_expanded(), set_just_edit(), sys_color_changed(), toggle_show_hide_incompatible(), update_dirty(), update_preset_choice(), and update_tab_ui().

m_printer_technology

PrinterTechnology Slic3r::GUI::TabPrinter::m_printer_technology = ptFFF

Referenced by append_option_line(), build(), build_fff(), build_unregular_pages(), init_options_list(), sync_extruders_count(), and update_pages().

m_reset_to_filament_color

ScalableButton* Slic3r::GUI::TabPrinter::m_reset_to_filament_color = nullptr

Referenced by clear_pages(), and msw_rescale().

m_scaled_bitmaps

std::vector<ScalableBitmap*> Slic3r::GUI::Tab::m_scaled_bitmaps = {}

protectedinherited

{};

Referenced by add_scaled_bitmap(), create_preset_tab(), msw_rescale(), and sys_color_changed().

m_scaled_buttons

std::vector<ScalableButton*> Slic3r::GUI::Tab::m_scaled_buttons = {}

protectedinherited

{};

Referenced by add_scaled_button(), create_preset_tab(), msw_rescale(), and sys_color_changed().

m_scaled_icons_list

std::vector<ScalableBitmap> Slic3r::GUI::Tab::m_scaled_icons_list = {}

protectedinherited

{};

Referenced by add_options_page(), msw_rescale(), and sys_color_changed().

m_search_input

TextInput* Slic3r::GUI::Tab::m_search_input

protectedinherited

Referenced by create_preset_tab().

m_search_item

StaticBox* Slic3r::GUI::Tab::m_search_item

protectedinherited

Referenced by create_preset_tab().

m_select_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_select_sizer

protectedinherited

m_show_btn_incompatible_presets

bool Slic3r::GUI::Tab::m_show_btn_incompatible_presets = false

inherited

Referenced by update_ui_from_settings().

m_show_incompatible_presets

bool Slic3r::GUI::Tab::m_show_incompatible_presets

protectedinherited

Referenced by create_preset_tab(), select_preset(), toggle_show_hide_incompatible(), and update_ui_from_settings().

m_sys_extruders_count

size_t Slic3r::GUI::TabPrinter::m_sys_extruders_count

Referenced by build_fff(), and Slic3r::GUI::Tab::update_changed_ui().

m_sys_label_clr

wxColour Slic3r::GUI::Tab::m_sys_label_clr

protectedinherited

Referenced by create_preset_tab(), decorate(), update_changed_tree_ui(), and update_label_colours().

m_tabctrl

TabCtrl* Slic3r::GUI::Tab::m_tabctrl

protectedinherited

Referenced by activate_option(), create_preset_tab(), msw_rescale(), OnActivate(), OnKeyDown(), rebuild_page_tree(), restore_last_select_item(), set_expanded(), sys_color_changed(), tree_sel_change_delayed(), unselect_tree_item(), update_changed_tree_ui(), update_current_page_in_background(), and update_label_colours().

m_title

const wxString Slic3r::GUI::Tab::m_title

protectedinherited

Referenced by Tab(), create_preset_tab(), and title().

m_top_left_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_top_left_sizer

protectedinherited

m_top_panel

wxPanel* Slic3r::GUI::Tab::m_top_panel

protectedinherited

Referenced by create_preset_tab().

m_top_right_sizer

wxGridSizer* Slic3r::GUI::Tab::m_top_right_sizer

protectedinherited

m_top_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_top_sizer

protectedinherited

Referenced by create_preset_tab(), and msw_rescale().

m_tree_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_tree_sizer

protectedinherited

m_tt_non_system

wxString* Slic3r::GUI::Tab::m_tt_non_system

protectedinherited

Referenced by decorate(), load_initial_data(), and update_ui_items_related_on_parent_preset().

m_tt_value_lock

wxString Slic3r::GUI::Tab::m_tt_value_lock

protectedinherited

Referenced by decorate().

m_tt_value_revert

wxString Slic3r::GUI::Tab::m_tt_value_revert

protectedinherited

Referenced by decorate(), and set_tooltips_text().

m_tt_value_unlock

wxString Slic3r::GUI::Tab::m_tt_value_unlock

protectedinherited

Referenced by load_initial_data(), set_tooltips_text(), and update_ui_items_related_on_parent_preset().

m_tt_white_bullet

wxString Slic3r::GUI::Tab::m_tt_white_bullet

protectedinherited

Referenced by create_line_with_widget(), and decorate().

m_ttg_non_system

wxString* Slic3r::GUI::Tab::m_ttg_non_system

protectedinherited

Referenced by load_initial_data(), and update_ui_items_related_on_parent_preset().

m_ttg_value_lock

wxString Slic3r::GUI::Tab::m_ttg_value_lock

protectedinherited

m_ttg_value_revert

wxString Slic3r::GUI::Tab::m_ttg_value_revert

protectedinherited

m_ttg_value_unlock

wxString Slic3r::GUI::Tab::m_ttg_value_unlock

protectedinherited

Referenced by load_initial_data(), and update_ui_items_related_on_parent_preset().

m_ttg_white_bullet

wxString Slic3r::GUI::Tab::m_ttg_white_bullet

protectedinherited

Referenced by update_undo_buttons().

m_ttg_white_bullet_ns

wxString Slic3r::GUI::Tab::m_ttg_white_bullet_ns

protectedinherited

Referenced by load_initial_data(), and update_ui_items_related_on_parent_preset().

m_type

Preset::Type Slic3r::GUI::Tab::m_type

protectedinherited

Referenced by Tab(), Slic3r::GUI::TabPrintPlate::TabPrintPlate(), activate_option(), Slic3r::GUI::TabPrintModel::activate_selected_page(), apply_config_from_cache(), apply_preset_config_values(), apply_searcher(), Slic3r::GUI::TabPrinter::build_unregular_pages(), check_extruder_options_status(), compare_preset(), Slic3r::GUI::TabPrinter::create_bed_shape_widget(), create_preset_tab(), decorate(), delete_preset(), generate_extruder_options(), is_printer_extruder_page(), load_current_preset(), may_discard_current_dirty_preset(), on_presets_changed(), on_roll_back_value(), on_value_change(), rebuild_page_tree(), reload_config(), save_preset(), select_preset(), set_type(), switch_excluder(), sync_excluder(), Slic3r::GUI::TabPrint::toggle_options(), transfer_options(), tree_sel_change_delayed(), type(), Slic3r::GUI::TabPrint::update(), update_all_extruder_options_status(), update_btns_enabling(), update_changed_tree_ui(), update_changed_ui(), update_current_page_in_background(), update_extruder_variants(), update_label_colours(), Slic3r::GUI::TabPrintModel::update_model_config(), update_preset_description_line(), update_ui_from_settings(), update_visibility(), validate_custom_gcodes(), and validate_filament_temperature_pairs().

m_undo_btn

ScalableButton* Slic3r::GUI::Tab::m_undo_btn

protectedinherited

Referenced by create_preset_tab(), and update_undo_buttons().

m_undo_to_sys_btn

ScalableButton* Slic3r::GUI::Tab::m_undo_to_sys_btn

protectedinherited

Referenced by create_preset_tab().

m_update_cnt

int Slic3r::GUI::Tab::m_update_cnt = 0

inherited

Referenced by Slic3r::GUI::TabFilament::update(), Slic3r::GUI::TabPrint::update(), Slic3r::GUI::TabPrinter::update(), and Slic3r::GUI::TabSLAPrint::update().

m_variant_combo

MultiSwitchButton* Slic3r::GUI::Tab::m_variant_combo = nullptr

inherited

Referenced by create_preset_tab(), msw_rescale(), Slic3r::GUI::TabFilament::selected_variant_index(), switch_excluder(), sys_color_changed(), update_all_extruder_options_status(), update_extruder_switch_colors(), update_extruder_variants(), Slic3r::GUI::TabFilament::update_filament_overrides_page(), and variant_switch_active().

m_variant_sizer

wxSizer* Slic3r::GUI::Tab::m_variant_sizer = nullptr

inherited

Referenced by create_preset_tab(), and update_variant_sizer_visibility().

m_was_belt_printer

bool Slic3r::GUI::TabPrinter::m_was_belt_printer = false

private

Referenced by on_preset_loaded(), and update_fff().

validate_custom_gcodes_was_shown

bool Slic3r::GUI::Tab::validate_custom_gcodes_was_shown { false }

inherited

{ false };

Referenced by edit_custom_gcode(), Slic3r::GUI::validate_custom_gcode_cb(), Slic3r::GUI::validate_custom_gcode_cb(), and validate_custom_gcodes().

---

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

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