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

Inheritance diagram for Slic3r::GUI::PublishSettingsDialog:

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog:

Classes
struct	Row
struct	Subcategory
struct	Category
struct	MixedVisualSpec
struct	SectionGroup

Public Member Functions
	PublishSettingsDialog (wxWindow parent=nullptr, const std::vector< std::string > published_keys=nullptr, const std::vector< Slic3r::PublishedMaterialEntry > *material_keys=nullptr)
	~PublishSettingsDialog ()
std::vector< std::string >	GetPublishedKeys () const
std::vector< Slic3r::PublishedMaterialEntry >	GetPublishedMaterialKeys () const
void	EndModal (int retCode) override
float	scale_factor () const
float	prev_scale_factor () const
void	set_scale_factor (float v)
void	set_prev_scale_factor (float v)
void	set_em_unit (int v)
bool	force_rescale () const
int	em_unit () const
const wxFont &	normal_font () const
void	enable_force_rescale ()
int	ShowModal ()

Protected Member Functions
void	on_dpi_changed (const wxRect &suggested_rect) override
void	on_sys_color_changed () override

Private Types
enum class	Section { Print , Printer , Material }
enum class	RowKind { Setting , Color , Type }
enum class	FilterMode { Text , SelectedOnly , UnselectedOnly }

Private Member Functions
void	fit_to_content ()
void	refresh_mixed_tab_bitmaps ()
void	build_option_model ()
void	apply_selection (const std::vector< std::string > &published_keys, const std::vector< Slic3r::PublishedMaterialEntry > &material_keys)
void	apply_filter (const wxString &filter_text)
void	apply_pseudo_filter (bool selected_only)
void	refresh_filter (const wxString &filter)
void	select_all (bool value)
void	select_visible (bool value)
void	show_menu (wxMouseEvent &evt)
void	set_row_bold (Row &row, bool bold)
void	on_full_toggle (size_t category_index)
void	on_enable_toggle (size_t category_index)
bool	category_has_selection (const Category &cat) const
void	refresh_tab_indicators ()
std::vector< MixedDependencyIssue >	unpublished_mixed_components () const
void	add_mixed_visual (size_t category_index, const MixedVisualSpec &spec)
size_t	section_group_for (Section kind)
size_t	category_index_for (const wxString &title, Section section, size_t group, size_t source_index, const PublishMaterialIdentity &identity=PublishMaterialIdentity(), bool is_mixed=false)
size_t	subcategory_index_for (size_t category_index, const wxString &title, const wxString &icon)
void	add_row_ui (const std::string &key, const wxString &label, const wxString &value, const wxString &unit, size_t category_index, size_t subcategory_index, RowKind kind=RowKind::Setting)
std::vector< std::string >	full_keys_for_slot () const
void	save_scroll_position (Category &category)
void	show_outer_page (size_t section_index)
void	show_inner_page (size_t section_index, int inner_index)
void	show_mixed_page (size_t section_index, int mixed_index)
void	on_outer_tab_changed (wxCommandEvent &event)
void	on_inner_tab_changed (size_t section_index, wxCommandEvent &event)
void	on_mixed_tab_changed (size_t section_index, wxCommandEvent &event)
bool	row_is_visible (const Row &row) const
void	apply_visibility ()
void	bind_tab_events ()
void	setup_variant_switch (size_t section_index)
void	update_em_unit ()
bool	is_new_scale_factor () const
void	rescale (const wxRect &suggested_rect)

Static Private Member Functions
static MixedVisualSpec	make_mixed_visual_spec (const Slic3r::DynamicPrintConfig &full, size_t slot)

Private Attributes
TabCtrl *	m_outer_tabs {nullptr}
wxPanel *	m_outer_host {nullptr}
wxBoxSizer *	m_outer_host_sizer {nullptr}
int	m_selected_outer {-1}
wxBoxSizer *	m_fb_sizer {nullptr}
FilterMode	m_filter_mode {FilterMode::Text}
TextInput *	m_filter_box {nullptr}
wxTextCtrl *	m_filter_ctrl {nullptr}
wxStaticBitmap *	m_menu_button {nullptr}
wxStaticText *	m_pseudo_chip {nullptr}
wxString	m_info_nonsel
wxString	m_info_allsel
wxString	m_info_empty
wxString	m_info_mix
ScalableBitmap	m_search
ScalableBitmap	m_menu
std::vector< Row >	m_rows
std::vector< Category >	m_categories
std::vector< SectionGroup >	m_sections
float	m_scale_factor
int	m_em_unit
wxFont	m_normal_font
float	m_prev_scale_factor
bool	m_can_rescale
bool	m_force_rescale
int	m_new_font_point_size

Detailed Description

Class Documentation

◆ Slic3r::GUI::PublishSettingsDialog::Row

struct Slic3r::GUI::PublishSettingsDialog::Row

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog::Row:

Class Members
wxString	category
::CheckBox *	check {nullptr}
wxStaticText *	check_label {nullptr}
wxStaticBitmap *	color_chip {nullptr}
bool	dirty {false}
size_t	inner_index {0}
wxSizerItem *	item {nullptr}
string	key
RowKind	kind {RowKind::Setting}
wxString	label
bool	matches_filter {false}
size_t	outer_index {0}
Section	section {Section::Print}
wxString	section_title
wxString	subcategory
wxString	unit
wxStaticText *	unit_label {nullptr}
wxString	value
wxStaticText *	value_label {nullptr}

◆ Slic3r::GUI::PublishSettingsDialog::Subcategory

struct Slic3r::GUI::PublishSettingsDialog::Subcategory

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog::Subcategory:

Class Members
::StaticLine *	header {nullptr}
wxSizerItem *	item {nullptr}
vector< size_t >	rows
wxString	title

◆ Slic3r::GUI::PublishSettingsDialog::Category

struct Slic3r::GUI::PublishSettingsDialog::Category

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog::Category:

Class Members
::CheckBox *	enable_check {nullptr}
wxStaticText *	enable_label {nullptr}
wxStaticBitmap *	filament_color_chip {nullptr}
string	filament_id
size_t	filament_slot {0}
string	filament_type
string	filament_vendor
::CheckBox *	full_check {nullptr}
wxStaticText *	full_label {nullptr}
wxSizerItem *	full_line_item {nullptr}
size_t	group {0}
wxStaticText *	info {nullptr}
bool	is_mixed {false}
wxBoxSizer *	list_sizer {nullptr}
wxPanel *	page {nullptr}
vector< size_t >	rows
wxScrolledWindow *	scroll {nullptr}
wxPoint	scroll_pos {0, 0}
Section	section {Section::Print}
size_t	source_index {0}
vector< Subcategory >	subs
wxString	title
wxStaticText *	title_label {nullptr}

◆ Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec

struct Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec:

Class Members
vector< wxColour >	component_colours
vector< pair< double, double > >	gradient_anchors
vector< pair< double, double > >	gradient_samples
bool	is_gradient {false}
vector< double >	ratios
vector< double >	tri_weights
bool	valid {false}

◆ Slic3r::GUI::PublishSettingsDialog::SectionGroup

struct Slic3r::GUI::PublishSettingsDialog::SectionGroup

Collaboration diagram for Slic3r::GUI::PublishSettingsDialog::SectionGroup:

Class Members
vector< size_t >	categories
ScalableBitmap	icon_bmp
string	icon_name
Section	kind {Section::Print}
vector< size_t >	mixed_categories
TabCtrl *	mixed_tabs {nullptr}
wxPanel *	page {nullptr}
wxPanel *	page_host {nullptr}
wxBoxSizer *	page_host_sizer {nullptr}
int	selected_inner {-1}
int	selected_mixed {-1}
TabCtrl *	tabs {nullptr}
wxString	title
MultiSwitchButton *	variant_switch {nullptr}

Member Enumeration Documentation

◆ FilterMode

enum class Slic3r::GUI::PublishSettingsDialog::FilterMode

strongprivate

Enumerator
Text
SelectedOnly
UnselectedOnly

294{ Text, SelectedOnly, UnselectedOnly };

◆ RowKind

enum class Slic3r::GUI::PublishSettingsDialog::RowKind

strongprivate

Enumerator
Setting
Color
Type

                       {
        Setting, // a regular setting key
        Color,   // material colour requirement (filament_colour)
        Type,    // material type requirement (read-only text)
    };

◆ Section

enum class Slic3r::GUI::PublishSettingsDialog::Section

strongprivate

Enumerator
Print
Printer
Material

95{ Print, Printer, Material };

Slic3r::GUI::Printer

@ Printer

Definition PrePrintChecker.hpp:21

Constructor & Destructor Documentation

◆ PublishSettingsDialog()

Slic3r::GUI::PublishSettingsDialog::PublishSettingsDialog	(	wxWindow *	parent = nullptr,
		const std::vector< std::string > *	published_keys = nullptr,
		const std::vector< Slic3r::PublishedMaterialEntry > *	material_keys = nullptr )

    : DPIDialog(parent ? parent : static_cast<wxWindow*>(wxGetApp().mainframe),
                wxID_ANY,
                _L("Publish 3MF..."),
                wxDefaultPosition,
                wxDefaultSize,
                wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER | wxFULL_REPAINT_ON_RESIZE)
    , m_search(this, "search", 16)
    , m_menu(this, "filter", 16)
{
    SetBackgroundColour(*wxWHITE);
 
    // --- filter bar: search box, All/None, menu button ---
    wxPanel* f_bar = new wxPanel(this, wxID_ANY);
    f_bar->SetBackgroundColour(GetBackgroundColour());
    wxBoxSizer* f_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_filter_box = new TextInput(f_bar, "", "", "", wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
    m_filter_box->SetIcon(m_search.bmp());
    m_filter_box->SetMinSize(FromDIP(wxSize(200, 24)));
    m_filter_box->SetSize(FromDIP(wxSize(-1, 24)));
    m_filter_box->SetFocus();
    m_filter_ctrl = m_filter_box->GetTextCtrl();
    m_filter_ctrl->SetFont(Label::Body_13);
    m_filter_ctrl->SetSize(wxSize(-1, FromDIP(16))); // centers text vertically
    m_filter_ctrl->SetHint(_L("Type to filter..."));
    m_filter_ctrl->Bind(wxEVT_TEXT, [this](auto&) { apply_filter(m_filter_ctrl->GetValue()); });
    m_filter_ctrl->Bind(wxEVT_TEXT_ENTER, [this](auto&) { apply_filter(m_filter_ctrl->GetValue()); });
    m_filter_ctrl->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
        if (m_filter_mode != FilterMode::Text)
            apply_filter(m_filter_ctrl->GetValue());
        e.Skip();
    });
    f_sizer->Add(m_filter_box, 1, wxEXPAND);
 
    m_fb_sizer      = new wxBoxSizer(wxHORIZONTAL);
    auto create_btn = [this, f_bar](wxString title, bool select) {
        auto btn = new wxStaticText(f_bar, wxID_ANY, title);
        btn->SetForegroundColour("#009687");
        btn->SetCursor(wxCURSOR_HAND);
        btn->SetFont(Label::Body_13);
        btn->Bind(wxEVT_LEFT_DOWN, [this, select](wxMouseEvent&) { select_all(select); });
        m_fb_sizer->Add(btn, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(10));
    };
    f_sizer->Add(m_fb_sizer, 0, wxALIGN_CENTER_VERTICAL);
    create_btn(_L("All"), true);
    create_btn(_L("None"), false);
 
    // Indicator for the menu's pseudo filters: sits where All/None go while they are hidden.
    // Labels reuse the menu entries (no new strings); clicking the chip returns to text
    // filtering, keeping the search box contents.
    m_pseudo_chip = new wxStaticText(f_bar, wxID_ANY, "");
    m_pseudo_chip->SetForegroundColour("#009687");
    m_pseudo_chip->SetCursor(wxCURSOR_HAND);
    m_pseudo_chip->SetFont(Label::Body_13);
    m_pseudo_chip->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent&) { apply_filter(m_filter_ctrl->GetValue()); });
    m_pseudo_chip->Hide();
    f_sizer->Add(m_pseudo_chip, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(10));
 
    m_menu_button = new wxStaticBitmap(f_bar, wxID_ANY, m_menu.bmp());
    m_menu_button->SetCursor(wxCURSOR_HAND);
    m_menu_button->Bind(wxEVT_LEFT_DOWN, &PublishSettingsDialog::show_menu, this);
    f_sizer->Add(m_menu_button, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(10));
 
    f_bar->SetSizerAndFit(f_sizer);
 
    m_outer_tabs = new TabCtrl(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, s_tab_style);
    m_outer_tabs->SetFont(Label::Body_14);
    m_outer_tabs->SetBackgroundColour(GetBackgroundColour());
 
    m_outer_host = new wxPanel(this, wxID_ANY);
#ifdef __WINDOWS__
    m_outer_host->SetDoubleBuffered(true);
#endif
    m_outer_host->SetBackgroundColour(GetBackgroundColour());
    m_outer_host_sizer = new wxBoxSizer(wxVERTICAL);
    m_outer_host->SetSizer(m_outer_host_sizer);
 
    wxBoxSizer* w_sizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText* msg = new wxStaticText(this, wxID_ANY, _L("Select which settings to be published in the 3MF file"));
    msg->SetFont(Label::Body_13);
    msg->Wrap(-1);
    w_sizer->Add(msg, 0, wxRIGHT | wxLEFT | wxTOP, FromDIP(10));
 
    w_sizer->Add(f_bar, 0, wxRIGHT | wxLEFT | wxTOP | wxEXPAND, FromDIP(10));
    w_sizer->Add(m_outer_tabs, 0, wxRIGHT | wxLEFT | wxTOP | wxEXPAND, FromDIP(10));
    w_sizer->Add(m_outer_host, 1, wxRIGHT | wxLEFT | wxTOP | wxEXPAND, FromDIP(10));
 
    build_option_model();
 
    // Seed from a remembered session selection or a freshly loaded published 3MF (authoritative).
    if (published_keys != nullptr || material_keys != nullptr)
        apply_selection(published_keys != nullptr ? *published_keys : std::vector<std::string>(),
                        material_keys != nullptr ? *material_keys : std::vector<Slic3r::PublishedMaterialEntry>());
 
    auto dlg_btns = new DialogButtons(this, {"OK", "Cancel"});
 
    dlg_btns->GetOK()->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
        // Publish is always allowed: no settings selected means no settings override. Warn only
        // when an enabled mixed filament would ship without the material of one of its
        // components; "Publish anyway" accepts that and publishes anyway.
        if (const std::vector<MixedDependencyIssue> issues = unpublished_mixed_components(); !issues.empty()) {
            const DynamicPrintConfig full = wxGetApp().preset_bundle->full_config();
            MixedFilamentWarningDialog warn(this, full, issues);
            if (warn.ShowModal() != wxID_OK)
                return; // Cancel: dismiss the warning and stay in this dialog
        }
        EndModal(wxID_OK);
    });
    dlg_btns->GetCANCEL()->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { EndModal(wxID_CANCEL); });
 
    // Guide links, bottom-left, sharing the footer row with the OK/Cancel buttons (pushed right).
    wxBoxSizer* links_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    auto wiki_btn = new Button(this, "", "toolbar_wiki", 0, 15);
    auto wiki_url = "https://www.orcaslicer.com/wiki/publishing_3mf/publish_3mf";
    wiki_btn->SetToolTip(_L("Wiki Guide") + "\n" + wiki_url);
    wiki_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Circle);
    wiki_btn->SetCanFocus(false);
    wiki_btn->Bind(wxEVT_LEFT_DOWN, ([wiki_url](auto& e) {wxLaunchDefaultBrowser(wiki_url);}));
 
    auto video_btn  = new Button(this, "", "toolbar_video_guide", 0, 15);
    auto video_url = "https://www.youtube.com/watch?v=-xt1N29UIOg";
    video_btn->SetToolTip(_L("Video Guide") + "\n" + video_url);
    video_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Circle);
    video_btn->SetCanFocus(false);
    video_btn->Bind(wxEVT_LEFT_DOWN, ([video_url](auto& e) {wxLaunchDefaultBrowser(video_url);}));
 
    links_sizer->Add(wiki_btn , 0, wxLEFT, FromDIP(10));
    links_sizer->Add(video_btn, 0, wxLEFT, FromDIP(10));
 
    wxBoxSizer* footer = new wxBoxSizer(wxHORIZONTAL);
    footer->Add(links_sizer, 0, wxALIGN_CENTER_VERTICAL);
    footer->AddStretchSpacer();
    footer->Add(dlg_btns, 0, wxALIGN_CENTER_VERTICAL);
    auto* footer_line = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1));
    footer_line->SetBackgroundColour(wxColour("#CECECE"));
    footer_line->SetMinSize(wxSize(-1, 1));
    footer_line->SetMaxSize(wxSize(-1, 1));
    w_sizer->Add(footer_line, 0, wxRIGHT | wxLEFT | wxTOP | wxEXPAND, FromDIP(10));
    w_sizer->Add(footer, 0, wxEXPAND, FromDIP(10));
 
    SetSizerAndFit(w_sizer);
    fit_to_content(); // initial size only; the dialog is resizable
    wxGetApp().UpdateDlgDarkUI(this);
    // The dark-UI walk re-colours the tab strips after the compositions were baked; rebuild so
    // they carry the theme-resolved background (the sidebar resolves its colours at paint time,
    // this dialog bakes, so the bake has to happen after the walk).
    refresh_mixed_tab_bitmaps();
}

References _L, apply_filter(), apply_selection(), Label::Body_13, Label::Body_14, build_option_model(), Circle, Confirm, Slic3r::GUI::DPIDialog::EndModal(), fit_to_content(), Slic3r::GUI::DialogButtons::GetOK(), m_fb_sizer, m_filter_box, m_filter_ctrl, m_filter_mode, m_menu, m_menu_button, m_outer_host, m_outer_host_sizer, m_outer_tabs, m_pseudo_chip, m_search, refresh_mixed_tab_bitmaps(), select_all(), show_menu(), Slic3r::GUI::DPIAware< P >::ShowModal(), Text, unpublished_mixed_components(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Here is the call graph for this function:

◆ ~PublishSettingsDialog()

Slic3r::GUI::PublishSettingsDialog::~PublishSettingsDialog ( )

833{}

Member Function Documentation

◆ add_mixed_visual()

void Slic3r::GUI::PublishSettingsDialog::add_mixed_visual	(	size_t	category_index,
		const MixedVisualSpec &	spec )

private

{
    if (category_index >= m_categories.size() || !spec.valid)
        return;
    Category& category = m_categories[category_index];
    if (category.page == nullptr || category.page->GetSizer() == nullptr || category.scroll == nullptr || spec.component_colours.empty())
        return;
 
    auto* viz = new wxPanel(category.page, wxID_ANY);
    viz->SetBackgroundStyle(wxBG_STYLE_PAINT);
    // Theme colours and DIP metrics are resolved inside the paint handler so dark-mode toggles
    // and DPI changes are picked up on the next repaint without any explicit listener. The
    // ternary fill cache lives inside the shared triangle painter (FilamentBitmapUtils).
    viz->Bind(wxEVT_PAINT, [this, panel = viz, spec](wxPaintEvent&) {
        const wxColour bg = StateColor::darkModeColorFor(*wxWHITE);
        wxBufferedPaintDC pdc(panel);
        pdc.SetBackground(wxBrush(bg));
        pdc.Clear();
        const wxRect rc = panel->GetClientRect();
        if (rc.width <= 0 || rc.height <= 0)
            return;
 
        const size_t n = spec.component_colours.size();
 
        if (spec.tri_weights.size() == 3 && n == 3 && !spec.is_gradient) {
            // Ternary mix: read-only miniature of the MixedFilamentDialog's triangle picker.
            const MixedTriangleTheme tri_theme{StateColor::darkModeColorFor(*wxWHITE), StateColor::darkModeColorFor(wxColour("#CECECE")),
                                               StateColor::darkModeColorFor(wxColour("#262E30")),
                                               StateColor::darkModeColorFor(wxColour(107, 107, 107))};
            draw_mixed_triangle_picker(pdc, rc.GetSize(), {spec.component_colours[0], spec.component_colours[1], spec.component_colours[2]},
                                       {spec.tri_weights[0], spec.tri_weights[1], spec.tri_weights[2]}, tri_theme);
            draw_mixed_triangle_labels(pdc, rc.GetSize(), {spec.tri_weights[0], spec.tri_weights[1], spec.tri_weights[2]}, tri_theme);
        } else if (!spec.is_gradient) {
            // Ratio bar. A 2-component slot matches the MixedFilamentDialog's continuous blend +
            // divider (with its two end labels); wider non-gradient mixes (rare) fall back to one
            // solid segment per component.
            if (n == 2) {
                const int bar_h = FromDIP(27);
                draw_mixed_ratio_blend_bar(pdc, wxRect(rc.x, rc.y, rc.width, bar_h), spec.component_colours[0], spec.component_colours[1],
                                           spec.ratios[1]);
                // Read-only twin of the dialog's left/right percentage labels.
                pdc.SetFont(::Label::Body_12);
                pdc.SetTextForeground(StateColor::darkModeColorFor(wxColour(107, 107, 107)));
                const wxString la = wxString::Format("%d%%", int(std::lround(spec.ratios[0] * 100.0)));
                const wxString lb = wxString::Format("%d%%", int(std::lround(spec.ratios[1] * 100.0)));
                const int lab_y   = rc.y + bar_h + FromDIP(2);
                pdc.DrawText(la, rc.x, lab_y);
                pdc.DrawText(lb, rc.x + rc.width - pdc.GetTextExtent(lb).GetWidth(), lab_y);
            } else {
                draw_mixed_ratio_segments(pdc, rc, spec.component_colours, spec.ratios);
                // Percent label centred in each segment wide enough to hold it.
                std::vector<double> shares = spec.ratios;
                double total               = 0.0;
                for (double r : shares)
                    total += r;
                if (total <= 0.0) {
                    shares.assign(n, 1.0 / n);
                    total = 1.0;
                }
                pdc.SetFont(::Label::Body_12);
                int x0 = rc.x;
                for (size_t i = 0; i < n; ++i) {
                    const int x1 = (i + 1 < n) ? rc.x + int(std::lround(std::accumulate(shares.begin(), shares.begin() + i + 1, 0.0) /
                                                                        total * double(rc.width))) :
                                                 rc.x + rc.width;
                    const int w  = std::max(1, x1 - x0);
                    const wxString text = wxString::Format("%d%%", int(std::lround(shares[i] / total * 100.0)));
                    const wxSize tsz    = pdc.GetTextExtent(text);
                    if (tsz.GetWidth() + FromDIP(4) <= w) {
                        const wxColour& c = spec.component_colours[i];
                        const double lum  = 0.299 * c.Red() + 0.587 * c.Green() + 0.114 * c.Blue();
                        pdc.SetTextForeground(lum > 140 ? wxColour("#262E30") : *wxWHITE);
                        pdc.DrawText(text, x0 + (w - tsz.GetWidth()) / 2, rc.y + (rc.height - tsz.GetHeight()) / 2);
                    }
                    x0 = x1;
                }
            }
        } else {
            // Gradient: read-only miniature of the GradientCurveEditor plot, drawn through the
            // shared painter so it anti-aliases and keeps the square proportions and labels.
            const MixedGradientTheme grad_theme{StateColor::darkModeColorFor(*wxWHITE),
                                                StateColor::darkModeColorFor(wxColour(238, 238, 238)),
                                                StateColor::darkModeColorFor(wxColour(107, 107, 107)),
                                                StateColor::darkModeColorFor(wxColour(107, 107, 107)),
                                                StateColor::darkModeColorFor(wxColour(38, 46, 48)),
                                                StateColor::darkModeColorFor(wxColour(172, 172, 172)),
                                                StateColor::darkModeColorFor(*wxWHITE)};
            std::vector<MixedGradientCurve> curves;
            std::vector<wxPoint2DDouble> anchors;
            if (spec.gradient_samples.size() >= 2 && n >= 2) {
                const wxRect plot = mixed_gradient_plot_rect(rc.GetSize());
                auto lift_alpha   = [](wxColour c) {
                    if (c.Alpha() == 0)
                        c.Set(c.Red(), c.Green(), c.Blue(), 150);
                    return c;
                };
                // First component's ratio solid, its mirror twin for the other.
                const wxColour col_a = lift_alpha(spec.component_colours[0]);
                const wxColour col_b = lift_alpha(spec.component_colours[1]);
                std::vector<wxPoint2DDouble> pts_a, pts_b;
                pts_a.reserve(spec.gradient_samples.size());
                pts_b.reserve(spec.gradient_samples.size());
                for (const auto& [t, r] : spec.gradient_samples) {
                    pts_a.push_back({plot.x + t * plot.width, plot.y + (1.0 - r) * plot.height});
                    pts_b.push_back({plot.x + t * plot.width, plot.y + r * plot.height});
                }
                // Control-point anchors of the stored curve on the first component's line.
                anchors.reserve(spec.gradient_anchors.size());
                for (const auto& [t, r] : spec.gradient_anchors)
                    anchors.push_back({plot.x + t * plot.width, plot.y + (1.0 - r) * plot.height});
                curves.push_back({std::move(pts_a), col_a, 4});
                curves.push_back({std::move(pts_b), col_b, 2});
            }
            draw_mixed_gradient_plot(pdc, rc.GetSize(), curves, anchors, grad_theme);
        }
    });
 
    // Fixed DIP size, left-aligned: the visualization keeps its proportions no matter how the
    // dialog is resized (the paint handler draws into whatever client rect the panel ends up
    // with, so nothing else has to change). Sizes mirror the MixedFilamentDialog controls: the
    // gradient plot and triangle picker match the editor's 260x200 / 160x160, the ratio bar is
    // the dialog's 27px bar plus its label line.
    int viz_h;
    int viz_w;
    if (spec.is_gradient) {
        viz_w = 260;
        viz_h = 200;
    } else if (spec.tri_weights.size() == 3 && spec.component_colours.size() == 3) {
        viz_w = 160;
        viz_h = 160;
    } else {
        viz_w = 240;
        viz_h = spec.component_colours.size() == 2 ? 50 : 30;
    }
    const wxSize viz_sz(FromDIP(viz_w), FromDIP(viz_h));
    viz->SetMinSize(viz_sz);
    viz->SetMaxSize(viz_sz);
    // Parented to the page right above the scroll area, so it is always shown with the tab:
    // the "Enable" toggle keeps gating only the rows/info below, never this preview.
    wxSizer* page_sizer = category.page->GetSizer();
    int scroll_idx      = -1;
    for (size_t i = 0; i < page_sizer->GetChildren().size(); ++i)
        if (page_sizer->GetChildren()[i]->GetWindow() == category.scroll) {
            scroll_idx = int(i);
            break;
        }
    if (scroll_idx < 0)
        page_sizer->Add(viz, 0, wxLEFT | wxRIGHT | wxTOP, FromDIP(10)); // defensive: no scroll item
    else
        page_sizer->Insert(scroll_idx, viz, 0, wxLEFT | wxRIGHT | wxTOP, FromDIP(10));
}

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_row_ui()

void Slic3r::GUI::PublishSettingsDialog::add_row_ui	(	const std::string &	key,
		const wxString &	label,
		const wxString &	value,
		const wxString &	unit,
		size_t	category_index,
		size_t	subcategory_index,
		RowKind	kind = RowKind::Setting )

private

{
    Category& category = m_categories[category_index];
    Row row;
    row.key                = key;
    row.label              = label;
    row.value              = value;
    row.unit               = unit;
    row.kind               = kind;
    row.category           = category.title;
    row.subcategory        = category.subs[subcategory_index].title;
    row.section            = category.section;
    row.section_title      = m_sections[category.group].title;
    row.outer_index        = category.group;
    row.inner_index        = category_index;
    const size_t row_index = m_rows.size();
    m_rows.push_back(std::move(row));
    Row& current  = m_rows[row_index];
    current.check = new ::CheckBox(category.scroll, wxID_ANY);
    current.check->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent& event) {
        refresh_tab_indicators();
        event.Skip();
    });
    auto* row_sizer = new wxBoxSizer(wxHORIZONTAL);
    current.check_label = add_checkbox_label(category.scroll, row_sizer, current.check, label + ":", wxEmptyString,
                                             24 * wxGetApp().em_unit());
    // The value is read-only text (incl. the Type row: the published type is the slot's
    // normalized type, not author-editable).
    current.value_label = new wxStaticText(category.scroll, wxID_ANY, value, wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
    current.value_label->SetFont(Label::Body_14);
    current.value_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#262E30")));
    current.value_label->SetToolTip(unit.IsEmpty() ? value : value + " " + unit);
    if (kind == RowKind::Color && !value.IsEmpty()) {
        // The colour swatch carries this slot's 1-based number, like the main GUI swatches.
        const std::string chip_label = std::to_string(category.filament_slot + 1);
        if (wxBitmap* chip = get_extruder_color_icon(value.ToStdString(), chip_label, FromDIP(20), FromDIP(20))) {
            current.color_chip = new wxStaticBitmap(category.scroll, wxID_ANY, *chip);
            row_sizer->Add(current.color_chip, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(8));
        }
    }
    row_sizer->Add(current.value_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(8));
    if (!unit.IsEmpty()) {
        current.unit_label = new wxStaticText(category.scroll, wxID_ANY, unit);
        current.unit_label->SetFont(Label::Body_14);
        current.unit_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#6B6B6B")));
        row_sizer->Add(current.unit_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(4));
    }
    current.item = category.list_sizer->Add(row_sizer, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(5));
    category.rows.push_back(row_index);
    category.subs[subcategory_index].rows.push_back(row_index);
}

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_filter()

void Slic3r::GUI::PublishSettingsDialog::apply_filter ( const wxString & filter_text )

private

{
    m_filter_mode = FilterMode::Text;
    refresh_filter(filter_text.Lower());
}

References m_filter_mode, refresh_filter(), and Text.

Referenced by PublishSettingsDialog(), select_visible(), and show_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_pseudo_filter()

void Slic3r::GUI::PublishSettingsDialog::apply_pseudo_filter ( bool selected_only )

private

{
    m_filter_mode = selected_only ? FilterMode::SelectedOnly : FilterMode::UnselectedOnly;
    refresh_filter(wxString()); // the pseudo modes ignore the search text
}

References m_filter_mode, refresh_filter(), SelectedOnly, and UnselectedOnly.

Referenced by show_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_selection()

void Slic3r::GUI::PublishSettingsDialog::apply_selection	(	const std::vector< std::string > &	published_keys,
		const std::vector< Slic3r::PublishedMaterialEntry > &	material_keys )

private

{
    // The supplied selection is authoritative: clear the dirty-default pre-check first so a
    // dirty key the user deselected stays off, then re-select exactly what the selection names.
    for (Row& row : m_rows)
        if (row.check != nullptr)
            row.check->SetValue(false);
    for (Category& cat : m_categories) {
        if (cat.section != Section::Material)
            continue;
        if (cat.enable_check != nullptr)
            cat.enable_check->SetValue(false);
        if (cat.full_check != nullptr)
            cat.full_check->SetValue(false);
    }
 
    // Print / printer rows: match by exact row key (the full "#N" opt_id where present).
    for (const std::string& key : published_keys)
        for (Row& row : m_rows)
            if ((row.section == Section::Print || row.section == Section::Printer) && row.check != nullptr && row.key == key) {
                row.check->SetValue(true);
                break;
            }
 
    // Per-slot material selections, applied positionally by slot.
    for (const Slic3r::PublishedMaterialEntry& entry : material_keys) {
        if (entry.slot < 0)
            continue;
        bool entry_mixed = false;
        for (const std::string& k : entry.keys)
            if (publish_mixed_keys().count(publish_base_key(k)) != 0) {
                entry_mixed = true;
                break;
            }
        size_t cat_idx = size_t(-1);
        for (size_t c = 0; c < m_categories.size(); ++c) {
            const Category& cat = m_categories[c];
            if (cat.section != Section::Material || cat.is_mixed != entry_mixed || cat.filament_slot != size_t(entry.slot))
                continue;
            cat_idx = c;
            break;
        }
        if (cat_idx == size_t(-1))
            continue; // slot not present in the receiver (out of range / skipped)
        Category& cat = m_categories[cat_idx];
        if (cat.enable_check != nullptr) {
            cat.enable_check->SetValue(true);
            on_enable_toggle(cat_idx);
        }
        if (entry.full && cat.full_check != nullptr) {
            cat.full_check->SetValue(true);
            on_full_toggle(cat_idx);
        } else {
            // Setting rows are keyed by the base key.
            for (const std::string& key : entry.keys) {
                const std::string base = publish_base_key(key);
                for (const size_t r : cat.rows) {
                    Row& row = m_rows[r];
                    if (row.kind == RowKind::Setting && row.key == base) {
                        row.check->SetValue(true);
                        break;
                    }
                }
            }
            if (entry.publish_type && !entry.publish_type_value.empty())
                for (const size_t r : cat.rows)
                    if (m_rows[r].kind == RowKind::Type && m_rows[r].check != nullptr) {
                        m_rows[r].check->SetValue(true);
                        break;
                    }
            if (entry.publish_color && !entry.color.empty())
                for (const size_t r : cat.rows)
                    if (m_rows[r].kind == RowKind::Color && m_rows[r].check != nullptr) {
                        m_rows[r].check->SetValue(true);
                        break;
                    }
        }
    }
 
    apply_visibility();
    refresh_tab_indicators();
}

Referenced by PublishSettingsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_visibility()

void Slic3r::GUI::PublishSettingsDialog::apply_visibility ( )

private

{
    Freeze();
    for (Category& category : m_categories) {
        // A disabled material slot hides everything below its header (rows, info and the Full
        // Publish line); enable it first to reveal its settings.
        const bool enabled = category.section != Section::Material ||
                             (category.enable_check != nullptr && category.enable_check->GetValue());
        if (category.scroll != nullptr)
            category.scroll->Show(enabled);
        if (category.full_line_item != nullptr)
            category.full_line_item->Show(enabled);
        bool category_any = false;
        for (size_t r : category.rows)
            category_any = category_any || m_rows[r].matches_filter;
        category.info->Show(enabled && !category_any);
        for (Subcategory& sub : category.subs) {
            bool sub_any = false;
            for (size_t r : sub.rows)
                sub_any = sub_any || m_rows[r].matches_filter;
            if (sub.header != nullptr)
                sub.item->Show(enabled && sub_any);
            for (size_t r : sub.rows)
                m_rows[r].item->Show(enabled && m_rows[r].matches_filter);
        }
        category.list_sizer->Layout();
        category.scroll->FitInside();
    }
    Thaw();
}

References Slic3r::GUI::PublishSettingsDialog::Subcategory::header, Slic3r::GUI::PublishSettingsDialog::Subcategory::item, m_categories, m_rows, Material, and Slic3r::GUI::PublishSettingsDialog::Subcategory::rows.

Referenced by apply_selection(), build_option_model(), on_enable_toggle(), refresh_filter(), and select_all().

Here is the caller graph for this function:

◆ bind_tab_events()

void Slic3r::GUI::PublishSettingsDialog::bind_tab_events ( )

private

{
    m_outer_tabs->Bind(wxEVT_TAB_SEL_CHANGED, &PublishSettingsDialog::on_outer_tab_changed, this);
    for (size_t section_index = 0; section_index < m_sections.size(); ++section_index) {
        m_sections[section_index].tabs->Bind(wxEVT_TAB_SEL_CHANGED,
                                             [this, section_index](wxCommandEvent& event) { on_inner_tab_changed(section_index, event); });
        if (m_sections[section_index].mixed_tabs != nullptr)
            m_sections[section_index].mixed_tabs->Bind(wxEVT_TAB_SEL_CHANGED, [this, section_index](wxCommandEvent& event) {
                on_mixed_tab_changed(section_index, event);
            });
    }
}

References m_outer_tabs, m_sections, on_inner_tab_changed(), on_mixed_tab_changed(), and on_outer_tab_changed().

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_option_model()

void Slic3r::GUI::PublishSettingsDialog::build_option_model ( )

private

{
    // Structural / non-publishable keys, shared with the published-3MF overlay path.
    const std::set<std::string>& denylist = publish_structural_keys();
    // Base keys already added in the print section (dedup across pages/optgroups). The printer
    // section keeps its own printer_added set keyed by the full per-extruder "#N" opt_id, so
    // every extruder gets its own row (see Phase 1 below).
    std::set<std::string> added;
 
    PresetBundle* bundle    = wxGetApp().preset_bundle;
    DynamicPrintConfig full = bundle->full_config();
 
    m_info_nonsel = _L("No selected items...");
    m_info_allsel = _L("All items selected...");
    m_info_empty  = _L("No matching items...");
    m_info_mix    = _L("Mixed filament - published as a whole when \"Enable\" above is selected");
 
    // Tab order differs from Section's enum order (Print, Printer, Material): the dialog
    // presents Printer, Filament, Process.
    m_sections.reserve(3);
    const Section tab_order[] = {Section::Printer, Section::Material, Section::Print};
    for (Section kind : tab_order)
        section_group_for(kind);
    bind_tab_events();
 
    // Shared per-option label/value computation; returns false when the option must be skipped
    // (denylisted / unknown / empty label). value is the stringified value; unit the translated
    // sidetext (may be empty).
    auto option_text = [&denylist, &full](const std::string& opt_id, const std::string& pure_key, wxString& label, wxString& value,
                                          wxString& unit) -> bool {
        if (denylist.count(pure_key) > 0)
            return false;
        const ConfigOptionDef* def = print_config_def.get(pure_key);
        if (def == nullptr)
            return false;
        label = _(def->full_label.empty() ? def->label : def->full_label);
        if (label.IsEmpty())
            return false;
        value = get_string_value(opt_id, full);
        unit  = _(def->sidetext);
        if (unit == "%" && value.EndsWith("%"))
            unit.clear();
        return true;
    };
 
    // --- Phase 1: printer per-extruder retraction settings (first, mirroring the sidebar's
    // Printer group), from the printer tab's "Extruder" page. One inner tab per extruder (named
    // as on the printer tab's switch, e.g. "Left Extruder"/"Right Extruder" via
    // Tab::translate_category), each holding that extruder's Retraction and Z-Hop rows with
    // per-extruder "#N" values.
    {
        size_t g = section_group_for(Section::Printer);
        std::set<std::string> printer_added;
        for (Tab* tab : wxGetApp().tabs_list) {
            // The page's controls edit the extruder chosen on the printer tab's switch, so its
            // option list is read once per extruder.
            auto*       printer_tab = dynamic_cast<TabPrinter*>(tab);
            const Page* page        = printer_tab ? printer_tab->extruder_page() : nullptr;
            if (page == nullptr)
                continue;
            const size_t extruders_count = printer_tab->m_extruders_count;
            for (size_t extruder_idx = 0; extruder_idx < extruders_count; ++extruder_idx) {
                const wxString page_title = Tab::translate_category(extruders_count > 1 ? wxString::Format("Extruder %d", int(extruder_idx + 1)) : wxString("Extruder"), tab->m_type);
                // Retraction and Z-Hop values are stored per variant column, not per extruder.
                const int variant_index = printer_tab->extruder_variant_index(int(extruder_idx));
                for (const ConfigOptionsGroupShp& optgroup : page->m_optgroups) {
                    // Allowlist on the untranslated optgroup title; the "Retraction when
                    // switching material" group is intentionally skipped.
                    if (optgroup->title != "Retraction" && optgroup->title != "Z-Hop")
                        continue;
                    const wxString subcategory = _(optgroup->title);
                    for (const auto& opt : optgroup->opt_map()) {
                        const std::string& pure_key = opt.second.first;
                        // Rows are keyed by the full per-extruder "#N" opt_id so each extruder
                        // tab publishes its own value; GetPublishedKeys() emits the checked rows
                        // as-is.
                        const std::string opt_id = pure_key + "#" + std::to_string(variant_index);
                        if (!printer_added.insert(opt_id).second)
                            continue;
                        wxString label, value, unit;
                        if (!option_text(opt_id, pure_key, label, value, unit))
                            continue;
                        size_t cat_index = category_index_for(page_title, Section::Printer, g, extruder_idx);
                        size_t sub_index = subcategory_index_for(cat_index, subcategory, optgroup->icon);
                        add_row_ui(opt_id, label, value, unit, cat_index, sub_index);
                    }
                }
            }
        }
    }
 
    // --- Phase 2: per-material sections synthesized from the filament tab's "Setting
    // Overrides" page, under the Filament group.
    {
        size_t g          = section_group_for(Section::Material);
        Tab* filament_tab = nullptr;
        for (Tab* tab : wxGetApp().tabs_list)
            if (tab->m_type == Preset::TYPE_FILAMENT) {
                filament_tab = tab;
                break;
            }
        if (filament_tab != nullptr) {
            const Page* overrides_page = nullptr;
            for (const PageShp& page : filament_tab->m_pages)
                if (page->title() == "Setting Overrides") {
                    overrides_page = page.get();
                    break;
                }
 
            if (overrides_page != nullptr) {
                // Mixed-color slots are virtual: they carry no per-key Material/Retraction
                // settings; their "Enable" toggle always embeds the mix definition (components,
                // ratios, gradient). Detect them via the project-level flag.
                const ConfigOptionBools* is_mixed_opt = full.opt<ConfigOptionBools>("filament_is_mixed");
                // Only the slots the project actually uses: base/MMU-painted volume extruders,
                // support/wall/infill overrides and custom-gcode tool changes, plus the physical
                // components of any in-use mixed slot. Unused slots get no section at all (and are
                // therefore never published). One section per used slot, disambiguated by its
                // colour chip and slot identity while showing the bare name.
                const std::set<size_t> used_slots = project_used_filament_slots(*bundle, full, wxGetApp().plater()->model());
                for (size_t slot = 0; slot < bundle->filament_presets.size(); ++slot) {
                    if (used_slots.find(slot) == used_slots.end())
                        continue;
                    const bool is_mixed = is_mixed_opt != nullptr && slot < is_mixed_opt->size() && is_mixed_opt->values[slot];
                    const PublishMaterialIdentity identity = material_identity(slot, full);
                    // A mixed slot's title is its component composition (e.g. "1 (60%) + 2
                    // (40%)"), not the cloned preset's name shown in the main GUI.
                    const wxString title        = is_mixed ? mixed_filament_label(full, slot) : material_title(slot, bundle, full);
                    const size_t category_index = category_index_for(title, Section::Material, g, slot, identity, is_mixed);
 
                    if (is_mixed) {
                        // A mixed slot publishes as one unit (its definition); nothing to select
                        // per-key. Its component filaments are auto-enabled + Full Published when
                        // "Enable" is checked (see on_enable_toggle). Its page still shows what
                        // would be published: a ratio bar, or the gradient graph.
                        add_mixed_visual(category_index, make_mixed_visual_spec(full, slot));
                        continue;
                    }
 
                    // Material requirement rows: an optional filament colour and/or a
                    // vendor-agnostic material type for this slot, in their own optgroup so they
                    // stay visually separated from the setting rows.
                    {
                        const size_t req_sub = subcategory_index_for(category_index, _L("Material"), "custom-gcode_filament");
                        add_row_ui("filament_colour", _L("Color"), from_u8(filament_color_hex(full, slot)), wxString(), category_index,
                                   req_sub, RowKind::Color);
                        std::string type;
                        if (const auto* types = full.opt<ConfigOptionStrings>("filament_type"))
                            if (slot < types->size())
                                type = types->get_at(slot);
                        add_row_ui("filament_type", _L("Type"), from_u8(normalize_filament_type(type)), wxString(), category_index, req_sub,
                                   RowKind::Type);
                    }
 
                    // A material section must not repeat a key; the same key may appear in other
                    // material sections - that is intended.
                    std::set<std::string> material_added;
 
                    for (const ConfigOptionsGroupShp& optgroup : overrides_page->m_optgroups) {
                        // Allowlist on the untranslated optgroup title; "Ironing" is skipped.
                        if (optgroup->title != "Retraction" && optgroup->title != "Retraction when switching material")
                            continue;
                        for (const auto& opt : optgroup->opt_map()) {
                            // Row keys are base keys; the load side applies them positionally.
                            const std::string& opt_id = opt.first;
                            std::string base          = publish_base_key(opt_id);
                            if (!material_added.insert(base).second)
                                continue;
                            // Show the value of this slot; fall back to slot 0 if out of range.
                            std::string value_opt_id = base + "#" + std::to_string(slot);
                            if (const ConfigOption* opt_cfg = full.option(base))
                                if (const auto* vec = dynamic_cast<const ConfigOptionVectorBase*>(opt_cfg))
                                    if (vec->size() > 0 && slot >= vec->size())
                                        value_opt_id = base + "#0";
                            wxString label, value, unit;
                            if (!option_text(value_opt_id, base, label, value, unit))
                                continue;
                            size_t sub_index = subcategory_index_for(category_index, _(optgroup->title), optgroup->icon);
                            add_row_ui(base, label, value, unit, category_index, sub_index);
                        }
                    }
                }
            }
        }
    }
 
    // --- Phase 3: process (print) settings; grouping matches the process tab.
    {
        size_t g = section_group_for(Section::Print);
        for (Tab* tab : wxGetApp().tabs_list) {
            if (tab->m_type != Preset::TYPE_PRINT)
                continue;
            size_t page_index = 0;
            for (const PageShp& page : tab->m_pages) {
                wxString category           = Tab::translate_category(page->title(), tab->m_type);
                const size_t category_index = category_index_for(category, Section::Print, g, page_index);
 
                for (const ConfigOptionsGroupShp& optgroup : page->m_optgroups) {
                    for (const auto& opt : optgroup->opt_map()) {
                        // opt_map() key is the opt_id (may carry "#N"); the value is
                        // (pure_opt_key, opt_index).
                        const std::string& opt_id   = opt.first;
                        const std::string& pure_key = opt.second.first;
                        // A key may appear in more than one page/group; keep the first.
                        if (!added.insert(pure_key).second)
                            continue;
                        wxString label, value, unit;
                        if (!option_text(opt_id, pure_key, label, value, unit))
                            continue;
                        size_t sub_index = subcategory_index_for(category_index, _(optgroup->title), optgroup->icon);
                        add_row_ui(opt_id, label, value, unit, category_index, sub_index);
                    }
                }
                ++page_index;
            }
        }
    }
 
    // Pre-check the dirty (modified) settings and mark them bold (per-slot match, across all
    // sections; collect_dirty_settings_keys unions the prints, printers and filaments).
    // Dirty keys carry a "#N" per-extruder/per-slot suffix (deep_diff), so the base key alone
    // cannot distinguish which extruder/filament slot changed: match the row's exact key, and
    // for material rows (base key + per-slot value) the base key plus the section's slot.
    std::set<std::string> dirty_keys;
    for (const std::string& key : collect_dirty_settings_keys(*wxGetApp().preset_bundle))
        dirty_keys.insert(key);
    for (Row& row : m_rows) {
        // The Color/Type requirement rows are not "dirty overrides": never auto-checked.
        if (row.kind != RowKind::Setting)
            continue;
        bool dirty = dirty_keys.count(row.key) != 0;
        if (!dirty && row.section == Section::Material)
            dirty = dirty_keys.count(publish_base_key(row.key) + "#" + std::to_string(m_categories[row.inner_index].filament_slot)) != 0;
        row.dirty = dirty;
        if (row.dirty) {
            row.check->SetValue(true);
            set_row_bold(row, true);
        }
    }
 
    // Wire the "Enable" checkboxes: toggling one reveals/hides the slot's settings below the
    // header (and, for a mixed slot, auto-selects its components). Bind by index so the lambda
    // stays valid even if the vector is reallocated later.
    for (size_t c = 0; c < m_categories.size(); ++c)
        if (m_categories[c].enable_check != nullptr)
            m_categories[c].enable_check->Bind(wxEVT_TOGGLEBUTTON, [this, c](wxCommandEvent& event) {
                on_enable_toggle(c);
                event.Skip();
            });
 
    // Wire the "Full Publish" checkboxes (physical slots): toggling one disables/enables the
    // material's rows.
    for (size_t c = 0; c < m_categories.size(); ++c)
        if (m_categories[c].full_check != nullptr)
            m_categories[c].full_check->Bind(wxEVT_TOGGLEBUTTON, [this, c](wxCommandEvent& event) {
                on_full_toggle(c);
                event.Skip();
            });
 
    // No filter is active at startup: every row matches until the user types.
    for (Row& row : m_rows)
        row.matches_filter = true;
    apply_visibility();
 
    for (Category& category : m_categories) {
        category.scroll->FitInside();
        category.list_sizer->Layout();
    }
    for (SectionGroup& section : m_sections)
        if (!section.categories.empty())
            section.tabs->SelectItem(0);
    // Orca: the Printer section shows its extruders on the same switch as the printer tab's Extruder page.
    for (size_t s = 0; s < m_sections.size(); ++s)
        if (m_sections[s].kind == Section::Printer && m_sections[s].categories.size() > 1)
            setup_variant_switch(s);
    if (!m_sections.empty()) {
        m_outer_tabs->SelectItem(0);
        show_outer_page(0);
    }
    refresh_tab_indicators();
}

References _, _L, add_mixed_visual(), add_row_ui(), apply_visibility(), bind_tab_events(), category_index_for(), Slic3r::collect_dirty_settings_keys(), Color, Slic3r::PresetBundle::filament_presets, Slic3r::GUI::from_u8(), Slic3r::PresetBundle::full_config(), Slic3r::ConfigOptionDef::full_label, Slic3r::GUI::get_string_value(), Slic3r::identity(), Slic3r::ConfigOptionDef::label, m_categories, m_info_allsel, m_info_empty, m_info_mix, m_info_nonsel, Slic3r::GUI::Page::m_optgroups, m_outer_tabs, Slic3r::GUI::Tab::m_pages, m_rows, m_sections, make_mixed_visual_spec(), Material, Slic3r::normalize_filament_type(), on_enable_toggle(), on_full_toggle(), Slic3r::DynamicConfig::opt(), Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), Print, Slic3r::print_config_def, Printer, Slic3r::publish_base_key(), Slic3r::publish_structural_keys(), refresh_tab_indicators(), section_group_for(), set_row_bold(), Setting, setup_variant_switch(), show_outer_page(), Slic3r::ConfigOptionDef::sidetext, Slic3r::ConfigOptionVector< unsigned char >::size(), subcategory_index_for(), Slic3r::GUI::Tab::translate_category(), Type, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by PublishSettingsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ category_has_selection()

bool Slic3r::GUI::PublishSettingsDialog::category_has_selection ( const Category & cat ) const

private

{
    // A material slot publishes (or not) as a whole, gated by "Enable".
    if (cat.section == Section::Material)
        return cat.enable_check != nullptr && cat.enable_check->GetValue();
    // Print/Printer categories have no gate: any checked row counts.
    for (const size_t r : cat.rows)
        if (m_rows[r].check->GetValue())
            return true;
    return false;
}

References Slic3r::GUI::PublishSettingsDialog::Category::enable_check, m_rows, Material, Slic3r::GUI::PublishSettingsDialog::Category::rows, and Slic3r::GUI::PublishSettingsDialog::Category::section.

Referenced by refresh_tab_indicators().

Here is the caller graph for this function:

◆ category_index_for()

size_t Slic3r::GUI::PublishSettingsDialog::category_index_for	(	const wxString &	title,
		Section	section,
		size_t	group,
		size_t	source_index,
		const PublishMaterialIdentity &	identity = PublishMaterialIdentity(),
		bool	is_mixed = false )

private

{
    // Dedup across both tab rows (physical + mixed); mixed slots are never duplicated anyway.
    auto match = [&](const Category& existing) {
        return existing.title == title && existing.section == section && existing.source_index == source_index &&
               existing.filament_id == identity.id && existing.filament_type == identity.type &&
               existing.filament_vendor == identity.vendor;
    };
    for (size_t i : m_sections[group].categories)
        if (match(m_categories[i]))
            return i;
    for (size_t i : m_sections[group].mixed_categories)
        if (match(m_categories[i]))
            return i;
 
    Category category;
    category.title           = title;
    category.section         = section;
    category.group           = group;
    category.source_index    = source_index;
    category.filament_type   = identity.type;
    category.filament_vendor = identity.vendor;
    category.filament_id     = identity.id;
    category.filament_slot   = source_index;
    category.is_mixed        = is_mixed;
    category.page            = new wxPanel(m_sections[group].page_host, wxID_ANY);
    category.page->SetBackgroundColour(GetBackgroundColour());
    auto* page_sizer = new wxBoxSizer(wxVERTICAL);
 
    // The physical slot's colour chip decorates the page header and the inner tab; it carries
    // the 1-based slot number, mirroring the main GUI's filament swatches. A mixed slot has no
    // header at all: its page is just the Enable toggle above the (always visible) definition
    // preview - the identification lives in the tab strip's composition bitmap.
    std::string hex;
    std::string chip_label;
    if (section == Section::Material && !is_mixed) {
        const DynamicPrintConfig full = wxGetApp().preset_bundle->full_config();
        hex                           = filament_color_hex(full, source_index);
        chip_label                    = std::to_string(source_index + 1);
    }
 
    if (section == Section::Material) {
        if (is_mixed) {
            // No chip/title: the lone "Enable" checkbox tops the page.
            auto* enable_sizer    = new wxBoxSizer(wxHORIZONTAL);
            category.enable_check = new ::CheckBox(category.page, wxID_ANY);
            category.enable_label = add_checkbox_label(category.page, enable_sizer, category.enable_check, _L("Enable"),
                                                       _L("Publish this mixed filament and enable + Full Publish its component filaments"));
            page_sizer->Add(enable_sizer, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(6));
        } else {
            // Line 1: [chip] [title] [Enable]. The Enable checkbox gates the whole slot: while
            // it is unchecked nothing below the title is shown and nothing of it is published.
            auto* header_sizer = new wxBoxSizer(wxHORIZONTAL);
            if (wxBitmap* chip = get_extruder_color_icon(hex, chip_label, FromDIP(20), FromDIP(20))) {
                category.filament_color_chip = new wxStaticBitmap(category.page, wxID_ANY, *chip);
                header_sizer->Add(category.filament_color_chip, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(4));
            }
            category.title_label = new wxStaticText(category.page, wxID_ANY, title);
            category.title_label->SetFont(Label::Head_14);
            header_sizer->Add(category.title_label, 0, wxALIGN_CENTER_VERTICAL);
            auto* enable_sizer    = new wxBoxSizer(wxHORIZONTAL);
            category.enable_check = new ::CheckBox(category.page, wxID_ANY);
            category.enable_label = add_checkbox_label(category.page, enable_sizer, category.enable_check, _L("Enable"),
                                                       _L("Publish this filament slot in the 3MF file"));
            header_sizer->Add(enable_sizer, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(10));
            page_sizer->Add(header_sizer, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(6));
 
            // Line 2: the "Full Publish" toggle, on its own line below the title (hidden until
            // the slot is enabled), aligned with the colour chip above it.
            auto* full_sizer    = new wxBoxSizer(wxHORIZONTAL);
            category.full_check = new ::CheckBox(category.page, wxID_ANY);
            category.full_label = add_checkbox_label(category.page, full_sizer, category.full_check, _L("Full Publish"),
                                                     _L("Embed the entire filament of this slot in the 3MF file"));
            category.full_line_item = page_sizer->Add(full_sizer, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(6));
        }
    }
 
    category.scroll = new wxScrolledWindow(category.page, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
    category.scroll->SetScrollRate(0, FromDIP(20));
    category.scroll->SetBackgroundColour(GetBackgroundColour());
    category.list_sizer = new wxBoxSizer(wxVERTICAL);
    category.scroll->SetSizer(category.list_sizer);
    category.scroll->DisableFocusFromKeyboard();
    category.scroll->Bind(wxEVT_RIGHT_DOWN, &PublishSettingsDialog::show_menu, this);
    category.info = new wxStaticText(category.scroll, wxID_ANY, is_mixed ? m_info_mix : m_info_empty);
    category.info->SetFont(Label::Body_13);
    category.list_sizer->Add(category.info, 1, wxALIGN_CENTER_HORIZONTAL | wxALL, FromDIP(10));
    category.info->Hide();
    page_sizer->Add(category.scroll, 1, wxEXPAND | wxTOP | wxBOTTOM, FromDIP(4));
    // A material slot starts disabled: its rows (and its Full Publish line) stay hidden until
    // "Enable" is checked.
    if (section == Section::Material)
        category.scroll->Hide();
    category.page->SetSizer(page_sizer);
    category.page->Hide();
 
    const size_t category_index = m_categories.size();
    m_categories.push_back(std::move(category));
    // Mixed slots live in a second tab row below the physical filament tabs.
    if (is_mixed)
        m_sections[group].mixed_categories.push_back(category_index);
    else
        m_sections[group].categories.push_back(category_index);
    if (section == Section::Material) {
        TabCtrl* target = is_mixed ? m_sections[group].mixed_tabs : m_sections[group].tabs;
        if (is_mixed) {
            // The tab's whole composition (mix chip + components + percents) lives in one
            // bitmap; the text is empty because a TabCtrl item cannot interleave images into
            // its text.
            const DynamicPrintConfig full_cfg = wxGetApp().preset_bundle->full_config();
            const wxBitmap tab_bmp = mixed_filament_tab_bitmap(full_cfg, source_index, FromDIP(20), target->GetBackgroundColour());
            if (tab_bmp.IsOk())
                target->AppendItem(wxString(), tab_bmp);
            else
                target->AppendItem(title);
        } else if (wxBitmap* chip = get_extruder_color_icon(hex, chip_label, FromDIP(20), FromDIP(20))) {
            target->AppendItem(title, *chip);
        } else {
            target->AppendItem(title);
        }
    } else {
        m_sections[group].tabs->AppendItem(title);
    }
    m_sections[group].page_host_sizer->Add(m_categories[category_index].page, 1, wxEXPAND);
    if (is_mixed) {
        if (m_sections[group].selected_mixed < 0)
            m_sections[group].selected_mixed = 0;
        m_sections[group].mixed_tabs->Show();
    } else if (m_sections[group].selected_inner < 0) {
        m_sections[group].selected_inner = 0;
    }
    return category_index;
}

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ em_unit()

int Slic3r::GUI::DPIAware< wxDialog >::em_unit ( ) const

inlineinherited

203{ return m_em_unit; }

Slic3r::GUI::DPIAware

Definition GUI_Utils.hpp:107

Here is the caller graph for this function:

◆ enable_force_rescale()

void Slic3r::GUI::DPIAware< wxDialog >::enable_force_rescale ( )

inlineinherited

206{ m_force_rescale = true; }

◆ EndModal()

void Slic3r::GUI::DPIDialog::EndModal ( int retCode )

inlineoverrideinherited

    {
        if (!dialogStack.empty() && dialogStack.front() != this) {
            // This is a bug in wxWidgets
            // when the dialog is not top modal dialog, EndModal() just hide dialog without quit 
            // the modal event loop. And the modal event loop blocks us from bottom widgets.
            // Solution: let user click it manually or close outside. FIXME
            BOOST_LOG_TRIVIAL(warning) << "DPIAware::EndModal Error: dialogStack is not empty, but top dialog is not this one. retCode=" << retCode;
            return;
        }
 
        return wxDialog::EndModal(retCode);
    }

References Slic3r::GUI::dialogStack.

◆ fit_to_content()

void Slic3r::GUI::PublishSettingsDialog::fit_to_content ( )

private

{
    static const wxSize BASE{530, 530}; // base size in DIP, the minimum the dialog can shrink to
    static const wxSize CAP{1300, 850}; // hard cap in DIP, the maximum the dialog can grow to
 
    int strip = m_outer_tabs->GetFullSize();
    for (const SectionGroup& section : m_sections) {
        strip = std::max(strip, section.tabs->GetFullSize());
        if (section.mixed_tabs != nullptr)
            strip = std::max(strip, section.mixed_tabs->GetFullSize());
    }
 
    // Minimum width: whatever keeps every tab visible (never below the base). strip is device
    // pixels (Button min sizes); BASE/CAP are DIP and converted over.
    const int min_w = std::max(strip + 2 * FromDIP(10), FromDIP(BASE.x));
 
    // Initial size: prefer proportional growth within the caps.
    const int w    = std::clamp(min_w, FromDIP(BASE.x), FromDIP(CAP.x));
    const double f = double(w) / FromDIP(BASE.x);
    const int h    = std::clamp(int(FromDIP(BASE.y) * f), FromDIP(BASE.y), FromDIP(CAP.y));
 
    const wxRect area = wxDisplay(this).GetClientArea();
    const int max_w   = area.width * 9 / 10;
    const int max_h   = area.height * 9 / 10;
 
    SetMinSize(wxSize(std::min(min_w, max_w), std::min(FromDIP(BASE.y), max_h)));
    SetSize(std::min(w, max_w), std::min(h, max_h));
}

References Slic3r::area(), Slic3r::f(), m_outer_tabs, and m_sections.

Referenced by PublishSettingsDialog(), and on_dpi_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_rescale()

bool Slic3r::GUI::DPIAware< wxDialog >::force_rescale ( ) const

inlineinherited

201{ return m_force_rescale; }

◆ full_keys_for_slot()

std::vector< std::string > Slic3r::GUI::PublishSettingsDialog::full_keys_for_slot ( ) const

private

{
    // The canonical filament preset keys minus the structural keys the published overlay must
    // never touch (inherits, compatibility, *_settings_id, ...), plus filament_colour (not a
    // member of Preset::filament_options). Values travel in the exported config, masked to
    // this slot, and are applied on load onto the receiver's slot.
    const std::set<std::string>& denylist = publish_structural_keys();
    std::vector<std::string> keys;
    for (const std::string& key : Preset::filament_options())
        if (denylist.count(key) == 0)
            keys.emplace_back(key);
    keys.emplace_back("filament_colour");
    return keys;
}

References Slic3r::Preset::filament_options(), and Slic3r::publish_structural_keys().

Referenced by GetPublishedMaterialKeys().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPublishedKeys()

std::vector< std::string > Slic3r::GUI::PublishSettingsDialog::GetPublishedKeys ( ) const

{
    std::vector<std::string> out;
    // Process and printer sections both travel through published_keys (the load-side overlay
    // applies process keys to the prints edited preset and the allowlisted printer keys to the
    // printers edited preset); material keys use a separate API. Printer rows carry the full
    // per-extruder "#N" opt_id (built in Phase 1), so a checked row publishes exactly that
    // extruder's value - per-extruder selection is independent.
    for (const Row& row : m_rows) {
        if ((row.section != Section::Print && row.section != Section::Printer) || !row.check->GetValue())
            continue;
        out.push_back(row.key);
    }
    return out;
}

References m_rows, Print, and Printer.

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

Here is the caller graph for this function:

◆ GetPublishedMaterialKeys()

std::vector< Slic3r::PublishedMaterialEntry > Slic3r::GUI::PublishSettingsDialog::GetPublishedMaterialKeys ( ) const

{
    std::vector<Slic3r::PublishedMaterialEntry> out;
    for (const Category& cat : m_categories) {
        if (cat.section != Section::Material)
            continue;
        // A slot that is not "Enable"d publishes nothing at all.
        if (cat.enable_check != nullptr && !cat.enable_check->GetValue())
            continue;
        Slic3r::PublishedMaterialEntry entry;
        entry.filament_type   = cat.filament_type;
        entry.filament_vendor = cat.filament_vendor;
        entry.filament_id     = cat.filament_id;
        entry.slot            = static_cast<int>(cat.filament_slot);
        // The author's preset id distinguishes exact variants that share filament_id
        // ("Generic PLA" vs "Generic PLA Matte"), so the receiver can match precisely; the
        // preset name is the most direct identity and is matched first on load.
        PresetBundle* bundle = wxGetApp().preset_bundle;
        if (bundle != nullptr && cat.filament_slot < bundle->filament_presets.size()) {
            if (const Preset* preset = bundle->filaments.find_preset(bundle->filament_presets[cat.filament_slot], false, true)) {
                entry.setting_id  = preset->setting_id;
                entry.preset_name = preset->name;
            }
        }
        // A mixed slot publishes as one unit: its definition (components, ratios, gradient)
        // always travels (its Enable implies this), and the component filaments are enabled +
        // Full Published by on_enable_toggle into their own entries.
        if (cat.is_mixed) {
            Slic3r::PublishedMaterialEntry mixed_entry;
            mixed_entry.filament_type   = cat.filament_type;
            mixed_entry.filament_vendor = cat.filament_vendor;
            mixed_entry.filament_id     = cat.filament_id;
            mixed_entry.slot            = static_cast<int>(cat.filament_slot);
            // The mix's own colour (blended) is a property of the definition, not a
            // requirement row; carry it so the receiver renders the swatch.
            const DynamicPrintConfig full_cfg = wxGetApp().preset_bundle->full_config();
            const std::string mix_color       = filament_color_hex(full_cfg, cat.filament_slot);
            if (!mix_color.empty()) {
                mixed_entry.publish_color = true;
                mixed_entry.color         = mix_color;
            }
            for (const std::string& key : publish_mixed_keys())
                mixed_entry.keys.emplace_back(key);
            out.push_back(std::move(mixed_entry));
            continue;
        }
        // "Full Publish": the whole filament preset is embedded; type and colour are implicitly
        // published, and the per-key rows are disabled / their state ignored.
        if (cat.full_check != nullptr && cat.full_check->GetValue()) {
            entry.full               = true;
            entry.full_keys          = full_keys_for_slot();
            entry.publish_type       = true;
            entry.publish_type_value = normalize_filament_type(cat.filament_type);
            for (size_t r : cat.rows) {
                const Row& row = m_rows[r];
                if (row.kind == RowKind::Color && !row.value.IsEmpty()) {
                    entry.publish_color = true;
                    entry.color         = row.value.ToStdString();
                }
            }
            out.push_back(std::move(entry));
            continue;
        }
        for (size_t r : cat.rows) {
            const Row& row = m_rows[r];
            if (!row.check->GetValue())
                continue;
            if (row.kind == RowKind::Color) {
                entry.publish_color = true;
                entry.color         = row.value.ToStdString();
            } else if (row.kind == RowKind::Type) {
                entry.publish_type       = true;
                entry.publish_type_value = row.value.ToStdString();
            } else {
                entry.keys.push_back(row.key);
            }
        }
        // Nothing checked at all -> nothing to write.
        if (!entry.keys.empty() || entry.publish_type || entry.publish_color)
            out.push_back(std::move(entry));
    }
    return out;
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_new_scale_factor()

bool Slic3r::GUI::DPIAware< wxDialog >::is_new_scale_factor ( ) const

inlineprivateinherited

262{ return fabs(m_scale_factor - m_prev_scale_factor) > 0.001; }

◆ make_mixed_visual_spec()

PublishSettingsDialog::MixedVisualSpec Slic3r::GUI::PublishSettingsDialog::make_mixed_visual_spec	(	const Slic3r::DynamicPrintConfig &	full,
		size_t	slot )

staticprivate

{
    MixedVisualSpec spec;
    const std::vector<unsigned int> comps = mixed_slot_components(full, slot);
    if (comps.empty())
        return spec;
 
    const auto* grad_opt = full.opt<ConfigOptionBools>("filament_mixed_gradient");
    spec.is_gradient     = grad_opt != nullptr && slot < grad_opt->size() && grad_opt->values[slot];
 
    const auto* colours = full.opt<ConfigOptionStrings>("filament_colour");
    for (unsigned int cid : comps) {
        std::string hex = "#D9D9D9";
        if (colours != nullptr && cid >= 1 && cid <= colours->size())
            hex = colours->values[cid - 1];
        const wxColour c(hex);
        spec.component_colours.push_back(c.IsOk() ? c : wxColour("#D9D9D9"));
    }
 
    if (!spec.is_gradient) {
        // Sublayer shares; parse_mixed_ratios already falls back to equal shares and
        // normalizes to sum 1.
        spec.ratios.assign(comps.size(), 1.0 / comps.size());
        if (const auto* ratios_opt = full.opt<ConfigOptionStrings>("filament_mixed_sublayer_ratios"))
            if (slot < ratios_opt->size()) {
                const std::vector<double> rs = parse_mixed_ratios(ratios_opt->values[slot], comps.size());
                if (rs.size() == comps.size())
                    spec.ratios = rs;
            }
        if (comps.size() == 3)
            spec.tri_weights = spec.ratios; // the picker's barycentric shares
    } else {
        const Slic3r::GradientCurve curve = mixed_gradient_curve(full, slot);
        constexpr int kSamples            = 256;
        for (int i = 0; i <= kSamples; ++i) {
            const double t = double(i) / kSamples;
            spec.gradient_samples.emplace_back(t, sample_gradient_curve(curve, t));
        }
        for (const Slic3r::GradientAnchor& anchor : curve.points)
            spec.gradient_anchors.emplace_back(anchor.x, anchor.y);
    }
 
    spec.valid = true;
    return spec;
}

References Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::component_colours, Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::gradient_anchors, Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::gradient_samples, Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::is_gradient, Slic3r::GUI::mixed_gradient_curve(), Slic3r::DynamicConfig::opt(), Slic3r::parse_mixed_ratios(), Slic3r::GradientCurve::points, Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::ratios, Slic3r::sample_gradient_curve(), Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::tri_weights, Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec::valid, Slic3r::GradientAnchor::x, and Slic3r::GradientAnchor::y.

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normal_font()

const wxFont & Slic3r::GUI::DPIAware< wxDialog >::normal_font ( ) const

inlineinherited

205{ return m_normal_font; }

Here is the caller graph for this function:

◆ on_dpi_changed()

void Slic3r::GUI::PublishSettingsDialog::on_dpi_changed ( const wxRect & suggested_rect )

overrideprotectedvirtual

Implements Slic3r::GUI::DPIAware< wxDialog >.

{
    // Rescale toolbar bitmaps and icons; collapse chevrons are vector-drawn and repaint.
    m_search.msw_rescale();
    m_menu.msw_rescale();
    m_filter_box->SetIcon(m_search.bmp());
    m_menu_button->SetBitmap(m_menu.bmp());
    m_outer_tabs->Rescale();
 
    const DynamicPrintConfig full = wxGetApp().preset_bundle->full_config();
 
    for (Category& cat : m_categories) {
        if (cat.full_check != nullptr)
            cat.full_check->Refresh();
        if (cat.enable_check != nullptr)
            cat.enable_check->Refresh();
        if (cat.title_label != nullptr)
            cat.title_label->Refresh();
        if (cat.filament_color_chip != nullptr) {
            // Mixed pages have no header chip; this only ever fires for physical slots.
            if (wxBitmap* chip = get_extruder_color_icon(filament_color_hex(full, cat.filament_slot), std::to_string(cat.filament_slot + 1),
                                                         FromDIP(20), FromDIP(20))) {
                cat.filament_color_chip->SetBitmap(*chip);
            }
        }
        cat.scroll->FitInside();
        cat.list_sizer->Layout();
    }
 
    for (size_t s = 0; s < m_sections.size(); ++s) {
        SectionGroup& section = m_sections[s];
        section.icon_bmp.msw_rescale();
        if (section.icon_bmp.bmp().IsOk())
            m_outer_tabs->SetItemBitmap(s, section.icon_bmp.bmp());
        section.tabs->Rescale();
        if (section.mixed_tabs != nullptr)
            section.mixed_tabs->Rescale();
        if (section.variant_switch != nullptr)
            section.variant_switch->Rescale();
    }
 
    // Refresh the per-row Color chips at the new DPI (they carry the slot number too).
    for (Row& row : m_rows) {
        if (row.color_chip != nullptr && !row.value.IsEmpty()) {
            const std::string chip_label = (row.inner_index < m_categories.size()) ?
                                               std::to_string(m_categories[row.inner_index].filament_slot + 1) :
                                               "";
            if (wxBitmap* chip = get_extruder_color_icon(row.value.ToStdString(), chip_label, FromDIP(20), FromDIP(20)))
                row.color_chip->SetBitmap(*chip);
        }
    }
 
    for (size_t category_index = 0; category_index < m_categories.size(); ++category_index) {
        const Category& category = m_categories[category_index];
        if (category.section != Section::Material || category.is_mixed)
            continue;
        if (wxBitmap* chip = get_extruder_color_icon(filament_color_hex(full, category.filament_slot),
                                                     std::to_string(category.filament_slot + 1), FromDIP(20), FromDIP(20))) {
            const SectionGroup& section = m_sections[category.group];
            const auto iter             = std::find(section.categories.begin(), section.categories.end(), category_index);
            if (iter != section.categories.end())
                m_sections[category.group].tabs->SetItemBitmap(static_cast<unsigned int>(iter - section.categories.begin()), *chip);
        }
    }
    refresh_mixed_tab_bitmaps();
 
    fit_to_content(); // tab buttons' min widths grew with the DPI: re-fit (incl. resize floor)
    Refresh();
}

Here is the call graph for this function:

◆ on_enable_toggle()

void Slic3r::GUI::PublishSettingsDialog::on_enable_toggle ( size_t category_index )

private

{
    Category& cat      = m_categories[category_index];
    const bool enabled = cat.enable_check->GetValue();
 
    // A published mixed filament needs its component filaments published too: mark the slots it
    // uses as "Enable"d and Full Published so the mix's physical components always ship their
    // identities.
    if (cat.is_mixed && enabled) {
        const DynamicPrintConfig full              = wxGetApp().preset_bundle->full_config();
        const std::vector<unsigned int> components = mixed_slot_components(full, cat.filament_slot);
        for (const unsigned int component : components) {
            // Components are 1-based physical filament indices.
            const size_t component_slot = size_t(component) - 1;
            for (size_t c = 0; c < m_categories.size(); ++c) {
                Category& comp_cat = m_categories[c];
                if (comp_cat.section != Section::Material || comp_cat.is_mixed || comp_cat.filament_slot != component_slot)
                    continue;
                if (comp_cat.enable_check != nullptr)
                    comp_cat.enable_check->SetValue(true);
                if (comp_cat.full_check != nullptr)
                    comp_cat.full_check->SetValue(true);
                on_full_toggle(c);
            }
        }
    }
 
    // Reveal/hide everything below the slot's header (rows, info, Full Publish line) and refresh
    // the visibility of the auto-selected component slots.
    apply_visibility();
    if (cat.page != nullptr)
        cat.page->GetSizer()->Layout();
    refresh_tab_indicators();
}

References apply_visibility(), Slic3r::GUI::PublishSettingsDialog::Category::enable_check, Slic3r::GUI::PublishSettingsDialog::Category::filament_slot, Slic3r::GUI::PublishSettingsDialog::Category::full_check, Slic3r::GUI::PublishSettingsDialog::Category::is_mixed, m_categories, Material, on_full_toggle(), Slic3r::GUI::PublishSettingsDialog::Category::page, refresh_tab_indicators(), and Slic3r::GUI::PublishSettingsDialog::Category::section.

Referenced by apply_selection(), build_option_model(), and select_all().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_full_toggle()

void Slic3r::GUI::PublishSettingsDialog::on_full_toggle ( size_t category_index )

private

{
    Category& cat   = m_categories[category_index];
    const bool full = cat.full_check->GetValue();
    for (size_t r : cat.rows) {
        m_rows[r].check->Enable(!full);
        m_rows[r].check_label->Enable(!full);
    }
    refresh_tab_indicators();
}

References Slic3r::GUI::PublishSettingsDialog::Category::full_check, m_categories, m_rows, refresh_tab_indicators(), and Slic3r::GUI::PublishSettingsDialog::Category::rows.

Referenced by apply_selection(), build_option_model(), and on_enable_toggle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_inner_tab_changed()

void Slic3r::GUI::PublishSettingsDialog::on_inner_tab_changed	(	size_t	section_index,
		wxCommandEvent &	event )

private

{
    const int selection = event.GetInt();
    if (section_index < m_sections.size() && selection >= 0 && selection < static_cast<int>(m_sections[section_index].categories.size()))
        show_inner_page(section_index, selection);
}

References m_sections, and show_inner_page().

Referenced by bind_tab_events().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_mixed_tab_changed()

void Slic3r::GUI::PublishSettingsDialog::on_mixed_tab_changed	(	size_t	section_index,
		wxCommandEvent &	event )

private

{
    const int selection = event.GetInt();
    if (section_index < m_sections.size() && selection >= 0 &&
        selection < static_cast<int>(m_sections[section_index].mixed_categories.size()))
        show_mixed_page(section_index, selection);
}

References m_sections, and show_mixed_page().

Referenced by bind_tab_events().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_outer_tab_changed()

void Slic3r::GUI::PublishSettingsDialog::on_outer_tab_changed ( wxCommandEvent & event )

private

{
    const int selection = event.GetInt();
    if (selection >= 0 && selection < static_cast<int>(m_sections.size()))
        show_outer_page(static_cast<size_t>(selection));
}

References m_sections, and show_outer_page().

Referenced by bind_tab_events().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_sys_color_changed()

void Slic3r::GUI::PublishSettingsDialog::on_sys_color_changed ( )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::DPIAware< wxDialog >.

{
    // The mixed-tab compositions bake the tab strip's background colour: rebuild them when the
    // theme changes (on_dpi_changed covers rescales).
    refresh_mixed_tab_bitmaps();
    Refresh();
}

References refresh_mixed_tab_bitmaps().

Here is the call graph for this function:

◆ prev_scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::prev_scale_factor ( ) const

inlineinherited

196{ return m_prev_scale_factor; }

◆ refresh_filter()

void Slic3r::GUI::PublishSettingsDialog::refresh_filter ( const wxString & filter )

private

{
    Freeze();
    const bool pseudo       = m_filter_mode != FilterMode::Text;
    const bool want_checked = m_filter_mode == FilterMode::SelectedOnly;
    m_fb_sizer->Show(!pseudo);
    if (pseudo) {
        // "×" marks the chip as a dismissible filter state (U+00D7, present in all UI fonts).
        m_pseudo_chip->SetLabel((want_checked ? _L("Filter selected") : _L("Filter non-selected")) + " " + wxString::FromUTF8("\u00d7"));
    }
    m_pseudo_chip->Show(pseudo);
 
    // Row matches are computed first; page and optgroup visibility is applied below.
    if (pseudo) {
        for (Row& row : m_rows)
            row.matches_filter = row.check->IsEnabled() && row.check->GetValue() == want_checked;
    } else {
        const bool clear = filter.IsEmpty();
        for (Row& row : m_rows) {
            row.matches_filter = clear || (row.section_title + " " + row.category + " " + row.subcategory + " " + row.label + " " +
                                           row.value + " " + row.unit)
                                              .Lower()
                                              .Contains(filter);
        }
    }
 
    size_t first_outer    = 0;
    int first_inner       = -1;
    bool active_has_match = false;
    for (size_t s = 0; s < m_sections.size(); ++s) {
        for (size_t inner = 0; inner < m_sections[s].categories.size(); ++inner) {
            Category& category = m_categories[m_sections[s].categories[inner]];
            bool has_match     = false;
            for (size_t r : category.rows)
                has_match = has_match || m_rows[r].matches_filter;
            category.info->Show(!has_match);
            if (!has_match)
                // A mixed slot has no selectable rows: always explain it is published whole.
                category.info->SetLabel(category.is_mixed ? m_info_mix :
                                                            (pseudo ? (want_checked ? m_info_nonsel : m_info_allsel) : m_info_empty));
            if (has_match && first_inner < 0) {
                first_outer = s;
                first_inner = static_cast<int>(inner);
            }
            if (static_cast<int>(s) == m_selected_outer && static_cast<int>(inner) == m_sections[s].selected_inner)
                active_has_match = has_match;
        }
        // Mixed slots have no rows: they can never match a filter, so they always fall back to
        // their explanatory hint (shown once the slot is enabled).
        for (size_t mixed : m_sections[s].mixed_categories) {
            Category& category = m_categories[mixed];
            category.info->Show(true);
            category.info->SetLabel(m_info_mix);
        }
    }
    if (!active_has_match && first_inner >= 0 &&
        (m_selected_outer != static_cast<int>(first_outer) || m_sections[first_outer].selected_inner != first_inner)) {
        if (m_selected_outer != static_cast<int>(first_outer)) {
            m_outer_tabs->SelectItem(static_cast<int>(first_outer));
            show_outer_page(first_outer);
        }
        m_sections[first_outer].tabs->SelectItem(first_inner);
        show_inner_page(first_outer, first_inner);
    }
 
    apply_visibility();
    for (Category& category : m_categories) {
        save_scroll_position(category);
        category.scroll->FitInside();
        category.list_sizer->Layout();
        category.scroll->Scroll(category.scroll_pos.x, category.scroll_pos.y);
    }
    Layout();
    Thaw();
}

References _L, apply_visibility(), Slic3r::GUI::PublishSettingsDialog::Category::info, Slic3r::GUI::PublishSettingsDialog::Category::is_mixed, m_categories, m_fb_sizer, m_filter_mode, m_info_allsel, m_info_empty, m_info_mix, m_info_nonsel, m_outer_tabs, m_pseudo_chip, m_rows, m_sections, m_selected_outer, Slic3r::GUI::PublishSettingsDialog::Category::rows, save_scroll_position(), SelectedOnly, show_inner_page(), show_outer_page(), and Text.

Referenced by apply_filter(), and apply_pseudo_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refresh_mixed_tab_bitmaps()

void Slic3r::GUI::PublishSettingsDialog::refresh_mixed_tab_bitmaps ( )

private

{
    // The mixed-tab composition bitmaps bake the tab strip's background colour and DPI-scaled
    // text, so both a theme flip and a DPI change have to rebuild them.
    const DynamicPrintConfig full = wxGetApp().preset_bundle->full_config();
    for (SectionGroup& section : m_sections) {
        if (section.mixed_tabs == nullptr)
            continue;
        const wxColour tab_bg = section.mixed_tabs->GetBackgroundColour();
        for (size_t i = 0; i < section.mixed_categories.size(); ++i) {
            const Category& category = m_categories[section.mixed_categories[i]];
            const wxBitmap tab_bmp   = mixed_filament_tab_bitmap(full, category.filament_slot, FromDIP(20), tab_bg);
            if (tab_bmp.IsOk())
                section.mixed_tabs->SetItemBitmap(static_cast<unsigned int>(i), tab_bmp);
        }
    }
}

References Slic3r::GUI::PublishSettingsDialog::Category::filament_slot, m_categories, and m_sections.

Referenced by PublishSettingsDialog(), on_dpi_changed(), and on_sys_color_changed().

Here is the caller graph for this function:

◆ refresh_tab_indicators()

void Slic3r::GUI::PublishSettingsDialog::refresh_tab_indicators ( )

private

{
    for (size_t s = 0; s < m_sections.size(); ++s) {
        SectionGroup& section = m_sections[s];
        bool any              = false;
        for (size_t i = 0; i < section.categories.size(); ++i) {
            const bool on = category_has_selection(m_categories[section.categories[i]]);
            section.tabs->SetItemIndicator(static_cast<unsigned int>(i), on);
            // The switch has no indicator dot; mark its option text instead.
            if (section.variant_switch != nullptr) {
                const wxString& title = m_categories[section.categories[i]].title;
                const wxString  text  = on ? title + wxString(" ") + wxString(wxUniChar(0x2022)) : title;
                if (section.variant_switch->GetOptionText(static_cast<unsigned int>(i)) != text) {
                    section.variant_switch->SetOptionText(static_cast<unsigned int>(i), text);
                    section.page->Layout();
                }
            }
            any = any || on;
        }
        if (section.mixed_tabs != nullptr)
            for (size_t i = 0; i < section.mixed_categories.size(); ++i) {
                const bool on = category_has_selection(m_categories[section.mixed_categories[i]]);
                section.mixed_tabs->SetItemIndicator(static_cast<unsigned int>(i), on);
                any = any || on;
            }
        m_outer_tabs->SetItemIndicator(static_cast<unsigned int>(s), any);
    }
}

References Slic3r::GUI::PublishSettingsDialog::SectionGroup::categories, category_has_selection(), MultiSwitchButton::GetOptionText(), m_categories, m_outer_tabs, m_sections, Slic3r::GUI::PublishSettingsDialog::SectionGroup::mixed_categories, Slic3r::GUI::PublishSettingsDialog::SectionGroup::mixed_tabs, Slic3r::GUI::PublishSettingsDialog::SectionGroup::page, TabCtrl::SetItemIndicator(), MultiSwitchButton::SetOptionText(), Slic3r::GUI::PublishSettingsDialog::SectionGroup::tabs, and Slic3r::GUI::PublishSettingsDialog::SectionGroup::variant_switch.

Referenced by add_row_ui(), apply_selection(), build_option_model(), on_enable_toggle(), on_full_toggle(), select_all(), and select_visible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rescale()

void Slic3r::GUI::DPIAware< wxDialog >::rescale ( const wxRect & suggested_rect )

inlineprivateinherited

    {
        this->Freeze();
 
        m_force_rescale = false;
 
        // set normal application font as a current window font
        m_normal_font = this->GetFont();
 
        update_em_unit();
 
        // rescale missed controls sizes and images
        on_dpi_changed(suggested_rect);
 
        this->Layout();
        this->Thaw();
 
        // reset previous scale factor from current scale factor value
        m_prev_scale_factor = m_scale_factor;
    }

◆ row_is_visible()

bool Slic3r::GUI::PublishSettingsDialog::row_is_visible ( const Row & row ) const

private

{
    if (m_selected_outer < 0 || m_selected_outer >= static_cast<int>(m_sections.size()) ||
        row.outer_index != static_cast<size_t>(m_selected_outer) || m_sections[m_selected_outer].selected_inner < 0 ||
        m_sections[m_selected_outer].selected_inner >= static_cast<int>(m_sections[m_selected_outer].categories.size()) ||
        row.inner_index != m_sections[m_selected_outer].categories[m_sections[m_selected_outer].selected_inner] || !row.matches_filter ||
        !row.check->IsEnabled())
        return false;
    return row.item->IsShown();
}

References Slic3r::GUI::PublishSettingsDialog::Row::check, Slic3r::GUI::PublishSettingsDialog::Row::inner_index, Slic3r::GUI::PublishSettingsDialog::Row::item, m_sections, m_selected_outer, Slic3r::GUI::PublishSettingsDialog::Row::matches_filter, and Slic3r::GUI::PublishSettingsDialog::Row::outer_index.

Referenced by select_visible(), and show_menu().

Here is the caller graph for this function:

◆ save_scroll_position()

void Slic3r::GUI::PublishSettingsDialog::save_scroll_position ( Category & category )

private

{
    if (category.scroll != nullptr)
        category.scroll->GetViewStart(&category.scroll_pos.x, &category.scroll_pos.y);
}

References Slic3r::GUI::PublishSettingsDialog::Category::scroll, and Slic3r::GUI::PublishSettingsDialog::Category::scroll_pos.

Referenced by refresh_filter(), show_inner_page(), show_mixed_page(), and show_outer_page().

Here is the caller graph for this function:

◆ scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::scale_factor ( ) const

inlineinherited

195{ return m_scale_factor; }

◆ section_group_for()

size_t Slic3r::GUI::PublishSettingsDialog::section_group_for ( Section kind )

private

{
    for (size_t i = 0; i < m_sections.size(); ++i)
        if (m_sections[i].kind == kind)
            return i;
 
    SectionGroup section;
    section.kind           = kind;
    const size_t new_index = m_sections.size();
    switch (kind) {
    case Section::Printer:
        section.title     = _L("Printer");
        section.icon_name = "printer";
        break;
    case Section::Material:
        section.title     = _L("Filament");
        section.icon_name = "filament";
        break;
    case Section::Print:
        section.title     = _L("Process");
        section.icon_name = "process";
        break;
    }
    section.icon_bmp = ScalableBitmap(this, section.icon_name, 16);
 
    section.page = new wxPanel(m_outer_host, wxID_ANY);
    section.page->SetBackgroundColour(GetBackgroundColour());
    auto* page_sizer = new wxBoxSizer(wxVERTICAL);
    section.tabs     = new TabCtrl(section.page, wxID_ANY, wxDefaultPosition, wxDefaultSize, s_tab_style);
    section.tabs->SetFont(Label::Body_14);
    section.tabs->SetBackgroundColour(GetBackgroundColour());
    page_sizer->Add(section.tabs, 0, wxEXPAND);
    // Mixed-color filament slots get a second tab strip below the physical filament tabs; only
    // the Material section has them.
    if (kind == Section::Material) {
        section.mixed_tabs = new TabCtrl(section.page, wxID_ANY, wxDefaultPosition, wxDefaultSize, s_tab_style);
        section.mixed_tabs->SetFont(Label::Body_14);
        section.mixed_tabs->SetBackgroundColour(GetBackgroundColour());
        page_sizer->Add(section.mixed_tabs, 0, wxEXPAND | wxTOP, FromDIP(2));
        section.mixed_tabs->Hide();
    }
    section.page_host = new wxPanel(section.page, wxID_ANY);
#ifdef __WINDOWS__
    section.page_host->SetDoubleBuffered(true);
#endif
    section.page_host->SetBackgroundColour(GetBackgroundColour());
    section.page_host_sizer = new wxBoxSizer(wxVERTICAL);
    section.page_host->SetSizer(section.page_host_sizer);
    page_sizer->Add(section.page_host, 1, wxEXPAND | wxTOP, FromDIP(4));
    section.page->SetSizer(page_sizer);
 
    if (section.icon_bmp.bmp().IsOk())
        m_outer_tabs->AppendItem(section.title, section.icon_bmp.bmp());
    else
        m_outer_tabs->AppendItem(section.title);
    m_outer_host_sizer->Add(section.page, 1, wxEXPAND);
    section.page->Hide();
    m_sections.push_back(std::move(section));
    return new_index;
}

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_all()

void Slic3r::GUI::PublishSettingsDialog::select_all ( bool value )

private

{
    // "All" skips disabled (gated) rows; "None" leaves a gated row's preserved value.
    for (Row& row : m_rows)
        if (row.check->IsEnabled())
            row.check->SetValue(value);
    // "All" also enables every material slot (so its rows/Full Publish become visible and the
    // selection is actually exported); "None" disables them all again.
    for (Category& cat : m_categories)
        if (cat.section == Section::Material && cat.enable_check != nullptr)
            cat.enable_check->SetValue(value);
    // CheckBox::SetValue does not emit wxEVT_TOGGLEBUTTON, so re-run the enable handlers to
    // propagate mixed-slot components and refresh visibility as if the user had clicked.
    for (size_t c = 0; c < m_categories.size(); ++c)
        if (m_categories[c].section == Section::Material)
            on_enable_toggle(c);
    apply_visibility();
    refresh_tab_indicators();
}

References apply_visibility(), m_categories, m_rows, Material, on_enable_toggle(), and refresh_tab_indicators().

Referenced by PublishSettingsDialog(), and show_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_visible()

void Slic3r::GUI::PublishSettingsDialog::select_visible ( bool value )

private

{
    // In a pseudo-filter view the rows being toggled would all disappear; drop the filter
    // afterwards so the result stays visible.
    const bool clear_pseudo = (m_filter_mode == FilterMode::UnselectedOnly && !value) ||
                              (m_filter_mode == FilterMode::SelectedOnly && value);
 
    // Toggle the rows visible under the *current* filter.
    for (Row& row : m_rows)
        if (row_is_visible(row))
            row.check->SetValue(value);
 
    if (clear_pseudo) {
        // Note: SetValue() may fire wxEVT_TEXT on some platforms, re-entering apply_filter() -
        // that is fine; the rows above were already toggled and the trailing call is idempotent.
        m_filter_ctrl->ChangeValue("");
        apply_filter(""); // resync visibility and the All/None bar
    }
    refresh_tab_indicators();
}

References apply_filter(), m_filter_ctrl, m_filter_mode, m_rows, refresh_tab_indicators(), row_is_visible(), SelectedOnly, and UnselectedOnly.

Referenced by show_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::set_em_unit ( int v )

inlineinherited

200{ m_em_unit = v; }

◆ set_prev_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_prev_scale_factor ( float v )

inlineinherited

199{ m_prev_scale_factor = v; }

◆ set_row_bold()

void Slic3r::GUI::PublishSettingsDialog::set_row_bold	(	Row &	row,
		bool	bold )

private

{
    // Rebase on the dialog's body font so clearing bold restores the exact original font.
    row.check_label->SetFont(bold ? Label::Body_13.Bold() : Label::Body_13);
}

References Label::Body_13, Slic3r::GUI::bold(), and Slic3r::GUI::PublishSettingsDialog::Row::check_label.

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_scale_factor ( float v )

inlineinherited

198{ m_scale_factor = v; }

◆ setup_variant_switch()

void Slic3r::GUI::PublishSettingsDialog::setup_variant_switch ( size_t section_index )

private

{
    SectionGroup& section = m_sections[section_index];
    std::vector<wxString> titles;
    for (size_t category : section.categories)
        titles.push_back(m_categories[category].title);
 
    section.variant_switch = new MultiSwitchButton(section.page);
    section.variant_switch->SetFitToOptions();
    section.variant_switch->SetOptions(titles);
    section.variant_switch->SetSelection(section.selected_inner);
    section.variant_switch->Bind(wxCUSTOMEVT_MULTISWITCH_SELECTION, [this, section_index](wxCommandEvent& evt) {
        evt.Skip();
        // The hidden tab strip stays the selection model; its event shows the page.
        SectionGroup& sec = m_sections[section_index];
        if (evt.GetInt() != sec.selected_inner)
            sec.tabs->SelectItem(evt.GetInt());
    });
 
    // The switch takes the place of the tab strip, centered like on the printer tab.
    wxSizer* page_sizer = section.page->GetSizer();
    page_sizer->Insert(1, section.variant_switch, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(4));
    section.tabs->Hide();
    section.page->Layout();
}

References Slic3r::GUI::PublishSettingsDialog::SectionGroup::categories, m_categories, m_sections, Slic3r::GUI::PublishSettingsDialog::SectionGroup::page, Slic3r::GUI::PublishSettingsDialog::SectionGroup::selected_inner, TabCtrl::SelectItem(), MultiSwitchButton::SetFitToOptions(), MultiSwitchButton::SetOptions(), MultiSwitchButton::SetSelection(), Slic3r::GUI::PublishSettingsDialog::SectionGroup::tabs, and Slic3r::GUI::PublishSettingsDialog::SectionGroup::variant_switch.

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_inner_page()

void Slic3r::GUI::PublishSettingsDialog::show_inner_page	(	size_t	section_index,
		int	inner_index )

private

{
    if (section_index >= m_sections.size())
        return;
    SectionGroup& section = m_sections[section_index];
    if (inner_index < 0 || inner_index >= static_cast<int>(section.categories.size()))
        return;
    if (section.selected_inner >= 0 && section.selected_inner < static_cast<int>(section.categories.size())) {
        save_scroll_position(m_categories[section.categories[section.selected_inner]]);
        m_categories[section.categories[section.selected_inner]].page->Hide();
    }
    if (section.selected_mixed >= 0 && section.selected_mixed < static_cast<int>(section.mixed_categories.size())) {
        save_scroll_position(m_categories[section.mixed_categories[section.selected_mixed]]);
        m_categories[section.mixed_categories[section.selected_mixed]].page->Hide();
        section.selected_mixed = -1;
    }
    section.selected_inner = inner_index;
    if (section.variant_switch != nullptr)
        section.variant_switch->SetSelection(inner_index); // fires its event, which ignores the shown page
    Category& category     = m_categories[section.categories[inner_index]];
    category.page->Show();
    category.scroll->FitInside();
    category.scroll->Scroll(category.scroll_pos.x, category.scroll_pos.y);
    if (section.mixed_tabs != nullptr)
        section.mixed_tabs->Unselect();
    section.page_host_sizer->Layout();
}

Referenced by on_inner_tab_changed(), refresh_filter(), and show_outer_page().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_menu()

void Slic3r::GUI::PublishSettingsDialog::show_menu ( wxMouseEvent & evt )

private

{
    bool filtering  = !m_filter_ctrl->GetValue().IsEmpty() || m_filter_mode != FilterMode::Text;
    bool list_empty = true;
    if (m_selected_outer >= 0) {
        for (const Row& row : m_rows)
            if (row_is_visible(row)) {
                list_empty = false;
                break;
            }
    }
 
    wxMenu m;
    m.Append(kPublishSelectAll, _L("Select All"))->Enable(!filtering);
    m.Append(kPublishDeselectAll, _L("Deselect All"))->Enable(!filtering);
    m.AppendSeparator();
    m.Append(kPublishSelectVisible, _L("Select visible"))->Enable(!list_empty && filtering);
    m.Append(kPublishDeselectVisible, _L("Deselect visible"))->Enable(!list_empty && filtering);
    m.AppendSeparator();
    m.AppendCheckItem(kPublishFilterSelected, _L("Filter selected"));
    m.AppendCheckItem(kPublishFilterNonSelected, _L("Filter non-selected"));
    m.Check(kPublishFilterSelected, m_filter_mode == FilterMode::SelectedOnly);
    m.Check(kPublishFilterNonSelected, m_filter_mode == FilterMode::UnselectedOnly);
 
    m.Bind(
        wxEVT_MENU,
        [this](wxCommandEvent& e) {
            switch (e.GetId()) {
            case kPublishSelectAll: select_all(true); break;
            case kPublishDeselectAll: select_all(false); break;
            case kPublishSelectVisible: select_visible(true); break;
            case kPublishDeselectVisible: select_visible(false); break;
            case kPublishFilterSelected:
                // Clicking the active entry again clears the pseudo filter.
                if (m_filter_mode == FilterMode::SelectedOnly)
                    apply_filter(m_filter_ctrl->GetValue());
                else
                    apply_pseudo_filter(true);
                break;
            case kPublishFilterNonSelected:
                if (m_filter_mode == FilterMode::UnselectedOnly)
                    apply_filter(m_filter_ctrl->GetValue());
                else
                    apply_pseudo_filter(false);
                break;
            default: break;
            }
        },
        kPublishSelectAll, kPublishFilterNonSelected);
 
    wxWindow* src = dynamic_cast<wxWindow*>(evt.GetEventObject());
    if (!src)
        return;
    wxPoint screen_pos = src->ClientToScreen(evt.GetPosition());
    wxPoint local_pos  = ScreenToClient(screen_pos);
    PopupMenu(&m, local_pos);
}

References _L, apply_filter(), apply_pseudo_filter(), m_filter_ctrl, m_filter_mode, m_rows, m_selected_outer, row_is_visible(), select_all(), select_visible(), SelectedOnly, Text, UnselectedOnly, and Slic3r::GUI::wxMouseEvent.

Referenced by PublishSettingsDialog(), and category_index_for().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_mixed_page()

void Slic3r::GUI::PublishSettingsDialog::show_mixed_page	(	size_t	section_index,
		int	mixed_index )

private

{
    if (section_index >= m_sections.size())
        return;
    SectionGroup& section = m_sections[section_index];
    if (mixed_index < 0 || mixed_index >= static_cast<int>(section.mixed_categories.size()))
        return;
    if (section.selected_mixed >= 0 && section.selected_mixed < static_cast<int>(section.mixed_categories.size())) {
        save_scroll_position(m_categories[section.mixed_categories[section.selected_mixed]]);
        m_categories[section.mixed_categories[section.selected_mixed]].page->Hide();
    }
    if (section.selected_inner >= 0 && section.selected_inner < static_cast<int>(section.categories.size())) {
        save_scroll_position(m_categories[section.categories[section.selected_inner]]);
        m_categories[section.categories[section.selected_inner]].page->Hide();
        section.selected_inner = -1;
    }
    section.selected_mixed = mixed_index;
    Category& category     = m_categories[section.mixed_categories[mixed_index]];
    category.page->Show();
    category.scroll->FitInside();
    category.scroll->Scroll(category.scroll_pos.x, category.scroll_pos.y);
    section.tabs->Unselect();
    section.page_host_sizer->Layout();
}

Referenced by on_mixed_tab_changed(), and show_outer_page().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_outer_page()

void Slic3r::GUI::PublishSettingsDialog::show_outer_page ( size_t section_index )

private

{
    if (section_index >= m_sections.size())
        return;
    if (m_selected_outer >= 0 && m_selected_outer < static_cast<int>(m_sections.size())) {
        SectionGroup& old_section = m_sections[m_selected_outer];
        if (old_section.selected_inner >= 0 && old_section.selected_inner < static_cast<int>(old_section.categories.size()))
            save_scroll_position(m_categories[old_section.categories[old_section.selected_inner]]);
        if (old_section.selected_mixed >= 0 && old_section.selected_mixed < static_cast<int>(old_section.mixed_categories.size()))
            save_scroll_position(m_categories[old_section.mixed_categories[old_section.selected_mixed]]);
        m_sections[m_selected_outer].page->Hide();
    }
    m_selected_outer      = static_cast<int>(section_index);
    SectionGroup& section = m_sections[section_index];
    section.page->Show();
    // Restore whichever tab row (physical or mixed) was active.
    if (section.selected_inner >= 0)
        show_inner_page(section_index, section.selected_inner);
    else if (section.selected_mixed >= 0)
        show_mixed_page(section_index, section.selected_mixed);
    m_outer_host_sizer->Layout();
}

References Slic3r::GUI::PublishSettingsDialog::SectionGroup::categories, m_categories, m_outer_host_sizer, m_sections, m_selected_outer, Slic3r::GUI::PublishSettingsDialog::SectionGroup::mixed_categories, Slic3r::GUI::PublishSettingsDialog::SectionGroup::page, save_scroll_position(), Slic3r::GUI::PublishSettingsDialog::SectionGroup::selected_inner, Slic3r::GUI::PublishSettingsDialog::SectionGroup::selected_mixed, show_inner_page(), and show_mixed_page().

Referenced by build_option_model(), on_outer_tab_changed(), and refresh_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowModal()

int Slic3r::GUI::DPIAware< wxDialog >::ShowModal ( )

inlineinherited

    {
        dialogStack.push_front(this);
        int r = wxDialog::ShowModal();
        dialogStack.pop_front();
        return r;
    }

Referenced by Slic3r::GUI::EditFilamentPresetDialog::delete_preset(), Slic3r::GUI::SingleChoiceDialog::GetSingleChoiceIndex(), Slic3r::GUI::ConfirmBeforeSendDialog::on_show(), Slic3r::GUI::PrivacyUpdateDialog::on_show(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::GUI::ExtrusionCalibration::Popup(), Slic3r::GUI::ObjectTableDialog::Popup(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), Slic3r::GUI::MultiNozzleSyncDialog::ShowModal(), Slic3r::GUI::RichMessageDialog::ShowModal(), Slic3r::GUI::TextureImportDialog::ShowModal(), and Slic3r::GUI::UnsavedChangesDialog::ShowModal().

Here is the caller graph for this function:

◆ subcategory_index_for()

size_t Slic3r::GUI::PublishSettingsDialog::subcategory_index_for	(	size_t	category_index,
		const wxString &	title,
		const wxString &	icon )

private

{
    Category& category = m_categories[category_index];
    for (size_t i = 0; i < category.subs.size(); ++i)
        if (category.subs[i].title == title)
            return i;
 
    Subcategory sub;
    sub.title = title;
    if (!title.IsEmpty()) {
        sub.header = new ::StaticLine(category.scroll, false, title, icon);
        sub.header->SetFont(Label::Head_14);
        sub.header->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#363636")));
        auto* wrap = new wxBoxSizer(wxVERTICAL);
        wrap->Add(sub.header, 0, wxEXPAND | wxTOP | wxBOTTOM, FromDIP(6));
        sub.item = category.list_sizer->Add(wrap, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(5));
    }
    category.subs.push_back(std::move(sub));
    return category.subs.size() - 1;
}

References StateColor::darkModeColorFor(), Label::Head_14, Slic3r::GUI::PublishSettingsDialog::Subcategory::header, Slic3r::GUI::PublishSettingsDialog::Subcategory::item, Slic3r::GUI::PublishSettingsDialog::Category::list_sizer, m_categories, Slic3r::GUI::PublishSettingsDialog::Category::scroll, Slic3r::GUI::PublishSettingsDialog::Category::subs, and Slic3r::GUI::PublishSettingsDialog::Subcategory::title.

Referenced by build_option_model().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unpublished_mixed_components()

std::vector< MixedDependencyIssue > Slic3r::GUI::PublishSettingsDialog::unpublished_mixed_components ( ) const

private

{
    std::vector<MixedDependencyIssue> out;
    for (const Category& cat : m_categories) {
        if (!cat.is_mixed || cat.section != Section::Material)
            continue;
        // Only enabled mixed slots depend on their components being published.
        if (cat.enable_check == nullptr || !cat.enable_check->GetValue())
            continue;
        const DynamicPrintConfig full = wxGetApp().preset_bundle->full_config();
        // Components are 1-based physical filament indices.
        for (const unsigned int component : mixed_slot_components(full, cat.filament_slot)) {
            const size_t component_slot = size_t(component) - 1;
            // Find the component slot's material category (one exists per physical slot).
            const Category* comp_cat = nullptr;
            for (const Category& other : m_categories) {
                if (other.section == Section::Material && !other.is_mixed && other.filament_slot == component_slot) {
                    comp_cat = &other;
                    break;
                }
            }
            if (comp_cat == nullptr || comp_cat->enable_check == nullptr)
                continue;
            // Missing when the component's "Enable" is off, or it is enabled with neither
            // "Full Publish" nor the "Type" requirement row checked. Colour never counts:
            // the receiver renders the mix from its own components' colours.
            if (!comp_cat->enable_check->GetValue()) {
                out.push_back({cat.filament_slot, component_slot, MixedDependencyIssue::Reason::Disabled});
                continue;
            }
            if (comp_cat->full_check != nullptr && comp_cat->full_check->GetValue())
                continue;
            bool type_checked = false;
            for (const size_t r : comp_cat->rows) {
                const Row& row = m_rows[r];
                if (row.kind == RowKind::Type && row.check->GetValue()) {
                    type_checked = true;
                    break;
                }
            }
            if (!type_checked)
                out.push_back({cat.filament_slot, component_slot, MixedDependencyIssue::Reason::MaterialNotPublished});
        }
    }
    // Deterministic order for the warning rows: by mixed slot, then component slot. The same
    // (mix, component) pair cannot repeat: each mix's components come from a config list.
    std::sort(out.begin(), out.end(), [](const MixedDependencyIssue& a, const MixedDependencyIssue& b) {
        return std::tie(a.mixed_slot, a.component_slot) < std::tie(b.mixed_slot, b.component_slot);
    });
    return out;
}

References Slic3r::GUI::PublishSettingsDialog::Row::check, Slic3r::GUI::MixedDependencyIssue::Disabled, Slic3r::GUI::PublishSettingsDialog::Category::enable_check, Slic3r::GUI::PublishSettingsDialog::Category::full_check, Slic3r::GUI::PublishSettingsDialog::Row::kind, m_categories, m_rows, Material, Slic3r::GUI::MixedDependencyIssue::MaterialNotPublished, Slic3r::GUI::PublishSettingsDialog::Category::rows, and Type.

Referenced by PublishSettingsDialog().

Here is the caller graph for this function:

◆ update_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::update_em_unit ( )

inlineprivateinherited

    {
        // Linux specific issue : get_dpi_for_window(this) still doesn't responce to the Display's scale in new wxWidgets(3.1.3).
        // So, calculate the m_em_unit value from the font size, as before
#if !defined(__WXGTK__)
        m_em_unit = std::max<size_t>(10, 10.0f * m_scale_factor);
#else
        // initialize default width_unit according to the width of the one symbol ("m") of the currently active font of this window.
        m_em_unit = std::max<size_t>(10, this->GetTextExtent("m").x - 1);
#endif // __WXGTK__
    }

Member Data Documentation

◆ m_can_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_can_rescale

privateinherited

235{ true };

◆ m_categories

std::vector<Category> Slic3r::GUI::PublishSettingsDialog::m_categories

private

◆ m_em_unit

int Slic3r::GUI::DPIAware< wxDialog >::m_em_unit

privateinherited

◆ m_fb_sizer

wxBoxSizer* Slic3r::GUI::PublishSettingsDialog::m_fb_sizer {nullptr}

private

292{nullptr}; // "All"/"None" buttons sizer

Referenced by PublishSettingsDialog(), and refresh_filter().

◆ m_filter_box

TextInput* Slic3r::GUI::PublishSettingsDialog::m_filter_box {nullptr}

private

296{nullptr};

Referenced by PublishSettingsDialog(), and on_dpi_changed().

◆ m_filter_ctrl

wxTextCtrl* Slic3r::GUI::PublishSettingsDialog::m_filter_ctrl {nullptr}

private

297{nullptr};

Referenced by PublishSettingsDialog(), select_visible(), and show_menu().

◆ m_filter_mode

FilterMode Slic3r::GUI::PublishSettingsDialog::m_filter_mode {FilterMode::Text}

private

295{FilterMode::Text};

Referenced by PublishSettingsDialog(), apply_filter(), apply_pseudo_filter(), refresh_filter(), select_visible(), and show_menu().

◆ m_force_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_force_rescale

privateinherited

236{ false };

◆ m_info_allsel

wxString Slic3r::GUI::PublishSettingsDialog::m_info_allsel

private

Referenced by build_option_model(), and refresh_filter().

◆ m_info_empty

wxString Slic3r::GUI::PublishSettingsDialog::m_info_empty

private

Referenced by build_option_model(), category_index_for(), and refresh_filter().

◆ m_info_mix

wxString Slic3r::GUI::PublishSettingsDialog::m_info_mix

private

Referenced by build_option_model(), category_index_for(), and refresh_filter().

◆ m_info_nonsel

wxString Slic3r::GUI::PublishSettingsDialog::m_info_nonsel

private

Referenced by build_option_model(), and refresh_filter().

◆ m_menu

ScalableBitmap Slic3r::GUI::PublishSettingsDialog::m_menu

private

Referenced by PublishSettingsDialog(), and on_dpi_changed().

◆ m_menu_button

wxStaticBitmap* Slic3r::GUI::PublishSettingsDialog::m_menu_button {nullptr}

private

298{nullptr};

Referenced by PublishSettingsDialog(), and on_dpi_changed().

◆ m_new_font_point_size

int Slic3r::GUI::DPIAware< wxDialog >::m_new_font_point_size

privateinherited

◆ m_normal_font

wxFont Slic3r::GUI::DPIAware< wxDialog >::m_normal_font

privateinherited

◆ m_outer_host

wxPanel* Slic3r::GUI::PublishSettingsDialog::m_outer_host {nullptr}

private

289{nullptr};

Referenced by PublishSettingsDialog(), and section_group_for().

◆ m_outer_host_sizer

wxBoxSizer* Slic3r::GUI::PublishSettingsDialog::m_outer_host_sizer {nullptr}

private

290{nullptr};

Referenced by PublishSettingsDialog(), section_group_for(), and show_outer_page().

◆ m_outer_tabs

TabCtrl* Slic3r::GUI::PublishSettingsDialog::m_outer_tabs {nullptr}

private

288{nullptr};

Referenced by PublishSettingsDialog(), bind_tab_events(), build_option_model(), fit_to_content(), on_dpi_changed(), refresh_filter(), refresh_tab_indicators(), and section_group_for().

◆ m_prev_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_prev_scale_factor

privateinherited

◆ m_pseudo_chip

wxStaticText* Slic3r::GUI::PublishSettingsDialog::m_pseudo_chip {nullptr}

private

301{nullptr};

Referenced by PublishSettingsDialog(), and refresh_filter().

◆ m_rows

std::vector<Row> Slic3r::GUI::PublishSettingsDialog::m_rows

private

Referenced by add_row_ui(), apply_selection(), apply_visibility(), build_option_model(), category_has_selection(), GetPublishedKeys(), GetPublishedMaterialKeys(), on_dpi_changed(), on_full_toggle(), refresh_filter(), select_all(), select_visible(), show_menu(), and unpublished_mixed_components().

◆ m_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_scale_factor

privateinherited

◆ m_search

ScalableBitmap Slic3r::GUI::PublishSettingsDialog::m_search

private

Referenced by PublishSettingsDialog(), and on_dpi_changed().

◆ m_sections

std::vector<SectionGroup> Slic3r::GUI::PublishSettingsDialog::m_sections

private

Referenced by add_row_ui(), bind_tab_events(), build_option_model(), category_index_for(), fit_to_content(), on_dpi_changed(), on_inner_tab_changed(), on_mixed_tab_changed(), on_outer_tab_changed(), refresh_filter(), refresh_mixed_tab_bitmaps(), refresh_tab_indicators(), row_is_visible(), section_group_for(), setup_variant_switch(), show_inner_page(), show_mixed_page(), and show_outer_page().

◆ m_selected_outer

int Slic3r::GUI::PublishSettingsDialog::m_selected_outer {-1}

private

291{-1};

Referenced by refresh_filter(), row_is_visible(), show_menu(), and show_outer_page().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PublishSettingsDialog.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PublishSettingsDialog.cpp

	OrcaSlicer latest OrcaSlicer

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::GUI::PublishSettingsDialog::Row

◆ Slic3r::GUI::PublishSettingsDialog::Subcategory

◆ Slic3r::GUI::PublishSettingsDialog::Category

◆ Slic3r::GUI::PublishSettingsDialog::MixedVisualSpec

◆ Slic3r::GUI::PublishSettingsDialog::SectionGroup

Member Enumeration Documentation

◆ FilterMode

◆ RowKind

◆ Section

Constructor & Destructor Documentation

◆ PublishSettingsDialog()

◆ ~PublishSettingsDialog()

Member Function Documentation

◆ add_mixed_visual()

◆ add_row_ui()

◆ apply_filter()

◆ apply_pseudo_filter()

◆ apply_selection()

◆ apply_visibility()

◆ bind_tab_events()

◆ build_option_model()

◆ category_has_selection()

◆ category_index_for()

◆ em_unit()

◆ enable_force_rescale()

◆ EndModal()

◆ fit_to_content()

◆ force_rescale()

◆ full_keys_for_slot()

◆ GetPublishedKeys()

◆ GetPublishedMaterialKeys()

◆ is_new_scale_factor()

◆ make_mixed_visual_spec()

◆ normal_font()

◆ on_dpi_changed()

◆ on_enable_toggle()

◆ on_full_toggle()

◆ on_inner_tab_changed()

◆ on_mixed_tab_changed()

◆ on_outer_tab_changed()

◆ on_sys_color_changed()

◆ prev_scale_factor()

◆ refresh_filter()

◆ refresh_mixed_tab_bitmaps()

◆ refresh_tab_indicators()

◆ rescale()

◆ row_is_visible()

◆ save_scroll_position()

◆ scale_factor()

◆ section_group_for()

◆ select_all()

◆ select_visible()

◆ set_em_unit()

◆ set_prev_scale_factor()

◆ set_row_bold()

◆ set_scale_factor()

◆ setup_variant_switch()

◆ show_inner_page()

◆ show_menu()

◆ show_mixed_page()

◆ show_outer_page()

◆ ShowModal()

◆ subcategory_index_for()

◆ unpublished_mixed_components()

◆ update_em_unit()

Member Data Documentation

◆ m_can_rescale

◆ m_categories

◆ m_em_unit

◆ m_fb_sizer

◆ m_filter_box