Slic3r::GUI::TabFilament Class Reference

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

Inheritance diagram for Slic3r::GUI::TabFilament:

Collaboration diagram for Slic3r::GUI::TabFilament:

Public Member Functions
	TabFilament (ParamsPanel *parent)
	~TabFilament ()
void	build () override
void	reload_config () override
void	update_description_lines () override
void	toggle_options () override
void	update () override
void	init_options_list () override
void	clear_pages () override
bool	supports_printer_technology (const PrinterTechnology tech) const override
void	on_value_change (const std::string &opt_key, const boost::any &value) override
const std::string &	get_custom_gcode (const t_config_option_key &opt_key) override
void	set_custom_gcode (const t_config_option_key &opt_key, const std::string &value) 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	activate_selected_page (std::function< void()> throw_if_canceled)
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 ()
virtual void	on_preset_loaded ()
std::string	options_list_storage_key (const std::string &opt_key) const
virtual void	update_custom_dirty (std::vector< std::string > &dirty_options, std::vector< std::string > &nonsys_options)
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	msw_rescale ()
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 ()
virtual void	activate_option (const std::string &opt_key, const wxString &category)
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)
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
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	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	add_filament_overrides_page ()
void	update_filament_overrides_page (const DynamicPrintConfig *printers_config)
void	update_volumetric_flow_preset_hints ()
unsigned int	selected_variant_index () const

Private Attributes
ogStaticText *	m_volumetric_speed_description_line {nullptr}
ogStaticText *	m_cooling_description_line {nullptr}
std::map< std::string, ::CheckBox * >	m_overrides_options

Detailed Description

Member Enumeration Documentation

OptStatus

enum Slic3r::GUI::Tab::OptStatus

protectedinherited

Enumerator
osSystemValue
osInitValue

{ osSystemValue = 1, osInitValue = 2 };

Constructor & Destructor Documentation

TabFilament()

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

inline

                                   :
    Tab(parent, _(L("Filament")), Slic3r::Preset::TYPE_FILAMENT) {}

References Slic3r::GUI::Tab::Tab(), _, L, and Slic3r::GUI::Tab::parent().

Here is the call graph for this function:

~TabFilament()

Slic3r::GUI::TabFilament::~TabFilament ( )

inline

{}

Member Function Documentation

activate_option()

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

virtualinherited

Reimplemented in Slic3r::GUI::TabPrinter.

{
    wxString page_title = translate_category(category, m_type);
 
    auto cur_item = m_tabctrl->GetFirstVisibleItem();
    if (cur_item < 0)
        return;
 
    // We should to activate a tab with searched option, if it doesn't.
    // And do it before finding of the cur_item to avoid a case when Tab isn't activated jet and all treeItems are invisible
    //BBS: GUI refactor
    //wxGetApp().mainframe->select_tab(this);
    wxGetApp().mainframe->select_tab((wxPanel*)m_parent);
 
    while (cur_item >= 0) {
        if (page_title.empty()) {
            bool has = false;
            for (auto &g : m_pages[cur_item]->m_optgroups) {
                for (auto &l : g->get_lines()) {
                    for (auto &o : l.get_options()) { if (o.opt.opt_key == opt_key) { has = true; break; } }
                    if (has) break;
                }
                if (has) break;
            }
            if (!has) {
                cur_item = m_tabctrl->GetNextVisible(cur_item);
                continue;
            }
        } else {
            auto title = m_tabctrl->GetItemText(cur_item);
            if (page_title != title) {
                cur_item = m_tabctrl->GetNextVisible(cur_item);
                continue;
            }
        }
 
        m_tabctrl->SelectItem(cur_item);
        break;
    }
 
    auto set_focus = [](wxWindow* win) {
        win->SetFocus();
#ifdef WIN32
        if (wxTextCtrl* text = dynamic_cast<wxTextCtrl*>(win))
            text->SetSelection(-1, -1);
        else if (wxSpinCtrl* spin = dynamic_cast<wxSpinCtrl*>(win))
            spin->SetSelection(-1, -1);
#endif // WIN32
    };
 
    Field* field = get_field(opt_key);
 
    // focused selected field
    if (field) {
        set_focus(field->getWindow());
        if (!field->getWindow()->HasFocus()) {
            wxScrollEvent evt(wxEVT_SCROLL_CHANGED);
            evt.SetEventObject(field->getWindow());
            wxPostEvent(m_page_view, evt);
        }
    }
    else if (category == "Single extruder MM setup") {
       // When we show and hide "Single extruder MM setup" page,
       // related options are still in the search list
       // So, let's hightlighte a "single_extruder_multi_material" option,
       // as a "way" to show hidden page again
       field = get_field("single_extruder_multi_material");
       if (field)
           set_focus(field->getWindow());
    }
 
    m_highlighter.init(get_custom_ctrl_with_blinking_ptr(opt_key));
}

References activate_option(), get_custom_ctrl_with_blinking_ptr(), get_field(), Slic3r::GUI::Field::getWindow(), m_highlighter, m_page_view, m_pages, m_parent, m_tabctrl, m_type, title(), and translate_category().

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

Here is the call graph for this function:

Here is the caller graph for this function:

activate_selected_page()

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

virtualinherited

Reimplemented in Slic3r::GUI::TabPrinter, and Slic3r::GUI::TabPrintModel.

{
    if (!m_active_page)
        return;
 
#ifdef __WXGTK__
    // Builds the page off screen, since GTK crashes when it desensitizes a multiline text view
    // that was built on screen and hidden before its first size allocation.
    const bool hide_view = m_active_page->build_pending() && m_page_view->IsShown();
    if (hide_view)
        m_page_view->Hide();
    ScopeGuard show_view([this, hide_view] { if (hide_view) m_page_view->Show(); });
#endif
    m_active_page->activate(m_mode, throw_if_canceled);
    update_changed_ui();
    update_description_lines();
    if (m_active_page && !(m_active_page->title() == "Dependencies"))
        toggle_options();
    m_active_page->update_visibility(m_mode, true); // for taggle line
}

References activate_selected_page(), m_active_page, m_mode, m_page_view, toggle_options(), update_changed_ui(), and update_description_lines().

Referenced by activate_selected_page(), Slic3r::GUI::TabPrinter::activate_selected_page(), Slic3r::GUI::TabPrintModel::activate_selected_page(), OnActivate(), and tree_sel_change_delayed().

Here is the call graph for this function:

Here is the caller graph for this function:

add_filament_overrides_page()

void Slic3r::GUI::TabFilament::add_filament_overrides_page ( )

private

{
    //BBS
    PageShp page = add_options_page(L("Setting Overrides"), "custom-gcode_setting_override"); // ORCA: icon only visible on placeholders
 
    const int extruder_idx = 0; // #ys_FIXME
 
    auto append_retraction_option = [this](ConfigOptionsGroupShp optgroup, const std::string& opt_key, int opt_index)
    {
        Line line {"",""};
        line = optgroup->create_single_option_line(optgroup->get_option(opt_key, opt_index));
 
        line.near_label_widget = [this, optgroup_wk = ConfigOptionsGroupWkp(optgroup), opt_key, opt_index](wxWindow* parent) {
            auto check_box = new ::CheckBox(parent); // ORCA modernize checkboxes
            check_box->Bind(wxEVT_TOGGLEBUTTON, [this, optgroup_wk, opt_key, opt_index](wxCommandEvent& evt) {
                const bool is_checked = evt.IsChecked();
                if (auto optgroup_sh = optgroup_wk.lock(); optgroup_sh) {
                    if (Field *field = optgroup_sh->get_fieldc(opt_key, opt_index); field != nullptr) {
                        field->toggle(is_checked);
 
                        if (is_checked) {
                            field->update_na_value(_(L("N/A")));
                            field->set_last_meaningful_value();
                        } else {
                            const std::string printer_opt_key = opt_key.substr(strlen("filament_"));
                            const auto printer_config = m_preset_bundle->printers.get_edited_preset().config;
                            const boost::any printer_config_value = optgroup_sh->get_config_value(printer_config, printer_opt_key, opt_index);
                            field->update_na_value(printer_config_value);
                            field->set_na_value();
                        }
                    }
                }
                evt.Skip();
            }, check_box->GetId());
 
            m_overrides_options[opt_key] = check_box;
            return check_box;
        };
 
        optgroup->append_line(line);
    };
 
    ConfigOptionsGroupShp retraction_optgroup = page->new_optgroup(L("Retraction"), L"param_retraction");
    for (const std::string opt_key : {  "filament_retraction_length",
                                        "filament_z_hop",
                                        "filament_z_hop_types",
                                        "filament_retract_lift_above",
                                        "filament_retract_lift_below",
                                        "filament_retract_lift_enforce",
                                        "filament_retraction_speed",
                                        "filament_deretraction_speed",
                                        "filament_retract_restart_extra",
                                        "filament_retraction_minimum_travel",
                                        "filament_retract_when_changing_layer",
                                        "filament_wipe",
                                        // BBS
                                        "filament_wipe_distance",
                                        "filament_retract_before_wipe",
                                        // Orca
                                        "filament_retract_after_wipe",
                                        // BBS
                                        "filament_long_retractions_when_cut",
                                        "filament_retraction_distances_when_cut"
                                        //SoftFever
                                        // "filament_seam_gap"
                                     })
        append_retraction_option(retraction_optgroup, opt_key, extruder_idx);
 
    ConfigOptionsGroupShp toolchange_optgroup = page->new_optgroup(L("Retraction when switching material"), L"param_retraction_material_change");
    for (const std::string opt_key : {  "filament_retract_length_toolchange",
                                        "filament_retract_restart_extra_toolchange"
                                     })
        append_retraction_option(toolchange_optgroup, opt_key, extruder_idx);
 
    ConfigOptionsGroupShp ironing_optgroup = page->new_optgroup(L("Ironing"), L"param_ironing");
    auto append_ironing_option = [this, ironing_optgroup](const std::string& opt_key, int opt_index)
    {
        Line line {"",""};
        line = ironing_optgroup->create_single_option_line(ironing_optgroup->get_option(opt_key, opt_index));
 
        line.near_label_widget = [this, optgroup_wk = ConfigOptionsGroupWkp(ironing_optgroup), opt_key, opt_index](wxWindow* parent) {
            auto check_box = new ::CheckBox(parent); // ORCA modernize checkboxes
            check_box->Bind(wxEVT_TOGGLEBUTTON, [this, optgroup_wk, opt_key, opt_index](wxCommandEvent& evt) {
                const bool is_checked = evt.IsChecked();
                if (auto optgroup_sh = optgroup_wk.lock(); optgroup_sh) {
                    if (Field *field = optgroup_sh->get_fieldc(opt_key, opt_index); field != nullptr) {
                        field->toggle(is_checked);
 
                        const std::string process_opt_key = opt_key.substr(strlen("filament_"));
                        const auto process_config = m_preset_bundle->prints.get_edited_preset().config;
                        const ConfigOption *process_option = process_config.option(process_opt_key);
                        const auto *process_vector = dynamic_cast<const ConfigOptionVectorBase*>(process_option);
                        const size_t target_index = opt_index < 0 ? 0 : static_cast<size_t>(opt_index);
                        bool has_process_value = process_option != nullptr;
                        if (has_process_value) {
                            if (process_vector != nullptr) {
                                has_process_value = target_index < process_vector->size() && !process_vector->is_nil(target_index);
                            } else {
                                has_process_value = !process_option->is_nil();
                            }
                        }
 
                        if (is_checked) {
                            bool applied_value = false;
                            if (has_process_value && process_option != nullptr) {
                                if (ConfigOption *filament_option = m_config->option(opt_key)) {
                                    if (auto filament_vector = dynamic_cast<ConfigOptionVectorBase*>(filament_option)) {
                                        std::unique_ptr<ConfigOption> process_clone(process_option->clone());
                                        size_t source_index = 0;
                                        if (process_vector != nullptr)
                                            source_index = target_index;
 
                                        filament_vector->set_at(process_clone.get(), target_index, source_index);
 
                                        const boost::any filament_config_value = optgroup_sh->get_config_value(*m_config, opt_key, opt_index);
                                        field->set_value(filament_config_value, false);
                                        field->update_na_value(_(L("N/A")));
                                        applied_value = true;
                                    }
                                }
                            }
 
                            if (applied_value)
                                field->set_last_meaningful_value();
                            else {
                                field->update_na_value(_(L("N/A")));
                                field->set_na_value();
                            }
                        } else {
                            if (has_process_value) {
                                const boost::any process_config_value = optgroup_sh->get_config_value(process_config, process_opt_key, opt_index);
                                field->update_na_value(process_config_value);
                            } else {
                                field->update_na_value(_(L("N/A")));
                            }
                            field->set_na_value();
 
                            if (ConfigOption *filament_option = m_config->option(opt_key)) {
                                if (auto filament_vector = dynamic_cast<ConfigOptionVectorBase*>(filament_option))
                                    filament_vector->set_at_to_nil(target_index);
                            }
                        }
                    }
                }
                evt.Skip();
            }, check_box->GetId());
 
            m_overrides_options[opt_key] = check_box;
            return check_box;
        };
 
        ironing_optgroup->append_line(line);
    };
 
    for (const std::string opt_key : {  "filament_ironing_flow",
                                        "filament_ironing_spacing",
                                        "filament_ironing_inset",
                                        "filament_ironing_speed"
                                     })
        append_ironing_option(opt_key, extruder_idx);
}

References _, Slic3r::GUI::Tab::add_options_page(), Slic3r::ConfigOption::clone(), Slic3r::ConfigOption::is_nil(), L, Slic3r::GUI::Tab::m_config, m_overrides_options, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Line::near_label_widget, Slic3r::GUI::Tab::parent(), and Slic3r::GUI::printer_config().

Referenced by build().

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:

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_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::TabFilament::build ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    m_presets = &m_preset_bundle->filaments;
    load_initial_data();
 
    auto page = add_options_page(L("Filament"), "custom-gcode_filament"); // ORCA: icon only visible on placeholders
        //BBS
        auto optgroup = page->new_optgroup(L("Basic information"), L"param_information");
        optgroup->append_single_option_line("filament_type", "material_basic_information#type"); // ORCA use same width with other elements
        optgroup->append_single_option_line("filament_vendor", "material_basic_information#vendor");
        optgroup->append_single_option_line("filament_soluble", "material_basic_information#soluble-material");
        // BBS
        optgroup->append_single_option_line("filament_is_support", "material_basic_information#support-material");
        optgroup->append_single_option_line("filament_change_length", "material_basic_information#filament-ramming-length");
 
        //optgroup->append_single_option_line("filament_colour");
        optgroup->append_single_option_line("required_nozzle_HRC", "material_basic_information#required-nozzle-hrc");
        optgroup->append_single_option_line("default_filament_colour", "material_basic_information#default-color");
        optgroup->append_single_option_line("filament_diameter", "material_basic_information#diameter");
        optgroup->append_single_option_line("filament_adhesiveness_category", "material_basic_information#adhesiveness-category");
 
        optgroup->append_single_option_line("filament_density", "material_basic_information#density");
        optgroup->append_single_option_line("filament_shrink", "material_basic_information#shrinkage-xy");
        optgroup->append_single_option_line("filament_shrinkage_compensation_z", "material_basic_information#shrinkage-z");
        optgroup->append_single_option_line("filament_cost", "material_basic_information#price");
        //BBS
        optgroup->append_single_option_line("temperature_vitrification", "material_basic_information#softening-temperature");
        optgroup->append_single_option_line("idle_temperature", "material_basic_information#idle-temperature");
        Line line = { L("Recommended nozzle temperature"), L("Recommended nozzle temperature range of this filament. 0 means not set") };
        line.append_option(optgroup->get_option("nozzle_temperature_range_low", 0));
        line.append_option(optgroup->get_option("nozzle_temperature_range_high", 0));
        optgroup->append_line(line);
 
        optgroup->m_on_change = [this, optgroup](t_config_option_key opt_key, boost::any value) {
            DynamicPrintConfig &filament_config = m_preset_bundle->filaments.get_edited_preset().config;
 
            update_dirty();
            const std::string opt_key_without_idx = opt_key.substr(0, opt_key.find('#'));
            if (!m_postpone_update_ui && (opt_key_without_idx == "nozzle_temperature_range_low" || opt_key_without_idx == "nozzle_temperature_range_high")) {
                m_config_manipulation.check_nozzle_recommended_temperature_range(&filament_config, selected_variant_index());
            }
            on_value_change(opt_key, value);
        };
 
        // Orca: New section to focus on flow rate and PA to declutter general section
        optgroup = page->new_optgroup(L("Flow ratio and Pressure Advance"), L"param_flow_ratio_and_pressure_advance");
        optgroup->append_single_option_line("pellet_flow_coefficient", "printer_basic_information_advanced#pellet-modded-printer");
        optgroup->append_single_option_line("filament_flow_ratio", "material_flow_ratio_and_pressure_advance#flow-ratio", 0);
 
        optgroup->append_single_option_line("enable_pressure_advance", "material_flow_ratio_and_pressure_advance#pressure-advance", 0);
        optgroup->append_single_option_line("pressure_advance", "material_flow_ratio_and_pressure_advance#pressure-advance", 0);
 
        // Orca: adaptive pressure advance and calibration model
        optgroup->append_single_option_line("adaptive_pressure_advance", "material_flow_ratio_and_pressure_advance#enable-adaptive-pressure-advance-beta", 0);
        optgroup->append_single_option_line("adaptive_pressure_advance_overhangs", "material_flow_ratio_and_pressure_advance#enable-adaptive-pressure-advance-for-overhangs-beta", 0);
        optgroup->append_single_option_line("adaptive_pressure_advance_bridges", "material_flow_ratio_and_pressure_advance#pressure-advance-for-bridges", 0);
 
        Option option = optgroup->get_option("adaptive_pressure_advance_model", 0);
        option.opt.full_width = true;
        option.opt.is_code = true;
        option.opt.height = 15;
        optgroup->append_single_option_line(option);
        optgroup->m_on_change = [this](const t_config_option_key& opt_key, const boost::any& value) {
            DynamicPrintConfig& filament_config = m_preset_bundle->filaments.get_edited_preset().config;
 
            update_dirty();
            if (opt_key.substr(0, opt_key.find('#')) == "adaptive_pressure_advance_model")
                m_config_manipulation.check_adaptive_pressure_advance_model(&filament_config);
 
            on_value_change(opt_key, value);
        };
        //
 
        optgroup = page->new_optgroup(L("Print chamber temperature"), L"param_chamber_temp");
        optgroup->append_single_option_line("activate_chamber_temp_control", "material_temperatures#print-chamber-temperature");
        line = { L("Chamber temperature"), L("Target chamber temperature, and the minimal chamber temperature at which printing should start") };
        line.label_path = "material_temperatures#print-chamber-temperature";
        Option chamber_temp_target_opt = optgroup->get_option("chamber_temperature");
        chamber_temp_target_opt.opt.label = L("Target");
        line.append_option(chamber_temp_target_opt);
        Option chamber_min_temp_opt = optgroup->get_option("chamber_minimal_temperature");
        chamber_min_temp_opt.opt.label = L("Minimal");
        line.append_option(chamber_min_temp_opt);
        optgroup->append_line(line);
        optgroup->m_on_change = [this](t_config_option_key opt_key, boost::any value) {
            DynamicPrintConfig& filament_config = m_preset_bundle->filaments.get_edited_preset().config;
 
            update_dirty();
            if (opt_key == "chamber_temperature") {
                m_config_manipulation.check_chamber_temperature(&filament_config);
                m_config_manipulation.check_chamber_minimal_temperature(&filament_config);
            }
            else if (opt_key == "chamber_minimal_temperature") {
                m_config_manipulation.check_chamber_minimal_temperature(&filament_config);
            }
 
            on_value_change(opt_key, value);
        };
 
        optgroup = page->new_optgroup(L("Print temperature"), L"param_extruder_temp");
        line = { L("Nozzle"), L("Nozzle temperature when printing") };
        line.label_path = "material_temperatures#nozzle";
        line.append_option(optgroup->get_option("nozzle_temperature_initial_layer", 0));
        line.append_option(optgroup->get_option("nozzle_temperature", 0));
        optgroup->append_line(line);
 
        optgroup = page->new_optgroup(L("Bed temperature"), L"param_bed_temp");
        line = { L("Cool Plate (SuperTack)"),
                 L("Bed temperature when the Cool Plate SuperTack is installed. A value of 0 means the filament does not support printing on the Cool Plate SuperTack.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("supertack_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("supertack_plate_temp"));
        optgroup->append_line(line);
 
        line = { L("Cool Plate"),
                 L("This is the bed temperature when the Cool Plate is installed. A value of 0 means the filament does not support printing on the Cool Plate.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("cool_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("cool_plate_temp"));
        optgroup->append_line(line);
 
        line = { L("Textured Cool Plate"),
                 L("This is the bed temperature when the Textured Cool Plate is installed. A value of 0 means the filament does not support printing on the Textured Cool Plate.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("textured_cool_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("textured_cool_plate_temp"));
        optgroup->append_line(line);
 
        line = { L("Engineering Plate"),
                 L("This is the bed temperature when the engineering plate is installed. A value of 0 means the filament does not support printing on the Engineering Plate.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("eng_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("eng_plate_temp"));
        optgroup->append_line(line);
 
        line = { L("Smooth PEI Plate / High Temp Plate"),
                 L("This is the bed temperature when the Smooth PEI Plate/High Temperature Plate is installed. A value of 0 means the filament does not support printing on the Smooth PEI Plate/High Temp Plate.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("hot_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("hot_plate_temp"));
        optgroup->append_line(line);
 
        line = { L("Textured PEI Plate"),
                 L("This is the bed temperature when the Textured PEI Plate is installed. A value of 0 means the filament does not support printing on the Textured PEI Plate.") };
        line.label_path = "material_temperatures#bed";
        line.append_option(optgroup->get_option("textured_plate_temp_initial_layer"));
        line.append_option(optgroup->get_option("textured_plate_temp"));
        optgroup->append_line(line);
 
        optgroup->m_on_change = [this](t_config_option_key opt_key, boost::any value)
        {
            DynamicPrintConfig& filament_config = m_preset_bundle->filaments.get_edited_preset().config;
 
            update_dirty();
            const std::string opt_key_without_idx = opt_key.substr(0, opt_key.find('#'));
            /*if (opt_key == "cool_plate_temp" || opt_key == "cool_plate_temp_initial_layer") {
                m_config_manipulation.check_bed_temperature_difference(BedType::btPC, &filament_config);
            }
            else if (opt_key == "eng_plate_temp" || opt_key == "eng_plate_temp_initial_layer") {
                m_config_manipulation.check_bed_temperature_difference(BedType::btEP, &filament_config);
            }
            else if (opt_key == "hot_plate_temp" || opt_key == "hot_plate_temp_initial_layer") {
                m_config_manipulation.check_bed_temperature_difference(BedType::btPEI, &filament_config);
            }
            else if (opt_key == "textured_plate_temp" || opt_key == "textured_plate_temp_initial_layer") {
                m_config_manipulation.check_bed_temperature_difference(BedType::btPTE, &filament_config);
            }
            else */if (opt_key_without_idx == "nozzle_temperature") {
                m_config_manipulation.check_nozzle_temperature_range(&filament_config, selected_variant_index());
            }
            else if (opt_key_without_idx == "nozzle_temperature_initial_layer") {
                m_config_manipulation.check_nozzle_temperature_initial_layer_range(&filament_config, selected_variant_index());
            }
 
            on_value_change(opt_key, value);
        };
 
        //BBS
        optgroup = page->new_optgroup(L("Volumetric speed limitation"), L"param_volumetric_speed");
        optgroup->append_single_option_line("filament_adaptive_volumetric_speed", "material_volumetric_speed_limitation#adaptive-volumetric-speed", 0);
        optgroup->append_single_option_line("filament_max_volumetric_speed", "material_volumetric_speed_limitation#max-volumetric-speed", 0);
 
        //line = { "", "" };
        //line.full_width = 1;
        //line.widget = [this](wxWindow* parent) {
        //    return description_line_widget(parent, &m_volumetric_speed_description_line);
        //};
        //optgroup->append_line(line);
 
    page = add_options_page(L("Cooling"), "custom-gcode_cooling_fan"); // ORCA: icon only visible on placeholders
 
        //line = { "", "" };
        //line.full_width = 1;
        //line.widget = [this](wxWindow* parent) {
        //    return description_line_widget(parent, &m_cooling_description_line);
        //};
        //optgroup->append_line(line);
        optgroup = page->new_optgroup(L("Cooling for specific layer"), L"param_cooling_specific_layer");
        optgroup->append_single_option_line("close_fan_the_first_x_layers", "material_cooling#no-cooling-for-the-first");
        // ORCA: explicit override for the part cooling fan on layer 0; also anchors the ramp when "Full fan speed at layer" is set.
        optgroup->append_single_option_line("initial_layer_fan_speed", "material_cooling#first-layer-fan-speed");
        optgroup->append_single_option_line("full_fan_speed_layer", "material_cooling#full-fan-speed-at-layer");
 
        optgroup = page->new_optgroup(L("Part cooling fan"), L"param_cooling_part_fan");
        line = { L("Min fan speed threshold"), L("The part cooling fan will run at the minimum fan speed when the estimated layer time is longer than the threshold value. When the layer time is shorter than the threshold, the fan speed will be interpolated between the minimum and maximum fan speed according to layer printing time.") };
        line.label_path = "material_cooling#material-part-cooling-fan";
        line.append_option(optgroup->get_option("fan_min_speed", 0));
        line.append_option(optgroup->get_option("fan_cooling_layer_time"));
        optgroup->append_line(line);
        line = { L("Max fan speed threshold"), L("The part cooling fan will run at maximum speed when the estimated layer time is shorter than the threshold value.") };
        line.label_path = "material_cooling#material-part-cooling-fan";
        line.append_option(optgroup->get_option("fan_max_speed", 0));
        line.append_option(optgroup->get_option("slow_down_layer_time"));
        optgroup->append_line(line);
        optgroup->append_single_option_line("reduce_fan_stop_start_freq", "material_cooling#keep-fan-always-on");
        optgroup->append_single_option_line("slow_down_for_layer_cooling", "material_cooling#slow-printing-down-for-better-layer-cooling");
        optgroup->append_single_option_line("dont_slow_down_outer_wall", "material_cooling#dont-slow-down-outer-walls");
        optgroup->append_single_option_line("slow_down_min_speed", "material_cooling#min-print-speed");
 
        optgroup->append_single_option_line("enable_overhang_bridge_fan", "material_cooling#force-cooling-for-overhangs-and-bridges");
        optgroup->append_single_option_line("overhang_fan_threshold", "material_cooling#overhang-cooling-activation-threshold");
        optgroup->append_single_option_line("overhang_fan_speed", "material_cooling#overhangs-and-external-bridges-fan-speed");
        optgroup->append_single_option_line("internal_bridge_fan_speed", "material_cooling#internal-bridges-fan-speed"); // ORCA: Add support for separate internal bridge fan speed control
        optgroup->append_single_option_line("support_material_interface_fan_speed", "material_cooling#support-interface-fan-speed");
        optgroup->append_single_option_line("ironing_fan_speed", "material_cooling#ironing-fan-speed"); // ORCA: Add support for ironing fan speed control
 
        optgroup = page->new_optgroup(L("Auxiliary part cooling fan"), L"param_cooling_aux_fan");
        optgroup->append_single_option_line("additional_cooling_fan_speed", "material_cooling#auxiliary-part-cooling-fan", 0);
 
        optgroup = page->new_optgroup(L("Exhaust fan"),L"param_cooling_exhaust");
 
        optgroup->append_single_option_line("activate_air_filtration", "material_cooling#activate-air-filtration");
 
        line = {L("During print"), ""};
        line.append_option(optgroup->get_option("activate_air_filtration_during_print"));
        line.append_option(optgroup->get_option("during_print_exhaust_fan_speed"));
        line.label_path = "material_cooling#during-print";
        optgroup->append_line(line);
 
 
        line = {L("Complete print"), ""};
        line.append_option(optgroup->get_option("activate_air_filtration_on_completion"));
        line.append_option(optgroup->get_option("complete_print_exhaust_fan_speed"));
        line.label_path = "material_cooling#complete-print";
        optgroup->append_line(line);
        //BBS
        add_filament_overrides_page();
        const int gcode_field_height = 15; // 150
        const int notes_field_height = 25; // 250
 
        auto edit_custom_gcode_fn = [this](const t_config_option_key& opt_key) { edit_custom_gcode(opt_key); };
 
    page = add_options_page(L("Advanced"), "custom-gcode_advanced"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("Filament 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("filament_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);
 
        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("filament_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);
 
        optgroup = page->new_optgroup(L("Filament 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("filament_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);
 
        optgroup = page->new_optgroup(L("Plugin Configuration"), L"param_gcode");
        optgroup->append_single_option_line("filament_plugin_config_overrides");
 
    page = add_options_page(L("Multimaterial"), "custom-gcode_multi_material"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("Wipe tower parameters"), "param_tower");
        optgroup->append_single_option_line("filament_minimal_purge_on_wipe_tower", "material_multimaterial#multimaterial-wipe-tower-parameters", 0);
        optgroup->append_single_option_line("filament_tower_interface_pre_extrusion_dist", "material_multimaterial#multimaterial-wipe-tower-parameters");
        optgroup->append_single_option_line("filament_tower_interface_pre_extrusion_length", "material_multimaterial#multimaterial-wipe-tower-parameters");
        optgroup->append_single_option_line("filament_tower_ironing_area", "material_multimaterial#multimaterial-wipe-tower-parameters");
        optgroup->append_single_option_line("filament_tower_interface_purge_volume", "material_multimaterial#multimaterial-wipe-tower-parameters");
        optgroup->append_single_option_line("filament_tower_interface_print_temp", "material_multimaterial#multimaterial-wipe-tower-parameters");
 
        optgroup = page->new_optgroup(L("Multi Filament"));
        // optgroup->append_single_option_line("filament_flush_temp", "", 0);
        // optgroup->append_single_option_line("filament_flush_volumetric_speed", "", 0);
        optgroup->append_single_option_line("long_retractions_when_ec", "material_multimaterial#multi-filament" , 0);
        optgroup->append_single_option_line("retraction_distances_when_ec", "material_multimaterial#multi-filament" , 0);
 
        optgroup = page->new_optgroup(L("Tool change parameters with single extruder MM printers"), "param_toolchange");
        optgroup->append_single_option_line("filament_loading_speed_start", "material_multimaterial#loading-speed-at-the-start");
        optgroup->append_single_option_line("filament_loading_speed", "material_multimaterial#loading-speed");
        optgroup->append_single_option_line("filament_unloading_speed_start", "material_multimaterial#unloading-speed-at-the-start");
        optgroup->append_single_option_line("filament_unloading_speed", "material_multimaterial#unloading-speed");
        optgroup->append_single_option_line("filament_toolchange_delay", "material_multimaterial#delay-after-unloading");
        optgroup->append_single_option_line("filament_cooling_moves", "material_multimaterial#number-of-cooling-moves");
        optgroup->append_single_option_line("filament_cooling_initial_speed", "material_multimaterial#speed-of-the-first-cooling-move");
        optgroup->append_single_option_line("filament_cooling_final_speed", "material_multimaterial#speed-of-the-last-cooling-move");
        optgroup->append_single_option_line("filament_stamping_loading_speed", "material_multimaterial#stamping-loading-speed");
        optgroup->append_single_option_line("filament_stamping_distance", "material_multimaterial#stamping-distance");
        create_line_with_widget(optgroup.get(), "filament_ramming_parameters", "material_multimaterial#ramming-parameters", [this](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);
 
            btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
                RammingDialog dlg(this,(m_config->option<ConfigOptionStrings>("filament_ramming_parameters"))->get_at(0));
                if (dlg.ShowModal() == wxID_OK) {
                    load_key_value("filament_ramming_parameters", dlg.get_parameters());
                    update_changed_ui();
                }
            });
            return sizer;
        });
 
        optgroup = page->new_optgroup(L("Tool change parameters with multi extruder MM printers"), "param_toolchange_multi_extruder");
        optgroup->append_single_option_line("filament_multitool_ramming", "material_multimaterial#tool-change-parameters-with-multi-extruder", 0);
        optgroup->append_single_option_line("filament_multitool_ramming_volume", "material_multimaterial#multi-tool-ramming-volume", 0);
        optgroup->append_single_option_line("filament_multitool_ramming_flow", "material_multimaterial#multi-tool-ramming-flow", 0);
 
    page = add_options_page(L("Dependencies"), "advanced");
        optgroup = page->new_optgroup(L("Compatible printers"), "param_dependencies_printers");
        create_line_with_widget(optgroup.get(), "compatible_printers", "", [this](wxWindow* parent) {
            return compatible_widget_create(parent, m_compatible_printers);
        });
 
        option = optgroup->get_option("compatible_printers_condition");
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "material_dependencies#printer-condition");
 
        optgroup = page->new_optgroup(L("Compatible process profiles"), "param_dependencies_presets");
        create_line_with_widget(optgroup.get(), "compatible_prints", "", [this](wxWindow* parent) {
            return compatible_widget_create(parent, m_compatible_prints);
        });
 
        option = optgroup->get_option("compatible_prints_condition");
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "material_dependencies#process-condition");
 
    page = add_options_page(L("Notes"), "custom-gcode_note"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("Notes"),"note", 0);
        optgroup->label_width = 0;
        option = optgroup->get_option("filament_notes");
        option.opt.full_width = true;
        option.opt.height = notes_field_height;// 250;
        optgroup->append_single_option_line(option);
 
        //build_preset_description_line(optgroup.get());
}

References add_filament_overrides_page(), Slic3r::GUI::Tab::add_options_page(), Slic3r::GUI::Line::append_option(), Slic3r::GUI::Tab::create_line_with_widget(), Slic3r::GUI::Tab::edit_custom_gcode(), Slic3r::ConfigOptionDef::full_width, Slic3r::ConfigOptionDef::height, Slic3r::ConfigOptionDef::is_code, L, Slic3r::ConfigOptionDef::label, Slic3r::GUI::Line::label_path, Slic3r::GUI::Tab::load_initial_data(), Slic3r::GUI::Tab::m_config_manipulation, Slic3r::GUI::Tab::m_postpone_update_ui, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_presets, on_value_change(), Slic3r::GUI::Option::opt, Slic3r::GUI::Tab::parent(), selected_variant_index(), Slic3r::GUI::Tab::update_dirty(), and Slic3r::GUI::validate_custom_gcode_cb().

Here is the call 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:

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:

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::TabFilament::clear_pages ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::clear_pages();
 
    m_volumetric_speed_description_line = nullptr;
  m_cooling_description_line = nullptr;
 
    //BBS: GUI refactor
    m_overrides_options.clear();
}

References Slic3r::GUI::Tab::clear_pages(), clear_pages(), m_cooling_description_line, m_overrides_options, and m_volumetric_speed_description_line.

Referenced by clear_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_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:

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::TabFilament::get_custom_gcode ( const t_config_option_key & opt_key )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    return m_config->opt_string(opt_key, unsigned(0));
}

References Slic3r::GUI::Tab::m_config.

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::TabFilament::init_options_list ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    if (!m_options_list.empty())
        m_options_list.clear();
 
    for (const std::string &opt_key : m_config->keys()) {
        if (filament_options_with_variant.find(opt_key) == filament_options_with_variant.end())
            m_options_list.emplace(opt_key, m_opt_status_value);
        else
            m_options_list.emplace(opt_key + "#0", m_opt_status_value);
    }
}

References Slic3r::filament_options_with_variant, init_options_list(), Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_opt_status_value, and Slic3r::GUI::Tab::m_options_list.

Referenced by init_options_list().

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::Tab::msw_rescale ( )

virtualinherited

Reimplemented in Slic3r::GUI::TabPrinter.

{
    m_em_unit = em_unit(m_parent);
 
    m_top_sizer->SetMinSize(-1, 3 * m_em_unit);
 
    //BBS: GUI refactor
    //if (m_mode_sizer)
    //    m_mode_sizer->msw_rescale();
    if (m_presets_choice)
        m_presets_choice->msw_rescale();
 
    m_tabctrl->SetMinSize(wxSize(20 * m_em_unit, -1));
 
    // rescale 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_mode_view)
        m_mode_view->Rescale();
    if (m_extruder_switch)
        m_extruder_switch->Rescale();
    if (m_variant_combo)
        m_variant_combo->Rescale();
 
    if (m_detach_preset_btn)
        m_detach_preset_btn->msw_rescale();
 
    // rescale 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);
 
    // rescale options_groups
    if (m_active_page)
        m_active_page->msw_rescale();
 
    m_tabctrl->Rescale();
 
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
}

References em_unit(), m_active_page, m_detach_preset_btn, m_em_unit, m_extruder_switch, m_icons, m_mode_view, m_parent, m_presets_choice, m_scaled_bitmaps, m_scaled_buttons, m_scaled_icons_list, m_tabctrl, m_top_sizer, m_variant_combo, and msw_rescale().

Referenced by msw_rescale(), and Slic3r::GUI::TabPrinter::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_preset_loaded()

virtual void Slic3r::GUI::Tab::on_preset_loaded ( )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::TabPrinter.

{}

Referenced by load_current_preset(), and Slic3r::GUI::Sidebar::update_presets().

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::TabFilament::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("#");
 
    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;
 
        std::string opt_key_pure = opt_key;
        boost::erase_tail(opt_key_pure, opt_key_pure.size() - pos);
 
        if (opt_key_pure == "filament_retract_after_wipe" || opt_key_pure == "filament_retract_before_wipe") {
            double dvalue = boost::any_cast<double>(value);
            auto percent_value_clamp = [](double percent_value) { return std::clamp(percent_value, 0., 100.); };
            auto get_value_by_opt_key = [&](const std::string& opt_key) {
                    if (opt_key_pure == opt_key && !std::isnan(dvalue)) {
                        // Return the incoming value (if it is valid) if the opt_key equals the key of the changed option.
                        return percent_value_clamp(dvalue);
                    } else if (!m_config->option<ConfigOptionPercents>(opt_key)->is_nil(opt_idx)) {
                        // Return the overridden value if the option value for the opt_key was overridden for the given filament.
                        return percent_value_clamp(m_config->option<ConfigOptionPercents>(opt_key)->get_at(opt_idx));
                    } else {
                        // Return the value of the option value for opt_key from the printer setting if it was not overridden for the filament.
                        const auto& printer_config = m_preset_bundle->printers.get_edited_preset().config;
                        const std::string printer_opt_key = opt_key.substr(strlen("filament_"));
                        return percent_value_clamp(printer_config.option<ConfigOptionPercents>(printer_opt_key)->get_at(opt_idx));
                    }
 
                    return 0.;
                };
 
            double retract_before_wipe = get_value_by_opt_key("filament_retract_before_wipe");
            double retract_after_wipe  = get_value_by_opt_key("filament_retract_after_wipe");
 
            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, "filament_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();
            }
        }
    }
 
    Tab::on_value_change(opt_key, value);
}

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

Referenced by build(), and on_value_change().

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:

reload_config()

void Slic3r::GUI::TabFilament::reload_config ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    this->compatible_widget_reload(m_compatible_printers);
    this->compatible_widget_reload(m_compatible_prints);
    Tab::reload_config();
 
    // Recompute derived override UI from the newly loaded config
    update_filament_overrides_page(&m_preset_bundle->printers.get_edited_preset().config);
}

References Slic3r::GUI::Tab::compatible_widget_reload(), Slic3r::GUI::Tab::m_compatible_printers, Slic3r::GUI::Tab::m_compatible_prints, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::reload_config(), reload_config(), and update_filament_overrides_page().

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

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:

selected_variant_index()

unsigned int Slic3r::GUI::TabFilament::selected_variant_index ( ) const

private

{
    return m_variant_combo ? std::max(0, m_variant_combo->GetSelection()) : 0;
}

References Slic3r::GUI::Tab::m_variant_combo, and selected_variant_index().

Referenced by build(), selected_variant_index(), and toggle_options().

Here is the call graph for this function:

Here is the caller graph for this function:

set_custom_gcode()

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

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    std::vector<std::string> gcodes = static_cast<const ConfigOptionStrings*>(m_config->option(opt_key))->values;
    gcodes[0] = value;
 
    DynamicPrintConfig new_conf = *m_config;
    new_conf.set_key_value(opt_key, new ConfigOptionStrings(gcodes));
    load_config(new_conf);
}

References Slic3r::GUI::Tab::load_config(), Slic3r::GUI::Tab::m_config, Slic3r::DynamicConfig::set_key_value(), and Slic3r::ConfigOptionVector< T >::values.

Here is the call 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_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::TabFilament::supports_printer_technology ( const PrinterTechnology tech ) const

inlineoverridevirtual

Implements Slic3r::GUI::Tab.

{ return tech == ptFFF; }

References Slic3r::ptFFF.

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:

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::TabFilament::toggle_options ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    const unsigned int variant_index = selected_variant_index();
    if (!m_active_page)
        return;
    bool is_BBL_printer = false;
    if (m_preset_bundle) {
        is_BBL_printer = wxGetApp().preset_bundle->is_bbl_vendor();
    }
 
    auto printer_cfg = m_preset_bundle->printers.get_edited_preset().config;
 
    if (m_active_page->title() == L("Cooling")) {
        bool has_enable_overhang_bridge_fan = m_config->opt_bool("enable_overhang_bridge_fan", 0);
        for (auto el : {"overhang_fan_speed", "overhang_fan_threshold", "internal_bridge_fan_speed"}) // ORCA: Add support for separate internal bridge fan speed control
            toggle_option(el, has_enable_overhang_bridge_fan);
 
        // Orca: toggle dont slow down for external perimeters if
        bool has_slow_down_for_layer_cooling = m_config->opt_bool("slow_down_for_layer_cooling", 0);
        toggle_option("dont_slow_down_outer_wall", has_slow_down_for_layer_cooling);
 
        // ORCA: First layer fan speed override only makes sense when no layers are gated off ("No cooling for
        // the first" == 0). Otherwise the override would set layer 0 to a non-zero value while the gate forces
        // layers 1..N-1 to zero, producing a confusing non-monotonic profile. When the gate is active we both
        // grey out the UI line and force the underlying value to -1 so the cooling buffer never enters the
        // override branch.
        const int close_fan_first_n = m_config->opt_int("close_fan_the_first_x_layers", 0);
        const bool initial_layer_fan_speed_enabled = close_fan_first_n <= 0;
        toggle_line("initial_layer_fan_speed", initial_layer_fan_speed_enabled);
        if (!initial_layer_fan_speed_enabled) {
            if (auto* opt = dynamic_cast<const ConfigOptionInts*>(m_config->option("initial_layer_fan_speed"))) {
                bool needs_reset = false;
                for (int v : opt->values) {
                    if (v != -1) { needs_reset = true; break; }
                }
                if (needs_reset) {
                    std::vector<int> reset_values(opt->values.size(), -1);
                    m_config->set_key_value("initial_layer_fan_speed", new ConfigOptionInts(reset_values));
                    update_dirty();
                    reload_config();
                }
            }
        }
 
        toggle_line("additional_cooling_fan_speed", printer_cfg.opt_bool("auxiliary_fan"), 256 + variant_index);
 
        bool support_air_filtration = printer_cfg.opt_bool("support_air_filtration");
        for (auto el : {"activate_air_filtration", "during_print_exhaust_fan_speed", "complete_print_exhaust_fan_speed"})
            toggle_line(el, support_air_filtration);
 
        if (support_air_filtration) {
            bool activate_air_filtration = m_config->opt_bool("activate_air_filtration", 0);
            toggle_option("activate_air_filtration_during_print", activate_air_filtration);
            toggle_option("during_print_exhaust_fan_speed", activate_air_filtration && m_config->opt_bool("activate_air_filtration_during_print", 0));
            toggle_option("activate_air_filtration_on_completion", activate_air_filtration);
            toggle_option("complete_print_exhaust_fan_speed", activate_air_filtration && m_config->opt_bool("activate_air_filtration_on_completion", 0));
        }
    }
    if (m_active_page->title() == L("Filament"))
    {
        bool pa = m_config->opt_bool("enable_pressure_advance", variant_index);
        toggle_option("pressure_advance", pa, 256 + variant_index);
 
        //Orca: Enable the plates that should be visible when multi bed support is enabled or a BBL printer is selected; otherwise, enable only the plate visible for the selected bed type.
        DynamicConfig& proj_cfg               = m_preset_bundle->project_config;
        std::string    bed_temp_1st_layer_key = "";
        if (proj_cfg.has("curr_bed_type"))
        {
            bed_temp_1st_layer_key = get_bed_temp_1st_layer_key(proj_cfg.opt_enum<BedType>("curr_bed_type"));
        }
 
        const std::vector<std::string> bed_temp_keys = {"supertack_plate_temp_initial_layer", "cool_plate_temp_initial_layer",
                                                        "textured_cool_plate_temp_initial_layer", "eng_plate_temp_initial_layer",
                                                        "textured_plate_temp_initial_layer", "hot_plate_temp_initial_layer"};
 
        bool support_multi_bed_types = std::find(bed_temp_keys.begin(), bed_temp_keys.end(), bed_temp_1st_layer_key) ==
                                           bed_temp_keys.end() ||
                                       is_BBL_printer || printer_cfg.opt_bool("support_multi_bed_types");
 
        for (const auto& key : bed_temp_keys)
        {
            toggle_line(key, support_multi_bed_types || bed_temp_1st_layer_key == key);
        }
 
 
 
        // Orca: adaptive pressure advance and calibration model
        // If PA is not enabled, disable adaptive pressure advance and hide the model section
        // If adaptive PA is not enabled, hide the adaptive PA model section
        toggle_option("adaptive_pressure_advance", pa, 0);
        toggle_option("adaptive_pressure_advance_overhangs", pa, 0);
        bool has_adaptive_pa = m_config->opt_bool("adaptive_pressure_advance", variant_index);
        toggle_line("adaptive_pressure_advance_overhangs", has_adaptive_pa && pa, 0);
        toggle_line("adaptive_pressure_advance_model", has_adaptive_pa && pa, 0);
        toggle_line("adaptive_pressure_advance_bridges", has_adaptive_pa && pa, 0);
 
        bool is_pellet_printer = printer_cfg.opt_bool("pellet_modded_printer");
        toggle_line("pellet_flow_coefficient", is_pellet_printer);
        toggle_line("filament_diameter", !is_pellet_printer);
 
        toggle_line("activate_chamber_temp_control", printer_cfg.opt_bool("support_chamber_temp_control"));
 
        std::string volumetric_speed_cos = m_config->opt_string("volumetric_speed_coefficients", variant_index);
        bool enable_fit = volumetric_speed_cos != "0 0 0 0 0 0";
        toggle_option("filament_adaptive_volumetric_speed", enable_fit, 256 + variant_index);
    }
 
    if (m_active_page->title() == L("Setting Overrides"))
        update_filament_overrides_page(&printer_cfg);
 
    if (m_active_page->title() == L("Multimaterial")) {
        // Orca: hide specific settings for BBL printers
        toggle_option("filament_minimal_purge_on_wipe_tower", !is_BBL_printer, 256 + variant_index);
        for (auto el : {"filament_loading_speed_start", "filament_loading_speed",
                        "filament_unloading_speed_start", "filament_unloading_speed", "filament_toolchange_delay", "filament_cooling_moves",
                        "filament_cooling_initial_speed", "filament_cooling_final_speed"})
            toggle_option(el, !is_BBL_printer);
 
        bool multitool_ramming = m_config->opt_bool("filament_multitool_ramming", variant_index);
        toggle_option("filament_multitool_ramming_volume", multitool_ramming, 256 + variant_index);
        toggle_option("filament_multitool_ramming_flow", multitool_ramming, 256 + variant_index);
 
        bool is_BBL_multi_extruder = is_BBL_printer && printer_cfg.option<ConfigOptionFloats>("nozzle_diameter")->size() > 1;
        toggle_line("long_retractions_when_ec", is_BBL_multi_extruder, 256 + variant_index);
        toggle_line("retraction_distances_when_ec", is_BBL_multi_extruder && m_config->opt_bool("long_retractions_when_ec", variant_index), 256 + variant_index);
    }
}

References Slic3r::activate_air_filtration(), Slic3r::get_bed_temp_1st_layer_key(), Slic3r::ConfigOptionResolver::has(), L, Slic3r::GUI::Tab::m_active_page, Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::DynamicConfig::opt_enum(), reload_config(), selected_variant_index(), Slic3r::support_air_filtration(), Slic3r::GUI::Tab::toggle_line(), Slic3r::GUI::Tab::toggle_option(), toggle_options(), Slic3r::GUI::Tab::update_dirty(), and update_filament_overrides_page().

Referenced by toggle_options(), and update().

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::TabFilament::update ( )

overridevirtual

Implements Slic3r::GUI::Tab.

{
    if (m_preset_bundle->printers.get_selected_preset().printer_technology() == ptSLA)
        return; // ys_FIXME
 
    m_config_manipulation.check_filament_max_volumetric_speed(m_config);
    m_config_manipulation.check_filament_ironing_spacing(m_config);
 
    m_update_cnt++;
 
    update_description_lines();
    //BBS: GUI refactor
    //Layout();
    m_parent->Layout();
 
    toggle_options();
 
    m_update_cnt--;
 
    if (m_update_cnt == 0)
        wxGetApp().mainframe->on_config_changed(m_config);
}

References Slic3r::GUI::Tab::m_config, Slic3r::GUI::Tab::m_config_manipulation, Slic3r::GUI::Tab::m_parent, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_update_cnt, Slic3r::ptSLA, toggle_options(), update(), and update_description_lines().

Referenced by 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()

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

inlinevirtualinherited

Reimplemented in Slic3r::GUI::TabPrinter, Slic3r::GUI::TabPrintLayer, Slic3r::GUI::TabPrintModel, and Slic3r::GUI::TabPrintPlate.

{}

Referenced by update_all_extruder_options_status(), and update_changed_ui().

Here is the caller graph for this function:

update_description_lines()

void Slic3r::GUI::TabFilament::update_description_lines ( )

overridevirtual

Reimplemented from Slic3r::GUI::Tab.

{
    Tab::update_description_lines();
 
    if (!m_active_page)
        return;
 
    if (m_active_page->title() == "Cooling" && m_cooling_description_line)
        m_cooling_description_line->SetText(from_u8(PresetHints::cooling_description(m_presets->get_edited_preset())));
    //BBS
    //if (m_active_page->title() == "Filament" && m_volumetric_speed_description_line)
    //    this->update_volumetric_flow_preset_hints();
}

References Slic3r::PresetHints::cooling_description(), Slic3r::from_u8(), Slic3r::GUI::Tab::m_active_page, m_cooling_description_line, Slic3r::GUI::Tab::m_presets, Slic3r::GUI::Tab::update_description_lines(), and update_description_lines().

Referenced by update(), and update_description_lines().

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_filament_overrides_page()

void Slic3r::GUI::TabFilament::update_filament_overrides_page ( const DynamicPrintConfig * printers_config )

private

{
    if (!m_active_page || m_active_page->title() != "Setting Overrides")
        return;
 
    //BBS: GUI refactor
    if (m_overrides_options.size() <= 0)
        return;
 
    Page* page = m_active_page;
 
    const auto og_it = std::find_if(page->m_optgroups.begin(), page->m_optgroups.end(), [](const ConfigOptionsGroupShp og) { return og->title == "Retraction"; });
    if (og_it == page->m_optgroups.end())
        return;
    ConfigOptionsGroupShp optgroup = *og_it;
 
    std::vector<std::string> opt_keys = {   "filament_retraction_length",
                                            "filament_z_hop",
                                            "filament_z_hop_types",
                                            "filament_retract_lift_above",
                                            "filament_retract_lift_below",
                                            "filament_retract_lift_enforce",
                                            "filament_retraction_speed",
                                            "filament_deretraction_speed",
                                            "filament_retract_restart_extra",
                                            "filament_retract_length_toolchange",
                                            "filament_retract_restart_extra_toolchange",
                                            "filament_retraction_minimum_travel",
                                            "filament_retract_when_changing_layer",
                                            "filament_wipe",
                                            // BBS
                                            "filament_wipe_distance",
                                            "filament_retract_before_wipe",
                                            // Orca
                                            "filament_retract_after_wipe",
                                            // BBS
                                            "filament_long_retractions_when_cut",
                                            "filament_retraction_distances_when_cut"
                                            //SoftFever
                                            // "filament_seam_gap"
                                        };
 
    const int selection = m_variant_combo ? m_variant_combo->GetSelection() : 0;
    auto opt = dynamic_cast<ConfigOptionVectorBase *>(m_config->option("filament_retraction_length"));
    const int extruder_idx = selection < 0 || selection >= static_cast<int>(opt->size()) ? 0 : selection;
 
    const bool have_retract_length = dynamic_cast<ConfigOptionVectorBase *>(m_config->option("filament_retraction_length"))->is_nil(extruder_idx) ||
                                     m_config->opt_float("filament_retraction_length", extruder_idx) > 0;
 
    for (const std::string& opt_key : opt_keys)
    {
        bool is_checked = opt_key=="filament_retraction_length" ? true : have_retract_length;
        m_overrides_options[opt_key]->Enable(is_checked);
 
        is_checked &= !dynamic_cast<ConfigOptionVectorBase*>(m_config->option(opt_key))->is_nil(extruder_idx);
        m_overrides_options[opt_key]->SetValue(is_checked);
 
        // the toolchange overrides live in their own optgroup, so search the whole page
        Field* field = page->get_field(opt_key, 0);
        if (field == nullptr) continue;
 
        if (opt_key == "filament_long_retractions_when_cut") {
            int machine_enabled_level = printers_config->option<ConfigOptionInt>(
                "enable_long_retraction_when_cut")->value;
            bool machine_enabled = machine_enabled_level == LongRectrationLevel::EnableFilament;
                toggle_line(opt_key, machine_enabled, extruder_idx + 256);
            field->toggle(is_checked && machine_enabled);
        } else if (opt_key == "filament_retraction_distances_when_cut") {
            int machine_enabled_level = printers_config->option<ConfigOptionInt>(
                "enable_long_retraction_when_cut")->value;
            bool machine_enabled = machine_enabled_level == LongRectrationLevel::EnableFilament;
            bool filament_enabled = m_config->option<ConfigOptionBools>("filament_long_retractions_when_cut")->values[extruder_idx] == 1;
            toggle_line(opt_key, filament_enabled && machine_enabled, extruder_idx + 256);
            field->toggle(is_checked && filament_enabled && machine_enabled);
        } else {
            if (!is_checked) {
                const std::string printer_opt_key = opt_key.substr(strlen("filament_"));
                boost::any printer_config_value = optgroup->get_config_value(*printers_config, printer_opt_key, extruder_idx);
                field->update_na_value(printer_config_value);
                field->set_value(printer_config_value, false);
            }
 
            field->toggle(is_checked);
        }
    }
 
    // Handle ironing overrides
    const auto og_ironing_it = std::find_if(page->m_optgroups.begin(), page->m_optgroups.end(), [](const ConfigOptionsGroupShp og) { return og->title == "Ironing"; });
    if (og_ironing_it != page->m_optgroups.end())
    {
        ConfigOptionsGroupShp ironing_optgroup = *og_ironing_it;
 
        std::vector<std::string> ironing_opt_keys = {
            "filament_ironing_flow",
            "filament_ironing_spacing",
            "filament_ironing_inset",
            "filament_ironing_speed"
        };
 
        for (const std::string& opt_key : ironing_opt_keys)
        {
            if (m_overrides_options.find(opt_key) == m_overrides_options.end())
                continue;
 
            bool is_checked = !dynamic_cast<ConfigOptionVectorBase*>(m_config->option(opt_key))->is_nil(extruder_idx);
            m_overrides_options[opt_key]->Enable(true);
            m_overrides_options[opt_key]->SetValue(is_checked);
 
            Field* field = ironing_optgroup->get_fieldc(opt_key, 0);
            if (field == nullptr) continue;
 
            if (!is_checked) {
                // Get the default value from the process config (ironing_* without filament_ prefix)
                const std::string process_opt_key = opt_key.substr(strlen("filament_"));
                const auto process_config = m_preset_bundle->prints.get_edited_preset().config;
                const boost::any process_config_value = ironing_optgroup->get_config_value(process_config, process_opt_key, 0);
                field->update_na_value(process_config_value);
                field->set_value(process_config_value, false);
            }
 
            field->toggle(is_checked);
        }
    }
}

References Slic3r::EnableFilament, Slic3r::GUI::Page::get_field(), Slic3r::ConfigOptionVectorBase::is_nil(), Slic3r::GUI::Tab::m_active_page, Slic3r::GUI::Tab::m_config, Slic3r::GUI::Page::m_optgroups, m_overrides_options, Slic3r::GUI::Tab::m_preset_bundle, Slic3r::GUI::Tab::m_variant_combo, Slic3r::ConfigBase::option(), Slic3r::GUI::Field::set_value(), Slic3r::GUI::Field::toggle(), Slic3r::GUI::Tab::toggle_line(), and Slic3r::GUI::Field::update_na_value().

Referenced by reload_config(), and toggle_options().

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_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_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_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_volumetric_flow_preset_hints()

void Slic3r::GUI::TabFilament::update_volumetric_flow_preset_hints ( )

private

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_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_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_cooling_description_line

ogStaticText* Slic3r::GUI::TabFilament::m_cooling_description_line {nullptr}

private

{nullptr};

Referenced by clear_pages(), and update_description_lines().

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_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_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_overrides_options

std::map<std::string, ::CheckBox*> Slic3r::GUI::TabFilament::m_overrides_options

private

Referenced by add_filament_overrides_page(), clear_pages(), and update_filament_overrides_page().

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_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_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_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_volumetric_speed_description_line

ogStaticText* Slic3r::GUI::TabFilament::m_volumetric_speed_description_line {nullptr}

private

{nullptr};

Referenced by clear_pages().

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