Slic3r::GUI::Tab Class Reference

#include <src/slic3r/GUI/Tab.hpp>

Inheritance diagram for Slic3r::GUI::Tab:

Collaboration diagram for Slic3r::GUI::Tab:

Classes
struct	PresetDependencies

Public Member Functions
	Tab (wxBookCtrlBase *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)
virtual void	load_current_preset ()
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	may_discard_current_dirty_preset (PresetCollection *presets=nullptr, const std::string &new_printer_name="")
virtual void	clear_pages ()
virtual void	update_description_lines ()
virtual void	activate_selected_page (std::function< void()> throw_if_canceled)
void	OnTreeSelChange (wxTreeEvent &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)
void	rename_preset ()
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	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 ()
void	emplace_option (const std::string &opt_key, bool respect_vec_values=false)
void	load_initial_data ()
void	update_dirty ()
void	update_tab_ui ()
void	load_config (const DynamicPrintConfig &config)
virtual void	reload_config ()
void	update_mode ()
void	update_mode_markers ()
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)
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 ()
DynamicPrintConfig *	get_config ()
PresetCollection *	get_presets ()
const PresetCollection *	get_presets () const
void	on_value_change (const std::string &opt_key, const boost::any &value)
void	update_wiping_button_visibility ()
void	activate_option (const std::string &opt_key, const wxString &category)
void	cache_config_diff (const std::vector< std::string > &selected_options, const DynamicPrintConfig *config=nullptr)
void	apply_config_from_cache ()
const std::map< wxString, std::string > &	get_category_icon_map ()
bool	validate_custom_gcodes ()

Static Public Member Functions
static wxString	translate_category (const wxString &title, Preset::Type preset_type)
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
DynamicPrintConfig *	m_config
ogStaticText *	m_parent_preset_description_line = nullptr
ScalableButton *	m_detach_preset_btn = nullptr
int	m_update_cnt = 0
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	tree_sel_change_delayed ()
void	on_presets_changed ()
void	build_preset_description_line (ConfigOptionsGroup *optgroup)
void	update_preset_description_line ()
void	update_frequently_changed_parameters ()
void	fill_icon_descriptions ()
void	set_tooltips_text ()
virtual bool	select_preset_by_name (const std::string &name_w_suffix, bool force)
virtual bool	save_current_preset (const std::string &new_name, bool detach)
virtual bool	delete_current_preset ()
ConfigManipulation	get_config_manipulation ()

Protected Attributes
Preset::Type	m_type
std::string	m_name
const wxString	m_title
TabPresetComboBox *	m_presets_choice
ScalableButton *	m_search_btn
ScalableButton *	m_btn_compare_preset
ScalableButton *	m_btn_save_preset
ScalableButton *	m_btn_rename_preset
ScalableButton *	m_btn_delete_preset
ScalableButton *	m_btn_edit_ph_printer {nullptr}
ScalableButton *	m_btn_hide_incompatible_presets
wxBoxSizer *	m_top_hsizer
wxBoxSizer *	m_hsizer
wxBoxSizer *	m_h_buttons_sizer
wxBoxSizer *	m_left_sizer
wxTreeCtrl *	m_treectrl
wxScrolledWindow *	m_page_view {nullptr}
wxBoxSizer *	m_page_sizer {nullptr}
ModeSizer *	m_mode_sizer {nullptr}
PresetDependencies	m_compatible_printers
PresetDependencies	m_compatible_prints
bool	m_is_default_preset {false}
ScalableButton *	m_undo_btn
ScalableButton *	m_undo_to_sys_btn
ScalableButton *	m_question_btn
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
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
std::vector< Preset::Type >	m_dependent_tabs
std::map< std::string, int >	m_options_list
int	m_opt_status_value = 0
std::vector< GUI_Descriptions::ButtonEntry >	m_icon_descriptions = {}
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 = comExpert
HighlighterForWx	m_highlighter
DynamicPrintConfig	m_cache_config
bool	m_page_switch_running = false
bool	m_page_switch_planned = false
ConfigManipulation	m_config_manipulation

Private Attributes
wxBookCtrlBase *	m_parent

Detailed Description

---

Class Documentation

Slic3r::GUI::Tab::PresetDependencies

struct Slic3r::GUI::Tab::PresetDependencies

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

Class Members
ScalableButton *	btn = nullptr
wxCheckBox *	checkbox = nullptr
wxString	dialog_label
wxString	dialog_title
string	key_condition
string	key_list
Type	type = Preset::TYPE_INVALID

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	(	wxBookCtrlBase *	parent,
		const wxString &	title,
		Preset::Type	type
	)

                                                                       :
    m_parent(parent), m_type(type), m_title(title)
{
    Create(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_LEFT | wxTAB_TRAVERSAL/*, name*/);
    this->SetFont(Slic3r::GUI::wxGetApp().normal_font());
 
    wxGetApp().UpdateDarkUI(this);
 
    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);
}

References _L, Slic3r::GUI::Tab::PresetDependencies::dialog_label, Slic3r::GUI::Tab::PresetDependencies::dialog_title, em_unit(), get_config_manipulation(), Slic3r::GUI::Tab::PresetDependencies::key_condition, Slic3r::GUI::Tab::PresetDependencies::key_list, m_compatible_printers, m_compatible_prints, m_config_manipulation, m_em_unit, m_highlighter, m_parent, parent(), Slic3r::GUI::Highlighter::set_timer_owner(), Slic3r::GUI::Tab::PresetDependencies::type, Slic3r::Preset::TYPE_PRINT, and Slic3r::Preset::TYPE_PRINTER.

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

{
    wxString page_title = translate_category(category, m_type);
 
    auto cur_item = m_treectrl->GetFirstVisibleItem();
    if (!cur_item)
        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
    wxGetApp().mainframe->select_tab(this);
 
    while (cur_item) {
        auto title = m_treectrl->GetItemText(cur_item);
        if (page_title != title) {
            cur_item = m_treectrl->GetNextVisible(cur_item);
            continue;
        }
 
        m_treectrl->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());
    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 Slic3r::GUI::Field::getWindow().

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

{
    if (!m_active_page)
        return;
 
    m_active_page->activate(m_mode, throw_if_canceled);
 
    if (m_active_page->title() == "Dependencies") {
        if (m_compatible_printers.checkbox)
            this->compatible_widget_reload(m_compatible_printers);
        if (m_compatible_prints.checkbox)
            this->compatible_widget_reload(m_compatible_prints);
    }
 
    update_changed_ui();
    update_description_lines();
    toggle_options();
}

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));
            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.
    PageShp page(new Page(m_page_view, title, icon_idx));
//  page->SetBackgroundStyle(wxBG_STYLE_SYSTEM);
#ifdef __WINDOWS__
//  page->SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    if (!is_extruder_pages)
        m_pages.push_back(page);
 
    page->set_config(m_config);
    return page;
}

Referenced by Slic3r::GUI::TabSLAMaterial::build(), and Slic3r::GUI::TabSLAPrint::build().

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);
}

Referenced by create_preset_tab().

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);
    m_scaled_buttons.push_back(*btn);
}

References style.

Referenced by create_preset_tab().

Here is the caller graph for this function:

apply_config_from_cache()

void Slic3r::GUI::Tab::apply_config_from_cache

(

)

{
    bool was_applied = false;
    // 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(m_cache_config);
        m_cache_config.clear();
 
        was_applied = true;
    }
 
    if (was_applied)
        update_dirty();
}

References Slic3r::Preset::TYPE_PRINTER.

Referenced by on_presets_changed().

Here is the caller graph for this function:

build()

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

pure virtual

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

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_open_sys", _L("Detach from system preset"), 
                                                 wxDefaultSize, wxDefaultPosition, wxBU_LEFT | wxBU_EXACTFIT);
        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 _, _L, Slic3r::GUI::OptionsGroup::append_line(), Slic3r::GUI::Line::append_widget(), Slic3r::GUI::Line::full_width, L, and wxEVT_BUTTON.

Referenced by Slic3r::GUI::TabSLAMaterial::build(), and Slic3r::GUI::TabSLAPrint::build().

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_config.apply_only(config ? *config : m_presets->get_edited_preset().config, selected_options);
}

Referenced by Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes().

Here is the caller graph for this function:

clear_pages()

void Slic3r::GUI::Tab::clear_pages ( )

virtual

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

{
    // invalidated highlighter, if any exists
    m_highlighter.invalidate();
    m_page_sizer->Clear(true);
    // clear pages from the controlls
    for (auto p : m_pages)
        p->clear();
 
    // 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;
}

Referenced by Slic3r::GUI::TabSLAPrint::clear_pages().

Here is the caller graph for this function:

compare_preset()

void Slic3r::GUI::Tab::compare_preset

(

)

{
    wxGetApp().mainframe->diff_dialog.show(m_type);
}

compatible_widget_create()

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

protected

{
    deps.checkbox = new wxCheckBox(parent, wxID_ANY, _(L("All")));
    deps.checkbox->SetFont(Slic3r::GUI::wxGetApp().normal_font());
    wxGetApp().UpdateDarkUI(deps.checkbox, false, true);
    deps.btn = new ScalableButton(parent, wxID_ANY, "printer", format_wxstr(" %s %s", _L("Set"), dots),
                                  wxDefaultSize, wxDefaultPosition, wxBU_LEFT | wxBU_EXACTFIT);
    deps.btn->SetFont(Slic3r::GUI::wxGetApp().normal_font());
    deps.btn->SetSize(deps.btn->GetBestSize());
 
    auto sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add((deps.checkbox), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add((deps.btn), 0, wxALIGN_CENTER_VERTICAL);
 
    deps.checkbox->Bind(wxEVT_CHECKBOX, ([this, &deps](wxCommandEvent e)
    {
        deps.btn->Enable(! deps.checkbox->GetValue());
        // All printers have been made compatible with this preset.
        if (deps.checkbox->GetValue())
            this->load_key_value(deps.key_list, std::vector<std::string> {});
        this->get_field(deps.key_condition)->toggle(deps.checkbox->GetValue());
        this->update_changed_ui();
    }) );
 
    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);
            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));
        }
 
        wxMultiChoiceDialog dlg(parent, deps.dialog_title, deps.dialog_label, 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] == preset_name) {
                        selections.Add(idx);
                        break;
                    }
        dlg.SetSelections(selections);
        std::vector<std::string> value;
        // Show the dialog.
        if (dlg.ShowModal() == wxID_OK) {
            selections.Clear();
            selections = dlg.GetSelections();
            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, Slic3r::GUI::Tab::PresetDependencies::btn, Slic3r::GUI::Tab::PresetDependencies::checkbox, Slic3r::GUI::Tab::PresetDependencies::dialog_label, Slic3r::GUI::Tab::PresetDependencies::dialog_title, Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), Slic3r::Preset::is_default, Slic3r::Preset::is_external, Slic3r::GUI::Tab::PresetDependencies::key_condition, Slic3r::GUI::Tab::PresetDependencies::key_list, L, Slic3r::Preset::name, Slic3r::PresetCollection::preset(), Slic3r::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::PresetCollection::size(), Slic3r::GUI::Tab::PresetDependencies::type, and wxEVT_BUTTON.

Here is the call 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, Slic3r::ConfigOptionVector< T >::empty(), Slic3r::GUI::Tab::PresetDependencies::key_condition, Slic3r::GUI::Tab::PresetDependencies::key_list, and Slic3r::GUI::Field::toggle().

Here is the call graph for this function:

completed()

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

inline

{ return m_completed; }

References m_completed.

Referenced by Slic3r::GUI::GUI_App::get_tab().

Here is the caller graph for this function:

create_line_with_widget()

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

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(), Slic3r::GUI::ConfigOptionsGroup::create_single_option_line(), Slic3r::GUI::Line::label_path, 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::TabSLAMaterial::build(), and Slic3r::GUI::TabSLAPrint::build().

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

(

)

{
#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    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__
 
    // preset chooser
    m_presets_choice = new TabPresetComboBox(panel, m_type);
    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
            std::string preset_name = m_presets_choice->GetString(selection).ToUTF8().data();
            select_preset(Preset::remove_suffix_modified(preset_name));
        }
    });
 
    auto color = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
 
    //buttons
    m_scaled_buttons.reserve(6);
    m_scaled_buttons.reserve(2);
 
    add_scaled_button(panel, &m_btn_compare_preset, "compare");
    add_scaled_button(panel, &m_btn_save_preset, "save");
    add_scaled_button(panel, &m_btn_rename_preset, "edit");
    add_scaled_button(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_button(panel, &m_btn_hide_incompatible_presets, "flag_green");
 
    //TRN Settings Tab: tooltip for toolbar button
    m_btn_compare_preset->SetToolTip(_L("Compare preset with another"));
    //TRN Settings Tab: tooltip for toolbar button
    m_btn_save_preset  ->SetToolTip(_L("Save preset"));
    //TRN Settings Tab: tooltip for toolbar button
    m_btn_rename_preset->SetToolTip(_L("Rename preset"));
    m_btn_rename_preset->Hide();
    //TRN Settings Tab: tooltip for toolbar button
    m_btn_delete_preset->SetToolTip(_(L("Delete 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%]"), "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  , "lock_closed");
    add_scaled_bitmap(this, m_bmp_value_unlock, "lock_open");
    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");
 
    fill_icon_descriptions();
    set_tooltips_text();
 
    add_scaled_button(panel, &m_undo_btn,        m_bmp_white_bullet.name());
    add_scaled_button(panel, &m_undo_to_sys_btn, m_bmp_white_bullet.name());
 
    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_question_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent) {
        GUI_Descriptions::Dialog dlg(this, m_icon_descriptions);
        if (dlg.ShowModal() == wxID_OK)
            wxGetApp().update_label_colours();
    });
    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();
 
#ifdef _MSW_DARK_MODE
    // Sizer with buttons for mode changing
    if (wxGetApp().tabs_as_menu())
#endif
        m_mode_sizer = new ModeSizer(panel, int (0.5*em_unit(this)));
 
    const float scale_factor = em_unit(this)*0.1;// GetContentScaleFactor();
    m_top_hsizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(m_top_hsizer, 0, wxEXPAND | wxBOTTOM | wxALIGN_CENTER_VERTICAL, 3);
    m_top_hsizer->Add(m_presets_choice, 0, wxLEFT | wxRIGHT | wxTOP | wxALIGN_CENTER_VERTICAL, 3);
    m_top_hsizer->AddSpacer(int(4*scale_factor));
 
    m_h_buttons_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_h_buttons_sizer->Add(m_btn_save_preset, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(4*scale_factor));
    m_h_buttons_sizer->Add(m_btn_rename_preset, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(4 * scale_factor));
    m_h_buttons_sizer->Add(m_btn_delete_preset, 0, wxALIGN_CENTER_VERTICAL);
    if (m_btn_edit_ph_printer) {
        m_h_buttons_sizer->AddSpacer(int(4 * scale_factor));
        m_h_buttons_sizer->Add(m_btn_edit_ph_printer, 0, wxALIGN_CENTER_VERTICAL);
    }
    m_h_buttons_sizer->AddSpacer(int(/*16*/8 * scale_factor));
    m_h_buttons_sizer->Add(m_btn_hide_incompatible_presets, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(8 * scale_factor));
    m_h_buttons_sizer->Add(m_question_btn, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(32 * scale_factor));
    m_h_buttons_sizer->Add(m_undo_to_sys_btn, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->Add(m_undo_btn, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(32 * scale_factor));
    m_h_buttons_sizer->Add(m_search_btn, 0, wxALIGN_CENTER_VERTICAL);
    m_h_buttons_sizer->AddSpacer(int(8*scale_factor));
    m_h_buttons_sizer->Add(m_btn_compare_preset, 0, wxALIGN_CENTER_VERTICAL);
 
    m_top_hsizer->Add(m_h_buttons_sizer, 1, wxEXPAND | wxALIGN_CENTRE_VERTICAL);
    m_top_hsizer->AddSpacer(int(16*scale_factor));
    // StretchSpacer has a strange behavior under OSX, so
    // There is used just additional sizer for m_mode_sizer with right alignment
    if (m_mode_sizer) {
        auto mode_sizer = new wxBoxSizer(wxVERTICAL);
        // Don't set the 2nd parameter to 1, making the sizer rubbery scalable in Y axis may lead 
        // to wrong vertical size assigned to wxBitmapComboBoxes, see GH issue #7176.
        mode_sizer->Add(m_mode_sizer, 0, wxALIGN_RIGHT);
        m_top_hsizer->Add(mode_sizer, 1, wxALIGN_CENTER_VERTICAL | wxRIGHT, wxOSX ? 15 : 10);
    }
    // hide whole top sizer to correct layout later
    m_top_hsizer->ShowItems(false);
 
    //Horizontal sizer to hold the tree and the selected page.
    m_hsizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(m_hsizer, 1, wxEXPAND, 0);
 
    //left vertical sizer
    m_left_sizer = new wxBoxSizer(wxVERTICAL);
    m_hsizer->Add(m_left_sizer, 0, wxEXPAND | wxLEFT | wxTOP | wxBOTTOM, 3);
 
    // tree
    m_treectrl = new wxTreeCtrl(panel, wxID_ANY, wxDefaultPosition, wxSize(20 * m_em_unit, -1),
        wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_SUNKEN | wxWANTS_CHARS);
    m_treectrl->SetFont(wxGetApp().normal_font());
    m_left_sizer->Add(m_treectrl, 1, wxEXPAND);
    // Index of the last icon inserted into m_treectrl
    m_icon_count = -1;
    m_treectrl->AddRoot("root");
    m_treectrl->SetIndent(0);
    wxGetApp().UpdateDarkUI(m_treectrl);
 
    // 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.
    m_treectrl->Bind(wxEVT_TREE_SEL_CHANGED, [this](wxTreeEvent&) {
#ifdef __linux__
        // Events queue is opposite On Linux. wxEVT_SET_FOCUS invokes after wxEVT_TREE_SEL_CHANGED,
        // and a result wxEVT_KILL_FOCUS doesn't invoke for the TextCtrls.
        // see https://github.com/prusa3d/PrusaSlicer/issues/5720
        // So, call SetFocus explicitly for this control before changing of the selection
        m_treectrl->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_treectrl->Update();
                    } while (this->tree_sel_change_delayed());
                    m_page_switch_running = false;
                }
            }
        });
 
    m_treectrl->Bind(wxEVT_KEY_DOWN, &Tab::OnKeyDown, this);
 
    // 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_rename_preset->Bind(wxEVT_BUTTON, ([this](wxCommandEvent e) { rename_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();
 
    if (!m_scaled_icons_list.empty()) {
        // update icons for tree_ctrl
        wxVector<wxBitmapBundle> img_bundles;
        for (const ScalableBitmap& bmp : m_scaled_icons_list)
            img_bundles.push_back(bmp.bmp());
        m_treectrl->SetImages(img_bundles);
    }
 
    // 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_treectrl->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(), em_unit(), fill_icon_descriptions(), Slic3r::GUI::format_wxstr(), L, m_bmp_non_system, m_bmp_value_lock, m_bmp_value_revert, m_bmp_value_unlock, m_bmp_white_bullet, m_btn_compare_preset, m_btn_delete_preset, m_btn_edit_ph_printer, m_btn_hide_incompatible_presets, m_btn_rename_preset, m_btn_save_preset, m_default_text_clr, m_disable_tree_sel_changed_event, m_em_unit, m_h_buttons_sizer, m_hsizer, m_icon_count, m_icon_descriptions, m_left_sizer, m_mode_sizer, m_modified_label_clr, m_pages, m_preset_bundle, m_presets_choice, m_question_btn, m_scaled_buttons, m_search_btn, m_show_incompatible_presets, m_sys_label_clr, m_top_hsizer, m_treectrl, m_type, m_undo_btn, m_undo_to_sys_btn, ScalableBitmap::name(), on_roll_back_value(), Slic3r::GUI::PresetComboBox::selection_is_changed_according_to_physical_printers(), Slic3r::GUI::PresetComboBox::set_selection_changed_function(), set_tooltips_text(), Slic3r::Preset::TYPE_PRINTER, wxEVT_BUTTON, and wxOSX.

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

decorate()

void Slic3r::GUI::Tab::decorate

(

)

{
    for (const auto& opt : m_options_list)
    {
        Field*      field = nullptr;
        bool        option_without_field = false;
 
        if(OptionsGroup::is_option_without_field(opt.first))
            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 (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);
        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 (m_active_page)
        m_active_page->refresh();
}

References Slic3r::GUI::Field::m_is_modified_value, Slic3r::GUI::Field::m_is_nonsys_value, 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(), and Slic3r::GUI::UndoValueUIManager::set_undo_tooltip().

Here is the call graph for this function:

delete_current_preset()

bool Slic3r::GUI::Tab::delete_current_preset ( )

protectedvirtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    return m_presets->delete_current_preset();
}

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.
    wxString action = current_preset.is_external ? _L("remove") : _L("delete");
 
    PhysicalPrinterCollection& physical_printers = m_preset_bundle->physical_printers;
    wxString msg;
    if (m_presets_choice->is_selected_physical_printer())
    {
        PhysicalPrinter& printer = physical_printers.get_selected_printer();
        if (printer.preset_names.size() == 1) {
            if (m_presets_choice->del_physical_printer(_L("It's a last preset for this physical printer.")))
                Layout();
            return;
        }
        
        msg = format_wxstr(_L("Are you sure you want to delete \"%1%\" preset from the physical printer \"%2%\"?"), current_preset.name, printer.name);
    }
    else
    {
        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, false);
            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";
            }
        }
 
        // TRN "remove/delete"
        msg += from_u8((boost::format(_u8L("Are you sure you want to %1% the selected preset?")) % action).str());
    }
 
    action = current_preset.is_external ? _L("Remove") : _L("Delete");
    // TRN Settings Tabs: Button in toolbar: "Remove/Delete"
    wxString title = format_wxstr(_L("%1% Preset"), action);
    if (current_preset.is_default ||
        //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);
}

References _L, _L_PLURAL, _u8L, Slic3r::PhysicalPrinter::delete_preset(), Slic3r::PhysicalPrinterCollection::delete_preset_from_printers(), Slic3r::PhysicalPrinterCollection::empty(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::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::PhysicalPrinter::name, Slic3r::PhysicalPrinter::preset_names, and Slic3r::PhysicalPrinterCollection::select_printer().

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

Referenced by Slic3r::GUI::TabSLAPrint::build_sla_support_params().

Here is the caller graph for this function:

emplace_option()

void Slic3r::GUI::Tab::emplace_option	(	const std::string &	opt_key,
		bool	respect_vec_values = false
	)

{
    if (respect_vec_values) {
        switch (m_config->option(opt_key)->type())
        {
        case coInts:  add_correct_opts_to_options_list<ConfigOptionInts   >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coBools: add_correct_opts_to_options_list<ConfigOptionBools    >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coFloats:  add_correct_opts_to_options_list<ConfigOptionFloats   >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coStrings: add_correct_opts_to_options_list<ConfigOptionStrings  >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coPercents:add_correct_opts_to_options_list<ConfigOptionPercents >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coPoints:  add_correct_opts_to_options_list<ConfigOptionPoints   >(opt_key, m_options_list, this, m_opt_status_value); break;
        case coFloatsOrPercents:  add_correct_opts_to_options_list<ConfigOptionFloatsOrPercents   >(opt_key, m_options_list, this, m_opt_status_value); break;
        default:    m_options_list.emplace(opt_key, m_opt_status_value);    break;
        }
    }
    else 
        m_options_list.emplace(opt_key, m_opt_status_value);
}

References Slic3r::coBools, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coPoints, and Slic3r::coStrings.

fill_icon_descriptions()

void Slic3r::GUI::Tab::fill_icon_descriptions ( )

protected

{
    m_icon_descriptions.emplace_back(&m_bmp_value_lock, L("LOCKED LOCK"),
        // TRN Description for "LOCKED LOCK"
        L("indicates that the settings are the same as the system (or default) values for the current option group"));
 
    m_icon_descriptions.emplace_back(&m_bmp_value_unlock, L("UNLOCKED LOCK"),
        // TRN Description for "UNLOCKED LOCK"
        L("indicates that some settings were changed and are not equal to the system (or default) values for "
        "the current option group.\n"
        "Click the UNLOCKED LOCK icon to reset all settings for current option group to "
        "the system (or default) values."));
 
    m_icon_descriptions.emplace_back(&m_bmp_white_bullet, L("WHITE BULLET"),
        // TRN Description for "WHITE BULLET"
        L("for the left button: indicates a non-system (or non-default) preset,\n"
          "for the right button: indicates that the settings hasn't been modified."));
 
    m_icon_descriptions.emplace_back(&m_bmp_value_revert, L("BACK ARROW"),
        // TRN Description for "BACK ARROW"
        L("indicates that the settings were changed and are not equal to the last saved preset for "
        "the current option group.\n"
        "Click the BACK ARROW icon to reset all settings for the current option group to "
        "the last saved preset."));
}

References L.

Referenced by create_preset_tab().

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.

get_config()

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

inline

{ return m_config; }

References m_config.

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);
    };
 
    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_value_change, nullptr, this);
}

References load_config(), on_value_change(), reload_config(), 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_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;
}

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

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

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

get_presets() [1/2]

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

inline

{ return m_presets; }

References m_presets.

get_presets() [2/2]

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

inline

{ return m_presets; }

References m_presets.

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 (sys_page) sys_page = (opt->second & osSystemValue) != 0;
    modified_page |= (opt->second & osInitValue) == 0;
}

init_options_list()

void Slic3r::GUI::Tab::init_options_list ( )

virtual

Reimplemented in Slic3r::GUI::TabPrinter.

{
    m_options_list.clear();
 
    for (const std::string& opt_key : m_config->keys())
        emplace_option(opt_key, m_type != Preset::TYPE_FILAMENT && !PresetCollection::is_independent_from_extruder_number_option(opt_key));
}

References Slic3r::PresetCollection::is_independent_from_extruder_number_option(), and Slic3r::Preset::TYPE_FILAMENT.

Here is the call 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(), and Slic3r::ConfigBase::option().

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), Slic3r::GUI::TabSLAMaterial::build(), get_config_manipulation(), and Slic3r::GUI::Plater::priv::undo_redo_to().

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

virtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    const Preset& preset = m_presets->get_edited_preset();
 
    update_btns_enabling();
 
    update();
    if (m_type == Slic3r::Preset::TYPE_PRINTER) {
        // For the printer profile, generate the extruder pages.
        if (preset.printer_technology() == ptFFF)
            on_preset_loaded();
        else
            wxGetApp().sidebar().update_objects_list_extruder_column(1);
    }
    // Reload preset pages with the new configuration values.
    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  ? "resin" : "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), 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
            }
            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();
        update_visibility();
        update_changed_ui();
    }
#if 0
    );
#endif
}

References Slic3r::Preset::config, Slic3r::ConfigBase::option(), Slic3r::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::ConfigOptionVector< T >::size(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::TYPE_SLA_MATERIAL.

Referenced by on_presets_changed().

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

Referenced by 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);
    }
    m_presets_choice->update_dirty();
    on_presets_changed();
    update();
}

References Slic3r::GUI::change_opt_value(), and Slic3r::Never.

Here is the call 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 = ""
	)

{
    if (presets == nullptr) presets = m_presets;
 
    UnsavedChangesDialog dlg(m_type, presets, new_printer_name);
    if (wxGetApp().app_config->get("default_action_on_select_preset") == "none" && 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();
 
        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);
            save_preset(name);
        }
        else
        {
            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 (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 Slic3r::ConfigBase::apply_only(), Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::UnsavedChangesDialog::get_preset_name(), Slic3r::GUI::UnsavedChangesDialog::get_selected_options(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::GUI::UnsavedChangesDialog::get_unselected_options(), Slic3r::GUI::UnsavedChangesDialog::save_preset(), Slic3r::GUI::UnsavedChangesDialog::transfer_changes(), and Slic3r::PresetCollection::type().

Here is the call graph for this function:

msw_rescale()

void Slic3r::GUI::Tab::msw_rescale ( )

virtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    m_em_unit = em_unit(m_parent);
 
    m_presets_choice->msw_rescale();
    m_treectrl->SetMinSize(wxSize(20 * m_em_unit, -1));
 
    // rescale options_groups
    if (m_active_page)
        m_active_page->msw_rescale();
 
    Layout();
}

References em_unit().

Here is the call graph for this function:

name()

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

inline

{ return m_presets->name(); }

References m_presets, and Slic3r::PresetCollection::name().

Referenced by Slic3r::GUI::Plater::priv::on_select_preset().

Here is the call graph for this function:

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.

{}

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);
 
    // 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();
 
    // Update Project dirty state, update application title bar.
    if (wxGetApp().mainframe)
        wxGetApp().plater()->update_project_dirty_from_presets();
}

References apply_config_from_cache(), and load_current_preset().

Here is the call graph for this function:

on_roll_back_value()

void Slic3r::GUI::Tab::on_roll_back_value

(

const bool

to_sys = false

)

{
    if (!m_active_page) return;
 
    int os;
    if (to_sys) {
        if (!m_is_nonsys_values) return;
        os = osSystemValue;
    }
    else {
        if (!m_is_modified_values) return;
        os = osInitValue;
    }
 
    m_postpone_update_ui = true;
 
    for (auto group : m_active_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["bed_shape"] & os) == 0) {
                to_sys ? group->back_to_sys_value("bed_shape") : group->back_to_initial_value("bed_shape");
                load_key_value("bed_shape", true/*some value*/, true);
            }
        }
        if (group->title == "Toolchange parameters with single extruder MM printers") {
            if ((m_options_list["filament_ramming_parameters"] & os) == 0)
                to_sys ? group->back_to_sys_value("filament_ramming_parameters") : group->back_to_initial_value("filament_ramming_parameters");
        }
        if (group->title == "G-code Substitutions") {
            if ((m_options_list["gcode_substitutions"] & os) == 0) {
                to_sys ? group->back_to_sys_value("gcode_substitutions") : group->back_to_initial_value("gcode_substitutions");
                load_key_value("gcode_substitutions", true/*some value*/, true);
            }
        }
        if (group->title == "Profile dependencies") {
            // "compatible_printers" option doesn't exists in Printer Settimgs Tab
            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);
            }
            // "compatible_prints" option exists only in Filament Settimgs and Materials Tabs
            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;
            if ((m_options_list[opt_key] & os) == 0)
                to_sys ? group->back_to_sys_value(opt_key) : group->back_to_initial_value(opt_key);
        }
    }
 
    m_postpone_update_ui = false;
 
    // When all values are rolled, then we have to update whole tab in respect to the reverted values
    update();
 
    update_changed_ui();
}

References Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::TYPE_SLA_MATERIAL.

Referenced by create_preset_tab().

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
	)

!!! ysFIXME ????

{
    if (wxGetApp().plater() == nullptr) {
        return;
    }
 
    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);
    if (opt_key == "fill_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 == "support_material" || opt_key == "support_material_auto" || opt_key == "support_material_buildplate_only") :
            (opt_key == "supports_enable"  || opt_key == "support_tree_type" || opt_key == get_sla_suptree_prefix(*m_config) + "support_buildplate_only" || opt_key == "support_enforcers_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 == "wipe_tower" || opt_key == "single_extruder_multi_material" || opt_key == "extruders_count" )
        update_wiping_button_visibility();
 
    if (opt_key == "extruders_count")
        wxGetApp().plater()->on_extruders_change(boost::any_cast<size_t>(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,
        // see https://github.com/prusa3d/PrusaSlicer/issues/7146
        return;
    }
 
    update();
}

References Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::get_sla_suptree_prefix(), Slic3r::GUI::pad_combo_value_for_config(), Slic3r::ptFFF, Slic3r::GUI::Field::set_value(), Slic3r::GUI::OptionsGroup::set_value(), and Slic3r::GUI::support_combo_value_for_config().

Referenced by Slic3r::GUI::TabSLAMaterial::build(), get_config_manipulation(), Slic3r::GUI::Plater::priv::process_validation_warning(), 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

{
    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_treectrl->GetHandle());
    if (hwnd_tt) {
      HWND hwnd_toplevel  = find_toplevel_parent(m_treectrl)->GetHandle();
      HWND hwnd_parent  = ::GetParent(hwnd_tt);
      if (hwnd_parent != hwnd_toplevel) {
        ::DestroyWindow(hwnd_tt);
      TreeView_SetToolTips(m_treectrl->GetHandle(), nullptr);
      }
    }
#endif
 
    // create controls on active page
    activate_selected_page([](){});
    m_hsizer->Layout();
 
    if (m_presets_choice->IsShown())
        Refresh(); // Just refresh page, if m_presets_choice is already shown
    else {
        // From the tab creation whole top sizer is hidden to correct update of preset combobox's size
        // (see https://github.com/prusa3d/PrusaSlicer/issues/10746)
 
        // On first OnActivate call show top sizer
        m_top_hsizer->ShowItems(true);
        // Size and layouts of all items are correct now,
        // but ALL items of top sizer are visible.
        // So, update visibility of each item according to the ui settings
        update_btns_enabling();
        m_btn_hide_incompatible_presets->Show(m_show_btn_incompatible_presets && m_type != Slic3r::Preset::TYPE_PRINTER);
        if (TabFilament* tab = dynamic_cast<TabFilament*>(this))
            tab->update_extruder_combobox();
 
        Layout();
    }
}

References Slic3r::GUI::find_toplevel_parent(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::GUI::MainFrame::init_tabpanel(), and Slic3r::GUI::MainFrame::select_tab().

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_treectrl->Navigate(event.ShiftDown() ? wxNavigationKeyEvent::IsBackward : wxNavigationKeyEvent::IsForward);
    else
        event.Skip();
}

OnTreeSelChange()

void Slic3r::GUI::Tab::OnTreeSelChange

(

wxTreeEvent &

event

)

parent()

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

inline

{ return m_parent; }

References m_parent.

Referenced by Tab(), Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabSLAPrint::build(), and Slic3r::GUI::TabSLAPrint::build_sla_support_params().

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
    const auto sel_item = m_treectrl->GetSelection();
    const auto selected = sel_item ? m_treectrl->GetItemText(sel_item) : "";
    const auto rootItem = m_treectrl->GetRootItem();
 
    wxTreeItemId item;
 
    // Delete/Append events invoke wxEVT_TREE_SEL_CHANGED event.
    // To avoid redundant clear/activate functions call
    // suppress activate page before page_tree rebuilding
    m_disable_tree_sel_changed_event = true;
    m_treectrl->DeleteChildren(rootItem);
 
    for (auto p : m_pages)
    {
        if (!p->get_show())
            continue;
        auto itemId = m_treectrl->AppendItem(rootItem, translate_category(p->title(), m_type), p->iconID());
        m_treectrl->SetItemTextColour(itemId, p->get_item_colour());
        if (translate_category(p->title(), m_type) == selected)
            item = itemId;
    }
    if (!item) {
        // this is triggered on first load, so we don't disable the sel change event
        item = m_treectrl->GetFirstVisibleItem();
    }
 
    // allow activate page before selection of a page_tree item
    m_disable_tree_sel_changed_event = false;
    if (item)
        m_treectrl->SelectItem(item);
}

reload_config()

void Slic3r::GUI::Tab::reload_config ( )

virtual

Reimplemented in Slic3r::GUI::TabPrinter.

{
    if (m_active_page)
        m_active_page->reload_config();
}

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), and get_config_manipulation().

Here is the caller graph for this function:

rename_preset()

void Slic3r::GUI::Tab::rename_preset

(

)

{
    if (m_presets_choice->is_selected_physical_printer())
        return;
 
    wxString msg;
 
    if (m_type == Preset::TYPE_PRINTER && !m_preset_bundle->physical_printers.empty()) {
        // Check preset for rename in physical printers
        std::vector<std::string> ph_printers = m_preset_bundle->physical_printers.get_printers_with_preset(m_presets->get_selected_preset().name);
        if (!ph_printers.empty()) {
            msg += _L_PLURAL("The physical printer below is based on the preset, you are going to rename.",
                "The physical printers below are based on the preset, you are going to rename.", 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 renamed in this printer too.",
                "Note, that the selected preset will be renamed in these printers too.", ph_printers.size()) + "\n\n";
        }
    }
 
    // get new name
 
    SavePresetDialog dlg(m_parent, m_type, msg);
    if (dlg.ShowModal() != wxID_OK)
        return;
 
    const std::string new_name = into_u8(dlg.get_name());
    if (new_name.empty() || new_name == m_presets->get_selected_preset().name)
        return;
 
    // Note: selected preset can be changed, if in SavePresetDialog was selected name of existing preset
    Preset& selected_preset = m_presets->get_selected_preset();
    Preset& edited_preset   = m_presets->get_edited_preset();
 
    const std::string old_name      = selected_preset.name;
    const std::string old_file_name = selected_preset.file;
 
    assert(old_name == edited_preset.name);
 
    using namespace boost;
    try {
        // rename selected and edited presets
 
        selected_preset.name = new_name;
        replace_last(selected_preset.file, old_name, new_name);
 
        edited_preset.name = new_name;
        replace_last(edited_preset.file, old_name, new_name);
 
        // rename file with renamed preset configuration
 
        filesystem::rename(old_file_name, selected_preset.file);
 
        // rename selected preset in printers, if it's needed
 
        if (!msg.IsEmpty())
            m_preset_bundle->physical_printers.rename_preset_in_printers(old_name, new_name);
    }
    catch (const exception& ex) {
        const std::string exception = diagnostic_information(ex);
        printf("Can't rename a preset : %s", exception.c_str());
    }
 
    // sort presets after renaming
    std::sort(m_presets->begin(), m_presets->end());
    // update selection
    select_preset_by_name(new_name, true);
 
    m_presets_choice->update();
    on_presets_changed();
}

References _L_PLURAL, Slic3r::Preset::file, Slic3r::GUI::from_u8(), Slic3r::GUI::SavePresetDialog::get_name(), Slic3r::GUI::into_u8(), and Slic3r::Preset::name.

Here is the call graph for this function:

save_current_preset()

bool Slic3r::GUI::Tab::save_current_preset ( const std::string &  new_name, bool  detach  )

protectedvirtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    return m_presets->save_current_preset(new_name, detach);
}

save_preset()

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

m_treectrl->OnSetFocus();

{
    // 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 ?
 
    Preset& edited_preset = m_presets->get_edited_preset();
    bool from_template = false;
    std::string edited_printer;
    if (m_type == Preset::TYPE_FILAMENT && edited_preset.vendor && edited_preset.vendor->templates_profile) {
        edited_printer = wxGetApp().preset_bundle->printers.get_edited_preset().config.opt_string("printer_model");
        from_template = !edited_printer.empty();
    }
 
    if (name.empty()) {
        SavePresetDialog dlg(m_parent, { m_type }, detach ? _u8L("Detached") : "", from_template);
        if (dlg.ShowModal() != wxID_OK)
            return;
        name = dlg.get_name();
        if (from_template)
            from_template = dlg.get_template_filament_checkbox();
    }
 
    if (detach && m_type == Preset::TYPE_PRINTER)
        m_config->opt_string("printer_model", true) = "";
 
    // Update compatible printers
    if (from_template && !edited_printer.empty()) {
        std::string cond = edited_preset.compatible_printers_condition();
        if (!cond.empty())
            cond += " and ";
        cond += "printer_model == \"" + edited_printer + "\"";
        edited_preset.config.opt_string("compatible_printers_condition") = cond;
    }
 
    // Save the preset into Slic3r::data_dir / presets / section_name / preset_name.ini
    save_current_preset(name, detach);
 
    if (detach && m_type == Preset::TYPE_PRINTER)
        wxGetApp().mainframe->on_config_changed(m_config);
 
 
    // 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();
    // If current profile is saved, "delete/rename preset" buttons have to be shown
    m_btn_delete_preset->Show();
    m_btn_rename_preset->Show(!m_presets_choice->is_selected_physical_printer());
    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();
    }
 
    // update preset comboboxes in DiffPresetDlg
    wxGetApp().mainframe->diff_dialog.update_presets(m_type);
 
    if (detach)
        update_description_lines();
}

References _u8L, Slic3r::Preset::compatible_printers_condition(), Slic3r::Preset::config, Slic3r::GUI::SavePresetDialog::get_name(), Slic3r::GUI::TabPrinter::m_extruders_count, Slic3r::ConfigBase::opt_string(), Slic3r::ptFFF, Slic3r::VendorProfile::templates_profile, and Slic3r::Preset::vendor.

Here is the call graph for this function:

saved_preset_is_dirty()

bool Slic3r::GUI::Tab::saved_preset_is_dirty

(

)

const

{ return m_presets->saved_is_dirty(); }

select_preset()

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

{
    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.
            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;
        } else {
            // If no name is provided, select the "-- default --" preset.
            preset_name = m_presets->default_preset().name;
        }
    }
    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 technology_changed = false;
    m_dependent_tabs.clear();
    if (current_dirty && ! may_discard_current_dirty_preset(nullptr, preset_name)) {
        canceled = true;
    } 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 && ! new_preset_compatible && ! may_discard_current_dirty_preset(&dependent, preset_name);
        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();
        }
    } 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(_L("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 }
            };
            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 && !pu.new_preset_compatible && !may_discard_current_dirty_preset(pu.presets, preset_name);
            }
            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;
    }
 
    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 {
            // cache previously selected names
            delete_current_preset();
        } catch (const std::exception & /* e */) {
            //FIXME add some error reporting!
            canceled = true;
        }
    }
 
    if (canceled) {
        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);
            }
            else 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(); //! ysFIXME delete after testing
 
        // 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 {
        if (current_dirty)
            m_presets->discard_current_changes();
 
        const bool is_selected = 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();
 
        load_current_preset();
    }
 
    if (technology_changed)
        wxGetApp().mainframe->technology_changed();
 
    return !canceled;
}

References _L, Slic3r::PresetCollection::current_is_dirty(), Slic3r::PresetCollection::discard_current_changes(), Slic3r::PresetCollection::get_edited_preset_with_vendor_profile(), Slic3r::is_compatible_with_print(), Slic3r::is_compatible_with_printer(), Slic3r::PresetWithVendorProfile::preset, Slic3r::printer_technology(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::ptSLA, and updates.

Referenced by Slic3r::GUI::Plater::priv::on_select_preset(), and Slic3r::GUI::PresetComboBox::selection_is_changed_according_to_physical_printers().

Here is the call graph for this function:

Here is the caller graph for this function:

select_preset_by_name()

bool Slic3r::GUI::Tab::select_preset_by_name ( const std::string &  name_w_suffix, bool  force  )

protectedvirtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    return m_presets->select_preset_by_name(name_w_suffix, force);
}

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("UNLOCKED LOCK icon indicates that the value was changed and is not equal "
                                "to the system (or default) value.\n"
                                "Click to reset current value to the system (or default) 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("BACK ARROW icon indicates that the value was changed and is not equal to the last saved preset.\n"
                                "Click to reset current value to the last saved preset."));
}

References _, and L.

Referenced by create_preset_tab().

Here is the caller graph for this function:

set_type()

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

protected

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

References m_name, m_type, 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.

supports_printer_technology()

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

pure virtual

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

Referenced by Slic3r::GUI::MainFrame::add_created_tab(), and Slic3r::GUI::MainFrame::init_tabpanel().

Here is the caller graph for this function:

sys_color_changed()

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

virtual

Reimplemented in Slic3r::GUI::TabFilament.

{
    m_presets_choice->sys_color_changed();
 
    // update buttons and cached bitmaps
    for (const auto btn : m_scaled_buttons)
        btn->sys_color_changed();
    for (const auto bmp : m_scaled_bitmaps)
        bmp->sys_color_changed();
    if (m_detach_preset_btn)
        m_detach_preset_btn->sys_color_changed();
 
    update_show_hide_incompatible_button();
 
    // update icons for tree_ctrl
    wxVector <wxBitmapBundle> img_bundles;
    for (ScalableBitmap& bmp : m_scaled_icons_list) {
        bmp.sys_color_changed();
        img_bundles.push_back(bmp.bmp());
    }
    m_treectrl->SetImages(img_bundles);
 
    // Colors for ui "decoration"
    update_label_colours();
#ifdef _WIN32
    wxWindowUpdateLocker noUpdates(this);
    if (m_mode_sizer)
        m_mode_sizer->sys_color_changed();
    wxGetApp().UpdateDarkUI(this);
    wxGetApp().UpdateDarkUI(m_treectrl);
#endif
    update_changed_tree_ui();
 
    // update options_groups
    if (m_active_page)
        m_active_page->sys_color_changed();
 
    Layout();
    Refresh();
}

title()

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

inline

{ return m_title; }

References m_title.

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

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 Slic3r::GUI::Field::toggle().

Referenced by get_config_manipulation().

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::TabPrint, Slic3r::GUI::TabFilament, Slic3r::GUI::TabPrinter, Slic3r::GUI::TabSLAMaterial, and Slic3r::GUI::TabSLAPrint.

toggle_show_hide_incompatible()

void Slic3r::GUI::Tab::toggle_show_hide_incompatible

(

)

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

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 Slic3r::Preset::config, and Slic3r::Preset::name.

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

Here is the caller graph for this function:

translate_category()

wxString Slic3r::GUI::Tab::translate_category ( const wxString &  title, Preset::Type  preset_type  )

static

{
    if (preset_type == Preset::TYPE_PRINTER && title.Contains("Extruder ")) {
        return _("Extruder") + title.SubString(8, title.Last());
    }
    return _(title);
}

References _, and Slic3r::Preset::TYPE_PRINTER.

Referenced by Slic3r::Search::OptionsSearcher::append_options(), and Slic3r::Search::create_option().

Here is the caller graph for this function:

tree_sel_change_delayed()

bool Slic3r::GUI::Tab::tree_sel_change_delayed ( )

protected

{
    // There is a bug related to Ubuntu overlay scrollbars, see https://github.com/prusa3d/PrusaSlicer/issues/898 and https://github.com/prusa3d/PrusaSlicer/issues/952.
    // 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
 
    Page* page = nullptr;
    const auto sel_item = m_treectrl->GetSelection();
    const auto selection = sel_item ? m_treectrl->GetItemText(sel_item) : "";
    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;
        }
    if (page == nullptr || m_active_page == page)
        return false;
 
    // clear pages from the controls
    m_active_page = page;
    
    auto throw_if_canceled = std::function<void()>([this](){
#ifdef WIN32
            CheckForInterrupt(m_treectrl);
            if (m_page_switch_planned)
                throw UIBuildCanceled();
#else // WIN32
            (void)this; // silence warning
#endif
        });
 
    try {
        clear_pages();
        throw_if_canceled();
 
        if (wxGetApp().mainframe!=nullptr && wxGetApp().mainframe->is_active_and_shown_tab(this))
            activate_selected_page(throw_if_canceled);
 
        #ifdef __linux__
            no_updates.reset(nullptr);
        #endif
 
        update_undo_buttons();
        throw_if_canceled();
 
        m_hsizer->Layout();
        throw_if_canceled();
        Refresh();
    } catch (const UIBuildCanceled&) {
      if (m_active_page)
        m_active_page->clear();
        return true;
    }
 
    return false;
}

References Slic3r::GUI::Page::m_is_modified_values, Slic3r::GUI::Page::m_is_nonsys_values, and void().

Here is the call graph for this function:

type()

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

inline

{ return m_type; }

References m_type.

update()

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

pure virtual

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

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), and get_config_manipulation().

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.is_default && !preset.is_system));
    m_btn_rename_preset->Show(!preset.is_default && !preset.is_system && !preset.is_external && 
                              !wxGetApp().preset_bundle->physical_printers.has_selection());
 
    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"));
    m_h_buttons_sizer->Layout();
}

References _L, Slic3r::Preset::is_default, Slic3r::Preset::is_external, and Slic3r::Preset::is_system.

update_changed_tree_ui()

void Slic3r::GUI::Tab::update_changed_tree_ui

(

)

{
    if (m_options_list.empty())
        return;
    auto cur_item = m_treectrl->GetFirstVisibleItem();
    if (!cur_item || !m_treectrl->IsVisible(cur_item))
        return;
 
    auto selected_item = m_treectrl->GetSelection();
    auto selection = selected_item ? m_treectrl->GetItemText(selected_item) : "";
 
    while (cur_item) {
        auto title = m_treectrl->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", "bed_shape" };
                for (auto &opt_key : optional_keys) {
                    get_sys_and_mod_flags(opt_key, sys_page, modified_page);
                }
            }
            if (m_type == Preset::TYPE_FILAMENT && page->title() == "Advanced") {
                get_sys_and_mod_flags("filament_ramming_parameters", 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);
                }
            }
            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_modified_label_clr :
                                                    &m_default_text_clr;
 
            if (page->set_item_colour(clr))
                m_treectrl->SetItemTextColour(cur_item, *clr);
 
            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_treectrl->GetNextVisible(cur_item);
        cur_item = next_item;
    }
    update_undo_buttons();
}

References Slic3r::optional_keys, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::TYPE_SLA_MATERIAL.

update_changed_ui()

void Slic3r::GUI::Tab::update_changed_ui

(

)

{
    if (m_postpone_update_ui)
        return;
 
    const bool deep_compare = m_type != Preset::TYPE_FILAMENT;
    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) {
        {
            auto check_bed_custom_options = [](std::vector<std::string>& keys) {
                size_t old_keys_size = keys.size();
                keys.erase(std::remove_if(keys.begin(), keys.end(), [](const std::string& key) { 
                    return key == "bed_custom_texture" || key == "bed_custom_model"; }), keys.end());
                if (old_keys_size != keys.size() && std::find(keys.begin(), keys.end(), "bed_shape") == keys.end())
                    keys.emplace_back("bed_shape");
            };
            check_bed_custom_options(dirty_options);
            check_bed_custom_options(nonsys_options);
        }
 
        if (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");
        }
    }
 
    for (auto& it : m_options_list)
        it.second = m_opt_status_value;
 
    for (auto opt_key : dirty_options)  m_options_list[opt_key] &= ~osInitValue;
    for (auto opt_key : nonsys_options) m_options_list[opt_key] &= ~osSystemValue;
 
    decorate();
 
    wxTheApp->CallAfter([this]() {
        if (parent()) //To avoid a crash, parent should be exist for a moment of a tree updating
            update_changed_tree_ui();
    });
}

References Slic3r::GUI::TabPrinter::m_extruders_count, Slic3r::GUI::TabPrinter::m_initial_extruders_count, Slic3r::GUI::TabPrinter::m_sys_extruders_count, Slic3r::ptFFF, Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::TYPE_PRINTER.

update_description_lines()

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

virtual

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

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

Referenced by Slic3r::GUI::TabSLAMaterial::update(), and Slic3r::GUI::TabSLAPrint::update_description_lines().

Here is the caller graph for this function:

update_dirty()

void Slic3r::GUI::Tab::update_dirty

(

)

{
    m_presets_choice->update_dirty();
    on_presets_changed();
    update_changed_ui();
}

Referenced by Slic3r::GUI::FreqChangedParams::FreqChangedParams(), Slic3r::GUI::TabSLAMaterial::build(), get_config_manipulation(), Slic3r::GUI::Plater::priv::undo_redo_to(), and Slic3r::GUI::validate_custom_gcode_cb().

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 ? "fill_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 Slic3r::GUI::pad_combo_value_for_config(), Slic3r::ptFFF, and Slic3r::GUI::support_combo_value_for_config().

Here is the call 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 (OptionsGroup::is_option_without_field(opt.first)) {
            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_treectrl->GetFirstVisibleItem();
    if (!cur_item || !m_treectrl->IsVisible(cur_item))
        return;
    while (cur_item) {
        auto title = m_treectrl->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_default_text_clr;
 
            m_treectrl->SetItemTextColour(cur_item, *clr);
            break;
        }
        cur_item = m_treectrl->GetNextVisible(cur_item);
    }
 
    decorate();
}

References Slic3r::GUI::UndoValueUIManager::set_label_colour().

Here is the call graph for this function:

update_mode()

void Slic3r::GUI::Tab::update_mode

(

)

{
    m_mode = wxGetApp().get_mode();
 
    // update mode for ModeSizer
    if (m_mode_sizer)
        m_mode_sizer->SetMode(m_mode);
 
    update_visibility();
 
    update_changed_tree_ui();
}

update_mode_markers()

void Slic3r::GUI::Tab::update_mode_markers

(

)

{
    // update mode for ModeSizer
    if (m_mode_sizer)
        m_mode_sizer->update_mode_markers();
 
    if (m_active_page)
        m_active_page->refresh();
}

update_preset_choice()

void Slic3r::GUI::Tab::update_preset_choice

(

)

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

Referenced by Slic3r::GUI::PresetComboBox::selection_is_changed_according_to_physical_printers().

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 +
                            ", 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);
    Layout();
}

References _, Slic3r::Preset::alias, Slic3r::Preset::config, Slic3r::VendorProfile::config_version, Slic3r::GUI::from_u8(), Slic3r::Preset::is_default, Slic3r::Preset::is_system, L, Slic3r::VendorProfile::name, Slic3r::Preset::name, Slic3r::ConfigBase::opt_string(), Slic3r::ConfigBase::option(), Slic3r::Preset::printer_technology(), Slic3r::ptFFF, Slic3r::ptSLA, Slic3r::Semver::to_string(), Slic3r::Preset::TYPE_PRINTER, and Slic3r::Preset::vendor.

Here is the call graph for this function:

update_saved_preset_from_current_preset()

void Slic3r::GUI::Tab::update_saved_preset_from_current_preset

(

)

{ m_presets->update_saved_preset_from_current_preset(); }

update_show_hide_incompatible_button()

void Slic3r::GUI::Tab::update_show_hide_incompatible_button

(

)

{
    m_btn_hide_incompatible_presets->SetBitmap(*get_bmp_bundle(m_show_incompatible_presets ? "flag_red" : "flag_green"));
    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 get_bmp_bundle().

Here is the call graph for this function:

update_tab_ui()

void Slic3r::GUI::Tab::update_tab_ui

(

)

{
    m_presets_choice->update();
}

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 = wxGetApp().app_config->get("show_incompatible_presets")[0] == '1' ? true : false;
    bool show = m_show_btn_incompatible_presets && m_type != Slic3r::Preset::TYPE_PRINTER;
    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 Slic3r::Preset::TYPE_PRINTER.

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.

update_undo_buttons()

void Slic3r::GUI::Tab::update_undo_buttons

(

)

{
    m_undo_btn->        SetBitmap_(m_is_modified_values ? m_bmp_value_revert.name(): m_bmp_white_bullet.name());
    m_undo_to_sys_btn-> SetBitmap_(m_is_nonsys_values   ? m_bmp_non_system->name() : m_bmp_value_lock.name());
 
    //m_undo_btn->        SetBitmap_(m_is_modified_values ? 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_is_modified_values ? m_ttg_value_revert : m_ttg_white_bullet);
    m_undo_to_sys_btn->SetToolTip(m_is_nonsys_values ? *m_ttg_non_system : m_ttg_value_lock);
}

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_PRINTER)
        update_description_lines();
 
    Layout();
    Thaw();
}

References Slic3r::Preset::TYPE_PRINTER.

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
    bool wipe_tower_enabled = dynamic_cast<ConfigOptionBool*>(  (m_preset_bundle->prints.get_edited_preset().config  ).option("wipe_tower"))->value;
    bool multiple_extruders = dynamic_cast<ConfigOptionFloats*>((m_preset_bundle->printers.get_edited_preset().config).option("nozzle_diameter"))->values.size() > 1;
    bool single_extruder_multi_material = dynamic_cast<ConfigOptionBool*>((m_preset_bundle->printers.get_edited_preset().config).option("single_extruder_multi_material"))->value;
 
    auto wiping_dialog_button = wxGetApp().sidebar().get_wiping_dialog_button();
    if (wiping_dialog_button) {
        wiping_dialog_button->Show(wipe_tower_enabled && multiple_extruders && single_extruder_multi_material);
        wiping_dialog_button->GetParent()->Layout();
    }
}

References Slic3r::ptSLA, and Slic3r::ConfigOptionVector< T >::size().

Here is the call 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);
    if (invalid) {
        std::string lines = ":\n";
        for (const std::string& keyword : tags)
            lines += ";" + keyword + "\n";
        wxString reports = format_wxstr(
            _L_PLURAL("The following line %s contains reserved keywords.\nPlease remove it, as it may cause problems in G-code visualization and printing time estimation.", 
                      "The following lines %s contain reserved keywords.\nPlease remove them, as they may cause problems in G-code visualization and printing time estimation.", 
                      tags.size()),
            lines);
        //wxMessageDialog dialog(wxGetApp().mainframe, reports, _L("Found reserved keywords in") + " " + _(title), wxICON_WARNING | wxOK);
        MessageDialog dialog(wxGetApp().mainframe, reports, _L("Found reserved keywords in") + " " + _(title), wxICON_WARNING | wxOK);
        dialog.ShowModal();
    }
    return !invalid;
}

References _, _L, _L_PLURAL, Slic3r::GCodeProcessor::contains_reserved_tags(), Slic3r::GUI::format_wxstr(), and keyword().

Referenced by Slic3r::DoubleSlider::get_custom_code().

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;
        if (key == "autoemit_temperature_commands")
            continue;
        valid &= validate_custom_gcode(opt_group->title, boost::any_cast<std::string>(opt_group->get_value(key)));
        if (!valid)
            break;
    }
    return valid;
}

References L, and Slic3r::ptFFF.

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

Here is the caller graph for this function:

Member Data Documentation

m_active_page

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

protected

Referenced by Slic3r::GUI::TabSLAPrint::toggle_options(), and Slic3r::GUI::TabSLAPrint::update_description_lines().

m_bmp_non_system

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

protected

Referenced by create_preset_tab().

m_bmp_value_lock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_lock

protected

Referenced by create_preset_tab().

m_bmp_value_revert

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_revert

protected

Referenced by create_preset_tab().

m_bmp_value_unlock

ScalableBitmap Slic3r::GUI::Tab::m_bmp_value_unlock

protected

Referenced by create_preset_tab().

m_bmp_white_bullet

ScalableBitmap Slic3r::GUI::Tab::m_bmp_white_bullet

protected

Referenced by create_preset_tab().

m_btn_compare_preset

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

protected

Referenced by create_preset_tab().

m_btn_delete_preset

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

protected

Referenced by create_preset_tab().

m_btn_edit_ph_printer

ScalableButton* Slic3r::GUI::Tab::m_btn_edit_ph_printer {nullptr}

protected

Referenced by create_preset_tab().

m_btn_hide_incompatible_presets

ScalableButton* Slic3r::GUI::Tab::m_btn_hide_incompatible_presets

protected

Referenced by create_preset_tab().

m_btn_rename_preset

ScalableButton* Slic3r::GUI::Tab::m_btn_rename_preset

protected

Referenced by create_preset_tab().

m_btn_save_preset

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

protected

Referenced by create_preset_tab().

m_cache_config

DynamicPrintConfig Slic3r::GUI::Tab::m_cache_config

protected

m_category_icon

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

protected

Referenced by get_category_icon_map().

m_compatible_printers

PresetDependencies Slic3r::GUI::Tab::m_compatible_printers

protected

Referenced by Tab().

m_compatible_prints

PresetDependencies Slic3r::GUI::Tab::m_compatible_prints

protected

Referenced by Tab().

m_completed

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

protected

Referenced by completed().

m_config

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

Referenced by Slic3r::GUI::add_correct_opts_to_options_list(), Slic3r::GUI::TabSLAMaterial::build(), get_config(), Slic3r::GUI::TabSLAPrint::toggle_options(), Slic3r::GUI::TabSLAMaterial::update(), Slic3r::GUI::TabSLAPrint::update(), and Slic3r::GUI::TabSLAPrint::update_description_lines().

m_config_manipulation

ConfigManipulation Slic3r::GUI::Tab::m_config_manipulation

protected

Referenced by Tab(), Slic3r::GUI::TabSLAMaterial::toggle_options(), Slic3r::GUI::TabSLAPrint::toggle_options(), and Slic3r::GUI::TabSLAPrint::update().

m_default_text_clr

wxColour Slic3r::GUI::Tab::m_default_text_clr

protected

Referenced by create_preset_tab().

m_dependent_tabs

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

protected

m_detach_preset_btn

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

m_disable_tree_sel_changed_event

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

protected

Referenced by create_preset_tab().

m_em_unit

int Slic3r::GUI::Tab::m_em_unit

protected

Referenced by Tab(), and create_preset_tab().

m_h_buttons_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_h_buttons_sizer

protected

Referenced by create_preset_tab().

m_highlighter

HighlighterForWx Slic3r::GUI::Tab::m_highlighter

protected

Referenced by Tab().

m_hsizer

wxBoxSizer* Slic3r::GUI::Tab::m_hsizer

protected

Referenced by create_preset_tab().

m_icon_count

int Slic3r::GUI::Tab::m_icon_count

protected

Referenced by create_preset_tab().

m_icon_descriptions

std::vector<GUI_Descriptions::ButtonEntry> Slic3r::GUI::Tab::m_icon_descriptions = {}

protected

Referenced by create_preset_tab().

m_icon_index

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

protected

m_is_default_preset

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

protected

m_is_modified_values

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

protected

m_is_nonsys_values

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

protected

m_left_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_left_sizer

protected

Referenced by create_preset_tab().

m_mode

ConfigOptionMode Slic3r::GUI::Tab::m_mode = comExpert

protected

Referenced by Slic3r::GUI::TabSLAPrint::update_description_lines().

m_mode_sizer

ModeSizer* Slic3r::GUI::Tab::m_mode_sizer {nullptr}

protected

Referenced by create_preset_tab().

m_modified_label_clr

wxColour Slic3r::GUI::Tab::m_modified_label_clr

protected

Referenced by create_preset_tab().

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

m_options_list

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

protected

m_page_sizer

wxBoxSizer* Slic3r::GUI::Tab::m_page_sizer {nullptr}

protected

m_page_switch_planned

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

protected

m_page_switch_running

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

protected

m_page_view

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

protected

m_pages

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

protected

Referenced by create_preset_tab().

m_parent

wxBookCtrlBase* Slic3r::GUI::Tab::m_parent

private

Referenced by Tab(), and parent().

m_parent_preset_description_line

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

m_postpone_update_ui

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

protected

m_preset_bundle

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

Referenced by Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabSLAPrint::build(), create_preset_tab(), Slic3r::GUI::TabSLAMaterial::update(), and Slic3r::GUI::TabSLAPrint::update().

m_presets

PresetCollection* Slic3r::GUI::Tab::m_presets

Referenced by Slic3r::GUI::TabSLAMaterial::build(), Slic3r::GUI::TabSLAPrint::build(), Slic3r::GUI::GUI_App::check_and_keep_current_preset_changes(), get_presets(), get_presets(), and name().

m_presets_choice

TabPresetComboBox* Slic3r::GUI::Tab::m_presets_choice

protected

Referenced by create_preset_tab().

m_question_btn

ScalableButton* Slic3r::GUI::Tab::m_question_btn

protected

Referenced by create_preset_tab().

m_scaled_bitmaps

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

protected

m_scaled_buttons

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

protected

Referenced by create_preset_tab().

m_scaled_icons_list

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

protected

m_search_btn

ScalableButton* Slic3r::GUI::Tab::m_search_btn

protected

Referenced by create_preset_tab().

m_show_btn_incompatible_presets

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

m_show_incompatible_presets

bool Slic3r::GUI::Tab::m_show_incompatible_presets

protected

Referenced by create_preset_tab().

m_sys_label_clr

wxColour Slic3r::GUI::Tab::m_sys_label_clr

protected

Referenced by create_preset_tab().

m_title

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

protected

Referenced by title().

m_top_hsizer

wxBoxSizer* Slic3r::GUI::Tab::m_top_hsizer

protected

Referenced by create_preset_tab().

m_treectrl

wxTreeCtrl* Slic3r::GUI::Tab::m_treectrl

protected

Referenced by create_preset_tab().

m_tt_non_system

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

protected

m_tt_value_lock

wxString Slic3r::GUI::Tab::m_tt_value_lock

protected

m_tt_value_revert

wxString Slic3r::GUI::Tab::m_tt_value_revert

protected

m_tt_value_unlock

wxString Slic3r::GUI::Tab::m_tt_value_unlock

protected

m_tt_white_bullet

wxString Slic3r::GUI::Tab::m_tt_white_bullet

protected

m_ttg_non_system

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

protected

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

m_ttg_white_bullet

wxString Slic3r::GUI::Tab::m_ttg_white_bullet

protected

m_ttg_white_bullet_ns

wxString Slic3r::GUI::Tab::m_ttg_white_bullet_ns

protected

m_type

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

protected

Referenced by create_preset_tab(), set_type(), and type().

m_undo_btn

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

protected

Referenced by create_preset_tab().

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

validate_custom_gcodes_was_shown

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

Referenced by Slic3r::GUI::validate_custom_gcode_cb().

---

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

• src/slic3r/GUI/Tab.hpp
• src/slic3r/GUI/Tab.cpp