Slic3r::GUI::ConfigOptionsGroup Class Reference

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

Inheritance diagram for Slic3r::GUI::ConfigOptionsGroup:

Collaboration diagram for Slic3r::GUI::ConfigOptionsGroup:

Public Member Functions
	ConfigOptionsGroup (wxWindow *parent, const wxString &title, const wxString &icon, DynamicPrintConfig *config=nullptr, bool is_tab_opt=false, column_t extra_clmn=nullptr)
	ConfigOptionsGroup (wxWindow *parent, const wxString &title, DynamicPrintConfig *config=nullptr, bool is_tab_opt=false, column_t extra_clmn=nullptr)
	ConfigOptionsGroup (wxWindow *parent, const wxString &title, ModelConfig *config, bool is_tab_opt=false, column_t extra_clmn=nullptr)
	ConfigOptionsGroup (wxWindow *parent)
const wxString &	config_category () const throw ()
int	config_type () const override throw ()
const t_opt_map &	opt_map () const throw ()
void	set_config_category_and_type (const wxString &category, int type)
void	set_config (DynamicPrintConfig *config)
Option	get_option (const std::string &opt_key, int opt_index=-1)
Line	create_single_option_line (const std::string &title, const std::string &path=std::string(), int idx=-1)
Line	create_single_option_line (const Option &option, const std::string &path=std::string()) const
void	append_single_option_line (const Option &option, const std::string &path=std::string())
void	append_single_option_line (const std::string title, const std::string &path=std::string(), int idx=-1)
void	on_change_OG (const t_config_option_key &opt_id, const boost::any &value) override
void	back_to_initial_value (const std::string &opt_key) override
void	back_to_sys_value (const std::string &opt_key) override
void	back_to_config_value (const DynamicPrintConfig &config, const std::string &opt_key)
void	on_kill_focus (const std::string &opt_key) override
void	reload_config ()
void	Hide ()
void	Show (const bool show)
bool	is_visible (ConfigOptionMode mode)
bool	update_visibility (ConfigOptionMode mode)
void	msw_rescale ()
void	sys_color_changed ()
void	refresh ()
boost::any	config_value (const std::string &opt_key, int opt_index, bool deserialize)
boost::any	get_config_value (const DynamicPrintConfig &config, const std::string &opt_key, int opt_index=-1)
boost::any	get_config_value2 (const DynamicPrintConfig &config, const std::string &opt_key, int opt_index=-1)
bool	commit_config_value (const t_config_option_key &opt_key, int opt_index=-1)
Field *	get_fieldc (const t_config_option_key &opt_key, int opt_index)
std::pair< OG_CustomCtrl *, bool * >	get_custom_ctrl_with_blinking_ptr (const t_config_option_key &opt_key, int opt_index)
wxWindow *	parent () const
	Returns a copy of the pointer of the parent wxWindow. Accessor function is because users are not allowed to change the parent but defining it as const means a lot of const_casts to deal with wx functions.
wxWindow *	ctrl_parent () const
void	append_line (const Line &line)
void	activate_line (Line &line)
Line *	get_line (const std::string &opt_key)
bool	activate (std::function< void()> throw_if_canceled=[](){}, int horiz_alignment=wxALIGN_LEFT)
void	clear (bool destroy_custom_ctrl=false)
void	append_separator ()
Field *	get_field (const t_config_option_key &id) const
bool	set_value (const t_config_option_key &id, const boost::any &value, bool change_event=false)
boost::any	get_value (const t_config_option_key &id)
void	show_field (const t_config_option_key &opt_key, bool show=true)
void	hide_field (const t_config_option_key &opt_key)
void	enable_field (const t_config_option_key &opt_key, bool enable=true)
void	disable_field (const t_config_option_key &opt_key)
void	set_name (const wxString &new_name)
void	enable ()
void	disable ()
void	set_grid_vgap (int gap)
void	clear_fields_except_of (const std::vector< std::string > left_fields)
void	hide_labels ()
wxGridSizer *	get_grid_sizer ()
const std::vector< Line > &	get_lines ()
bool	is_legend_line ()
void	set_max_win_width (int max_win_width)
bool	is_activated ()
void	remove_option_if (std::function< bool(std::string const &)> const &comp)

Static Public Member Functions
static wxString	get_url (const std::string &path_end)
static bool	launch_browser (const std::string &path_end)

Public Attributes
const bool	staticbox {true}
bool	split_multi_line {false}
bool	option_label_at_right {false}
wxWindow *	stb { nullptr }
const wxString	icon
const wxString	title
bool	m_labels_hidden {false}
size_t	label_width = 20
wxSizer *	sizer {nullptr}
OG_CustomCtrl *	custom_ctrl { nullptr }
int	ctrl_horiz_alignment { wxALIGN_LEFT}
column_t	extra_column {nullptr}
t_change	m_on_change { nullptr }
t_kill_focus	m_fill_empty_value { nullptr }
std::function< DynamicPrintConfig()>	m_get_initial_config { nullptr }
std::function< DynamicPrintConfig()>	m_get_sys_config { nullptr }
std::function< bool()>	have_sys_config { nullptr }
std::function< void(wxWindow *win)>	rescale_extra_column_item { nullptr }
std::function< void(wxWindow *win)>	rescale_near_label_widget { nullptr }
std::function< void(const t_config_option_key &opt_key)>	edit_custom_gcode { nullptr }
wxFont	sidetext_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) }
wxFont	label_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) }
int	sidetext_width { -1 }
int	sublabel_width { -1 }
bool	draw_multi_extruder { false }

Protected Member Functions
void	change_opt_value (const t_config_option_key &opt_key, const boost::any &value, int opt_index=0)
const t_field &	build_field (const t_config_option_key &id, const ConfigOptionDef &opt)
	Generate a wxSizer or wxWindow from a configuration option Precondition: opt resolves to a known ConfigOption Postcondition: fields contains a wx gui object.
const t_field &	build_field (const t_config_option_key &id)
const t_field &	build_field (const Option &opt)
std::string	pick_plugin (const ConfigOptionDef &opt)

Protected Attributes
const DynamicPrintConfig *	m_config {nullptr}
ModelConfig *	m_modelconfig { nullptr }
t_opt_map	m_opt_map
wxString	m_config_category
int	m_config_type
std::map< t_config_option_key, Option >	m_options
wxWindow *	m_parent {nullptr}
std::vector< ConfigOptionMode >	m_options_mode
std::vector< wxWindow * >	m_extra_column_item_ptrs
std::vector< Line >	m_lines
t_optionfield_map	m_fields
	Field list, contains unique_ptrs of the derived type. using types that need to know what it is beyond the public interface need to cast based on the related ConfigOptionDef.
bool	m_disabled {false}
wxGridSizer *	m_grid_sizer {nullptr}
bool	m_use_custom_ctrl { false }
bool	m_use_custom_ctrl_as_parent { false }

Detailed Description

Constructor & Destructor Documentation

ConfigOptionsGroup() [1/4]

Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup ( wxWindow * parent, const wxString & title, const wxString & icon, DynamicPrintConfig * config = nullptr, bool is_tab_opt = false, column_t extra_clmn = nullptr )

inline

                                                                    :
    OptionsGroup(parent, title, icon, is_tab_opt, extra_clmn), m_config(config) {}

References Slic3r::GUI::OptionsGroup::OptionsGroup(), Slic3r::GUI::OptionsGroup::icon, m_config, Slic3r::GUI::OptionsGroup::parent(), and Slic3r::GUI::OptionsGroup::title.

Referenced by ConfigOptionsGroup(), and Slic3r::GUI::ExtruderOptionsGroup::ExtruderOptionsGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

ConfigOptionsGroup() [2/4]

Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup ( wxWindow * parent, const wxString & title, DynamicPrintConfig * config = nullptr, bool is_tab_opt = false, column_t extra_clmn = nullptr )

inline

                                                                    :
    ConfigOptionsGroup(parent, title, wxEmptyString, config, is_tab_opt, extra_clmn) {}

References ConfigOptionsGroup(), Slic3r::GUI::OptionsGroup::parent(), and Slic3r::GUI::OptionsGroup::title.

Here is the call graph for this function:

ConfigOptionsGroup() [3/4]

Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup ( wxWindow * parent, const wxString & title, ModelConfig * config, bool is_tab_opt = false, column_t extra_clmn = nullptr )

inline

                                                                    :
    OptionsGroup(parent, title, wxEmptyString, is_tab_opt, extra_clmn), m_config(&config->get()), m_modelconfig(config) {}

References Slic3r::GUI::OptionsGroup::OptionsGroup(), m_config, m_modelconfig, Slic3r::GUI::OptionsGroup::parent(), and Slic3r::GUI::OptionsGroup::title.

Here is the call graph for this function:

ConfigOptionsGroup() [4/4]

Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup ( wxWindow * parent )

inline

                                        :
    OptionsGroup(parent, wxEmptyString, wxEmptyString, true, nullptr) {}

References Slic3r::GUI::OptionsGroup::OptionsGroup(), and Slic3r::GUI::OptionsGroup::parent().

Here is the call graph for this function:

Member Function Documentation

activate()

bool Slic3r::GUI::OptionsGroup::activate ( std::function< void()> throw_if_canceled = [](){}, int horiz_alignment = wxALIGN_LEFT )

inherited

{
    if (sizer) //(!sizer->IsEmpty())
        return false;
 
    try {
        if (staticbox) {
            // ORCA match style of wxStaticBox between platforms
            LabeledStaticBox* stb = new LabeledStaticBox(m_parent, _(title));
            // wxGetApp().UpdateDarkUI(stb);
            this->stb = stb;
            sizer     = new wxStaticBoxSizer(stb, wxVERTICAL);
        } else {
            // BBS: new layout
            ::StaticLine* stl = new ::StaticLine(m_parent, false, _(title), icon);
            stl->SetFont(Label::Head_14);
            stl->SetForegroundColour("#363636"); // ORCA Match Parameters title color with tab title color
            sizer = new wxBoxSizer(wxVERTICAL);
            if (title.IsEmpty()) {
                stl->Hide();
            } else {
                sizer->Add(stl, 0, wxEXPAND);
                sizer->AddSpacer(8);
            }
            this->stb = stl;
        }
 
        auto num_columns = 1U;
        size_t grow_col  = 1;
 
        if (label_width == 0)
            grow_col = 0;
        else
            num_columns++;
 
        if (extra_column) {
            num_columns++;
            grow_col++;
        }
 
        m_grid_sizer = new wxFlexGridSizer(0, num_columns, 1, 0);
        static_cast<wxFlexGridSizer*>(m_grid_sizer)->SetFlexibleDirection(wxBOTH);
        static_cast<wxFlexGridSizer*>(m_grid_sizer)->AddGrowableCol(grow_col);
 
        sizer->Add(m_grid_sizer, 0, wxEXPAND | wxALL, !staticbox ? 0 : 5);
 
        // activate lines
        for (Line& line : m_lines) {
            throw_if_canceled();
            activate_line(line);
        }
 
        ctrl_horiz_alignment = horiz_alignment;
        if (custom_ctrl)
            custom_ctrl->init_max_win_width();
    } catch (UIBuildCanceled&) {
        auto p = sizer;
        this->clear();
        p->Clear(true);
        delete p;
        throw;
    }
 
    return true;
}

References _, activate_line(), clear(), ctrl_horiz_alignment, custom_ctrl, extra_column, Label::Head_14, icon, label_width, m_grid_sizer, m_lines, m_parent, sizer, staticbox, stb, and title.

Here is the call graph for this function:

activate_line()

void Slic3r::GUI::OptionsGroup::activate_line ( Line & line )

inherited

To correct translation by context have to use wxGETTEXT_IN_CONTEXT macro from wxWidget 3.1.1

.target<wxWindow>()

requires verification

istead of (opt != option_set.back())

requires verification

{
    if (line.is_separator())
        return;
 
    m_use_custom_ctrl_as_parent = false;
 
    if (line.full_width && (line.widget != nullptr || !line.get_extra_widgets().empty())) {
        // BBS: new layout
        const auto h_sizer = new wxBoxSizer(wxHORIZONTAL);
        sizer->Add(h_sizer, 1, wxEXPAND | wxALL, (wxOSX && !staticbox) ? 0 : 15);
        if (line.widget != nullptr) {
            // description lines
            sizer->Add(line.widget(this->ctrl_parent()), 0, wxEXPAND | wxALL, (wxOSX && !staticbox) ? 0 : 15);
            return;
        }
        if (!line.get_extra_widgets().empty()) {
            bool is_first_item = true;
            for (auto extra_widget : line.get_extra_widgets()) {
                h_sizer->Add(extra_widget(this->ctrl_parent()), is_first_item ? 1 : 0, wxLEFT, titleWidth * wxGetApp().em_unit());
                is_first_item = false;
            }
            return;
        }
    }
 
    auto option_set     = line.get_options();
    bool is_legend_line = option_set.front().opt.gui_type == ConfigOptionDef::GUIType::legend;
 
    if (!custom_ctrl && m_use_custom_ctrl) {
        custom_ctrl = new OG_CustomCtrl(is_legend_line || !staticbox ? this->parent() : static_cast<wxWindow*>(this->stb), this);
        // BBS: new layout
        custom_ctrl->SetLabel("");
        if (is_legend_line)
            sizer->Add(custom_ctrl, 0, wxEXPAND | wxLEFT, (wxOSX && !staticbox) ? 0 : 10);
        else
            sizer->Add(custom_ctrl, 0, wxEXPAND | wxALL, !staticbox ? 0 : 5);
    }
 
    // Set sidetext width for a better alignment of options in line
    // "m_show_modified_btns==true" means that options groups are in tabs
    if (option_set.size() > 1 && m_use_custom_ctrl) {
        sublabel_width = Field::def_width() + 1;
        sidetext_width = Field::def_width_thinner();
    }
 
    // if we have a single option with no label, no sidetext just add it directly to sizer
    if (option_set.size() == 1 && label_width == 0 && option_set.front().opt.full_width && option_set.front().opt.sidetext.size() == 0 &&
        option_set.front().side_widget == nullptr && line.get_extra_widgets().size() == 0) {
        const auto& option = option_set.front();
        const auto& field  = build_field(option);
 
        // BBS: new layout
        const auto h_sizer = new wxBoxSizer(wxHORIZONTAL);
        sizer->Add(h_sizer, 1, wxEXPAND | wxALL, (wxOSX && !staticbox) ? 0 : 5);
 
        int left_padding = option.opt.multiline ? 0 : titleWidth * wxGetApp().em_unit();
        if (m_labels_hidden)
            left_padding = 0;
 
        if (is_window_field(field)) {
            int flags = wxEXPAND;
            if (left_padding > 0)
                flags |= wxLEFT;
            h_sizer->Add(field->getWindow(), 1, flags, left_padding);
        }
        if (is_sizer_field(field)) {
            int flags = wxEXPAND;
            if (left_padding > 0)
                flags |= wxLEFT;
            h_sizer->Add(field->getSizer(), 1, flags, left_padding);
        }
        return;
    }
 
    auto grid_sizer = m_grid_sizer;
 
    if (custom_ctrl)
        m_use_custom_ctrl_as_parent = true;
 
    // if we have an extra column, build it
    if (extra_column) {
        m_extra_column_item_ptrs.push_back(extra_column(this->ctrl_parent(), line));
        grid_sizer->Add(m_extra_column_item_ptrs.back(), 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 3);
    }
 
    // Build a label if we have it
    wxStaticText* label = nullptr;
    if (label_width != 0) {
        if (custom_ctrl) {
            if (line.near_label_widget)
                line.near_label_widget_win = line.near_label_widget(this->ctrl_parent());
        } else {
            if (!line.near_label_widget || !line.label.IsEmpty()) {
                // Only create the label if it is going to be displayed.
                long label_style = staticbox ? 0 : wxALIGN_RIGHT;
#ifdef __WXGTK__
                // workaround for correct text align of the StaticBox on Linux
                // flags wxALIGN_RIGHT and wxALIGN_CENTRE don't work when Ellipsize flags are _not_ given.
                // Text is properly aligned only when Ellipsize is checked.
                label_style |= staticbox ? 0 : wxST_ELLIPSIZE_END;
#endif /* __WXGTK__ */
                label = new wxStaticText(this->ctrl_parent(), wxID_ANY, line.label + (line.label.IsEmpty() ? "" : ": "), wxDefaultPosition,
                                         wxSize(label_width * wxGetApp().em_unit(), -1), label_style);
                label->SetBackgroundStyle(wxBG_STYLE_PAINT);
                label->SetFont(wxGetApp().normal_font());
                label->Wrap(label_width * wxGetApp().em_unit()); // avoid a Linux/GTK bug
            }
            if (!line.near_label_widget)
                grid_sizer->Add(label, 0, (staticbox ? 0 : wxALIGN_RIGHT | wxRIGHT) | wxALIGN_CENTER_VERTICAL, line.label.IsEmpty() ? 0 : 5);
            else if (!line.label.IsEmpty()) {
                // If we're here, we have some widget near the label
                // so we need a horizontal sizer to arrange these things
                auto sizer = new wxBoxSizer(wxHORIZONTAL);
                grid_sizer->Add(sizer, 0, wxEXPAND | (staticbox ? wxALL : wxBOTTOM | wxTOP | wxLEFT), staticbox ? 0 : 1);
                sizer->Add(label, 0, (staticbox ? 0 : wxALIGN_RIGHT | wxRIGHT) | wxALIGN_CENTER_VERTICAL, 5);
            }
            if (label != nullptr && line.label_tooltip != "")
                label->SetToolTip(line.label_tooltip);
            line.label_widget = label;
        }
    }
 
    // If there's a widget, build it and add the result to the sizer.
    if (line.widget != nullptr) {
        auto wgt = line.widget(this->ctrl_parent());
        if (custom_ctrl)
            line.widget_sizer = wgt;
        else
            grid_sizer->Add(wgt, 0, wxEXPAND | wxBOTTOM | wxTOP, (wxOSX || line.label.IsEmpty()) ? 0 : 5);
        return;
    }
 
    // If we're here, we have more than one option or a single option with sidetext
    // so we need a horizontal sizer to arrange these things
    auto sizer = custom_ctrl ? nullptr : new wxBoxSizer(wxHORIZONTAL);
    if (!custom_ctrl)
        grid_sizer->Add(sizer, 0, wxEXPAND | (staticbox ? wxALL : wxBOTTOM | wxTOP | wxLEFT), staticbox ? 0 : 1);
    // If we have a single option with no sidetext just add it directly to the grid sizer
    if (option_set.size() == 1 && option_set.front().opt.sidetext.size() == 0 && option_set.front().side_widget == nullptr &&
        line.get_extra_widgets().size() == 0) {
        const auto& option = option_set.front();
        const auto& field  = build_field(option);
 
        if (!custom_ctrl) {
            int flags = option.opt.full_width ? wxEXPAND : wxALIGN_CENTER_VERTICAL;
            if (m_labels_hidden)
                flags &= ~wxALIGN_CENTER_VERTICAL;
            int border = (wxOSX || !staticbox) ? 0 : 2;
 
            if (is_window_field(field))
                sizer->Add(field->getWindow(), option.opt.full_width ? 1 : 0, wxBOTTOM | wxTOP | flags, border);
            if (is_sizer_field(field))
                sizer->Add(field->getSizer(), 1, flags, 0);
        }
        return;
    }
 
    bool is_multioption_line = option_set.size() > 1;
    for (auto opt : option_set) {
        ConfigOptionDef option = opt.opt;
        wxSizer* sizer_tmp     = sizer;
        // add label if any
        if ((is_multioption_line || line.label.IsEmpty()) && !option.label.empty() && !custom_ctrl) {
            wxString str_label = (option.label == L_CONTEXT("Top", "Layers") || option.label == L_CONTEXT("Bottom", "Layers")) ?
                                     _L_CONTEXT(option.label, "Layers") :
                                     _(option.label);
            label = new wxStaticText(this->ctrl_parent(), wxID_ANY, str_label + ": ", wxDefaultPosition, // wxDefaultSize);
                                     wxSize(sublabel_width != -1 ? sublabel_width * wxGetApp().em_unit() : -1, -1), wxALIGN_RIGHT);
            label->SetBackgroundStyle(wxBG_STYLE_PAINT);
            label->SetFont(wxGetApp().normal_font());
            sizer_tmp->Add(label, 0, wxALIGN_CENTER_VERTICAL, 0);
        }
 
        // add field
        const Option& opt_ref = opt;
        auto& field           = build_field(opt_ref);
        if (!custom_ctrl) {
            if (option_set.size() == 1 && option_set.front().opt.full_width) {
                const auto v_sizer = new wxBoxSizer(wxVERTICAL);
                sizer_tmp->Add(v_sizer, 1, wxEXPAND);
                is_sizer_field(field) ? v_sizer->Add(field->getSizer(), 0, wxEXPAND) : v_sizer->Add(field->getWindow(), 0, wxEXPAND);
                break;
            }
 
            is_sizer_field(field) ? sizer_tmp->Add(field->getSizer(), 0, wxALIGN_CENTER_VERTICAL, 0) :
                                    sizer_tmp->Add(field->getWindow(), 0, wxALIGN_CENTER_VERTICAL, 0);
 
            // add sidetext if any
            if (!field->combine_side_text() && (!option.sidetext.empty() || sidetext_width > 0)) {
                auto sidetext = new wxStaticText(this->ctrl_parent(), wxID_ANY, _(option.sidetext), wxDefaultPosition,
                                                 wxSize(sidetext_width != -1 ? sidetext_width * wxGetApp().em_unit() : -1, -1),
                                                 wxALIGN_LEFT);
                sidetext->SetBackgroundStyle(wxBG_STYLE_PAINT);
                sidetext->SetFont(wxGetApp().normal_font());
                sizer_tmp->Add(sidetext, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 4);
            }
 
            // add side widget if any
            if (opt.side_widget != nullptr) {
                sizer_tmp->Add(opt.side_widget(this->ctrl_parent()) , 0, wxLEFT | wxALIGN_CENTER_VERTICAL,
                               1); 
            }
 
            if (opt.opt_id != option_set.back().opt_id) 
                sizer_tmp->AddSpacer(6);
        }
    }
 
    // add extra sizers if any
    for (auto extra_widget : line.get_extra_widgets()) {
        if (line.get_extra_widgets().size() == 1 && !staticbox) {
            // extra widget for non-staticbox option group (like for the frequently used parameters on the sidebar) should be wxALIGN_RIGHT
            const auto v_sizer = new wxBoxSizer(wxVERTICAL);
            sizer->Add(v_sizer, option_set.size() == 1 ? 0 : 1, wxEXPAND);
            v_sizer->Add(extra_widget(this->ctrl_parent()), 0, wxALIGN_RIGHT);
            return;
        }
 
        line.extra_widget_sizer = extra_widget(this->ctrl_parent());
        if (!custom_ctrl)
            sizer->Add(line.extra_widget_sizer, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, 4); 
    }
}

References _, _L_CONTEXT, build_field(), ctrl_parent(), custom_ctrl, Slic3r::GUI::Field::def_width(), Slic3r::GUI::Field::def_width_thinner(), em_unit(), extra_column, Slic3r::GUI::Line::extra_widget_sizer, Slic3r::GUI::Line::full_width, Slic3r::GUI::Line::get_extra_widgets(), Slic3r::GUI::Line::get_options(), is_legend_line(), Slic3r::GUI::Line::is_separator(), Slic3r::GUI::is_sizer_field(), Slic3r::GUI::is_window_field(), L_CONTEXT, Slic3r::ConfigOptionDef::label, Slic3r::GUI::Line::label, Slic3r::GUI::Line::label_tooltip, Slic3r::GUI::Line::label_widget, label_width, Slic3r::ConfigOptionDef::legend, m_extra_column_item_ptrs, m_grid_sizer, m_labels_hidden, m_use_custom_ctrl, m_use_custom_ctrl_as_parent, Slic3r::GUI::Line::near_label_widget, Slic3r::GUI::Line::near_label_widget_win, parent(), Slic3r::ConfigOptionDef::sidetext, sidetext_width, sizer, staticbox, stb, sublabel_width, Slic3r::GUI::titleWidth, Slic3r::GUI::Line::widget, Slic3r::GUI::Line::widget_sizer, wxOSX, and wxStaticText.

Referenced by activate().

Here is the call graph for this function:

Here is the caller graph for this function:

append_line()

void Slic3r::GUI::OptionsGroup::append_line ( const Line & line )

inherited

{
    m_lines.emplace_back(line);
 
    // Feed the searcher the row's wiki path (Line::label_path, for the Speed Dial's "open wiki"
    // affordance) and the label the row actually draws, so a setting action is named like the page.
    if (m_use_custom_ctrl) {
        Search::SettingsIndex& index = wxGetApp().sidebar().settings_index();
        const Preset::Type      type  = static_cast<Preset::Type>(config_type());
        const bool              multi = line.get_options().size() > 1;
        for (const auto& opt : line.get_options()) {
            if (!line.label_path.empty())
                index.set_path(opt.opt_id, type, line.label_path);
            // Mirror the sub-label OG_CustomCtrl draws for a multi-option row, so the palette
            // names each field like the page does.
            const std::string& leaf_src = opt.opt.label;
            const wxString leaf = (leaf_src == L_CONTEXT("Top", "Layers") || leaf_src == L_CONTEXT("Bottom", "Layers")) ?
                                      _L_CONTEXT(leaf_src, "Layers") :
                                      _(leaf_src);
            index.set_line_label(opt.opt_id, type, Search::compose_display_label(line.label, leaf, multi),
                                 Search::compose_display_label(line.label_en, from_u8(leaf_src), multi));
        }
    }
 
    if (line.full_width && (line.widget != nullptr || !line.get_extra_widgets().empty()))
        return;
 
    auto option_set = line.get_options();
    for (auto opt : option_set)
        m_options.emplace(opt.opt_id, opt);
 
    // add mode value for current line to m_options_mode
    if (!option_set.empty())
        m_options_mode.push_back(option_set[0].opt.mode);
}

References _, _L_CONTEXT, Slic3r::Search::compose_display_label(), config_type(), Slic3r::GUI::from_u8(), Slic3r::GUI::Line::full_width, Slic3r::GUI::Line::get_extra_widgets(), Slic3r::GUI::Line::get_options(), L_CONTEXT, Slic3r::GUI::Line::label, Slic3r::GUI::Line::label_en, Slic3r::GUI::Line::label_path, m_lines, m_options, m_options_mode, m_use_custom_ctrl, Slic3r::Search::SettingsIndex::set_line_label(), Slic3r::Search::SettingsIndex::set_path(), and Slic3r::GUI::Line::widget.

Referenced by append_single_option_line(), Slic3r::GUI::Tab::build_preset_description_line(), and Slic3r::GUI::Tab::create_line_with_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

append_separator()

void Slic3r::GUI::OptionsGroup::append_separator ( )

inherited

{ m_lines.emplace_back(Line()); }

References m_lines.

append_single_option_line() [1/2]

void Slic3r::GUI::ConfigOptionsGroup::append_single_option_line ( const Option & option, const std::string & path = std::string() )

inline

                                                                                                {
    OptionsGroup::append_single_option_line(option, path);
  }

References Slic3r::GUI::OptionsGroup::append_single_option_line().

Referenced by append_single_option_line(), and Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

append_single_option_line() [2/2]

void Slic3r::GUI::ConfigOptionsGroup::append_single_option_line ( const std::string title, const std::string & path = std::string(), int idx = -1 )

inline

  {
    Option option = get_option(title, idx);
    append_single_option_line(option, path);
  }

References append_single_option_line(), get_option(), and Slic3r::GUI::OptionsGroup::title.

Here is the call graph for this function:

back_to_config_value()

void Slic3r::GUI::ConfigOptionsGroup::back_to_config_value	(	const DynamicPrintConfig &	config,
		const std::string &	opt_key )

{
    boost::any value;
    if (opt_key == "extruders_count") {
        auto* nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(config.option("nozzle_diameter"));
        value                 = int(nozzle_diameter->values.size());
    }
#if 0
    // BBS
    else if (opt_key == "bed_temperature" || opt_key == "bed_temperature_initial_layer") {
        // BBS: config is preset initial value, not presets.m_edited_preset,
        // so bed_type value does not contains modification.
        //int bed_type = config.opt_enum("bed_type", 0);
        if (!this->get_field("bed_type")) {
            value = 0;
            throw Slic3r::InvalidArgument("Too old 3MF which has no bed_type field.");
        } else {
            int bed_type = boost::any_cast<int>(this->get_field("bed_type")->get_value());
            const ConfigOptionInts* bed_temps = dynamic_cast<const ConfigOptionInts*>(config.option(opt_key));
            value = bed_type < bed_temps->size() ? bed_temps->get_at(bed_type) : 0;
        }
    }
#endif
    else if (opt_key == "printer_agent")
    {
        // A deregistered/"(missing)" saved id has no selectable row, so the field yields no
        // value. Restore the saved id directly instead of letting the generic revert path read
        // the field value back into the edited config.
        const std::string saved_id = config.opt_string("printer_agent");
        set_value(opt_key, saved_id);
        this->change_opt_value(opt_key, saved_id);
        OptionsGroup::on_change_OG(opt_key, saved_id);
        return;
    }
    else if (m_opt_map.find(opt_key) == m_opt_map.end() ||
             // This option don't have corresponded field
             opt_key == "printable_area" || opt_key == "compatible_printers" || opt_key == "compatible_prints" || opt_key == "thumbnails" ||
             opt_key == "bed_custom_texture" || opt_key == "bed_custom_model") {
        value = get_config_value(config, opt_key);
        set_value(opt_key, value);
        this->change_opt_value(opt_key, get_value(opt_key));
        OptionsGroup::on_change_OG(opt_key, get_value(opt_key));
        return;
    } else {
        auto opt_id               = m_opt_map.find(opt_key)->first;
        std::string opt_short_key = m_opt_map.at(opt_id).first;
        int opt_index             = m_opt_map.at(opt_id).second;
        value                     = get_config_value(config, opt_short_key, opt_index);
    }
 
    // BBS: restore all pages in preset
    if (set_value(opt_key, value))
        on_change_OG(opt_key, get_value(opt_key));
    else if (m_opt_map.find(opt_key) != m_opt_map.end()) {
        auto opt_id               = m_opt_map.find(opt_key)->first;
        std::string opt_short_key = m_opt_map.at(opt_id).first;
        int opt_index             = m_opt_map.at(opt_id).second;
        on_change_OG(opt_key, get_config_value2(config, opt_short_key, opt_index));
    }
}

References change_opt_value(), Slic3r::ConfigOptionVector< int >::get_at(), get_config_value(), get_config_value2(), Slic3r::GUI::OptionsGroup::get_field(), Slic3r::GUI::OptionsGroup::get_value(), m_opt_map, Slic3r::nozzle_diameter(), on_change_OG(), Slic3r::GUI::OptionsGroup::on_change_OG(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::GUI::OptionsGroup::set_value(), and Slic3r::ConfigOptionVector< int >::size().

Referenced by back_to_initial_value(), and back_to_sys_value().

Here is the call graph for this function:

Here is the caller graph for this function:

back_to_initial_value()

void Slic3r::GUI::ConfigOptionsGroup::back_to_initial_value ( const std::string & opt_key )

overridevirtual

Reimplemented from Slic3r::GUI::OptionsGroup.

{
    if (m_get_initial_config == nullptr)
        return;
    back_to_config_value(m_get_initial_config(), opt_key);
}

References back_to_config_value(), and Slic3r::GUI::OptionsGroup::m_get_initial_config.

Here is the call graph for this function:

back_to_sys_value()

void Slic3r::GUI::ConfigOptionsGroup::back_to_sys_value ( const std::string & opt_key )

overridevirtual

Reimplemented from Slic3r::GUI::OptionsGroup.

{
    if (m_get_sys_config == nullptr)
        return;
    if (!have_sys_config())
        return;
    back_to_config_value(m_get_sys_config(), opt_key);
}

References back_to_config_value(), Slic3r::GUI::OptionsGroup::have_sys_config, and Slic3r::GUI::OptionsGroup::m_get_sys_config.

Here is the call graph for this function:

build_field() [1/3]

const t_field & Slic3r::GUI::OptionsGroup::build_field ( const Option & opt )

protectedinherited

{ return build_field(opt.opt_id, opt.opt); }

References build_field().

Here is the call graph for this function:

build_field() [2/3]

const t_field & Slic3r::GUI::OptionsGroup::build_field ( const t_config_option_key & id )

protectedinherited

{
    const ConfigOptionDef& opt = m_options.at(id).opt;
    return build_field(id, opt);
}

References build_field(), and m_options.

Here is the call graph for this function:

build_field() [3/3]

const t_field & Slic3r::GUI::OptionsGroup::build_field ( const t_config_option_key & id, const ConfigOptionDef & opt )

protectedinherited

Generate a wxSizer or wxWindow from a configuration option Precondition: opt resolves to a known ConfigOption Postcondition: fields contains a wx gui object.

This function will be called from Field. Call OptionGroup._on_change(...)

This function will be called from Field.

{
    // Check the gui_type field first, fall through
    // is the normal type.
    switch (opt.gui_type) {
    case ConfigOptionDef::GUIType::select_open: m_fields.emplace(id, Choice::Create<Choice>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::color: m_fields.emplace(id, ColourPicker::Create<ColourPicker>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::f_enum_open:
    case ConfigOptionDef::GUIType::i_enum_open: m_fields.emplace(id, Choice::Create<Choice>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::slider: m_fields.emplace(id, SliderCtrl::Create<SliderCtrl>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::legend: // StaticText
        m_fields.emplace(id, StaticText::Create<StaticText>(this->ctrl_parent(), opt, id));
        break;
    case ConfigOptionDef::GUIType::one_string: m_fields.emplace(id, TextCtrl::Create<TextCtrl>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::plugin_picker: m_fields.emplace(id, PluginField::Create<PluginField>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::plugin_config: m_fields.emplace(id, PluginConfigField::Create<PluginConfigField>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::printer_agent_select: m_fields.emplace(
            id, PrinterAgentChoice::Create<PrinterAgentChoice>(this->ctrl_parent(), opt, id));
        break;
    default:
        switch (opt.type) {
            case coFloatOrPercent:
            case coFloatsOrPercents:
            case coFloat:
            case coFloats:
      case coPercent:
      case coPercents:
      case coString:
      case coStrings:
                m_fields.emplace(id, TextCtrl::Create<TextCtrl>(this->ctrl_parent(), opt, id));
                break;
      case coBool:
      case coBools:
                m_fields.emplace(id, CheckBox::Create<CheckBox>(this->ctrl_parent(), opt, id));
        break;
      case coInt:
      case coInts:
                m_fields.emplace(id, SpinCtrl::Create<SpinCtrl>(this->ctrl_parent(), opt, id));
        break;
            case coEnum:
            case coEnums:
                m_fields.emplace(id, Choice::Create<Choice>(this->ctrl_parent(), opt, id));
        break;
            case coPoint:
            case coPoints:
                m_fields.emplace(id, PointCtrl::Create<PointCtrl>(this->ctrl_parent(), opt, id));
        break;
            case coNone:   break;
            default:
        throw Slic3r::LogicError("This control doesn't exist till now"); break;
        }
    }
    // Grab a reference to fields for convenience
    const t_field& field = m_fields[id];
    field->m_on_change   = [this](const std::string& opt_id, const boost::any& value) {
        if (!m_disabled)
            this->on_change_OG(opt_id, value);
    };
    field->m_on_kill_focus = [this](const std::string& opt_id) {
        if (!m_disabled)
            this->on_kill_focus(opt_id);
    };
    field->m_parent = parent();
 
    if (edit_custom_gcode && opt.is_code) {
        field->m_fn_edit_value = [this](std::string opt_id) {
            if (!m_disabled)
                this->edit_custom_gcode(opt_id);
        };
        field->set_edit_tooltip(_L("Edit Custom G-code"));
    }
 
    field->m_back_to_initial_value = [this](std::string opt_id) {
        if (!m_disabled)
            this->back_to_initial_value(opt_id);
    };
    field->m_back_to_sys_value = [this](std::string opt_id) {
        if (!this->m_disabled)
            this->back_to_sys_value(opt_id);
    };
 
    if (auto plugin_field = dynamic_cast<PluginField*>(field.get())) {
        plugin_field->set_selector([this, plugin_field]() -> std::string {
            if (m_disabled)
                return {};
            return this->pick_plugin(plugin_field->m_opt);
        });
    }
 
    // The dialog behind the button edits one preset's overrides, so it has to know which preset. Set
    // here because fields are built lazily on activate() — too late for the Tab to reach in afterwards.
    if (auto plugin_config_field = dynamic_cast<PluginConfigField*>(field.get()))
        if (auto config_group = dynamic_cast<ConfigOptionsGroup*>(this))
            plugin_config_field->set_preset_type(config_group->config_type());
 
    // assign function objects for callbacks, etc.
    return field;
}

References _L, back_to_initial_value(), back_to_sys_value(), Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::ConfigOptionDef::color, Slic3r::coNone, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::GUI::Field::Create(), ctrl_parent(), edit_custom_gcode, Slic3r::ConfigOptionDef::f_enum_open, Slic3r::ConfigOptionDef::i_enum_open, Slic3r::ConfigOptionDef::legend, m_disabled, m_fields, on_change_OG(), on_kill_focus(), Slic3r::ConfigOptionDef::one_string, parent(), pick_plugin(), Slic3r::ConfigOptionDef::plugin_config, Slic3r::ConfigOptionDef::plugin_picker, Slic3r::ConfigOptionDef::printer_agent_select, Slic3r::ConfigOptionDef::select_open, and Slic3r::ConfigOptionDef::slider.

Referenced by activate_line(), build_field(), and build_field().

Here is the call graph for this function:

Here is the caller graph for this function:

change_opt_value()

void Slic3r::GUI::ConfigOptionsGroup::change_opt_value ( const t_config_option_key & opt_key, const boost::any & value, int opt_index = 0 )

protected

{
    Slic3r::GUI::change_opt_value(const_cast<DynamicPrintConfig&>(*m_config), opt_key, value, opt_index);
    if (m_modelconfig)
        m_modelconfig->touch();
}

References Slic3r::GUI::change_opt_value(), m_config, and m_modelconfig.

Referenced by back_to_config_value(), on_change_OG(), and Slic3r::GUI::ExtruderOptionsGroup::on_change_OG().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::GUI::OptionsGroup::clear ( bool destroy_custom_ctrl = false )

inherited

{
    if (!sizer)
        return;
 
    m_grid_sizer = nullptr;
    sizer        = nullptr;
    stb          = nullptr; // BBS: fix pointer
 
    for (Line& line : m_lines) {
        if (line.near_label_widget_win)
            line.near_label_widget_win = nullptr;
        line.label_widget = nullptr;
 
        if (line.widget_sizer) {
            line.widget_sizer->Clear(true);
            line.widget_sizer = nullptr;
        }
 
        if (line.extra_widget_sizer) {
            line.extra_widget_sizer->Clear(true);
            line.extra_widget_sizer = nullptr;
        }
    }
 
    if (custom_ctrl) {
        for (auto const& item : m_fields) {
            wxWindow* win = item.second.get()->getWindow();
            if (win) {
                free_window(win);
                win = nullptr;
            }
        }
        // BBS: custom_ctrl already destroyed from sizer->clear(), no need to destroy here anymore
        if (destroy_custom_ctrl)
            // custom_ctrl->Destroy();
            custom_ctrl = nullptr;
        else
            custom_ctrl = nullptr;
    }
 
    m_extra_column_item_ptrs.clear();
    m_fields.clear();
}

References custom_ctrl, Slic3r::GUI::free_window(), m_extra_column_item_ptrs, m_fields, m_grid_sizer, m_lines, sizer, and stb.

Referenced by ~OptionsGroup(), and activate().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_fields_except_of()

void Slic3r::GUI::OptionsGroup::clear_fields_except_of ( const std::vector< std::string > left_fields )

inherited

{
    auto it = m_fields.begin();
    while (it != m_fields.end()) {
        if (std::find(left_fields.begin(), left_fields.end(), it->first) == left_fields.end())
            it = m_fields.erase(it);
        else
            it++;
    }
}

References m_fields.

commit_config_value()

bool Slic3r::GUI::ConfigOptionsGroup::commit_config_value	(	const t_config_option_key &	opt_key,
		int	opt_index = -1 )

{
    if (m_config == nullptr)
        return false;
 
    // m_opt_map is filled while the option lines are created, so it still resolves the option when
    // the group's controls (and thus its fields) have not been built yet.
    const std::string opt_id = option_id_in_map(m_opt_map, opt_key, opt_index);
    if (opt_id.empty())
        return false;
 
    on_change_OG(opt_id, get_config_value2(*m_config, opt_key, opt_index));
    return true;
}

References get_config_value2(), m_config, m_opt_map, on_change_OG(), and Slic3r::GUI::option_id_in_map().

Here is the call graph for this function:

config_category()

const wxString & Slic3r::GUI::ConfigOptionsGroup::config_category ( ) const throw (  )

inline

{ return m_config_category; }

References m_config_category.

Referenced by get_option().

Here is the caller graph for this function:

config_type()

int Slic3r::GUI::ConfigOptionsGroup::config_type ( ) const throw (  )

inlineoverridevirtual

Reimplemented from Slic3r::GUI::OptionsGroup.

{ return m_config_type; }

References m_config_type.

Referenced by get_option().

Here is the caller graph for this function:

config_value()

boost::any Slic3r::GUI::ConfigOptionsGroup::config_value	(	const std::string &	opt_key,
		int	opt_index,
		bool	deserialize )

{
    if (opt_key == "bed_type")
        return boost::any((int) BedType::btPC);
 
    if (deserialize) {
        // Want to edit a vector value(currently only multi - strings) in a single edit box.
        // Aggregate the strings the old way.
        // Currently used for the post_process config value only.
        if (opt_index != -1)
            throw Slic3r::OutOfRange("Can't deserialize option indexed value");
        //    return join(';', m_config->get(opt_key)});
        return get_config_value(*m_config, opt_key);
    } else {
        //    return opt_index == -1 ? m_config->get(opt_key) : m_config->get_at(opt_key, opt_index);
        return get_config_value(*m_config, opt_key, opt_index);
    }
}

References Slic3r::btPC, get_config_value(), m_config, and Slic3r::OutOfRange.

Referenced by reload_config().

Here is the call graph for this function:

Here is the caller graph for this function:

create_single_option_line() [1/2]

Line Slic3r::GUI::ConfigOptionsGroup::create_single_option_line ( const Option & option, const std::string & path = std::string() ) const

inline

                                                                                                     {
    return OptionsGroup::create_single_option_line(option, path);
  }

References Slic3r::GUI::OptionsGroup::create_single_option_line().

Here is the call graph for this function:

create_single_option_line() [2/2]

Line Slic3r::GUI::ConfigOptionsGroup::create_single_option_line ( const std::string & title, const std::string & path = std::string(), int idx = -1 )

inline

                                                                                                                {
    Option option = get_option(title, idx);
    return OptionsGroup::create_single_option_line(option, path);
  }

References Slic3r::GUI::OptionsGroup::create_single_option_line(), get_option(), and Slic3r::GUI::OptionsGroup::title.

Referenced by Slic3r::GUI::Tab::create_line_with_widget().

Here is the call graph for this function:

Here is the caller graph for this function:

ctrl_parent()

wxWindow * Slic3r::GUI::OptionsGroup::ctrl_parent ( ) const

inherited

{
    // BBS: new layout
    return this->custom_ctrl && m_use_custom_ctrl_as_parent ? static_cast<wxWindow*>(this->custom_ctrl) :
                                                              (staticbox ? static_cast<wxWindow*>(this->stb) : this->parent());
}

References custom_ctrl, m_use_custom_ctrl_as_parent, parent(), staticbox, and stb.

Referenced by activate_line(), and build_field().

Here is the call graph for this function:

Here is the caller graph for this function:

disable()

void Slic3r::GUI::OptionsGroup::disable ( )

inlineinherited

{ for (auto& field : m_fields) field.second->disable(); }

References m_fields.

disable_field()

void Slic3r::GUI::OptionsGroup::disable_field ( const t_config_option_key & opt_key )

inlineinherited

{ enable_field(opt_key, false); }

References enable_field().

Here is the call graph for this function:

enable()

void Slic3r::GUI::OptionsGroup::enable ( )

inlineinherited

{ for (auto& field : m_fields) field.second->enable(); }

References m_fields.

Referenced by enable_field().

Here is the caller graph for this function:

enable_field()

void Slic3r::GUI::OptionsGroup::enable_field ( const t_config_option_key & opt_key, bool enable = true )

inherited

{
    if (Field* f = get_field(opt_key); f) {
        f->toggle(enable);
    }
}

References enable(), Slic3r::f(), and get_field().

Referenced by disable_field().

Here is the call graph for this function:

Here is the caller graph for this function:

get_config_value()

boost::any Slic3r::GUI::ConfigOptionsGroup::get_config_value	(	const DynamicPrintConfig &	config,
		const std::string &	opt_key,
		int	opt_index = -1 )

{
    size_t idx = opt_index == -1 ? 0 : opt_index;
 
    boost::any ret;
    wxString text_value        = wxString("");
    const ConfigOptionDef* opt = config.def()->get(opt_key);
 
    if (opt->nullable) {
        switch (opt->type) {
        case coPercents:
        case coFloats: {
            if (opt_index < 0 ? config.option(opt_key)->is_nil() :
                                dynamic_cast<ConfigOptionVectorBase const*>(config.option(opt_key))->is_nil(opt_index))
                ret = _(L("N/A"));
            else {
                double val = opt->type == coFloats ? config.option<ConfigOptionFloatsNullable>(opt_key)->get_at(idx) :
                                                     config.option<ConfigOptionPercentsNullable>(opt_key)->get_at(idx);
                ret        = double_to_string(val);
            }
            break;
        }
        case coFloatsOrPercents: {
            if (opt_index < 0 ? config.option(opt_key)->is_nil() :
                                dynamic_cast<ConfigOptionVectorBase const*>(config.option(opt_key))->is_nil(opt_index))
                ret = _(L("N/A"));
            else {
                const auto& value = config.option<ConfigOptionFloatsOrPercentsNullable>(opt_key)->get_at(idx);
                text_value        = double_to_string(value.value);
                if (value.percent)
                    text_value += "%";
 
                ret = text_value;
            }
            break;
        }
        case coBools: ret = config.option<ConfigOptionBoolsNullable>(opt_key)->values[idx]; break;
        case coInts: ret = config.option<ConfigOptionIntsNullable>(opt_key)->get_at(idx); break;
        case coEnums: ret = config.option<ConfigOptionEnumsGenericNullable>(opt_key)->get_at(idx); break;
        default: break;
        }
        return ret;
    }
 
    switch (opt->type) {
    case coFloatOrPercent: {
        const auto& value = *config.option<ConfigOptionFloatOrPercent>(opt_key);
 
        text_value = double_to_string(value.value);
        if (value.percent)
            text_value += "%";
 
        ret = text_value;
        break;
    }
    case coFloatsOrPercents: {
        const auto& value = config.option<ConfigOptionFloatsOrPercents>(opt_key)->get_at(idx);
 
        text_value = double_to_string(value.value);
        if (value.percent)
            text_value += "%";
 
        ret = text_value;
        break;
    }
    case coPercent: {
        double val = config.option<ConfigOptionPercent>(opt_key)->value;
        ret        = double_to_string(val); // += "%";
    } break;
    case coPercents:
    case coFloats:
    case coFloat: {
        if (opt_key == "extruder_printable_height") {
            auto opt_values = dynamic_cast<const ConfigOptionFloatsNullable*>(config.option(opt_key))->values;
            if (!opt_values.empty()) {
                double val = opt_values[idx];
                ret        = double_to_string(val);
            }
        } else {
            double val = opt->type == coFloats ? config.opt_float(opt_key, idx) :
                         opt->type == coFloat  ? config.opt_float(opt_key) :
                                                 config.option<ConfigOptionPercents>(opt_key)->get_at(idx);
            ret        = double_to_string(val);
        }
        break;
    }
    case coString: ret = from_u8(config.opt_string(opt_key)); break;
    case coStrings:
        if (opt_key == "compatible_printers" || opt_key == "compatible_prints") {
            ret = config.option<ConfigOptionStrings>(opt_key)->values;
            break;
        }
        if (opt->gui_type == ConfigOptionDef::GUIType::plugin_picker) {
            ret = config.option<ConfigOptionStrings>(opt_key)->values;
            break;
        }
        if (config.option<ConfigOptionStrings>(opt_key)->values.empty())
            ret = text_value;
        else if (opt->gui_flags == "serialized") {
            std::vector<std::string> values = config.option<ConfigOptionStrings>(opt_key)->values;
            if (!values.empty() && !values[0].empty())
                for (auto el : values)
                    text_value += el + ";";
            ret = text_value;
        } else
            ret = from_u8(config.opt_string(opt_key, static_cast<unsigned int>(idx)));
        break;
    case coBool: ret = config.opt_bool(opt_key); break;
    case coBools: ret = config.opt_bool(opt_key, idx); break;
    case coInt: ret = config.opt_int(opt_key); break;
    case coInts: ret = config.opt_int(opt_key, idx); break;
    case coEnum:
        if (!config.has("first_layer_sequence_choice") && opt_key == "first_layer_sequence_choice") {
            // reset to Auto value
            ret = 0;
            break;
        }
        if (!config.has("other_layers_sequence_choice") && opt_key == "other_layers_sequence_choice") {
            // reset to Auto value
            ret = 0;
            break;
        }
        if (!config.has("curr_bed_type") && opt_key == "curr_bed_type") {
            // reset to global value
            DynamicConfig& global_cfg = wxGetApp().preset_bundle->project_config;
            ret                       = global_cfg.option("curr_bed_type")->getInt();
            break;
        }
        ret = config.option(opt_key)->getInt();
        break;
    // BBS
    case coEnums: ret = config.opt_int(opt_key, idx); break;
    case coPoint: ret = config.option<ConfigOptionPoint>(opt_key)->value; break;
    case coPoints:
        if (opt_key == "printable_area")
            ret = get_thumbnails_string(config.option<ConfigOptionPoints>(opt_key)->values);
        else if (opt_key == "bed_exclude_area")
            ret = from_u8(config.option<ConfigOptionPoints>(opt_key)->serialize());
        else if (opt_key == "wrapping_exclude_area")
            ret = get_thumbnails_string(config.option<ConfigOptionPoints>(opt_key)->values);
        else
            ret = config.option<ConfigOptionPoints>(opt_key)->get_at(idx);
        break;
    case coPointsGroups:
        if (opt_key == "extruder_printable_area") {
            auto values = config.option<ConfigOptionPointsGroups>(opt_key)->values;
            if (!values.empty())
                ret = get_thumbnails_string(config.option<ConfigOptionPointsGroups>(opt_key)->get_at(idx));
        } else
            ret = config.option<ConfigOptionPointsGroups>(opt_key)->get_at(idx);
        break;
    case coNone:
    default: break;
    }
    return ret;
}

References _, Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coNone, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoints, Slic3r::coPointsGroups, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), Slic3r::GUI::double_to_string(), Slic3r::GUI::from_u8(), Slic3r::ConfigDef::get(), Slic3r::ConfigOptionVector< T >::get_at(), Slic3r::GUI::get_thumbnails_string(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionVectorBase::is_nil(), L, Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionDef::plugin_picker, Slic3r::ConfigOptionPoints::serialize(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by back_to_config_value(), config_value(), and Slic3r::GUI::Tab::on_value_change().

Here is the call graph for this function:

Here is the caller graph for this function:

get_config_value2()

boost::any Slic3r::GUI::ConfigOptionsGroup::get_config_value2	(	const DynamicPrintConfig &	config,
		const std::string &	opt_key,
		int	opt_index = -1 )

{
    size_t idx = opt_index == -1 ? 0 : opt_index;
 
    boost::any ret;
    const ConfigOptionDef* opt = config.def()->get(opt_key);
 
    if (opt->nullable) {
        switch (opt->type) {
        case coPercents:
        case coFloats: {
            if (config.option(opt_key)->is_nil())
                ret = ConfigOptionFloatsNullable::nil_value();
            else {
                double val = opt->type == coFloats ? config.option<ConfigOptionFloatsNullable>(opt_key)->get_at(idx) :
                                                     config.option<ConfigOptionPercentsNullable>(opt_key)->get_at(idx);
                ret        = val;
            }
        } break;
        case coFloatsOrPercents: {
            if (config.option(opt_key)->is_nil())
                ret = ConfigOptionFloatsOrPercentsNullable::nil_value();
            else {
                const auto& value   = config.option<ConfigOptionFloatsOrPercentsNullable>(opt_key)->get_at(idx);
                wxString text_value = double_to_string(value.value);
                if (value.percent)
                    text_value += "%";
 
                ret = text_value;
            }
            break;
        }
        case coBools: ret = config.option<ConfigOptionBoolsNullable>(opt_key)->values[idx]; break;
        case coInts: ret = config.option<ConfigOptionIntsNullable>(opt_key)->get_at(idx); break;
        default: break;
        }
        return ret;
    }
 
    switch (opt->type) {
    case coFloatOrPercent: {
        const auto& value = *config.option<ConfigOptionFloatOrPercent>(opt_key);
 
        wxString text_value = double_to_string(value.value);
        if (value.percent)
            text_value += "%";
 
        ret = into_u8(text_value);
        break;
    }
    case coPercent: {
        double val = config.option<ConfigOptionPercent>(opt_key)->value;
        ret        = val;
    } break;
    case coPercents:
    case coFloats:
    case coFloat: {
        double val = opt->type == coFloats ? config.opt_float(opt_key, idx) :
                     opt->type == coFloat  ? config.opt_float(opt_key) :
                                             config.option<ConfigOptionPercents>(opt_key)->get_at(idx);
        ret        = val;
    } break;
    case coString: ret = config.opt_string(opt_key); break;
    case coStrings:
        if (opt_key == "compatible_printers" || opt_key == "compatible_prints") {
            ret = config.option<ConfigOptionStrings>(opt_key)->values;
            break;
        }
        if (opt->gui_type == ConfigOptionDef::GUIType::plugin_picker) {
            ret = config.option<ConfigOptionStrings>(opt_key)->values;
            break;
        }
        if (config.option<ConfigOptionStrings>(opt_key)->values.empty())
            ret = std::string();
        else if (opt->gui_flags == "serialized") {
            ret = config.option<ConfigOptionStrings>(opt_key)->values;
        } else
            ret = config.opt_string(opt_key, static_cast<unsigned int>(idx));
        break;
    case coBool: ret = config.opt_bool(opt_key); break;
    case coBools: ret = static_cast<unsigned char>(config.opt_bool(opt_key, idx)); break;
    case coInt: ret = config.opt_int(opt_key); break;
    case coInts: ret = config.opt_int(opt_key, idx); break;
    case coEnum: ret = config.option(opt_key)->getInt(); break;
    case coEnums: ret = config.opt_int(opt_key, idx); break;
    case coPoint: ret = config.option<ConfigOptionPoint>(opt_key)->value; break;
    case coPoints:
        if (opt_key == "printable_area")
            ret = get_thumbnails_string(config.option<ConfigOptionPoints>(opt_key)->values);
        else if (opt_key == "bed_exclude_area")
            ret = from_u8(config.option<ConfigOptionPoints>(opt_key)->serialize());
        else if (opt_key == "wrapping_exclude_area")
            ret = get_thumbnails_string(config.option<ConfigOptionPoints>(opt_key)->values);
        else
            ret = config.option<ConfigOptionPoints>(opt_key)->get_at(idx);
        break;
    case coNone:
    default: break;
    }
    return ret;
}

References Slic3r::coBool, Slic3r::coBools, Slic3r::coEnum, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInt, Slic3r::coInts, Slic3r::coNone, Slic3r::coPercent, Slic3r::coPercents, Slic3r::coPoint, Slic3r::coPoints, Slic3r::coString, Slic3r::coStrings, Slic3r::DynamicPrintConfig::def(), Slic3r::GUI::double_to_string(), Slic3r::GUI::from_u8(), Slic3r::ConfigDef::get(), Slic3r::GUI::get_thumbnails_string(), Slic3r::ConfigOption::getInt(), Slic3r::GUI::into_u8(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionFloatsOrPercentsTempl< true >::nil_value(), Slic3r::ConfigOptionFloatsTempl< true >::nil_value(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_float(), Slic3r::DynamicConfig::opt_int(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionDef::plugin_picker, Slic3r::ConfigOptionPoints::serialize(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by back_to_config_value(), and commit_config_value().

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::ConfigOptionsGroup::get_custom_ctrl_with_blinking_ptr	(	const t_config_option_key &	opt_key,
		int	opt_index )

{
    Field* field = get_fieldc(opt_key, opt_index);
 
    if (field)
        return {custom_ctrl, field->get_blink_ptr()};
 
    for (Line& line : m_lines)
        for (const Option& opt : line.get_options())
            if (opt.opt_id == opt_key && line.widget)
                return {custom_ctrl, line.get_blink_ptr()};
 
    return {nullptr, nullptr};
}

References Slic3r::GUI::OptionsGroup::custom_ctrl, Slic3r::GUI::UndoValueUIManager::get_blink_ptr(), get_fieldc(), and Slic3r::GUI::OptionsGroup::m_lines.

Here is the call graph for this function:

get_field()

Field * Slic3r::GUI::OptionsGroup::get_field ( const t_config_option_key & id ) const

inlineinherited

                                                                {
              if (m_fields.find(id) == m_fields.end()) return nullptr;
              return m_fields.at(id).get();
    }

References m_fields.

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), enable_field(), Slic3r::GUI::ConfigOptionsGroup::get_fieldc(), and show_field().

Here is the caller graph for this function:

get_fieldc()

Field * Slic3r::GUI::ConfigOptionsGroup::get_fieldc	(	const t_config_option_key &	opt_key,
		int	opt_index )

{
    Field* field = get_field(opt_key);
    if (field != nullptr)
        return field;
    std::string opt_id = opt_key + '#' + std::to_string(opt_index);
    return get_field(opt_id);
}

References Slic3r::GUI::OptionsGroup::get_field().

Referenced by get_custom_ctrl_with_blinking_ptr(), and Slic3r::GUI::ObjectTableSettings::update_extra_column_visible_status().

Here is the call graph for this function:

Here is the caller graph for this function:

get_grid_sizer()

wxGridSizer * Slic3r::GUI::OptionsGroup::get_grid_sizer ( )

inlineinherited

{ return m_grid_sizer; }

References m_grid_sizer.

Referenced by Slic3r::GUI::ObjectTableSettings::update_extra_column_visible_status().

Here is the caller graph for this function:

get_line()

Line * Slic3r::GUI::OptionsGroup::get_line ( const std::string & opt_key )

inherited

{
    for (int index = 0; index < m_lines.size(); index++) {
        for (auto& opt : m_lines[index].get_options())
            if (opt.opt_id == opt_key)
                return &(m_lines[index]);
    }
 
    return nullptr;
}

References m_lines.

Referenced by Slic3r::GUI::ObjectTableSettings::update_extra_column_visible_status().

Here is the caller graph for this function:

get_lines()

const std::vector< Line > & Slic3r::GUI::OptionsGroup::get_lines ( )

inlineinherited

{ return m_lines; }

References m_lines.

get_option()

Option Slic3r::GUI::ConfigOptionsGroup::get_option	(	const std::string &	opt_key,
		int	opt_index = -1 )

{
    if (!m_config->has(opt_key)) {
        std::cerr << "No " << opt_key << " in ConfigOptionsGroup config.\n";
    }
 
    std::string opt_id = opt_index == -1 ? opt_key : opt_key + "#" + std::to_string(opt_index);
    std::pair<std::string, int> pair(opt_key, opt_index);
    m_opt_map.emplace(opt_id, pair);
 
    if (m_use_custom_ctrl) // fill group and category values just for options from Settings Tab
        wxGetApp().sidebar().settings_index().add_key(opt_id, static_cast<Preset::Type>(this->config_type()), title, this->config_category(), this->icon);
 
    return Option(*m_config->def()->get(opt_key), opt_id);
}

References config_category(), config_type(), Slic3r::GUI::OptionsGroup::icon, m_config, m_opt_map, Slic3r::GUI::OptionsGroup::m_use_custom_ctrl, and Slic3r::GUI::OptionsGroup::title.

Referenced by append_single_option_line(), and create_single_option_line().

Here is the call graph for this function:

Here is the caller graph for this function:

get_url()

wxString Slic3r::GUI::OptionsGroup::get_url ( const std::string & path_end )

staticinherited

{
    // BBS
    wxString str = from_u8(path_end);
    auto pos     = str.find(L'#');
    if (pos != size_t(-1)) {
        pos++;
        wxString anchor = str.Mid(pos).Lower();
        anchor.Replace(L" ", "-");
        str = str.Left(pos) + anchor;
    }
    // Orca: point to sf wiki for seam parameters
    return wxString::Format(L"https://www.orcaslicer.com/wiki/%s", from_u8(path_end));
}

References Slic3r::GUI::from_u8(), and L.

Referenced by launch_browser(), Slic3r::GUI::ActionRegistry::materialize_setting_actions(), Slic3r::GUI::OG_CustomCtrl::OnMotion(), and Slic3r::GUI::ogStaticText::SetPathEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

get_value()

boost::any Slic3r::GUI::OptionsGroup::get_value ( const t_config_option_key & id )

inlineinherited

                                                       {
              boost::any out;
                if (m_fields.find(id) == m_fields.end()) ;
              else
                out = m_fields.at(id)->get_value();
              return out;
    }

References m_fields.

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_config_value().

Here is the caller graph for this function:

Hide()

void Slic3r::GUI::ConfigOptionsGroup::Hide

(

)

{ Show(false); }

References Show().

Here is the call graph for this function:

hide_field()

void Slic3r::GUI::OptionsGroup::hide_field ( const t_config_option_key & opt_key )

inlineinherited

{  show_field(opt_key, false);  }

References show_field().

Here is the call graph for this function:

hide_labels()

void Slic3r::GUI::OptionsGroup::hide_labels ( )

inlineinherited

{ label_width = 0; m_labels_hidden = true; }

References label_width, and m_labels_hidden.

is_activated()

bool Slic3r::GUI::OptionsGroup::is_activated ( )

inlineinherited

{ return sizer != nullptr; }

References sizer.

is_legend_line()

bool Slic3r::GUI::OptionsGroup::is_legend_line ( )

inherited

{
    if (m_lines.size() == 1) {
        const std::vector<Option>& option_set = m_lines.front().get_options();
        return !option_set.empty() && option_set.front().opt.gui_type == ConfigOptionDef::GUIType::legend;
    }
    return false;
}

References Slic3r::ConfigOptionDef::legend, and m_lines.

Referenced by activate_line().

Here is the caller graph for this function:

is_visible()

bool Slic3r::GUI::ConfigOptionsGroup::is_visible

(

ConfigOptionMode

mode

)

{
    if (m_options_mode.empty())
        return true;
    if (m_options_mode.size() == 1)
        return m_options_mode[0] <= mode;
 
    size_t hidden_row_cnt = 0;
    for (auto opt_mode : m_options_mode)
        if (opt_mode > mode)
            hidden_row_cnt++;
 
    return hidden_row_cnt != m_options_mode.size();
}

References Slic3r::GUI::OptionsGroup::m_options_mode.

launch_browser()

bool Slic3r::GUI::OptionsGroup::launch_browser ( const std::string & path_end )

staticinherited

{ return wxLaunchDefaultBrowser(OptionsGroup::get_url(path_end)); }

References get_url().

Referenced by Slic3r::GUI::OG_CustomCtrl::CtrlLine::launch_browser().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::ConfigOptionsGroup::msw_rescale

(

)

{
    // update bitmaps for extra column items (like "mode markers" or buttons on settings panel)
    if (rescale_extra_column_item)
        for (auto extra_col : m_extra_column_item_ptrs)
            rescale_extra_column_item(extra_col);
 
    // update undo buttons : rescale bitmaps
    for (const auto& field : m_fields)
        field.second->msw_rescale();
 
    auto rescale = [](wxSizer* sizer) {
        for (wxSizerItem* item : sizer->GetChildren())
            if (item->IsWindow()) {
                wxWindow* win = item->GetWindow();
                // check if window is ScalableButton
                ScalableButton* sc_btn = dynamic_cast<ScalableButton*>(win);
                if (sc_btn) {
                    sc_btn->msw_rescale();
                    sc_btn->SetSize(sc_btn->GetBestSize());
                    return;
                }
                // check if window is wxButton
                wxButton* btn = dynamic_cast<wxButton*>(win);
                if (btn) {
                    btn->SetSize(btn->GetBestSize());
                    return;
                }
            }
    };
 
    // scale widgets and extra widgets if any exists
    for (const Line& line : m_lines) {
        if (line.widget_sizer)
            rescale(line.widget_sizer);
        if (line.extra_widget_sizer)
            rescale(line.extra_widget_sizer);
    }
 
    if (custom_ctrl)
        custom_ctrl->msw_rescale();
 
    if (auto line = dynamic_cast<::StaticLine*>(stb))
        line->Rescale();
}

References Slic3r::GUI::OptionsGroup::custom_ctrl, Slic3r::GUI::OptionsGroup::m_extra_column_item_ptrs, Slic3r::GUI::OptionsGroup::m_fields, Slic3r::GUI::OptionsGroup::m_lines, ScalableButton::msw_rescale(), Slic3r::GUI::OptionsGroup::rescale_extra_column_item, Slic3r::GUI::OptionsGroup::sizer, Slic3r::GUI::OptionsGroup::stb, and wxButton.

Here is the call graph for this function:

on_change_OG()

void Slic3r::GUI::ConfigOptionsGroup::on_change_OG ( const t_config_option_key & opt_id, const boost::any & value )

overridevirtual

Reimplemented from Slic3r::GUI::OptionsGroup.

Reimplemented in Slic3r::GUI::ExtruderOptionsGroup.

{
    if (opt_id == "printer_agent") {
        // TODO: Replace this option-specific branch with a generic value adapter if
        // more fields need custom field-value to config-value conversion.
        if (const std::string* id = boost::any_cast<std::string>(&value))
            this->change_opt_value("printer_agent", wxGetApp().canonical_printer_agent_id(*id));
 
        OptionsGroup::on_change_OG(opt_id, value);
        return;
    }
 
    if (!m_opt_map.empty()) {
        auto it = m_opt_map.find(opt_id);
        if (it == m_opt_map.end()) {
            OptionsGroup::on_change_OG(opt_id, value);
            return;
        }
 
#if 0
        // BBS
        if (opt_id == "bed_temperature" || opt_id == "bed_temperature_initial_layer") {
            if (m_modelconfig)
                m_modelconfig->touch();
            OptionsGroup::on_change_OG(opt_id, value);
            return;
        }
#endif
 
        auto itOption              = it->second;
        const std::string& opt_key = itOption.first;
        int opt_index              = itOption.second;
        this->change_opt_value(opt_key, value, opt_index == -1 ? 0 : opt_index);
    }
 
    OptionsGroup::on_change_OG(opt_id, value);
}

References change_opt_value(), m_modelconfig, m_opt_map, and Slic3r::GUI::OptionsGroup::on_change_OG().

Referenced by back_to_config_value(), and commit_config_value().

Here is the call graph for this function:

Here is the caller graph for this function:

on_kill_focus()

void Slic3r::GUI::ConfigOptionsGroup::on_kill_focus ( const std::string & opt_key )

overridevirtual

Reimplemented from Slic3r::GUI::OptionsGroup.

{
    if (m_fill_empty_value)
        m_fill_empty_value(opt_key);
    else
        reload_config();
}

References Slic3r::GUI::OptionsGroup::m_fill_empty_value, and reload_config().

Here is the call graph for this function:

opt_map()

const t_opt_map & Slic3r::GUI::ConfigOptionsGroup::opt_map ( ) const throw (  )

inline

{ return m_opt_map; }

References m_opt_map.

parent()

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

inlineinherited

Returns a copy of the pointer of the parent wxWindow. Accessor function is because users are not allowed to change the parent but defining it as const means a lot of const_casts to deal with wx functions.

{ return m_parent; }

References m_parent.

Referenced by Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ExtruderOptionsGroup::ExtruderOptionsGroup(), activate_line(), build_field(), and ctrl_parent().

Here is the caller graph for this function:

pick_plugin()

std::string Slic3r::GUI::OptionsGroup::pick_plugin ( const ConfigOptionDef & opt )

protectedinherited

{
    Slic3r::PluginManager& manager = Slic3r::PluginManager::instance();
    const Slic3r::PluginCapabilityType plugin_type = Slic3r::plugin_capability_type_from_string(opt.plugin_type);
    if (plugin_type == Slic3r::PluginCapabilityType::Unknown) {
        MessageDialog dlg(m_parent, 
            opt.plugin_type.empty() ? _L("This setting does not specify a plugin capability type.")
                                    : _L("This setting specifies an unrecognized plugin capability type: ") + "'" + opt.plugin_type + "'.", 
            _L("Plugin Selection"), 
            wxOK | wxICON_WARNING
        );
        dlg.CenterOnParent();
        dlg.ShowModal();
 
        return {};
    }
 
    struct CapabilityRef { std::string plugin_key; std::string name; };
    std::vector<CapabilityRef> caps;
    for (const auto& capability : manager.get_plugin_capabilities(/*plugin_key=*/"", plugin_type, /*only_enabled=*/true))
        caps.push_back({capability->audit_plugin_key(), capability->name()});
    std::sort(caps.begin(), caps.end(), [](const CapabilityRef& lhs, const CapabilityRef& rhs) {
        return lhs.name == rhs.name ? lhs.plugin_key < rhs.plugin_key : lhs.name < rhs.name;
    });
 
    if (caps.empty()) {
        MessageDialog dlg(m_parent,
            _L("No plugins capabilities available for this type.\nEnable or install some to use."),
            _L("Plugin Selection"),
            wxOK | wxICON_INFORMATION
        );
        dlg.CenterOnParent();
        dlg.ShowModal();
        return {};
    }
 
    std::vector<PluginPickerDialog::CapabilityEntry> entries;
    entries.reserve(caps.size());
    for (const auto& cap : caps) {
        Slic3r::PluginDescriptor descriptor;
        wxString package_name = manager.try_get_plugin_descriptor(cap.plugin_key, descriptor)
                                    ? from_u8(descriptor.name) : from_u8(cap.plugin_key);
        entries.push_back({
            cap.plugin_key, cap.name, from_u8(cap.name) + from_u8(" \xE2\x80\x94 ") + package_name, package_name
        });
    }
 
    PluginPickerDialog dlg(m_parent, from_u8(opt.plugin_type), std::move(entries));
    if (dlg.ShowModal() != wxID_OK)
        return {};
    const auto selection = dlg.selected_capability();
    if (selection.plugin_key.empty() || selection.name.empty())
        return {};
 
    // Only the bare capability name is stored; the full "name;uuid;capability" reference is derived when
    // the preset is serialized (see ConfigBase::save_plugin_collection). Resolve here to reject bad picks.
    Slic3r::PluginDescriptor descriptor;
    if (!manager.try_get_plugin_descriptor(selection.plugin_key, descriptor) || descriptor.name.empty())
        return {};
 
    BOOST_LOG_TRIVIAL(info) << "Picked plugin capability: " << selection.name;
    return selection.name;
}

References _L, Slic3r::GUI::from_u8(), Slic3r::PluginManager::get_plugin_capabilities(), Slic3r::PluginManager::instance(), m_parent, Slic3r::PluginDescriptor::name, Slic3r::plugin_capability_type_from_string(), Slic3r::GUI::PluginPickerDialog::selected_capability(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::PluginManager::try_get_plugin_descriptor(), and Slic3r::Unknown.

Referenced by build_field().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh()

void Slic3r::GUI::ConfigOptionsGroup::refresh

(

)

{
    if (custom_ctrl)
        custom_ctrl->Refresh();
}

References Slic3r::GUI::OptionsGroup::custom_ctrl.

reload_config()

void Slic3r::GUI::ConfigOptionsGroup::reload_config

(

)

{
    for (auto& kvp : m_opt_map) {
        // Name of the option field (name of the configuration key, possibly suffixed with '#' and the index of a scalar inside a vector.
        const std::string& opt_id = kvp.first;
        // option key (may be scalar or vector)
        const std::string& opt_key = kvp.second.first;
        // index in the vector option, zero for scalars
        int opt_index                 = kvp.second.second;
        const ConfigOptionDef& option = m_options.at(opt_id).opt;
        this->set_value(opt_id, config_value(opt_key, opt_index, option.gui_flags == "serialized"));
    }
}

References config_value(), Slic3r::ConfigOptionDef::gui_flags, m_opt_map, Slic3r::GUI::OptionsGroup::m_options, and Slic3r::GUI::OptionsGroup::set_value().

Referenced by on_kill_focus().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_option_if()

void Slic3r::GUI::OptionsGroup::remove_option_if ( std::function< bool(std::string const &)> const & comp )

inherited

{
    for (auto& l : m_lines) {
        auto& opts = const_cast<std::vector<Option>&>(l.get_options());
        opts.erase(std::remove_if(opts.begin(), opts.end(), [&comp](Option& o) { return comp(o.opt.opt_key); }), opts.end());
        l.undo_to_sys = true;
    }
    for (int i = m_lines.size() - 1; i >= 0; --i) {
        if (m_lines[i].get_options().empty())
            m_options_mode.erase(m_options_mode.begin() + i);
    }
    m_lines.erase(std::remove_if(m_lines.begin(), m_lines.end(), [](auto& l) { return l.get_options().empty(); }), m_lines.end());
    // TODO: remove items from g->m_options;
}

References Slic3r::empty(), m_lines, and m_options_mode.

Here is the call graph for this function:

set_config()

void Slic3r::GUI::ConfigOptionsGroup::set_config ( DynamicPrintConfig * config )

inline

                                                       {
    m_config = config; m_modelconfig = nullptr; }

References m_config, and m_modelconfig.

set_config_category_and_type()

void Slic3r::GUI::ConfigOptionsGroup::set_config_category_and_type ( const wxString & category, int type )

inline

{ m_config_category = category; m_config_type = type; }

References m_config_category, and m_config_type.

set_grid_vgap()

void Slic3r::GUI::OptionsGroup::set_grid_vgap ( int gap )

inlineinherited

{ m_grid_sizer->SetVGap(gap); }

References m_grid_sizer.

set_max_win_width()

void Slic3r::GUI::OptionsGroup::set_max_win_width ( int max_win_width )

inherited

{
    if (custom_ctrl)
        custom_ctrl->set_max_win_width(max_win_width);
}

References custom_ctrl.

set_name()

void Slic3r::GUI::OptionsGroup::set_name ( const wxString & new_name )

inherited

{ stb->SetLabel(new_name); }

References stb.

set_value()

bool Slic3r::GUI::OptionsGroup::set_value ( const t_config_option_key & id, const boost::any & value, bool change_event = false )

inlineinherited

                                                                                                       {
              if (m_fields.find(id) == m_fields.end()) return false;
              m_fields.at(id)->set_value(value, change_event);
              return true;
    }

References m_fields.

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_config_value(), Slic3r::GUI::Tab::on_value_change(), and Slic3r::GUI::ConfigOptionsGroup::reload_config().

Here is the caller graph for this function:

Show()

void Slic3r::GUI::ConfigOptionsGroup::Show

(

const bool

show

)

{
    sizer->ShowItems(show);
#if 0  // #ifdef __WXGTK__
    m_panel->Show(show);
    m_grid_sizer->Show(show);
#endif /* __WXGTK__ */
}

References Slic3r::GUI::OptionsGroup::m_grid_sizer, and Slic3r::GUI::OptionsGroup::sizer.

Referenced by Hide(), and update_visibility().

Here is the caller graph for this function:

show_field()

void Slic3r::GUI::OptionsGroup::show_field ( const t_config_option_key & opt_key, bool show = true )

inherited

{
    Field* field = get_field(opt_key);
    if (!field)
        return;
    wxWindow* win = field->getWindow();
    if (!win)
        return;
    wxSizerItem* win_item = m_grid_sizer->GetItem(win, true);
    if (!win_item)
        return;
 
    const size_t cols = (size_t) m_grid_sizer->GetCols();
    const size_t rows = (size_t) m_grid_sizer->GetEffectiveRowsCount();
 
    auto show_row = [this, show, cols, win_item](wxSizerItem* item, size_t row_shift) {
        // check if item contanes required win
        if (!item->IsWindow() || item != win_item)
            return false;
        // show/hide hole line contanes this window
        for (size_t i = 0; i < cols; ++i)
            m_grid_sizer->Show(row_shift + i, show);
        return true;
    };
 
    size_t row_shift = 0;
    for (size_t j = 0; j < rows; ++j) {
        for (size_t i = 0; i < cols; ++i) {
            wxSizerItem* item = m_grid_sizer->GetItem(row_shift + i);
            if (!item)
                continue;
            if (item->IsSizer()) {
                for (wxSizerItem* child_item : item->GetSizer()->GetChildren())
                    if (show_row(child_item, row_shift))
                        return;
            } else if (show_row(item, row_shift))
                return;
        }
        row_shift += cols;
    }
}

References get_field(), Slic3r::GUI::Field::getWindow(), and m_grid_sizer.

Referenced by hide_field().

Here is the call graph for this function:

Here is the caller graph for this function:

sys_color_changed()

void Slic3r::GUI::ConfigOptionsGroup::sys_color_changed

(

)

{
#ifdef _WIN32
    if (staticbox && stb) {
        wxGetApp().UpdateAllStaticTextDarkUI(stb);
        // update bitmaps for extra column items (like "delete" buttons on settings panel)
        for (auto extra_col : m_extra_column_item_ptrs)
            wxGetApp().UpdateDarkUI(extra_col);
    }
 
    if (custom_ctrl)
        wxGetApp().UpdateDarkUI(custom_ctrl);
#endif
 
    auto update = [](wxSizer* sizer) {
        for (wxSizerItem* item : sizer->GetChildren())
            if (item->IsWindow()) {
                wxWindow* win = item->GetWindow();
                // check if window is ScalableButton
                if (ScalableButton* sc_btn = dynamic_cast<ScalableButton*>(win)) {
                    sc_btn->msw_rescale();
                    return;
                }
                wxGetApp().UpdateDarkUI(win, dynamic_cast<wxButton*>(win) != nullptr);
            }
    };
 
    // scale widgets and extra widgets if any exists
    for (const Line& line : m_lines) {
        if (line.widget_sizer)
            update(line.widget_sizer);
        if (line.extra_widget_sizer)
            update(line.extra_widget_sizer);
    }
 
    // update undo buttons : rescale bitmaps
    for (const auto& field : m_fields)
        field.second->sys_color_changed();
}

References Slic3r::GUI::OptionsGroup::custom_ctrl, Slic3r::GUI::OptionsGroup::m_extra_column_item_ptrs, Slic3r::GUI::OptionsGroup::m_fields, Slic3r::GUI::OptionsGroup::m_lines, Slic3r::GUI::OptionsGroup::sizer, Slic3r::GUI::OptionsGroup::staticbox, Slic3r::GUI::OptionsGroup::stb, and wxButton.

update_visibility()

bool Slic3r::GUI::ConfigOptionsGroup::update_visibility

(

ConfigOptionMode

mode

)

{
    if (m_options_mode.empty() || !m_grid_sizer)
        return true;
 
    if (custom_ctrl) {
        bool show = custom_ctrl->update_visibility(mode);
        this->Show(show);
        return show;
    }
 
    int opt_mode_size = m_options_mode.size();
    if (m_grid_sizer->GetEffectiveRowsCount() != opt_mode_size && opt_mode_size == 1)
        return m_options_mode[0] <= mode;
 
    Show(true);
 
    int coef            = 0;
    int hidden_row_cnt  = 0;
    const int cols      = m_grid_sizer->GetCols();
    Line* line          = &m_lines.front();
    size_t line_opt_end = line->get_options().size();
    for (auto opt_mode : m_options_mode) {
        const bool show = opt_mode <= mode && line->toggle_visible;
        if (--line_opt_end == 0) {
            ++line;
            line_opt_end = line->get_options().size();
        }
        if (!show) {
            hidden_row_cnt++;
            for (int i = 0; i < cols; ++i)
                m_grid_sizer->Show(coef + i, show);
        }
        coef += cols;
    }
 
    if (hidden_row_cnt == opt_mode_size) {
        sizer->ShowItems(false);
        return false;
    }
    return true;
}

References Slic3r::GUI::OptionsGroup::custom_ctrl, Slic3r::GUI::Line::get_options(), Slic3r::GUI::OptionsGroup::m_grid_sizer, Slic3r::GUI::OptionsGroup::m_lines, Slic3r::GUI::OptionsGroup::m_options_mode, Show(), Slic3r::GUI::OptionsGroup::sizer, and Slic3r::GUI::Line::toggle_visible.

Here is the call graph for this function:

Member Data Documentation

ctrl_horiz_alignment

int Slic3r::GUI::OptionsGroup::ctrl_horiz_alignment { wxALIGN_LEFT}

inherited

{ wxALIGN_LEFT};

Referenced by activate().

custom_ctrl

OG_CustomCtrl* Slic3r::GUI::OptionsGroup::custom_ctrl { nullptr }

inherited

{ nullptr };

Referenced by activate(), activate_line(), clear(), ctrl_parent(), Slic3r::GUI::ConfigOptionsGroup::get_custom_ctrl_with_blinking_ptr(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), Slic3r::GUI::ConfigOptionsGroup::refresh(), set_max_win_width(), Slic3r::GUI::ConfigOptionsGroup::sys_color_changed(), and Slic3r::GUI::ConfigOptionsGroup::update_visibility().

draw_multi_extruder

bool Slic3r::GUI::OptionsGroup::draw_multi_extruder { false }

inherited

{ false };

edit_custom_gcode

std::function<void(const t_config_option_key& opt_key)> Slic3r::GUI::OptionsGroup::edit_custom_gcode { nullptr }

inherited

{ nullptr };

Referenced by build_field().

extra_column

column_t Slic3r::GUI::OptionsGroup::extra_column {nullptr}

inherited

{nullptr};

Referenced by OptionsGroup(), activate(), and activate_line().

have_sys_config

std::function<bool()> Slic3r::GUI::OptionsGroup::have_sys_config { nullptr }

inherited

{ nullptr };

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_sys_value().

icon

const wxString Slic3r::GUI::OptionsGroup::icon

inherited

Referenced by Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ExtruderOptionsGroup::ExtruderOptionsGroup(), OptionsGroup(), activate(), and Slic3r::GUI::ConfigOptionsGroup::get_option().

label_font

wxFont Slic3r::GUI::OptionsGroup::label_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) }

inherited

{wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) };

label_width

size_t Slic3r::GUI::OptionsGroup::label_width = 20

inherited

Referenced by activate(), activate_line(), and hide_labels().

m_config

const DynamicPrintConfig* Slic3r::GUI::ConfigOptionsGroup::m_config {nullptr}

protected

{nullptr};

Referenced by ConfigOptionsGroup(), ConfigOptionsGroup(), change_opt_value(), commit_config_value(), config_value(), get_option(), and set_config().

m_config_category

wxString Slic3r::GUI::ConfigOptionsGroup::m_config_category

protected

Referenced by config_category(), and set_config_category_and_type().

m_config_type

int Slic3r::GUI::ConfigOptionsGroup::m_config_type

protected

Referenced by config_type(), and set_config_category_and_type().

m_disabled

bool Slic3r::GUI::OptionsGroup::m_disabled {false}

protectedinherited

{false};

Referenced by build_field().

m_extra_column_item_ptrs

std::vector<wxWindow*> Slic3r::GUI::OptionsGroup::m_extra_column_item_ptrs

protectedinherited

Referenced by activate_line(), clear(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), and Slic3r::GUI::ConfigOptionsGroup::sys_color_changed().

m_fields

t_optionfield_map Slic3r::GUI::OptionsGroup::m_fields

protectedinherited

Field list, contains unique_ptrs of the derived type. using types that need to know what it is beyond the public interface need to cast based on the related ConfigOptionDef.

Referenced by build_field(), clear(), clear_fields_except_of(), disable(), enable(), get_field(), get_value(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), set_value(), and Slic3r::GUI::ConfigOptionsGroup::sys_color_changed().

m_fill_empty_value

t_kill_focus Slic3r::GUI::OptionsGroup::m_fill_empty_value { nullptr }

inherited

{ nullptr };

Referenced by Slic3r::GUI::ConfigOptionsGroup::on_kill_focus().

m_get_initial_config

std::function<DynamicPrintConfig()> Slic3r::GUI::OptionsGroup::m_get_initial_config { nullptr }

inherited

{ nullptr };

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_initial_value().

m_get_sys_config

std::function<DynamicPrintConfig()> Slic3r::GUI::OptionsGroup::m_get_sys_config { nullptr }

inherited

{ nullptr };

Referenced by Slic3r::GUI::ConfigOptionsGroup::back_to_sys_value().

m_grid_sizer

wxGridSizer* Slic3r::GUI::OptionsGroup::m_grid_sizer {nullptr}

protectedinherited

{nullptr};

Referenced by activate(), activate_line(), clear(), get_grid_sizer(), set_grid_vgap(), Slic3r::GUI::ConfigOptionsGroup::Show(), show_field(), and Slic3r::GUI::ConfigOptionsGroup::update_visibility().

m_labels_hidden

bool Slic3r::GUI::OptionsGroup::m_labels_hidden {false}

inherited

{false};

Referenced by activate_line(), and hide_labels().

m_lines

std::vector<Line> Slic3r::GUI::OptionsGroup::m_lines

protectedinherited

Referenced by activate(), append_line(), append_separator(), clear(), Slic3r::GUI::ConfigOptionsGroup::get_custom_ctrl_with_blinking_ptr(), get_line(), get_lines(), is_legend_line(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), remove_option_if(), Slic3r::GUI::ConfigOptionsGroup::sys_color_changed(), and Slic3r::GUI::ConfigOptionsGroup::update_visibility().

m_modelconfig

ModelConfig* Slic3r::GUI::ConfigOptionsGroup::m_modelconfig { nullptr }

protected

{ nullptr };

Referenced by ConfigOptionsGroup(), change_opt_value(), on_change_OG(), and set_config().

m_on_change

t_change Slic3r::GUI::OptionsGroup::m_on_change { nullptr }

inherited

{ nullptr };

Referenced by on_change_OG().

m_opt_map

t_opt_map Slic3r::GUI::ConfigOptionsGroup::m_opt_map

protected

Referenced by back_to_config_value(), commit_config_value(), get_option(), on_change_OG(), Slic3r::GUI::ExtruderOptionsGroup::on_change_OG(), opt_map(), and reload_config().

m_options

std::map<t_config_option_key, Option> Slic3r::GUI::OptionsGroup::m_options

protectedinherited

Referenced by append_line(), build_field(), and Slic3r::GUI::ConfigOptionsGroup::reload_config().

m_options_mode

std::vector<ConfigOptionMode> Slic3r::GUI::OptionsGroup::m_options_mode

protectedinherited

Referenced by append_line(), Slic3r::GUI::ConfigOptionsGroup::is_visible(), remove_option_if(), and Slic3r::GUI::ConfigOptionsGroup::update_visibility().

m_parent

wxWindow* Slic3r::GUI::OptionsGroup::m_parent {nullptr}

protectedinherited

{nullptr};

Referenced by OptionsGroup(), activate(), parent(), and pick_plugin().

m_use_custom_ctrl

bool Slic3r::GUI::OptionsGroup::m_use_custom_ctrl { false }

protectedinherited

{ false };

Referenced by OptionsGroup(), activate_line(), append_line(), and Slic3r::GUI::ConfigOptionsGroup::get_option().

m_use_custom_ctrl_as_parent

bool Slic3r::GUI::OptionsGroup::m_use_custom_ctrl_as_parent { false }

protectedinherited

{ false };

Referenced by activate_line(), and ctrl_parent().

option_label_at_right

bool Slic3r::GUI::OptionsGroup::option_label_at_right {false}

inherited

{false};

rescale_extra_column_item

std::function<void(wxWindow* win)> Slic3r::GUI::OptionsGroup::rescale_extra_column_item { nullptr }

inherited

{ nullptr };

Referenced by Slic3r::GUI::ConfigOptionsGroup::msw_rescale().

rescale_near_label_widget

std::function<void(wxWindow* win)> Slic3r::GUI::OptionsGroup::rescale_near_label_widget { nullptr }

inherited

{ nullptr };

sidetext_font

wxFont Slic3r::GUI::OptionsGroup::sidetext_font {wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) }

inherited

{wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) };

sidetext_width

int Slic3r::GUI::OptionsGroup::sidetext_width { -1 }

inherited

{ -1 };

Referenced by activate_line().

sizer

wxSizer* Slic3r::GUI::OptionsGroup::sizer {nullptr}

inherited

{nullptr};

Referenced by activate(), activate_line(), clear(), is_activated(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), Slic3r::GUI::ConfigOptionsGroup::Show(), Slic3r::GUI::ConfigOptionsGroup::sys_color_changed(), and Slic3r::GUI::ConfigOptionsGroup::update_visibility().

split_multi_line

bool Slic3r::GUI::OptionsGroup::split_multi_line {false}

inherited

{false};

staticbox

const bool Slic3r::GUI::OptionsGroup::staticbox {true}

inherited

{true};

Referenced by OptionsGroup(), activate(), activate_line(), ctrl_parent(), and Slic3r::GUI::ConfigOptionsGroup::sys_color_changed().

stb

wxWindow* Slic3r::GUI::OptionsGroup::stb { nullptr }

inherited

{ nullptr };

Referenced by activate(), activate_line(), clear(), ctrl_parent(), Slic3r::GUI::ConfigOptionsGroup::msw_rescale(), set_name(), and Slic3r::GUI::ConfigOptionsGroup::sys_color_changed().

sublabel_width

int Slic3r::GUI::OptionsGroup::sublabel_width { -1 }

inherited

{ -1 };

Referenced by activate_line().

title

const wxString Slic3r::GUI::OptionsGroup::title

inherited

Referenced by Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ConfigOptionsGroup::ConfigOptionsGroup(), Slic3r::GUI::ExtruderOptionsGroup::ExtruderOptionsGroup(), OptionsGroup(), activate(), Slic3r::GUI::ConfigOptionsGroup::append_single_option_line(), Slic3r::GUI::ConfigOptionsGroup::create_single_option_line(), Slic3r::GUI::ConfigOptionsGroup::get_option(), and Slic3r::GUI::validate_custom_gcode_cb().

---

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

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