Slic3r::GUI::Tab Class Reference

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

Inheritance diagram for Slic3r::GUI::Tab:

Collaboration diagram for Slic3r::GUI::Tab:

Classes
struct	PresetDependencies
struct	Highlighter
struct	SettingRowState

Public Member Functions
	Tab (ParamsPanel *parent, const wxString &title, Preset::Type type)
	~Tab ()
wxWindow *	parent () const
wxString	title () const
std::string	name () const
Preset::Type	type () const
bool	completed () const
virtual bool	supports_printer_technology (const PrinterTechnology tech) const =0
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	clear_pages ()
virtual void	update_description_lines ()
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 ()
virtual void	build ()=0
virtual void	update ()=0
virtual void	toggle_options ()=0
virtual void	init_options_list ()
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)
virtual void	reload_config ()
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
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)
Field *	get_field (const t_config_option_key &opt_key, Page **selected_page, 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 ()
virtual void	on_value_change (const std::string &opt_key, const boost::any &value)
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)
virtual const std::string &	get_custom_gcode (const t_config_option_key &opt_key)
virtual void	set_custom_gcode (const t_config_option_key &opt_key, const std::string &value)
void	update_extruder_variants (int extruder_id=-1, bool reload=true)
	Call from: 1: on_value_change "nozzle_volume_type" 2: on_preset_loaded (extruder_id = -1).
void	switch_excluder (int extruder_id=-1, bool reload=true)
void	sync_excluder ()
void	parse_extruder_selection (int selection, int &extruder_id, NozzleVolumeType &nozzle_type)
int	calculate_selection_index_for_extruder (int extruder_id, NozzleVolumeType nozzle_type)
bool	get_extruder_sync_enable_state (int extruder_id)
int	get_current_active_extruder ()
std::vector< wxString >	generate_extruder_options ()
NozzleVolumeType	get_actual_nozzle_volume_type (int extruder_id)

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

Public Attributes
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

Friends
class	EditGCodeDialog
class	PublishSettingsDialog

Detailed Description

---

Class Documentation

Slic3r::GUI::Tab::PresetDependencies

struct Slic3r::GUI::Tab::PresetDependencies

Collaboration diagram for Slic3r::GUI::Tab::PresetDependencies:

Class Members
Button *	btn = nullptr
::CheckBox *	checkbox = nullptr
wxStaticText *	checkbox_title = nullptr
wxString	dialog_label
wxString	dialog_title
string	key_condition
string	key_list
Type	type = Preset::TYPE_INVALID

Slic3r::GUI::Tab::SettingRowState

struct Slic3r::GUI::Tab::SettingRowState

Class Members
wxString	label
wxString	label_en
bool	multi {false}
bool	visible {true}

Member Enumeration Documentation

OptStatus

enum Slic3r::GUI::Tab::OptStatus

protected

Enumerator
osSystemValue
osInitValue

{ osSystemValue = 1, osInitValue = 2 };

Constructor & Destructor Documentation

Tab()

Slic3r::GUI::Tab::Tab	(	ParamsPanel *	parent,
		const wxString &	title,
		Preset::Type	type )

                                                                    :
    m_parent(parent), m_title(title), m_type(type)
{
    Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL/*, name*/);
    this->SetFont(Slic3r::GUI::wxGetApp().normal_font());
 
    wxGetApp().UpdateDarkUI(this);
    SetBackgroundColour(*wxWHITE);
 
    m_compatible_printers.type      = Preset::TYPE_PRINTER;
    m_compatible_printers.key_list    = "compatible_printers";
    m_compatible_printers.key_condition = "compatible_printers_condition";
    //m_compatible_printers.dialog_title  = _L("Compatible printers");
    //m_compatible_printers.dialog_label  = _L("Select the printers this profile is compatible with.");
 
    m_compatible_prints.type      = Preset::TYPE_PRINT;
    m_compatible_prints.key_list    = "compatible_prints";
    m_compatible_prints.key_condition = "compatible_prints_condition";
    //m_compatible_prints.dialog_title  = _L("Compatible print profiles");
    //m_compatible_prints.dialog_label  = _L("Select the print profiles this profile is compatible with.");
 
    wxGetApp().tabs_list.push_back(this);
 
    m_em_unit = em_unit(m_parent); //wxGetApp().em_unit();
 
    m_config_manipulation = get_config_manipulation();
 
    Bind(wxEVT_SIZE, ([](wxSizeEvent &evt) {
        //for (auto page : m_pages)
        //    if (! page.get()->IsShown())
        //        page->layout_valid = false;
        evt.Skip();
    }));
 
    m_highlighter.set_timer_owner(this, 0);
    this->Bind(wxEVT_TIMER, [this](wxTimerEvent&)
    {
        m_highlighter.blink();
    });
}

References em_unit(), get_config_manipulation(), m_compatible_printers, m_compatible_prints, m_config_manipulation, m_em_unit, m_highlighter, m_parent, m_title, m_type, parent(), title(), type(), Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::TabFilament::TabFilament(), Slic3r::GUI::TabPrint::TabPrint(), Slic3r::GUI::TabPrinter::TabPrinter(), Slic3r::GUI::TabSLAMaterial::TabSLAMaterial(), Slic3r::GUI::TabSLAPrint::TabSLAPrint(), on_presets_changed(), and tree_sel_change_delayed().

Here is the call graph for this function:

Here is the caller graph for this function:

~Tab()

Slic3r::GUI::Tab::~Tab ( )

inline

{}

Member Function Documentation

activate_option()

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

virtual

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 )

virtual

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

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

{
    // 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 )

{
    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 )

{
    *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

(

)

{
    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 )

{
    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

)

{
    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

(

)

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

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

pure virtual

Implemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabPrintModel, Slic3r::GUI::TabPrintPlate, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

Referenced by create_preset_tab().

Here is the caller graph for this function:

build_preset_description_line()

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

protected

{
    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 )

{
    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 )

{
    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 )

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

virtual

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

{
    // invalidated highlighter, if any exists
    m_highlighter.invalidate();
    // clear pages from the controlls
    for (auto p : m_pages)
        p->clear();
    //BBS: clear page in Parent
    //m_page_sizer->Clear(true);
    m_parent->clear_page();
 
    // nulling pointers
    m_parent_preset_description_line = nullptr;
    m_detach_preset_btn = nullptr;
 
    m_compatible_printers.checkbox  = nullptr;
    m_compatible_printers.btn       = nullptr;
 
    m_compatible_prints.checkbox    = nullptr;
    m_compatible_prints.btn         = nullptr;
}

References clear_pages(), m_compatible_printers, m_compatible_prints, m_detach_preset_btn, m_highlighter, m_pages, m_parent, and m_parent_preset_description_line.

Referenced by Slic3r::GUI::ParamsPanel::~ParamsPanel(), clear_pages(), Slic3r::GUI::TabFilament::clear_pages(), Slic3r::GUI::TabPrint::clear_pages(), Slic3r::GUI::TabPrinter::clear_pages(), Slic3r::GUI::TabSLAPrint::clear_pages(), and tree_sel_change_delayed().

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 )

protected

{
    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

(

)

{
    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 )

protected

{
    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 )

protected

{
    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

inline

{ 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 )

protected

{
    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

(

)

{
//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

{ 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

(

)

{
    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

(

)

{
    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 )

{
    *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

)

{
    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 )

protected

{
    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

(

)

{
    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

)

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

inline

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

inline

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

inline

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

protected

{
    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

(

)

{
    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 )

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

References get_custom_ctrl_with_blinking_ptr(), and m_active_page.

Referenced by activate_option(), and get_custom_ctrl_with_blinking_ptr().

Here is the call graph for this function:

Here is the caller graph for this function:

get_custom_gcode()

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

virtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    return m_config->opt_string(opt_key);
}

References m_config.

Referenced by edit_custom_gcode().

Here is the caller graph for this function:

get_extruder_sync_enable_state()

bool Slic3r::GUI::Tab::get_extruder_sync_enable_state

(

int

extruder_id

)

{
    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

{
    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 )

{
    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

)

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

inline

{ 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 )

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

virtual

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

{
    if (!m_options_list.empty())
        m_options_list.clear();
 
    for (const std::string& opt_key : m_config->keys())
        m_options_list.emplace(options_list_storage_key(opt_key), m_opt_status_value);
}

References init_options_list(), m_config, m_opt_status_value, m_options_list, and options_list_storage_key().

Referenced by Slic3r::GUI::TabPrintModel::build(), init_options_list(), Slic3r::GUI::TabPrinter::init_options_list(), and load_current_preset().

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

inline

{ 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

)

{
    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

(

)

{
    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

(

)

{
    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 )

protected

{
    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 )

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

virtual

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

inline

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

inlinevirtual

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

protected

{
    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

)

{
    // 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::Tab::on_value_change ( const std::string & opt_key, const boost::any & value )

virtual

!!! ysFIXME ????

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

{
    // Orca:
    // TODO: Move filament-specific checks to TabFilament::on_value_change()
    // TODO: Move printer-specific checks to TabPrinter::on_value_change()
 
    if (wxGetApp().plater() == nullptr) {
        return;
    }
 
    // The bed-area point option cannot store collision-volume syntax. Offer to
    // copy it to the volume setting while retaining the area's previous value.
    if (opt_key == "bed_exclude_area" && m_type == Preset::TYPE_PRINTER) {
        const std::string *definition = boost::any_cast<std::string>(&value);
        if (definition != nullptr && is_bed_exclusion_volume_syntax(*definition)) {
            const double printable_height = m_config->opt_float("printable_height");
            if (!is_valid_bed_exclude_volumes_string(*definition, printable_height)) {
                show_error(wxGetApp().plater(), _L("Invalid collision volume format. Use XxY, XxY, ... or ZMIN..ZMAX;XxY, XxY, ... and separate multiple volumes with |."));
                reload_config();
                return;
            }
 
            MessageDialog dialog(
                wxGetApp().plater(),
                _L("This definition contains collision-volume syntax. Add it to the toolhead collision volumes for G-code checking and travel avoidance? The existing excluded bed area will be preserved."),
                _L("Add collision volumes"), wxICON_QUESTION | wxYES | wxNO);
            if (dialog.ShowModal() == wxID_YES) {
                DynamicPrintConfig converted = *m_config;
                append_bed_exclude_volumes(converted, *definition);
                load_config(converted);
                reload_config();
                on_presets_changed();
                wxGetApp().plater()->update();
            } else {
                reload_config();
            }
            return;
        }
    }
 
    // Keep this preset's "plugins" manifest in sync when a plugin picker changes, so full_config() and
    // save_to_json() always find resolved "name;uuid;capability" references and rebuild it nowhere else.
    // Also drop any plugin config override entries for a capability the change just stopped
    // referencing (e.g. a plugin removed from slicing_pipeline_plugin), so a saved preset never
    // carries configuration for a capability it no longer names. The Configure button is a separate
    // field holding its own cached copy of that value, so it needs to be told explicitly, or it
    // keeps showing the stale count until something else happens to refresh it.
    if (const ConfigOptionDef* opt_def = m_config->def()->get(opt_key);
        opt_def && opt_def->is_plugin_backed()) {
        m_config->update_plugin_manifest();
        const std::string overrides_key = Preset::plugin_overrides_key(m_type);
        if (prune_stale_plugin_overrides(*m_config, overrides_key)) {
            if (Field* overrides_field = get_field(overrides_key))
                overrides_field->set_value(boost::any(m_config->opt_string(overrides_key)), false);
        }
    }
 
    if (opt_key == "gcode_flavor" && m_type == Preset::TYPE_PRINTER) {
        if (auto printer_tab = dynamic_cast<TabPrinter*>(this))
            printer_tab->on_gcode_flavor_changed();
    }
 
    if (opt_key == "bed_exclude_volume_mode" && m_type == Preset::TYPE_PRINTER &&
        m_config->opt_enum<BedExcludeVolumeMode>("bed_exclude_volume_mode") == BedExcludeVolumeMode::PerExtruder) {
        auto *per_extruder = m_config->option<ConfigOptionStrings>("extruder_bed_exclude_volumes");
        const auto *shared = m_config->option<ConfigOptionString>("bed_exclude_volumes");
        const size_t extruder_count = m_config->option<ConfigOptionFloats>("nozzle_diameter")->size();
        const bool definitions_empty = per_extruder == nullptr ||
            std::all_of(per_extruder->values.begin(), per_extruder->values.end(), [](const std::string &entry) { return entry.empty(); });
 
        if (definitions_empty && shared != nullptr && extruder_count > 0) {
            const std::string serialized = shared->value;
            const bool valid_shared_definition =
                is_valid_bed_exclude_volumes_string(serialized, std::numeric_limits<double>::max());
            DynamicPrintConfig new_conf = *m_config;
            new_conf.set_key_value("extruder_bed_exclude_volumes",
                new ConfigOptionStrings(std::vector<std::string>(extruder_count, valid_shared_definition ? serialized : std::string{})));
            m_config_manipulation.apply(m_config, &new_conf);
        }
    }
 
    if (opt_key == "compatible_prints")
        this->compatible_widget_reload(m_compatible_prints);
    if (opt_key == "compatible_printers")
        this->compatible_widget_reload(m_compatible_printers);
 
    const bool is_fff = supports_printer_technology(ptFFF);
    ConfigOptionsGroup* og_freq_chng_params = wxGetApp().sidebar().og_freq_chng_params(is_fff);
    //BBS: GUI refactor
    if (og_freq_chng_params) {
        if (opt_key == "sparse_infill_density" || opt_key == "pad_enable")
        {
            boost::any val = og_freq_chng_params->get_config_value(*m_config, opt_key);
            og_freq_chng_params->set_value(opt_key, val);
        }
 
        if (opt_key == "pad_around_object") {
            for (PageShp& pg : m_pages) {
                Field* fld = pg->get_field(opt_key); 
                if (fld) fld->set_value(value, false);
            }
        }
 
        if (is_fff ?
            (opt_key == "enable_support" || opt_key == "support_type" || opt_key == "support_on_build_plate_only") :
            (opt_key == "supports_enable" || opt_key == "support_buildplate_only"))
            og_freq_chng_params->set_value("support", support_combo_value_for_config(*m_config, is_fff));
 
        if (!is_fff && (opt_key == "pad_enable" || opt_key == "pad_around_object"))
            og_freq_chng_params->set_value("pad", pad_combo_value_for_config(*m_config));
 
        if (opt_key == "brim_width")
        {
            bool val = m_config->opt_float("brim_width") > 0.0 ? true : false;
            og_freq_chng_params->set_value("brim", val);
        }
    }
 
    if (opt_key == "single_extruder_multi_material" || opt_key == "extruders_count" )
        update_wiping_button_visibility();
 
 
    if (opt_key == "pellet_flow_coefficient")
    {
        double double_value = Preset::convert_pellet_flow_to_filament_diameter(boost::any_cast<double>(value));
        m_config->set_key_value("filament_diameter", new ConfigOptionFloats{double_value});
  }
 
    if (opt_key == "filament_diameter") {
        double double_value = Preset::convert_filament_diameter_to_pellet_flow(boost::any_cast<double>(value));
        m_config->set_key_value("pellet_flow_coefficient", new ConfigOptionFloats{double_value});
    }
 
 
    if (opt_key == "single_extruder_multi_material"  ){
        wxGetApp().sidebar().show_SEMM_buttons();
        wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
    }
 
    if(opt_key == "purge_in_prime_tower")
        wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
 
 
    if (opt_key == "enable_prime_tower") {
        auto timelapse_type = m_config->option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
        bool timelapse_enabled = timelapse_type->value == TimelapseType::tlSmooth;
        if (!boost::any_cast<bool>(value)) {
            // Disabling the prime tower on a multi-nozzle printer degrades quality because nozzle changes rely
            // on it. Gate on any extruder having extruder_max_nozzle_count > 1 so single-nozzle and dual-extruder
            // (H2D, {1,1}) printers keep their exact existing behavior.
            // Orca: gate on any_of(count > 1) rather than the sum of counts >= 2. The sum form would also fire for
            // H2D ({1,1} sums to 2); any_of(>1) preserves H2D's current no-dialog behavior.
            auto *max_nozzle_counts_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
            const bool has_multiple_nozzle = max_nozzle_counts_opt &&
                std::any_of(max_nozzle_counts_opt->values.begin(), max_nozzle_counts_opt->values.end(),
                            [](int v) { return v > 1 && v != ConfigOptionIntsNullable::nil_value(); });
            if (has_multiple_nozzle) {
                MessageDialog dlg(wxGetApp().plater(),
                    _L("Prime tower is required for nozzle changing. There may be flaws on the model without prime tower. Are you sure you want to disable prime tower?"),
                    _L("Warning"), wxICON_WARNING | wxYES | wxNO);
                if (dlg.ShowModal() == wxID_NO) {
                    DynamicPrintConfig new_conf = *m_config;
                    new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(true));
                    m_config_manipulation.apply(m_config, &new_conf);
                }
            }
        }
        bool enable_wrapping = m_config->option<ConfigOptionBool>("enable_wrapping_detection")->value;
        if (!boost::any_cast<bool>(value) && (timelapse_enabled || enable_wrapping)) {
            bool set_enable_prime_tower = false;
            if (timelapse_enabled) {
                MessageDialog dlg(wxGetApp().plater(), _L("A prime tower is required for smooth timelapse mode. There may be flaws on the model without a prime tower. Are you sure you want to disable the prime tower\?"),
                                  _L("Warning"), wxICON_WARNING | wxYES | wxNO);
                if (dlg.ShowModal() == wxID_NO) {
                    DynamicPrintConfig new_conf = *m_config;
                    new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(true));
                    m_config_manipulation.apply(m_config, &new_conf);
                    set_enable_prime_tower = true;
                }
            }
            if (enable_wrapping && !set_enable_prime_tower) {
                MessageDialog dlg(wxGetApp().plater(),
                        _L("A prime tower is required for clumping detection. There may be flaws on the model without prime tower. Are you sure you want to disable prime tower?"),
                        _L("Warning"), wxICON_WARNING | wxYES | wxNO);
                if (dlg.ShowModal() == wxID_NO) {
                    DynamicPrintConfig new_conf = *m_config;
                    new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(true));
                    m_config_manipulation.apply(m_config, &new_conf);
                    set_enable_prime_tower = true;
                }
            }
            wxGetApp().plater()->update();
        }
        bool is_precise_z_height = m_config->option<ConfigOptionBool>("precise_z_height")->value;
        if (boost::any_cast<bool>(value) && is_precise_z_height) {
            MessageDialog dlg(wxGetApp().plater(), _L("Enabling both precise Z height and the prime tower may cause slicing errors. Do you still want to enable?"),
                _L("Warning"), wxICON_WARNING | wxYES | wxNO);
            if (dlg.ShowModal() == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(false));
                m_config_manipulation.apply(m_config, &new_conf);
            }
            wxGetApp().plater()->update();
        }
        update_wiping_button_visibility();
    }
 
 
    if (opt_key == "single_extruder_multi_material"  ){
        wxGetApp().sidebar().show_SEMM_buttons();
        wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
    }
 
    if(opt_key == "purge_in_prime_tower")
        wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
 
    if (opt_key == "enable_wrapping_detection") {
        bool wipe_tower_enabled = m_config->option<ConfigOptionBool>("enable_prime_tower")->value;
        if (boost::any_cast<bool>(value) && !wipe_tower_enabled) {
            MessageDialog dlg(wxGetApp().plater(),
                              _L("A prime tower is required for clumping detection. There may be flaws on the model without prime tower. Do you still want to enable clumping detection?"),
                              _L("Warning"), wxICON_WARNING | wxYES | wxNO);
            if (dlg.ShowModal() == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("enable_wrapping_detection", new ConfigOptionBool(false));
                m_config_manipulation.apply(m_config, &new_conf);
                wxGetApp().plater()->update();
            }
        } else {
            wxGetApp().plater()->update();
        }
    }
 
    if (opt_key == "precise_z_height") {
        bool wipe_tower_enabled = m_config->option<ConfigOptionBool>("enable_prime_tower")->value;
        if (boost::any_cast<bool>(value) && wipe_tower_enabled) {
            MessageDialog dlg(wxGetApp().plater(), _L("Enabling both precise Z height and the prime tower may cause slicing errors. Do you still want to enable precise Z height?"),
                _L("Warning"), wxICON_WARNING | wxYES | wxNO);
            if (dlg.ShowModal() == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("precise_z_height", new ConfigOptionBool(false));
                m_config_manipulation.apply(m_config, &new_conf);
            }
            wxGetApp().plater()->update();
        }
    }
 
    // reload scene to update timelapse wipe tower
    if (opt_key == "timelapse_type") {
        // Smooth timelapse parks the nozzle on the prime tower every layer, so it needs a tower on
        // every layer. That is exactly what "No sparse layers" removes, and with both on the tower is
        // planned full height and then dropped on emission. Drop "No sparse layers" and tell the user.
        if (boost::any_cast<int>(value) == (int) TimelapseType::tlSmooth && m_config->opt_bool("wipe_tower_no_sparse_layers")) {
            MessageDialog dlg(wxGetApp().plater(),
                              _L("Smooth timelapse needs a prime tower on every layer, which is not compatible with \"No sparse layers\". "
                                 "\"No sparse layers\" has been turned off."),
                              _L("Warning"), wxICON_WARNING | wxOK);
            dlg.ShowModal();
            DynamicPrintConfig new_conf = *m_config;
            new_conf.set_key_value("wipe_tower_no_sparse_layers", new ConfigOptionBool(false));
            m_config_manipulation.apply(m_config, &new_conf);
        }
 
        bool wipe_tower_enabled = m_config->option<ConfigOptionBool>("enable_prime_tower")->value;
        if (!wipe_tower_enabled && boost::any_cast<int>(value) == (int)TimelapseType::tlSmooth) {
            MessageDialog dlg(wxGetApp().plater(), _L("A prime tower is required for smooth timelapse mode. There may be flaws on the model without prime tower. Do you want to enable the prime tower\?"),
                              _L("Warning"), wxICON_WARNING | wxYES | wxNO);
            if (dlg.ShowModal() == wxID_YES) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("enable_prime_tower", new ConfigOptionBool(true));
                m_config_manipulation.apply(m_config, &new_conf);
                wxGetApp().plater()->update();
            }
        } else {
            wxGetApp().plater()->update();
        }
    }
 
    // Mirror of the timelapse_type branch above: enabling "No sparse layers" while smooth timelapse
    // is active would leave the tower on every layer anyway, so fall back to traditional timelapse.
    if (opt_key == "wipe_tower_no_sparse_layers" && boost::any_cast<bool>(value)) {
        auto timelapse_type = m_config->option<ConfigOptionEnum<TimelapseType>>("timelapse_type");
        if (timelapse_type && timelapse_type->value == TimelapseType::tlSmooth) {
            MessageDialog dlg(wxGetApp().plater(),
                              _L("\"No sparse layers\" is not compatible with smooth timelapse, which needs a prime tower on every layer. "
                                 "Timelapse has been switched to traditional mode."),
                              _L("Warning"), wxICON_WARNING | wxOK);
            dlg.ShowModal();
            DynamicPrintConfig new_conf = *m_config;
            new_conf.set_key_value("timelapse_type", new ConfigOptionEnum<TimelapseType>(TimelapseType::tlTraditional));
            m_config_manipulation.apply(m_config, &new_conf);
            wxGetApp().plater()->update();
        }
    }
 
    if (opt_key == "print_sequence" && m_config->opt_enum<PrintSequence>("print_sequence") == PrintSequence::ByObject) {
        auto printer_structure_opt = m_preset_bundle->printers.get_edited_preset().config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
        if (printer_structure_opt && printer_structure_opt->value == PrinterStructure::psI3) {
            wxString msg_text = _(L("The current printer does not support timelapse in Traditional Mode when printing By-Object."));
            msg_text += "\n\n" + _(L("Still print by object?"));
 
            MessageDialog dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxYES | wxNO);
            auto          answer = dialog.ShowModal();
            if (answer == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("print_sequence", new ConfigOptionEnum<PrintSequence>(PrintSequence::ByLayer));
                m_config_manipulation.apply(m_config, &new_conf);
                wxGetApp().plater()->update();
            }
        }
    }
 
    // BBS set support style to default when support type changes
    // Orca: do this only in simple mode
    if (opt_key == "support_type" && m_mode == comSimple) {
        DynamicPrintConfig new_conf = *m_config;
        new_conf.set_key_value("support_style", new ConfigOptionEnum<SupportMaterialStyle>(smsDefault));
        m_config_manipulation.apply(m_config, &new_conf);
    }
 
    if (opt_key == "support_filament") {
        int filament_id           = m_config->opt_int("support_filament") - 1; // the displayed id is based from 1, while internal id is based from 0
        int interface_filament_id = m_config->opt_int("support_interface_filament") - 1;
        if (is_support_filament(filament_id, false) && !is_soluble_filament(filament_id) && !has_filaments({"TPU", "TPU-AMS"})) {
            wxString           msg_text = _L("Non-soluble support materials are not recommended for support base.\n"
                                                       "Are you sure to use them for support base?\n");
            MessageDialog      dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxYES | wxNO);
            DynamicPrintConfig new_conf = *m_config;
            if (dialog.ShowModal() == wxID_NO) {
                new_conf.set_key_value("support_filament", new ConfigOptionInt(0));
                m_config_manipulation.apply(m_config, &new_conf);
                on_value_change(opt_key, 0);
            }
            wxGetApp().plater()->update();
        }
    }
 
    // BBS popup a message to ask the user to set optimum parameters for support interface if support materials are used
    if (opt_key == "support_interface_filament") {
        int filament_id           = m_config->opt_int("support_filament") - 1;
        int interface_filament_id = m_config->opt_int("support_interface_filament") - 1; // the displayed id is based from 1, while internal id is based from 0
        if ((is_support_filament(interface_filament_id, false) &&
             !(m_config->opt_float("support_top_z_distance") == 0 && m_config->opt_float("support_interface_spacing") == 0 &&
               m_config->opt_enum<SupportMaterialInterfacePattern>("support_interface_pattern") == SupportMaterialInterfacePattern::smipRectilinearInterlaced)) ||
            (is_soluble_filament(interface_filament_id) && !is_soluble_filament(filament_id))) {
            wxString msg_text;
            if (!is_soluble_filament(interface_filament_id)) {
                msg_text = _L("When using support material for the support interface, we recommend the following settings:\n"
                              "0 top Z distance, 0 interface spacing, interlaced rectilinear pattern and disable independent support layer height.");
                msg_text += "\n\n" + _L("Change these settings automatically\?\nYes - Change these settings automatically.\nNo  - Do not change these settings for me.");
            } else {
                msg_text = _L("When using soluble material for the support interface, we recommend the following settings:\n"
                              "0 top Z distance, 0 interface spacing, interlaced rectilinear pattern, disable independent support layer height\n"
                              "and use soluble materials for both support interface and support base.");
                msg_text += "\n\n" + _L("Change these settings automatically\?\nYes - Change these settings automatically.\nNo  - Do not change these settings for me.");
            }
            MessageDialog      dialog(wxGetApp().plater(), msg_text, _L("Suggestion"), wxICON_WARNING | wxYES | wxNO);
            DynamicPrintConfig new_conf = *m_config;
            if (dialog.ShowModal() == wxID_YES) {
                auto &filament_presets = Slic3r::GUI::wxGetApp().preset_bundle->filament_presets;
                auto &filaments        = Slic3r::GUI::wxGetApp().preset_bundle->filaments;
                Slic3r::Preset *filament         = filaments.find_preset(filament_presets[interface_filament_id]);
                std::string     filament_type    = filament->config.option<ConfigOptionStrings>("filament_type")->values[0];
 
                new_conf.set_key_value("support_top_z_distance", new ConfigOptionFloat(0));
                new_conf.set_key_value("support_interface_spacing", new ConfigOptionFloat(0));
                new_conf.set_key_value("support_interface_pattern", new ConfigOptionEnum<SupportMaterialInterfacePattern>(SupportMaterialInterfacePattern::smipRectilinearInterlaced));
                new_conf.set_key_value("independent_support_layer_height", new ConfigOptionBool(false));
                if ((filament_type == "PLA" && has_filaments({"TPU", "TPU-AMS"})) || (is_soluble_filament(interface_filament_id) && !is_soluble_filament(filament_id)))
                    new_conf.set_key_value("support_filament", new ConfigOptionInt(interface_filament_id + 1));
                m_config_manipulation.apply(m_config, &new_conf);
            }
            wxGetApp().plater()->update();
        }
    }
 
    if(opt_key == "make_overhang_printable"){
        if(m_config->opt_bool("make_overhang_printable")){
            wxString msg_text = _(
                L("Enabling this option will modify the model's shape. If your print requires precise dimensions or is part of an "
                  "assembly, it's important to double-check whether this change in geometry impacts the functionality of your print."));
            msg_text += "\n\n" + _(L("Are you sure you want to enable this option?"));
            MessageDialog dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxYES | wxNO);
            dialog.SetButtonLabel(wxID_YES, _L("Enable"));
            dialog.SetButtonLabel(wxID_NO, _L("Cancel"));
            if (dialog.ShowModal() == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("make_overhang_printable", new ConfigOptionBool(false));
                m_config_manipulation.apply(m_config, &new_conf);
                wxGetApp().plater()->update();
            }
        }
    }
 
    if (opt_key == "sparse_infill_rotate_template") {
        // Orca: show warning dialog if rotate template for solid infill if not support
        const auto _sparse_infill_pattern = m_config->option<ConfigOptionEnum<InfillPattern>>("sparse_infill_pattern")->value;
        bool       is_safe_to_rotate      = _sparse_infill_pattern == ipRectilinear || _sparse_infill_pattern == ipLine ||
                                 _sparse_infill_pattern == ipZigZag || _sparse_infill_pattern == ipCrossZag ||
                                 _sparse_infill_pattern == ipLockedZag;
 
        auto new_value = boost::any_cast<std::string>(value);
        is_safe_to_rotate = is_safe_to_rotate || new_value.empty();
        const bool had_previous_value = !m_last_sparse_infill_rotate_template_value.empty();
 
        if (!is_safe_to_rotate && !had_previous_value) {
            wxString msg_text = _(
                L("Infill patterns are typically designed to handle rotation automatically to ensure proper printing and achieve their "
                  "intended effects (e.g., Gyroid, Cubic). Rotating the current sparse infill pattern may lead to insufficient support. "
                  "Please proceed with caution and thoroughly check for any potential printing issues. "
                  "Are you sure you want to enable this option?"));
            msg_text += "\n\n" + _(L("Are you sure you want to enable this option?"));
            MessageDialog dialog(wxGetApp().plater(), msg_text, "", wxICON_WARNING | wxYES | wxNO);
            dialog.SetButtonLabel(wxID_YES, _L("Enable"));
            dialog.SetButtonLabel(wxID_NO, _L("Cancel"));
            if (dialog.ShowModal() == wxID_NO) {
                DynamicPrintConfig new_conf = *m_config;
                new_conf.set_key_value("sparse_infill_rotate_template", new ConfigOptionString(""));
                m_config_manipulation.apply(m_config, &new_conf);
                wxGetApp().plater()->update();
            }
        }
 
        m_last_sparse_infill_rotate_template_value = m_config->opt_string("sparse_infill_rotate_template");
    }
 
    if (opt_key == "layer_height") {
        if (m_config_manipulation.check_layer_height(m_config))
            wxGetApp().plater()->update();
    }
 
    std::string opt_key_without_idx = opt_key.substr(0, opt_key.find('#'));
 
    if (opt_key_without_idx == "long_retractions_when_cut") {
        unsigned char activate = boost::any_cast<unsigned char>(value);
        if (activate == 1) {
            MessageDialog dialog(wxGetApp().plater(),
                _L("Experimental feature: Retracting and cutting off the filament at a greater distance during filament changes to minimize flush. "
                    "Although it can notably reduce flush, it may also elevate the risk of nozzle clogs or other printing complications."), "", wxICON_WARNING | wxOK);
            dialog.ShowModal();
        }
        if (wxGetApp().app_config->get("auto_calculate_flush") == "all"){
            wxGetApp().plater()->sidebar().auto_calc_flushing_volumes(-1);
        }
    }
 
    if (opt_key == "filament_long_retractions_when_cut"){
        unsigned char activate = boost::any_cast<unsigned char>(value);
        if (activate == 1) {
            MessageDialog dialog(wxGetApp().plater(),
                _L("Experimental feature: Retracting and cutting off the filament at a greater distance during filament changes to minimize flush. "
                   "Although it can notably reduce flush, it may also elevate the risk of nozzle clogs or other printing complications. "
                   "Please use with the latest printer firmware."), "", wxICON_WARNING | wxOK);
            dialog.ShowModal();
        }
        if (wxGetApp().app_config->get("auto_calculate_flush") == "all"){
            wxGetApp().plater()->sidebar().auto_calc_flushing_volumes(-1);
        }
    }
 
 
    //Orca: sync filament num if it's a multi tool printer
    if (opt_key == "extruders_count" && !m_config->opt_bool("single_extruder_multi_material")){
        const size_t num_extruder = boost::any_cast<size_t>(value);
        auto        *bundle       = wxGetApp().preset_bundle;
        Sidebar     &sidebar      = wxGetApp().plater()->sidebar();
        // A tool changer feeds filament N from nozzle N, so the extruder count sizes the physical
        // run only; mixed slots are virtual and keep the tail. Go one slot at a time through the
        // sidebar's own +/- calls: they insert ahead of the mixed tail and renumber filament ids,
        // painted facets, custom g-code and mixed components, which a bulk resize clamps away.
        // Both also refresh the print tab and export the selections, so nothing to do afterwards.
        size_t physical = bundle->num_physical_filaments();
        while (physical != num_extruder) {
            if (physical < num_extruder)
                sidebar.add_custom_filament(Plater::get_next_color_for_filament());
            else
                sidebar.delete_filament(physical - 1);   // physical > num_extruder >= 1
            const size_t updated = bundle->num_physical_filaments();
            if (updated == physical)
                break;   // the call declined, e.g. the total slot limit - do not spin
            physical = updated;
        }
    }
 
    //Orca: disable purge_in_prime_tower if single_extruder_multi_material is disabled
    if (opt_key == "single_extruder_multi_material" && m_config->opt_bool("single_extruder_multi_material") == false){
        DynamicPrintConfig new_conf = *m_config;
        new_conf.set_key_value("purge_in_prime_tower", new ConfigOptionBool(false));
        m_config_manipulation.apply(m_config, &new_conf);
    }
 
    if (opt_key.find("nozzle_volume_type") != std::string::npos) {
        int extruder_idx = std::atoi(opt_key.substr(opt_key.find_last_of('#') + 1).c_str());
        update_all_extruder_variants(extruder_idx);
        if (wxGetApp().app_config->get("auto_calculate_flush") == "all") {
            wxGetApp().plater()->sidebar().auto_calc_flushing_volumes(-1,extruder_idx);
        }
    }
 
    // Orca: allow different layer height for non-bbl printers
    // TODO: allow this for BBL printers too?
    if (m_preset_bundle->get_printer_extruder_count() > 1 && m_preset_bundle->is_bbl_vendor()) {
        int extruder_idx = std::atoi(opt_key.substr(opt_key.find_last_of('#') + 1).c_str());
        if (opt_key.find("min_layer_height") != std::string::npos) {
            auto min_layer_height_from_nozzle = m_preset_bundle->full_config().option<ConfigOptionFloats>("min_layer_height")->values;
            if (extruder_idx < min_layer_height_from_nozzle.size()) {
                double value = min_layer_height_from_nozzle[extruder_idx];
                std::fill(min_layer_height_from_nozzle.begin(), min_layer_height_from_nozzle.end(), value);
            }
            auto new_conf = *m_config;
            new_conf.set_key_value("min_layer_height", new ConfigOptionFloats(min_layer_height_from_nozzle));
            m_config_manipulation.apply(m_config, &new_conf);
        }
        else if (opt_key.find("max_layer_height") != std::string::npos) {
            auto max_layer_height_from_nozzle = m_preset_bundle->full_config().option<ConfigOptionFloats>("max_layer_height")->values;
            if (extruder_idx < max_layer_height_from_nozzle.size()) {
                double value = max_layer_height_from_nozzle[extruder_idx];
                std::fill(max_layer_height_from_nozzle.begin(), max_layer_height_from_nozzle.end(), value);
            }
            auto new_conf = *m_config;
            new_conf.set_key_value("max_layer_height", new ConfigOptionFloats(max_layer_height_from_nozzle));
            m_config_manipulation.apply(m_config, &new_conf);
        }
    }
 
    if (opt_key == "parallel_printheads_count" || opt_key == "parallel_printheads_bed_exclude_areas") {
        if (m_config->opt_bool("support_parallel_printheads")) {
            const int count = opt_key == "parallel_printheads_count" ? boost::any_cast<int>(value) : m_config->opt_int("parallel_printheads_count");
            if (auto *field = this->get_field("bed_exclude_area")) {
                wxString exclude_area;
                if (count > 0) {
                    if (const auto *areas = m_config->option<ConfigOptionStrings>("parallel_printheads_bed_exclude_areas");
                        areas != nullptr) {
                        const size_t index = static_cast<size_t>(count - 1);
                        if (index < areas->values.size())
                            exclude_area = wxString::FromUTF8(areas->values[index]);
                    }
                }
 
                field->set_value(exclude_area, true);
                field->propagate_value();
            }
        }
    }
 
    if (m_postpone_update_ui) {
        // It means that not all values are rolled to the system/last saved values jet.
        // And call of the update() can causes a redundant check of the config values,
        return;
    }
 
    update();
    if(m_active_page)
        m_active_page->update_visibility(m_mode, true);
    m_page_view->GetParent()->Layout();
 
    // 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 _, _L, Slic3r::GUI::Sidebar::add_custom_filament(), Slic3r::append_bed_exclude_volumes(), Slic3r::ByLayer, Slic3r::ByObject, compatible_widget_reload(), Slic3r::comSimple, Slic3r::Preset::config, Slic3r::ConfigOptionFloat, Slic3r::ConfigOptionString, Slic3r::Preset::convert_filament_diameter_to_pellet_flow(), Slic3r::Preset::convert_pellet_flow_to_filament_diameter(), count, Slic3r::GUI::Sidebar::delete_filament(), Slic3r::filament_type(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), get_field(), Slic3r::GUI::Plater::get_next_color_for_filament(), Slic3r::GUI::has_filaments(), Slic3r::ipCrossZag, Slic3r::ipLine, Slic3r::ipLockedZag, Slic3r::ipRectilinear, Slic3r::ipZigZag, Slic3r::is_bed_exclusion_volume_syntax(), Slic3r::GUI::is_soluble_filament(), Slic3r::GUI::is_support_filament(), Slic3r::is_valid_bed_exclude_volumes_string(), L, Slic3r::load_config(), m_active_page, m_compatible_printers, m_compatible_prints, m_config, m_config_manipulation, m_last_sparse_infill_rotate_template_value, m_mode, m_page_view, m_pages, m_postpone_update_ui, m_preset_bundle, m_type, Slic3r::max_layer_height_from_nozzle(), Slic3r::min_layer_height_from_nozzle(), on_presets_changed(), on_value_change(), Slic3r::ConfigBase::option(), Slic3r::GUI::pad_combo_value_for_config(), Slic3r::PerExtruder, Slic3r::GUI::plater(), Slic3r::Preset::plugin_overrides_key(), Slic3r::printable_height(), Slic3r::prune_stale_plugin_overrides(), Slic3r::psI3, Slic3r::ptFFF, reload_config(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::Field::set_value(), Slic3r::GUI::OptionsGroup::set_value(), Slic3r::GUI::MsgDialog::SetButtonLabel(), Slic3r::GUI::show_error(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::smipRectilinearInterlaced, Slic3r::smsDefault, Slic3r::GUI::support_combo_value_for_config(), supports_printer_technology(), Slic3r::tlSmooth, Slic3r::tlTraditional, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, update(), Slic3r::GUI::update_all_extruder_variants(), update_wiping_button_visibility(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by get_config_manipulation(), on_value_change(), Slic3r::GUI::TabFilament::on_value_change(), Slic3r::GUI::TabPrinter::on_value_change(), Slic3r::GUI::TabPrintModel::on_value_change(), 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:

OnActivate()

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

virtual

{
    //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

)

{
    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

)

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

{
    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

{
    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

(

)

{
    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

inline

{ 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 )

{
    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

(

)

{
    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

(

)

{
    // 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::Tab::reload_config ( )

virtual

Reimplemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabPrintModel, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

{
    if (m_active_page)
        m_active_page->reload_config();
    if (m_type == Preset::TYPE_PRINT && m_config != nullptr)
        m_last_sparse_infill_rotate_template_value = m_config->opt_string("sparse_infill_rotate_template");
}

References m_active_page, m_config, m_last_sparse_infill_rotate_template_value, m_type, reload_config(), and Slic3r::Preset::TYPE_PRINT.

Referenced by apply_preset_config_values(), create_preset_tab(), get_config_manipulation(), load_config(), load_current_preset(), on_value_change(), reload_config(), Slic3r::GUI::TabFilament::reload_config(), Slic3r::GUI::TabPrint::reload_config(), Slic3r::GUI::TabPrinter::reload_config(), Slic3r::GUI::TabSLAMaterial::reload_config(), Slic3r::GUI::TabSLAPrint::reload_config(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::reload_local_bundle(), switch_excluder(), and sync_excluder().

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

(

)

{
    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 = "" )

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

{ 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 )

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_custom_gcode()

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

virtual

Reimplemented in Slic3r::GUI::TabFilament.

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

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

Referenced by edit_custom_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

set_expanded()

void Slic3r::GUI::Tab::set_expanded

(

bool

value

)

{
    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

)

{
    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 )

{
    // 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 ( )

protected

{
    // --- 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 ( )

protected

{
    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

{
    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

(

)

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

virtual bool Slic3r::GUI::Tab::supports_printer_technology ( const PrinterTechnology tech ) const

pure virtual

Implemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

References parent(), and style.

Referenced by on_value_change(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::require_tab(), and update_frequently_changed_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_excluder()

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

{
    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

(

)

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

virtual

{
    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

inline

{ 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 )

{
    // 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 )

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

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

pure virtual

Implemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

Referenced by activate_selected_page(), create_preset_tab(), switch_excluder(), and update_mode().

Here is the caller graph for this function:

toggle_show_hide_incompatible()

void Slic3r::GUI::Tab::toggle_show_hide_incompatible

(

)

{
    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 )

{
    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 )

static

{
    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 )

protected

{
    // 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

inline

{ 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

(

)

{
    // 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()

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

pure virtual

Implemented in Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrint, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

Referenced by apply_preset_config_values(), edit_custom_gcode(), get_config_manipulation(), load_config(), load_current_preset(), load_key_value(), on_roll_back_value(), on_value_change(), sync_excluder(), and Slic3r::GUI::Sidebar::update_presets().

Here is the caller graph for this function:

update_all_extruder_options_status()

void Slic3r::GUI::Tab::update_all_extruder_options_status

(

)

{
    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

(

)

{
    // 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

(

)

{
    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

(

)

{
    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

)

{
    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 )

inlinevirtual

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

virtual

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_dirty()

void Slic3r::GUI::Tab::update_dirty

(

)

{
    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

(

)

{
    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 )

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

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

protected

{
    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

(

)

{
    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

(

)

{
    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

(

)

{
    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

(

)

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

protected

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

protected

update_saved_preset_from_current_preset()

void Slic3r::GUI::Tab::update_saved_preset_from_current_preset

(

)

{ 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

(

)

{
    //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

)

{
    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

(

)

{
    // 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

)

{
    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

(

)

{
    // 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

(

)

{
    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

(

)

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_wiping_button_visibility()

void Slic3r::GUI::Tab::update_wiping_button_visibility

(

)

                                          {
    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 )

static

{
    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

(

)

{
    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

(

)

{
    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

{
    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:

Friends And Related Symbol Documentation

EditGCodeDialog

friend class EditGCodeDialog

friend

References EditGCodeDialog.

Referenced by edit_custom_gcode(), and EditGCodeDialog.

PublishSettingsDialog

friend class PublishSettingsDialog

friend

References PublishSettingsDialog.

Referenced by PublishSettingsDialog.

Member Data Documentation

m_active_page

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

protected

{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

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

protected

Referenced by check_extruder_options_status(), and update_all_extruder_options_status().

m_bmp_edit_value

ScalableBitmap Slic3r::GUI::Tab::m_bmp_edit_value

protected

Referenced by create_preset_tab(), and decorate().

m_bmp_hide_incompatible_presets

ScalableBitmap Slic3r::GUI::Tab::m_bmp_hide_incompatible_presets

protected

Referenced by create_preset_tab().

m_bmp_non_system

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

protected

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

protected

Referenced by create_preset_tab().

m_bmp_value_lock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_lock

protected

Referenced by create_preset_tab(), and decorate().

m_bmp_value_revert

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_revert

protected

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

m_bmp_value_unlock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_unlock

protected

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

protected

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

protected

m_btn_delete_preset

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

protected

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

protected

Referenced by create_preset_tab().

m_btn_search

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

protected

Referenced by create_preset_tab().

m_cache_config

DynamicPrintConfig Slic3r::GUI::Tab::m_cache_config

protected

Referenced by apply_config_from_cache(), and cache_config_diff().

m_cache_options

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

protected

Referenced by apply_config_from_cache(), and cache_config_diff().

m_category_icon

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

protected

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

m_compatible_printers

PresetDependencies Slic3r::GUI::Tab::m_compatible_printers

protected

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

protected

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 }

protected

{ false };

Referenced by completed(), and create_preset_tab().

m_config

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

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

protected

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

m_default_text_clr

wxColour Slic3r::GUI::Tab::m_default_text_clr

protected

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

protected

Referenced by on_presets_changed(), and select_preset().

m_detach_preset_btn

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

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}

protected

{false};

Referenced by create_preset_tab(), and rebuild_page_tree().

m_em_unit

int Slic3r::GUI::Tab::m_em_unit

protected

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

m_extruder_switch

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

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

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

m_extruder_sync

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

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

Referenced by create_preset_tab().

m_highlighter

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

protected

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

m_icon_count

int Slic3r::GUI::Tab::m_icon_count

protected

Referenced by add_options_page(), and create_preset_tab().

m_icon_index

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

protected

Referenced by add_options_page().

m_icons

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

protected

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

m_is_default_preset

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

protected

{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 }

protected

{ 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 }

protected

{ 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

protected

Referenced by show_timelapse_warning_dialog().

m_just_edit

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

protected

{false};

Referenced by save_preset(), and set_just_edit().

m_last_select_item

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

protected

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

protected

Referenced by on_value_change(), and reload_config().

m_main_sizer

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

protected

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

m_mode

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

protected

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

Referenced by create_preset_tab().

m_mode_view

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

Referenced by create_preset_tab(), and msw_rescale().

m_modified_label_clr

wxColour Slic3r::GUI::Tab::m_modified_label_clr

protected

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

protected

Referenced by set_type().

m_opt_status_value

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

protected

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

protected

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

m_page_switch_planned

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

protected

Referenced by create_preset_tab(), and tree_sel_change_delayed().

m_page_switch_running

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

protected

Referenced by create_preset_tab().

m_page_view

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

protected

{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

protected

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

protected

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

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}

protected

{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

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

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 }

protected

{ 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 = {}

protected

{};

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 = {}

protected

{};

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 = {}

protected

{};

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

m_search_input

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

protected

Referenced by create_preset_tab().

m_search_item

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

protected

Referenced by create_preset_tab().

m_select_sizer

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

protected

m_show_btn_incompatible_presets

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

Referenced by update_ui_from_settings().

m_show_incompatible_presets

bool Slic3r::GUI::Tab::m_show_incompatible_presets

protected

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

protected

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

m_tabctrl

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

protected

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

protected

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

m_top_left_sizer

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

protected

m_top_panel

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

protected

Referenced by create_preset_tab().

m_top_right_sizer

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

protected

m_top_sizer

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

protected

Referenced by create_preset_tab(), and msw_rescale().

m_tree_sizer

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

protected

m_tt_non_system

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

protected

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

protected

Referenced by decorate().

m_tt_value_revert

wxString Slic3r::GUI::Tab::m_tt_value_revert

protected

Referenced by decorate(), and set_tooltips_text().

m_tt_value_unlock

wxString Slic3r::GUI::Tab::m_tt_value_unlock

protected

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

protected

Referenced by create_line_with_widget(), and decorate().

m_ttg_non_system

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

protected

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

protected

m_ttg_value_revert

wxString Slic3r::GUI::Tab::m_ttg_value_revert

protected

m_ttg_value_unlock

wxString Slic3r::GUI::Tab::m_ttg_value_unlock

protected

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

protected

Referenced by update_undo_buttons().

m_ttg_white_bullet_ns

wxString Slic3r::GUI::Tab::m_ttg_white_bullet_ns

protected

Referenced by load_initial_data(), and update_ui_items_related_on_parent_preset().

m_type

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

protected

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

protected

Referenced by create_preset_tab(), and update_undo_buttons().

m_undo_to_sys_btn

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

protected

Referenced by create_preset_tab().

m_update_cnt

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

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

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

Referenced by create_preset_tab(), and update_variant_sizer_visibility().

validate_custom_gcodes_was_shown

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

{ 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