Slic3r::GUI::Sidebar::priv Struct Reference

Collaboration diagram for Slic3r::GUI::Sidebar::priv:

Public Member Functions
int	FromDIP (int n)
void	layout_printer (bool isBBL, bool isDual)
void	flush_printer_sync (bool restart=false)
	priv (Plater *plater)
	~priv ()
void	show_preset_comboboxes ()
void	jump_to_object (ObjectDataViewModelNode *item)
void	can_search ()
bool	sync_extruder_list (bool &only_external_material, bool is_manual=false)
std::optional< NozzleOption >	get_nozzle_options (MachineObject *obj, int extruder_count, bool support_multi_nozzle, bool is_manual)
bool	switch_diameter (bool single)
bool	switch_diameter_to (const wxString &diameter)
void	update_sync_status (const MachineObject *obj)
bool	is_fila_switch_ready ()
void	show_filament_switcher_dialog (bool is_ready, bool is_manual)
void	show_fila_switch_msg (bool ready)
void	update_extruder_separator_icon (bool show, bool ready)

Public Attributes
Plater *	plater
wxPanel *	scrolled = nullptr
PlaterPresetComboBox *	combo_sla_print = nullptr
PlaterPresetComboBox *	combo_sla_material = nullptr
wxSizer *	vsizer_printer = nullptr
wxBoxSizer *	extruder_dual_sizer = nullptr
wxBoxSizer *	extruder_single_sizer = nullptr
StaticBox *	panel_printer_preset = nullptr
wxStaticBitmap *	image_printer = nullptr
PlaterPresetComboBox *	combo_printer = nullptr
ScalableButton *	btn_edit_printer = nullptr
ScalableButton *	btn_connect_printer = nullptr
StaticBox *	panel_nozzle_dia = nullptr
Label *	label_nozzle_title = nullptr
ComboBox *	combo_nozzle_dia = nullptr
Label *	label_nozzle_type = nullptr
StaticBox *	panel_printer_bed = nullptr
wxStaticBitmap *	image_printer_bed = nullptr
ComboBox *	combo_printer_bed = nullptr
ImageDPIFrame *	big_bed_image_popup = nullptr
std::shared_ptr< int >	counter_sync_printer = std::make_shared<int>()
wxTimer *	timer_sync_printer = new wxTimer()
ExtruderGroup *	left_extruder = nullptr
ExtruderGroup *	right_extruder = nullptr
ExtruderGroup *	single_extruder = nullptr
PlaterPresetComboBox *	combo_print = nullptr
std::vector< PlaterPresetComboBox * >	combos_filament
int	editing_filament = -1
wxBoxSizer *	sizer_filaments = nullptr
wxPanel *	m_panel_print_title
wxStaticText *	m_staticText_print_title
wxPanel *	m_panel_print_content
wxBoxSizer *	sizer_params
wxStaticLine *	m_staticline1
StaticBox *	m_panel_filament_title
wxPanel *	m_panel_filament_separator
wxStaticText *	m_staticText_filament_settings
wxStaticText *	m_staticText_filament_count
ScalableButton *	m_bpButton_add_filament
ScalableButton *	m_bpButton_del_filament
ScalableButton *	m_bpButton_ams_filament
ScalableButton *	m_bpButton_set_filament
int	m_menu_filament_id = -1
wxPanel *	m_filament_area_wrapper
wxScrolledWindow *	m_panel_filament_content
wxPanel *	m_btn_add_mixed_filament {nullptr}
wxPanel *	m_panel_mixed_title {nullptr}
StaticLine *	m_text_mixed_title {nullptr}
ScalableButton *	m_btn_mixed_add {nullptr}
ScalableButton *	m_btn_mixed_del {nullptr}
ScalableButton *	m_btn_mixed_del_all {nullptr}
wxScrolledWindow *	m_mixed_scroll_area {nullptr}
wxPanel *	m_panel_mixed_content {nullptr}
wxBoxSizer *	m_sizer_mixed_filaments {nullptr}
wxPanel *	m_panel_mixed_warning {nullptr}
wxStaticText *	m_text_mixed_warning {nullptr}
bool	m_mixed_filament_broken {false}
wxScrolledWindow *	m_scrolledWindow_filament_content
wxStaticLine *	m_staticline2
wxPanel *	m_panel_project_title
ScalableButton *	m_filament_icon = nullptr
Button *	m_purge_mode_btn = nullptr
Button *	m_flushing_volume_btn = nullptr
TextInput *	m_search_item = nullptr
StaticBox *	m_search_bar = nullptr
Search::SearchObjectDialog *	dia = nullptr
StaticBox *	m_panel_printer_title = nullptr
wxPanel *	m_panel_printer_separator = nullptr
ScalableButton *	m_printer_icon = nullptr
ScalableButton *	m_printer_connect = nullptr
ScalableButton *	m_printer_bbl_sync = nullptr
ScalableButton *	m_printer_setting = nullptr
wxStaticText *	m_text_printer_settings = nullptr
wxPanel *	m_panel_printer_content = nullptr
wxStaticBitmap *	extruder_separator_icon = nullptr
ObjectList *	m_object_list { nullptr }
ObjectSettings *	object_settings { nullptr }
ObjectLayers *	object_layers { nullptr }
wxButton *	btn_export_gcode
wxButton *	btn_reslice
ScalableButton *	btn_send_gcode
ScalableButton *	btn_export_gcode_removable
bool	is_switching_diameter {false}
Search::OptionsSearcher	searcher
std::string	ams_list_device
bool	fila_switch_warning_shown = false
std::string	last_sync_dev_id

Detailed Description

Constructor & Destructor Documentation

priv()

Slic3r::GUI::Sidebar::priv::priv ( Plater * plater )

inline

: plater(plater) {}

References plater.

~priv()

Slic3r::GUI::Sidebar::priv::~priv

(

)

{
    // BBS
    //delete object_manipulation;
    delete object_settings;
    // BBS
#if 0
    delete frequently_changed_parameters;
#endif
}

References object_settings.

Member Function Documentation

can_search()

void Slic3r::GUI::Sidebar::priv::can_search

(

)

{
    if (m_search_bar->IsShown()) {
        m_search_item->SetFocus();
    }
}

References m_search_bar, and m_search_item.

flush_printer_sync()

void Slic3r::GUI::Sidebar::priv::flush_printer_sync

(

bool

restart = false

)

{
    if (restart) {
        *counter_sync_printer = 6;
        timer_sync_printer->Start(500);
    }
    //btn_sync_printer->SetBackgroundColorNormal((*counter_sync_printer & 1) ? "#F8F8F8" :"#009688");
    m_printer_bbl_sync->SetBitmap_((*counter_sync_printer & 1) ? "printer_sync_not" : "printer_sync_ok");
    if (--*counter_sync_printer <= 0)
        timer_sync_printer->Stop();
}

References counter_sync_printer, m_printer_bbl_sync, and timer_sync_printer.

FromDIP()

int Slic3r::GUI::Sidebar::priv::FromDIP ( int n )

inline

{ return plater->FromDIP(n); }

References plater.

Referenced by layout_printer(), and update_extruder_separator_icon().

Here is the caller graph for this function:

get_nozzle_options()

std::optional< NozzleOption > Slic3r::GUI::Sidebar::priv::get_nozzle_options	(	MachineObject *	obj,
		int	extruder_count,
		bool	support_multi_nozzle,
		bool	is_manual )

{
    if (extruder_count < 2 || !support_multi_nozzle) {
        return std::nullopt;
    }
    if (!obj || !obj->GetNozzleSystem()) return std::nullopt;
    auto nozzle_system = obj->GetNozzleSystem();
 
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle) return std::nullopt;
 
    std::string curr_dev_id = obj->get_dev_id();
    std::map<int, std::vector<DevNozzle>> curr_nozzle_cfg;
 
    for (const auto& ext_nozzle : nozzle_system->GetExtNozzles()) {
        int extruder_id = ext_nozzle.first;
        curr_nozzle_cfg[extruder_id].emplace_back(ext_nozzle.second);
    }
 
    for (const auto& rack_nozzle : nozzle_system->GetRackNozzles()) {
        curr_nozzle_cfg[MAIN_EXTRUDER_ID].emplace_back(rack_nozzle.second);
    }
 
    AppConfig *app_config = wxGetApp().app_config;
    std::string saved_dev_id = app_config->get("sync_extruder", "dev_id");
    std::string saved_nozzle_config_str = app_config->get("sync_extruder", "nozzle_config");
    std::string saved_nozzle_option_str = app_config->get("sync_extruder", "nozzle_option");
    std::optional<NozzleOption> nozzle_option;
 
    if (is_manual) {
        nozzle_option = tryPopUpMultiNozzleDialog(obj);
    } else {
        bool can_reuse_saved_option = false;
        if (!saved_dev_id.empty() && !saved_nozzle_config_str.empty() && !saved_nozzle_option_str.empty() && saved_dev_id == curr_dev_id) {
            auto saved_nozzle_config = deserialize_nozzle_config(saved_nozzle_config_str);
            if (is_same_nozzle_config(saved_nozzle_config, curr_nozzle_cfg)) {
                nozzle_option = deserialize_nozzle_option(saved_nozzle_option_str);
                can_reuse_saved_option = nozzle_option.has_value();
            }
            if (can_reuse_saved_option) {
                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Reusing saved nozzle option for dev_id: " << curr_dev_id;
 
                auto                     &project_config         = preset_bundle->project_config;
                ConfigOptionEnumsGeneric *nozzle_volume_type_opt = project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
 
                // Write to preset bundle config
                for (int extruder_id = 0; extruder_id < extruder_count; ++extruder_id) {
                    NozzleVolumeType volume_type;
                    int              nozzle_count;
                    bool             clear_all = true;
 
                    if (!nozzle_option->extruder_nozzle_stats.count(extruder_id)) {
                        nozzle_count = 0;
                        // Reset the concrete volume types (Standard/High Flow); Hybrid is not a physical
                        // nozzle type and never appears in the stats. TPU High Flow is a concrete variant
                        // shipped on 0.4/0.6 nozzles, so reset it too, but only there (mirrors the
                        // High-Flow-skip-for-0.2 guard).
                        std::vector<NozzleVolumeType> reset_types{nvtStandard, nvtHighFlow};
                        if (extruder_supports_tpu_high_flow(preset_bundle, extruder_id))
                            reset_types.push_back(nvtTPUHighFlow);
                        for (NozzleVolumeType vt : reset_types) {
                            volume_type = vt;
                            setExtruderNozzleCount(preset_bundle, extruder_id, volume_type, nozzle_count, clear_all);
                            clear_all = false;
                        }
                    } else {
                        for (auto &stat : nozzle_option->extruder_nozzle_stats[extruder_id]) {
                            volume_type  = stat.first;
                            nozzle_count = stat.second;
                            setExtruderNozzleCount(preset_bundle, extruder_id, volume_type, nozzle_count, clear_all);
                            clear_all = false;
                        }
                    }
                }
                // The stats now hold the device's per-type breakdown: protect it from being collapsed by
                // a manual flow switch, and refresh the sidebar badges.
                setNozzleStatsFromMachine(true);
                if (nozzle_volume_type_opt) {
                    for (int extruder_id = 0; extruder_id < extruder_count && extruder_id < (int) nozzle_volume_type_opt->values.size(); ++extruder_id)
                        updateNozzleCountDisplay(preset_bundle, extruder_id, NozzleVolumeType(nozzle_volume_type_opt->values[extruder_id]));
                }
            }
        }
 
        if (!can_reuse_saved_option) {
            nozzle_option = tryPopUpMultiNozzleDialog(obj);
        }
    }
    if (nozzle_option) {
        std::string current_nozzle_config = serialize_nozzle_config(curr_nozzle_cfg);
        std::string current_nozzle_option = serialize_nozzle_option(*nozzle_option);
        if (app_config->has_section("sync_extruder")) {
            app_config->set("sync_extruder", "dev_id", curr_dev_id);
            app_config->set("sync_extruder", "nozzle_config", current_nozzle_config);
            app_config->set("sync_extruder", "nozzle_option", current_nozzle_option);
        } else {
            std::map<std::string, std::string> data;
            data["dev_id"]        = curr_dev_id;
            data["nozzle_config"] = current_nozzle_config;
            data["nozzle_option"] = current_nozzle_option;
            app_config->set_section("sync_extruder", data);
        }
    }
 
    return nozzle_option;
}

References Slic3r::GUI::deserialize_nozzle_config(), Slic3r::GUI::deserialize_nozzle_option(), Slic3r::GUI::extruder_supports_tpu_high_flow(), Slic3r::AppConfig::get(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::GetNozzleSystem(), Slic3r::AppConfig::has_section(), Slic3r::GUI::is_same_nozzle_config(), MAIN_EXTRUDER_ID, Slic3r::nvtHighFlow, Slic3r::nvtStandard, Slic3r::nvtTPUHighFlow, Slic3r::PresetBundle::project_config, Slic3r::GUI::serialize_nozzle_config(), Slic3r::GUI::serialize_nozzle_option(), Slic3r::AppConfig::set(), Slic3r::AppConfig::set_section(), Slic3r::GUI::setExtruderNozzleCount(), Slic3r::GUI::setNozzleStatsFromMachine(), Slic3r::GUI::tryPopUpMultiNozzleDialog(), Slic3r::GUI::updateNozzleCountDisplay(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by sync_extruder_list().

Here is the call graph for this function:

Here is the caller graph for this function:

is_fila_switch_ready()

bool Slic3r::GUI::Sidebar::priv::is_fila_switch_ready

(

)

{
    if (!wxGetApp().plater()->is_same_printer_for_connected_and_selected(false))
        return false;
    auto device_manager = wxGetApp().getDeviceManager();
    if (device_manager == nullptr)
        return false;
    auto obj = device_manager->get_selected_machine();
    if (obj == nullptr || !obj->is_online())
        return false;
    auto fila_switch = obj->GetFilaSwitch();
    if (fila_switch == nullptr)
        return false;
    return fila_switch->IsInstalled() && fila_switch->IsReady();
}

References Slic3r::GUI::plater().

Referenced by layout_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

jump_to_object()

void Slic3r::GUI::Sidebar::priv::jump_to_object

(

ObjectDataViewModelNode *

item

)

{
    m_object_list->selected_object(item);
}

References m_object_list.

layout_printer()

void Slic3r::GUI::Sidebar::priv::layout_printer	(	bool	isBBL,
		bool	isDual )

{
    // Printer - preset
    if (auto sizer = static_cast<wxBoxSizer *>(panel_printer_preset->GetSizer());
            sizer == nullptr /*|| isBBL != (sizer->GetOrientation() == wxVERTICAL)*/) {
 
        //if (isBBL) {
            wxBoxSizer *hsizer = new wxBoxSizer(wxHORIZONTAL);
            hsizer->Add(image_printer, 0, wxLEFT  | wxALIGN_LEFT  | wxALIGN_CENTER_VERTICAL, FromDIP(10));
            hsizer->Add(combo_printer, 1, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(2)); // 1 already triggers wxEXPAND
            hsizer->AddSpacer(FromDIP(2));
            hsizer->Add(btn_edit_printer, 0, wxRIGHT | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, FromDIP(SidebarProps::IconSpacing()));
            //hsizer->Add(btn_connect_printer, 0, wxRIGHT | wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL, FromDIP(SidebarProps::IconSpacing()));
            panel_printer_preset->SetSizer(hsizer);
        //} else {
        //    wxBoxSizer *hsizer = new wxBoxSizer(wxHORIZONTAL);
        //    hsizer->Add(image_printer, 0, wxLEFT | wxALIGN_CENTER, FromDIP(4));
        //    hsizer->Add(combo_printer, 1, wxALIGN_CENTRE | wxLEFT | wxRIGHT, FromDIP(6));
        //    hsizer->Add(hsizer_printer_btn, 0, wxALIGN_TOP | wxTOP | wxRIGHT, FromDIP(4));
        //    hsizer->AddSpacer(FromDIP(10));
        //    panel_printer_preset->SetSizer(hsizer);
        //}
    }
 
    if (vsizer_printer->GetItemCount() == 0) {
        wxBoxSizer *hsizer_printer = new wxBoxSizer(wxHORIZONTAL);
        hsizer_printer->Add(panel_printer_preset, 1, wxEXPAND, 0);
        hsizer_printer->Add(panel_nozzle_dia , 0, wxLEFT, FromDIP(4));
        hsizer_printer->Add(panel_printer_bed, 0, wxLEFT, FromDIP(4));
        //hsizer_printer->Add(btn_sync_printer , 0, wxLEFT, FromDIP(4));
        vsizer_printer->AddSpacer(FromDIP(SidebarProps::ContentMarginV()));
        vsizer_printer->Add(hsizer_printer, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(SidebarProps::ContentMargin()));
 
        // Printer - extruder
 
        // double
        extruder_dual_sizer = new wxBoxSizer(wxHORIZONTAL);
        extruder_dual_sizer->Add(left_extruder, 1, wxEXPAND, 0);
        extruder_dual_sizer->AddSpacer(FromDIP(4));
        extruder_dual_sizer->Add(right_extruder, 1, wxEXPAND, 0);
 
        // Filament Track Switch status icon, floated over the extruder AMS area (positioned in
        // update_extruder_separator_icon). Created hidden; a click re-shows the ready/not-ready tip.
        if (!extruder_separator_icon) {
            auto bitmap = ScalableBitmap(m_panel_printer_content, "fila_switch", 10);
            extruder_separator_icon = new wxStaticBitmap(m_panel_printer_content, wxID_ANY, bitmap.bmp(), wxDefaultPosition, bitmap.GetBmpSize());
            extruder_separator_icon->Hide();
            extruder_separator_icon->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& evt) {
                show_fila_switch_msg(is_fila_switch_ready());
                evt.Skip();
            });
        }
 
        // single
        extruder_single_sizer = new wxBoxSizer(wxHORIZONTAL);
        extruder_single_sizer->Add(single_extruder, 1, wxEXPAND, 0);
 
        wxBoxSizer * extruder_sizer = new wxBoxSizer(wxVERTICAL);
        extruder_sizer->Add(extruder_dual_sizer  , 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(SidebarProps::ContentMargin()));
        extruder_sizer->Add(extruder_single_sizer, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(SidebarProps::ContentMargin()));
 
        vsizer_printer->Add(extruder_sizer, 1, wxEXPAND | wxTOP, FromDIP(2));
 
        vsizer_printer->AddSpacer(FromDIP(SidebarProps::ContentMarginV()));
    }
 
    //btn_connect_printer->Show(!isBBL);
    m_printer_connect->Show(!isBBL);
    //btn_sync_printer->Show(isBBL);
    m_printer_bbl_sync->Show(isBBL);
 
    // ORCA show plate type combo box only when its supported
    PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
    const auto& cfg = preset_bundle.printers.get_edited_preset().config;
    // Orca: we use preset_bundle.is_bbl_vendor() instead of isBBL to determine if the plate type combo box should be shown
    // ref: https://github.com/OrcaSlicer/OrcaSlicer/pull/11610#discussion_r2607411847
    panel_printer_bed->Show(preset_bundle.is_bbl_vendor() || cfg.opt_bool("support_multi_bed_types"));
 
    extruder_dual_sizer->Show(isDual);
 
    // NEEDFIX requires AMS check or any type of ???
    // Single nozzle & non ams
    if (!isDual) {
        // Orca: for printer without flow variant, we do not show flow combo
        int extruder_count = 0;
        const bool has_flow_variant = cfg.support_different_extruders(extruder_count);
 
        // ORCA: a non-Bambu printer with several extruders lists one nozzle row per tool; Bambu's own
        // multi-extruder printers keep the left/right pair above.
        const bool multi_extruder_rows = !preset_bundle.is_bbl_vendor() && extruder_count > 1;
        const auto &diameters = cfg.option<ConfigOptionFloats>("nozzle_diameter")->values;
        const bool mixed_diameters = std::any_of(diameters.begin(), diameters.end(), [&diameters](double value) {
            return get_diameter_string(value) != get_diameter_string(diameters.front());
        });
 
        // The variant box switches the machine variant. The card below lists the nozzles when there
        // are flow variants to choose or extruders of different diameters; otherwise the box says it all.
        panel_nozzle_dia->Show(true);
        extruder_single_sizer->Show(has_flow_variant || (multi_extruder_rows && mixed_diameters));
        single_extruder->SetNozzleRowCount(multi_extruder_rows ? size_t(extruder_count) : 1);
    } else {
        panel_nozzle_dia->Show(false);
        extruder_single_sizer->Show(false);
        single_extruder->SetNozzleRowCount(1);
    }
 
    // ORCA ensure printer section is visible after changing printer from printer selection dialog
    // this will inform user on printer change when printer section is collapsed
    if (m_panel_printer_content){
        bool isShown = m_panel_printer_content->IsShown();
        if(!isShown && m_text_printer_settings){
            m_text_printer_settings->SetLabel(_L("Printer")); // ensure title returns to default state
            m_panel_printer_content->Show();
        }
    }
}

References _L, btn_edit_printer, combo_printer, Slic3r::Preset::config, Slic3r::GUI::SidebarProps::ContentMargin(), Slic3r::GUI::SidebarProps::ContentMarginV(), extruder_dual_sizer, extruder_separator_icon, extruder_single_sizer, FromDIP(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::GUI::SidebarProps::IconSpacing(), image_printer, Slic3r::PresetBundle::is_bbl_vendor(), is_fila_switch_ready(), left_extruder, m_panel_printer_content, m_printer_bbl_sync, m_printer_connect, m_text_printer_settings, panel_nozzle_dia, panel_printer_bed, panel_printer_preset, Slic3r::PresetBundle::printers, right_extruder, show_fila_switch_msg(), single_extruder, vsizer_printer, and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

show_fila_switch_msg()

void Slic3r::GUI::Sidebar::priv::show_fila_switch_msg

(

bool

ready

)

{
    wxString msg = ready ? _L("Filament switcher detected. All AMS filaments are now available for both extruders. "
                              "The slicer will auto-assign for optimal printing.") :
                           _L("A filament switcher is detected but not calibrated and thus currently unavailable. "
                              "Please calibrate it on the printer and synchronize before use.");
 
    long style = ready ? (wxICON_INFORMATION | wxOK) : (wxICON_WARNING | wxOK);
    // Orca: drop the vendor "Learn more" tracking link; there is no Orca help page for the switch yet.
    MessageDialog dlg(static_cast<wxWindow *>(wxGetApp().mainframe), msg, _L("Tips"), style);
    dlg.CenterOnParent();
    dlg.ShowModal();
}

References _L, Slic3r::GUI::DPIAware< P >::ShowModal(), and style.

Referenced by layout_printer(), and show_filament_switcher_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

show_filament_switcher_dialog()

void Slic3r::GUI::Sidebar::priv::show_filament_switcher_dialog	(	bool	is_ready,
		bool	is_manual )

{
    if (is_ready) {
        // Show the "switch is ready" tip only once, ever.
        if (wxGetApp().app_config->get("show_fila_switch_tips") == "true") {
            wxGetApp().app_config->set("show_fila_switch_tips", "false");
            show_fila_switch_msg(true);
        }
    } else {
        // A manual sync always warns; an automatic update warns once per session.
        if (is_manual || !fila_switch_warning_shown) {
            fila_switch_warning_shown = true;
            show_fila_switch_msg(false);
        }
    }
}

References fila_switch_warning_shown, and show_fila_switch_msg().

Referenced by sync_extruder_list(), and update_sync_status().

Here is the call graph for this function:

Here is the caller graph for this function:

show_preset_comboboxes()

void Slic3r::GUI::Sidebar::priv::show_preset_comboboxes

(

)

{
    const bool showSLA = wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA;
 
//BBS
#if 0
    for (size_t i = 0; i < 4; ++i)
        sizer_presets->Show(i, !showSLA);
 
    for (size_t i = 4; i < 8; ++i) {
        if (sizer_presets->IsShown(i) != showSLA)
            sizer_presets->Show(i, showSLA);
    }
 
    frequently_changed_parameters->Show(!showSLA);
#endif
 
    scrolled->GetParent()->Layout();
    scrolled->Refresh();
}

References Slic3r::ptSLA, and scrolled.

switch_diameter()

bool Slic3r::GUI::Sidebar::priv::switch_diameter

(

bool

single

)

{
    wxString diameter;
    if (single) {
        diameter = single_extruder->combo_diameter->GetValue();
    } else {
        auto diameter_left = left_extruder->combo_diameter->GetValue();
        auto diameter_right = right_extruder->combo_diameter->GetValue();
        if (diameter_left != diameter_right) {
            double left_value = 0.0, right_value = 0.0;
            if (!diameter_left.ToCDouble(&left_value) || !diameter_right.ToCDouble(&right_value))
                return false;
 
            Tab* printer_tab = wxGetApp().get_tab(Preset::TYPE_PRINTER);
            DynamicPrintConfig new_conf = wxGetApp().preset_bundle->printers.get_edited_preset().config;
            auto* nozzle_diameter_opt = new_conf.option<ConfigOptionFloats>("nozzle_diameter");
            if (printer_tab == nullptr || nozzle_diameter_opt == nullptr || nozzle_diameter_opt->size() < 2)
                return false;
 
            nozzle_diameter_opt->values[0] = left_value;
            nozzle_diameter_opt->values[1] = right_value;
            printer_tab->load_config(new_conf);
            return true;
        }
        diameter = diameter_left;
    }
 
    return switch_diameter_to(diameter);
}

References left_extruder, Slic3r::GUI::Tab::load_config(), Slic3r::ConfigBase::option(), right_extruder, single_extruder, switch_diameter_to(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by sync_extruder_list().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_diameter_to()

bool Slic3r::GUI::Sidebar::priv::switch_diameter_to

(

const wxString &

diameter

)

{
    // ORCA: Check if the selected diameter matches the current nozzle diameter in the config
    Preset& printer_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
    auto* nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(printer_preset.config.option("nozzle_diameter"));
    // ORCA: the left/right combos of a BBL multi-nozzle printer set the nozzles apart without leaving
    // the preset (see switch_diameter), so there the preset is only kept while every nozzle matches.
    const bool nozzles_apart = nozzle_diameter && nozzle_diameter->size() > 1 && wxGetApp().preset_bundle->is_bbl_vendor() &&
        std::any_of(nozzle_diameter->values.begin(), nozzle_diameter->values.end(),
                    [&diameter](double value) { return get_diameter_string(value) != diameter.ToStdString(); });
    // The combo lists printer variants, and the variant of a mixed-nozzle machine ("0.4+0.6") is no
    // single extruder's diameter, so the preset's own variant answers first.
    const std::string &printer_variant = printer_preset.config.opt_string("printer_variant");
    if (printer_variant == diameter.ToStdString() && !nozzles_apart) {
        return true;
    }
    // A named variant ("0.4 High Flow") shares its diameter with the standard profile, which selecting
    // the plain diameter switches back to, so only a preset naming no variant is kept by its diameter.
    if (printer_variant.empty() && nozzle_diameter && nozzle_diameter->size() > 0) {
        auto current_nozzle_dia = get_diameter_string(nozzle_diameter->values[0]);
        // If the selected diameter is the same as current nozzle, don't switch profiles
        if (current_nozzle_dia == diameter.ToStdString()) {
            return true;
        }
    }
    
    auto preset          = wxGetApp().preset_bundle->get_similar_printer_preset({}, diameter.ToStdString());
    if (preset == nullptr) {
        // ORCA add a text. this appears when user tries to change nozzle value but config doesnt have a inherited or compatible preset
        MessageDialog dlg(this->plater, _L("Configuration incompatible"), _L("Warning"), wxICON_WARNING | wxOK);
        dlg.ShowModal();
        return false;
    }
    preset->is_visible = true; // force visible
    return wxGetApp().get_tab(Preset::TYPE_PRINTER)->select_preset(preset->name);
}

References _L, Slic3r::Preset::config, Slic3r::GUI::get_diameter_string(), Slic3r::nozzle_diameter(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), plater, Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::Preset::TYPE_PRINTER.

Referenced by switch_diameter().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_extruder_list()

bool Slic3r::GUI::Sidebar::priv::sync_extruder_list	(	bool &	only_external_material,
		bool	is_manual = false )

{
    MachineObject *obj = wxGetApp().getDeviceManager()->get_selected_machine();
    auto           printer_name = plater->get_selected_printer_name_in_combox();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " begin sync_extruder_list";
    if (obj == nullptr) {
        plater->pop_warning_and_go_to_device_page(printer_name, Plater::PrinterWarningType::NOT_CONNECTED, _L("Sync printer information"));
        return false;
    }
    //if (obj->get_extder_system()->extders.size() != 2) {//wxString(obj->get_preset_printer_model_name(machine_print_name))
    //    plater->pop_warning_and_go_to_device_page(printer_name, Plater::PrinterWarningType::INCONSISTENT, _L("Sync printer information"));
    //    return false;
    //}
 
    if (!plater->check_printer_initialized(obj)) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " check_printer_initialized fail";
        return false;
    }
 
    std::string machine_print_name = obj->get_show_printer_type();
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    std::string target_model_id  = preset_bundle->printers.get_selected_preset().get_printer_type(preset_bundle);
    const bool optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type);
    const bool optional_target_model  = DevPrinterConfigUtil::is_optional_printer_model_id(target_model_id);
    Preset* machine_preset = optional_printer_model ? nullptr : get_printer_preset(obj);
    if (!optional_printer_model && !optional_target_model && !machine_preset) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "check error: machine_preset empty";
        return false;
    }
    if (!optional_printer_model && !optional_target_model && machine_print_name != target_model_id) {
        MessageDialog dlg(this->plater, _L("The currently selected machine preset is inconsistent with the connected printer type.\n"
                                            "Are you sure to continue syncing?"), _L("Sync printer information"), wxICON_WARNING | wxYES | wxNO);
        if (dlg.ShowModal() == wxID_NO) {
            return false;
        }
 
        if (!this->plater)
            return false;
 
        this->plater->update_objects_position_when_select_preset([machine_preset]() {
            Tab *printer_tab = GUI::wxGetApp().get_tab(Preset::Type::TYPE_PRINTER);
            printer_tab->select_preset(machine_preset->name);
        });
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " go on sync_extruder_list";
    const Preset &cur_preset  = preset_bundle->printers.get_selected_preset();
    int extruder_nums = preset_bundle->get_printer_extruder_count();
    std::vector<int> extruder_map(extruder_nums);
    std::iota(extruder_map.begin(), extruder_map.end(), 0);
    const ConfigOptionInts *physical_extruder_map = cur_preset.config.option<ConfigOptionInts>("physical_extruder_map");
    if (physical_extruder_map != nullptr) {
        assert(physical_extruder_map->values.size() == extruder_nums);
        extruder_map = physical_extruder_map->values;
    }
    assert(obj->GetExtderSystem()->GetTotalExtderCount() == extruder_nums);
 
    // Multi-nozzle: resolve the nozzle option (pops MultiNozzleSyncDialog when is_manual). No-op for every
    // existing printer — support_multi_nozzle is false unless some extruder_max_nozzle_count entry is a real
    // value > 1 (nil-guarded, matching the manual/ToolOrdering gates), which no shipping single-nozzle or
    // dual-extruder profile sets. When the machine is multi-nozzle but no option resolves (e.g. user cancelled),
    // abort the sync.
    const ConfigOptionIntsNullable *extruder_max_nozzle_count = cur_preset.config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
    bool support_multi_nozzle = extruder_max_nozzle_count != nullptr &&
                                std::any_of(extruder_max_nozzle_count->values.begin(), extruder_max_nozzle_count->values.end(),
                                            [](int val) { return val > 1 && val != ConfigOptionIntsNullable::nil_value(); });
    auto nozzle_option = get_nozzle_options(obj, extruder_nums, support_multi_nozzle, is_manual);
    if (!nozzle_option && support_multi_nozzle)
        return false;
 
    std::vector<float> nozzle_diameters;
    nozzle_diameters.resize(extruder_nums);
    std::vector<NozzleVolumeType> target_types(extruder_nums, NozzleVolumeType::nvtStandard);
    for (size_t index = 0; index < extruder_nums; ++index) {
        int extruder_id = extruder_map[index];
        nozzle_diameters[extruder_id] = nozzle_option ? atof(nozzle_option->diameter.c_str()) : obj->GetExtderSystem()->GetNozzleDiameter(index);
        NozzleVolumeType target_type = NozzleVolumeType::nvtStandard;
        std::optional<NozzleVolumeType> select_type;
        if (nozzle_option && nozzle_option->extruder_nozzle_stats.count(index)) {
            const auto &stats = nozzle_option->extruder_nozzle_stats[index];
            if (stats.size() > 1)
                // The extruder holds nozzles of several flow types: select the mixed-flow mode.
                select_type = NozzleVolumeType::nvtHybrid;
            else
                select_type = stats.begin()->first;
        }
        if (obj->is_nozzle_flow_type_supported()) {
            if (obj->GetExtderSystem()->GetNozzleFlowType(index) == NozzleFlowType::NONE_FLOWTYPE) {
                MessageDialog dlg(this->plater, _L("There are unset nozzle types. Please set the nozzle types of all extruders before synchronizing."),
                                  _L("Sync extruder infomation"), wxICON_WARNING | wxOK);
                dlg.ShowModal();
                continue;
            }
            // hack code, only use standard flow for 0.2
            if (std::fabs(nozzle_diameters[extruder_id] - 0.2) > EPSILON)
                // Map device flow->volume via the table, not `flowtype - 1`.
                // The arithmetic only aligns for S_FLOW/H_FLOW; U_FLOW(3)-1 would yield nvtHybrid(2), not nvtTPUHighFlow(3).
                target_type = DevNozzle::ToNozzleVolumeType(obj->GetExtderSystem()->GetNozzleFlowType(extruder_id));
        }
        if (select_type)
            target_type = *select_type;
        target_types[index] = target_type;
    }
 
    int deputy_4 = 0, main_4 = 0, deputy_1 = 0, main_1 = 0;
    const bool switch_ready = is_fila_switch_ready();
    for (auto ams : obj->GetFilaSystem()->GetAmsList()) {
        for (int extruder_id : ams.second->GetBindedExtruderSet()) {
            // With the switch installed every AMS binds to both extruders; once it is ready, attribute
            // each to the extruder its input track feeds so the per-extruder counts stay correct. Without
            // a switch the binding set is the single extruder and the filter is skipped, matching the
            // pre-switch counts.
            if (switch_ready) {
                auto switcher_pos = ams.second->GetSwitcherPos();
                if (!switcher_pos)
                    continue;
                int switcher_id = obj->is_main_extruder_on_left() ? (1 - static_cast<int>(switcher_pos.value()))
                                                                  : static_cast<int>(switcher_pos.value());
                if (extruder_id != switcher_id)
                    continue;
            }
            const bool is_n3s = ams.second->GetAmsType() == DevAms::N3S;
            // Main (first) extruder is id 0, deputy is id 1.
            if (extruder_id == 0) {
                if (is_n3s) ++main_1; else ++main_4;
            } else if (extruder_id == 1) {
                if (is_n3s) ++deputy_1; else ++deputy_4;
            }
        }
    }
    only_external_material = !obj->GetFilaSystem()->HasAms();
    int main_index = obj->is_main_extruder_on_left() ? 0 : 1;
    int deputy_index = obj->is_main_extruder_on_left() ? 1 : 0;
 
    if (extruder_nums > 1) {
        int left_index  = left_extruder->combo_diameter->FindString(get_diameter_string(nozzle_diameters[0]));
        int right_index = left_extruder->combo_diameter->FindString(get_diameter_string(nozzle_diameters[1]));
        assert(left_index != -1 && right_index != -1);
        left_extruder->combo_diameter->SetSelection(left_index);
        right_extruder->combo_diameter->SetSelection(right_index);
        is_switching_diameter = true;
        switch_diameter(false);
        is_switching_diameter = false;
        AMSCountPopupWindow::SetAMSCount(deputy_index, deputy_4, deputy_1);
        AMSCountPopupWindow::SetAMSCount(main_index, main_4, main_1);
        AMSCountPopupWindow::UpdateAMSCount(0, left_extruder);
        AMSCountPopupWindow::UpdateAMSCount(1, right_extruder);
    } else {
        int index = single_extruder->combo_diameter->FindString(get_diameter_string(nozzle_diameters[0]));
        assert(index != -1);
        single_extruder->combo_diameter->SetSelection(index);
        is_switching_diameter = true;
        switch_diameter(true);
        is_switching_diameter = false;
    }
 
    // set nozzle volume type after switching prset, so this value can override the old value stored in conf
    auto printer_tab = dynamic_cast<TabPrinter *>(wxGetApp().get_tab(Preset::TYPE_PRINTER));
    for (size_t idx = 0; idx < target_types.size(); ++idx) {
        printer_tab->set_extruder_volume_type(idx, target_types[idx]);
    }
 
    if (extruder_nums > 1) {
        auto fila_switch = obj->GetFilaSwitch();
        if (fila_switch->IsInstalled())
            show_filament_switcher_dialog(fila_switch->IsReady(), is_manual);
        else
            fila_switch_warning_shown = false;
    }
 
    // Copy the live switch state into the project so slicing and the send dialog honor it. Both
    // resolve to false unless the switch is installed and calibrated, so nothing changes without one.
    auto &project_config = wxGetApp().preset_bundle->project_config;
    if (auto *dynamic_filament = project_config.opt<ConfigOptionBool>("enable_filament_dynamic_map"))
        dynamic_filament->value = is_fila_switch_ready();
    if (auto *has_switcher = project_config.opt<ConfigOptionBool>("has_filament_switcher"))
        has_switcher->value = is_fila_switch_ready();
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << " finish sync_extruder_list";
    return true;
}

References _L, Slic3r::Preset::config, EPSILON, Slic3r::extruder_max_nozzle_count(), fila_switch_warning_shown, Slic3r::GUI::get_diameter_string(), get_nozzle_options(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::GUI::get_printer_preset(), Slic3r::Preset::get_printer_type(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::MachineObject::get_show_printer_type(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::MachineObject::GetFilaSwitch(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::DevExtderSystem::GetNozzleDiameter(), Slic3r::DevExtderSystem::GetNozzleFlowType(), Slic3r::DevExtderSystem::GetTotalExtderCount(), Slic3r::GUI::Sidebar::is_fila_switch_ready(), Slic3r::MachineObject::is_main_extruder_on_left(), Slic3r::MachineObject::is_nozzle_flow_type_supported(), Slic3r::DevPrinterConfigUtil::is_optional_printer_model_id(), is_switching_diameter, left_extruder, Slic3r::DevAms::N3S, Slic3r::Preset::name, Slic3r::NONE_FLOWTYPE, Slic3r::GUI::Plater::NOT_CONNECTED, Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::ConfigBase::option(), Slic3r::physical_extruder_map(), plater, Slic3r::MachineObject::printer_type, Slic3r::PresetBundle::printers, right_extruder, Slic3r::GUI::Tab::select_preset(), Slic3r::GUI::AMSCountPopupWindow::SetAMSCount(), show_filament_switcher_dialog(), Slic3r::GUI::DPIAware< P >::ShowModal(), single_extruder, switch_diameter(), Slic3r::DevNozzle::ToNozzleVolumeType(), Slic3r::Preset::TYPE_PRINTER, and Slic3r::GUI::AMSCountPopupWindow::UpdateAMSCount().

Here is the call graph for this function:

update_extruder_separator_icon()

void Slic3r::GUI::Sidebar::priv::update_extruder_separator_icon	(	bool	show,
		bool	ready )

{
    if (!extruder_separator_icon)
        return;
    static bool last_show  = false;
    static bool last_ready = false;
    static bool first_call = true;
 
    if (!first_call && last_show == show && last_ready == ready)
        return;
    first_call = false;
    last_show  = show;
    last_ready = ready;
 
    // Never overlay the icon when the connected printer is not the selected preset.
    if (!wxGetApp().plater()->is_same_printer_for_connected_and_selected(false)) {
        extruder_separator_icon->Hide();
        if (m_panel_printer_content)
            m_panel_printer_content->Refresh();
        return;
    }
 
    if (show && left_extruder && left_extruder->hsizer_ams && left_extruder->sizer) {
        // Orca: center the icon over the seam between the two extruder cards, vertically aligned with
        // the AMS row. left_extruder and the icon share m_panel_printer_content as parent, so
        // left_extruder->GetPosition() and the icon position live in the same coordinate space.
        wxPoint left_box_pos  = left_extruder->GetPosition();
        wxPoint ams_local_pos = left_extruder->hsizer_ams->GetPosition();
        wxSize  left_size     = left_extruder->sizer->GetSize();
        wxSize  ams_size      = left_extruder->hsizer_ams->GetSize();
        wxSize  icon_size     = extruder_separator_icon->GetSize();
        int     ams_abs_y     = left_box_pos.y + ams_local_pos.y + FromDIP(4);
        int     center_x      = left_size.GetWidth() + FromDIP(6);
        int     center_y      = ams_abs_y + (ams_size.GetHeight() - icon_size.GetHeight()) / 2;
        center_x -= icon_size.GetWidth() / 2;
        center_y -= icon_size.GetHeight() / 2;
        extruder_separator_icon->SetPosition(wxPoint(center_x, center_y));
 
        auto normal_bitmap = ScalableBitmap(m_panel_printer_content, "fila_switch", 10);
        auto error_bitmap  = ScalableBitmap(m_panel_printer_content, "fila_switch_error", 10);
        extruder_separator_icon->SetBitmap(ready ? normal_bitmap.bmp() : error_bitmap.bmp());
 
        extruder_separator_icon->Show();
        extruder_separator_icon->Raise();
    } else {
        extruder_separator_icon->Hide();
    }
 
    if (m_panel_printer_content)
        m_panel_printer_content->Refresh();
}

References extruder_separator_icon, FromDIP(), left_extruder, m_panel_printer_content, and Slic3r::GUI::plater().

Referenced by update_sync_status().

Here is the call graph for this function:

Here is the caller graph for this function:

update_sync_status()

void Slic3r::GUI::Sidebar::priv::update_sync_status

(

const MachineObject *

obj

)

{
    StateColor not_synced_colour(std::pair<wxColour, int>(wxColour("#009688"), StateColor::Normal));
    auto clear_all_sync_status = [this]() {
        panel_printer_preset->ShowBadge(false);
        panel_printer_bed->ShowBadge(false);
        panel_nozzle_dia->ShowBadge(false); // ORCA add support for nozzle sync
        left_extruder->ShowBadge(false);
        left_extruder->sync_ams(nullptr, {}, {});
        right_extruder->ShowBadge(false);
        right_extruder->sync_ams(nullptr, {}, {});
        single_extruder->ShowBadge(false);
        single_extruder->sync_ams(nullptr, {}, {});
        update_extruder_separator_icon(false, false);
        //btn_sync_printer->SetBorderColor(not_synced_colour);
        //btn_sync_printer->SetIcon("printer_sync");
        m_printer_bbl_sync->SetBitmap_("printer_sync_not");
    };
 
    if (!obj || !obj->is_info_ready()) {
        clear_all_sync_status();
        return;
    }
 
    // Orca: replaces BBS's reset_fila_switch hook on DeviceManager::OnSelectedMachineChanged (absent
    // in Orca). Selection/MQTT updates all funnel through here, so a change of the selected device id
    // resets the switcher icon and the once-per-session not-ready warning for the new printer.
    const std::string cur_dev_id = obj->get_dev_id();
    if (cur_dev_id != last_sync_dev_id) {
        last_sync_dev_id = cur_dev_id;
        update_extruder_separator_icon(false, false);
        fila_switch_warning_shown = false;
    }
 
    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
    if (!preset_bundle) {
        clear_all_sync_status();
        return;
    }
 
    if (DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type)) {
        clear_all_sync_status();
        return;
    }
 
    bool printer_synced = false;
    // 1. update printer status
    const Preset &cur_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
    if (preset_bundle && preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) == obj->get_show_printer_type()) {
        panel_printer_preset->ShowBadge(true);
        printer_synced = true;
 
        wxGetApp().plater()->sidebar().udpate_combos_filament_badge();
    } else {
        clear_all_sync_status();
 
        wxGetApp().plater()->sidebar().clear_combos_filament_badge();
        return;
    }
 
    struct ExtruderInfo
    {
        float diameter{0.4};
        //int   nozzle_volue_type{0};
        int   ams_4{0};
        int   ams_1{0};
        std::vector<DevAms *> ams_v4;
        std::vector<DevAms *> ams_v1;
 
        bool operator==(const ExtruderInfo &other) const
        {
            return abs(diameter - other.diameter) < EPSILON
                && /*nozzle_volue_type == other.nozzle_volue_type
                &&*/ ams_4 == other.ams_4
                && ams_1 == other.ams_1;
        }
    };
 
    auto is_same_nozzle_info = [obj](const ExtruderInfo &left, const ExtruderInfo &right) {
        bool is_same_nozzle_type = true;
        if (obj->is_nozzle_flow_type_supported())
            is_same_nozzle_type = true;//left.nozzle_volue_type == right.nozzle_volue_type; // TODO: Orca hack
        return abs(left.diameter - right.diameter) < EPSILON && is_same_nozzle_type;
    };
 
    // 2. update extruder status
    int extruder_nums = preset_bundle->get_printer_extruder_count();
    if (extruder_nums != obj->GetExtderSystem()->GetTotalExtderCount())
        return;
 
    // Filament Track Switch: only ever surfaced on multi-extruder machines. When installed, tip/warn
    // and show the status icon (green ready / red not-calibrated); when absent the icon stays hidden.
    // Inert on any printer without a switch: GetFilaSwitch()->IsInstalled() is false.
    const bool fila_switch_flag = is_fila_switch_ready();
    if (extruder_nums > 1) {
        auto fila_switch = obj->GetFilaSwitch();
        if (fila_switch->IsInstalled()) {
            show_filament_switcher_dialog(fila_switch->IsReady(), false);
            update_extruder_separator_icon(true, fila_switch->IsReady());
        } else {
            update_extruder_separator_icon(false, false);
            fila_switch_warning_shown = false;
        }
    }
 
    std::vector<ExtruderInfo> extruder_infos(extruder_nums);
    std::vector<int> nozzle_volume_types = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
    //for (size_t i = 0; i < nozzle_volume_types.size(); ++i) {
    //    extruder_infos[i].nozzle_volue_type = nozzle_volume_types[i];
    //}
 
    std::vector<std::map<int, int>> extruder_ams_counts = wxGetApp().preset_bundle->extruder_ams_counts;
    if (extruder_ams_counts.size() >= extruder_nums) {
        for (size_t i = 0; i < extruder_nums; ++i) {
            for (auto iter = extruder_ams_counts[i].begin(); iter != extruder_ams_counts[i].end(); ++iter) {
                if (iter->first == 4)
                    extruder_infos[i].ams_4 = iter->second;
                if (iter->first == 1)
                    extruder_infos[i].ams_1 = iter->second;
            }
        }
    }
 
    if (extruder_nums == 1) {
        double value = 0.0;
        single_extruder->diameter.ToDouble(&value);
        extruder_infos[0].diameter = float(value);
    }
    else if(extruder_nums == 2){
        double value = 0.0;
        left_extruder->diameter.ToDouble(&value);
        extruder_infos[0].diameter = float(value);
    
        value = 0.0;
        right_extruder->diameter.ToDouble(&value);
        extruder_infos[1].diameter = float(value);
    }
 
    std::vector<ExtruderInfo> machine_extruder_infos(obj->GetExtderSystem()->GetTotalExtderCount());
 
    const auto& extruders = obj->GetExtderSystem()->GetExtruders();
    for (const DevExtder &extruder : extruders) {
        //machine_extruder_infos[extruder.GetExtId()].nozzle_volue_type = int(extruder.GetNozzleFlowType()) - 1;
        machine_extruder_infos[extruder.GetExtId()].diameter          = extruder.GetNozzleDiameter();
    }
    for (auto &item : obj->GetFilaSystem()->GetAmsList()) {
        int extruder_id;
        // With the switch ready every AMS feeds both extruders, so attribute each to the extruder its
        // input track feeds. Without a switch the binding is a single extruder
        // (GetUniqueBindedExtruderId() == GetExtruderId()) and the switcher position is empty, so this
        // yields the same attribution as before.
        if (fila_switch_flag) {
            auto switcher_pos = item.second->GetSwitcherPos();
            if (!switcher_pos)
                continue;
            extruder_id = obj->is_main_extruder_on_left() ? (1 - static_cast<int>(switcher_pos.value()))
                                                          : static_cast<int>(switcher_pos.value());
        } else {
            const auto &uniq_extruder_id = item.second->GetUniqueBindedExtruderId();
            if (!uniq_extruder_id)
                continue;
            extruder_id = uniq_extruder_id.value();
        }
 
        if (extruder_id >= machine_extruder_infos.size())
            continue;
 
        if (item.second->GetAmsType() == DevAms::N3S)
        { // N3S
            machine_extruder_infos[extruder_id].ams_1++;
            machine_extruder_infos[extruder_id].ams_v1.push_back(item.second);
        } else {
            machine_extruder_infos[extruder_id].ams_4++;
            machine_extruder_infos[extruder_id].ams_v4.push_back(item.second);
        }
    }
 
    std::reverse(machine_extruder_infos.begin(), machine_extruder_infos.end());
 
    std::vector<bool> extruder_synced(extruder_nums, false);
    if (extruder_nums == 1) {
        if (is_same_nozzle_info(extruder_infos[0], machine_extruder_infos[0])) {
            single_extruder->ShowBadge(true);
            panel_nozzle_dia->ShowBadge(true); // ORCA add support for nozzle sync
            single_extruder->sync_ams(obj, machine_extruder_infos[0].ams_v4, machine_extruder_infos[0].ams_v1);
            extruder_synced[0] = true;
        }
        else {
            single_extruder->ShowBadge(false);
            panel_nozzle_dia->ShowBadge(false); // ORCA add support for nozzle sync
            single_extruder->sync_ams(obj, {}, {});
        }
    }
    else if (extruder_nums == 2) {
        if (extruder_infos[0] == machine_extruder_infos[0]) {
            left_extruder->ShowBadge(true);
            left_extruder->sync_ams(obj, machine_extruder_infos[0].ams_v4, machine_extruder_infos[0].ams_v1);
            extruder_synced[0] = true;
        }
        else {
            left_extruder->ShowBadge(false);
            left_extruder->sync_ams(obj, {}, {});
        }
 
        if (extruder_infos[1] == machine_extruder_infos[1]) {
            right_extruder->ShowBadge(true);
            right_extruder->sync_ams(obj, machine_extruder_infos[1].ams_v4, machine_extruder_infos[1].ams_v1);
            extruder_synced[1] = true;
        }
        else {
            right_extruder->ShowBadge(false);
            right_extruder->sync_ams(obj, {}, {});
        }
    }
 
    StateColor synced_colour(std::pair<wxColour, int>(wxColour("#CECECE"), StateColor::Normal));
    bool all_extruder_synced = std::all_of(extruder_synced.begin(), extruder_synced.end(), [](bool value) { return value; });
    if (printer_synced && all_extruder_synced) {
    //    btn_sync_printer->SetBorderColor(synced_colour);
    //    btn_sync_printer->SetIcon("ams_nozzle_sync");
        m_printer_bbl_sync->SetBitmap_("printer_sync_ok");
    }
    else {
    //    btn_sync_printer->SetBorderColor(not_synced_colour);
    //    btn_sync_printer->SetIcon("printer_sync");
        m_printer_bbl_sync->SetBitmap_("printer_sync_not");
    }
 
    // When the switch is ready every AMS filament is available to both extruders; refresh the
    // filament combos whenever the AMS list changes so both extruders pick up the full set.
    if (fila_switch_flag) {
        static std::map<int, DynamicPrintConfig> last_filament_ams_list;
        bool is_same_ams_list = last_filament_ams_list == wxGetApp().preset_bundle->filament_ams_list;
        if (!is_same_ams_list)
            last_filament_ams_list = wxGetApp().preset_bundle->filament_ams_list;
        const auto print_tech = wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology();
        if (print_tech == ptFFF && !is_same_ams_list) {
            for (PlaterPresetComboBox *cb : combos_filament)
                cb->update();
        }
    }
 }

References combos_filament, EPSILON, fila_switch_warning_shown, Slic3r::MachineObject::get_dev_id(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::Preset::get_printer_type(), Slic3r::MachineObject::get_show_printer_type(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetExtruders(), Slic3r::MachineObject::GetFilaSwitch(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::DevExtderSystem::GetTotalExtderCount(), Slic3r::GUI::Sidebar::is_fila_switch_ready(), Slic3r::MachineObject::is_info_ready(), Slic3r::MachineObject::is_main_extruder_on_left(), Slic3r::MachineObject::is_nozzle_flow_type_supported(), Slic3r::DevPrinterConfigUtil::is_optional_printer_model_id(), Slic3r::GUI::is_same_nozzle_type(), last_sync_dev_id, left_extruder, m_printer_bbl_sync, Slic3r::DevAms::N3S, StateColor::Normal, Slic3r::GUI::operator==(), panel_nozzle_dia, panel_printer_bed, panel_printer_preset, Slic3r::MachineObject::printer_type, Slic3r::PresetBundle::printers, Slic3r::ptFFF, right_extruder, show_filament_switcher_dialog(), single_extruder, and update_extruder_separator_icon().

Here is the call graph for this function:

Member Data Documentation

ams_list_device

std::string Slic3r::GUI::Sidebar::priv::ams_list_device

big_bed_image_popup

ImageDPIFrame* Slic3r::GUI::Sidebar::priv::big_bed_image_popup = nullptr

btn_connect_printer

ScalableButton* Slic3r::GUI::Sidebar::priv::btn_connect_printer = nullptr

btn_edit_printer

ScalableButton* Slic3r::GUI::Sidebar::priv::btn_edit_printer = nullptr

Referenced by layout_printer().

btn_export_gcode

wxButton* Slic3r::GUI::Sidebar::priv::btn_export_gcode

btn_export_gcode_removable

ScalableButton* Slic3r::GUI::Sidebar::priv::btn_export_gcode_removable

btn_reslice

wxButton* Slic3r::GUI::Sidebar::priv::btn_reslice

btn_send_gcode

ScalableButton* Slic3r::GUI::Sidebar::priv::btn_send_gcode

combo_nozzle_dia

ComboBox* Slic3r::GUI::Sidebar::priv::combo_nozzle_dia = nullptr

combo_print

PlaterPresetComboBox* Slic3r::GUI::Sidebar::priv::combo_print = nullptr

combo_printer

PlaterPresetComboBox* Slic3r::GUI::Sidebar::priv::combo_printer = nullptr

Referenced by layout_printer().

combo_printer_bed

ComboBox* Slic3r::GUI::Sidebar::priv::combo_printer_bed = nullptr

combo_sla_material

PlaterPresetComboBox* Slic3r::GUI::Sidebar::priv::combo_sla_material = nullptr

combo_sla_print

PlaterPresetComboBox* Slic3r::GUI::Sidebar::priv::combo_sla_print = nullptr

combos_filament

std::vector<PlaterPresetComboBox*> Slic3r::GUI::Sidebar::priv::combos_filament

Referenced by update_sync_status().

counter_sync_printer

std::shared_ptr<int> Slic3r::GUI::Sidebar::priv::counter_sync_printer = std::make_shared<int>()

Referenced by flush_printer_sync().

dia

Search::SearchObjectDialog* Slic3r::GUI::Sidebar::priv::dia = nullptr

editing_filament

int Slic3r::GUI::Sidebar::priv::editing_filament = -1

extruder_dual_sizer

wxBoxSizer* Slic3r::GUI::Sidebar::priv::extruder_dual_sizer = nullptr

Referenced by layout_printer().

extruder_separator_icon

wxStaticBitmap* Slic3r::GUI::Sidebar::priv::extruder_separator_icon = nullptr

Referenced by layout_printer(), and update_extruder_separator_icon().

extruder_single_sizer

wxBoxSizer* Slic3r::GUI::Sidebar::priv::extruder_single_sizer = nullptr

Referenced by layout_printer().

fila_switch_warning_shown

bool Slic3r::GUI::Sidebar::priv::fila_switch_warning_shown = false

Referenced by show_filament_switcher_dialog(), sync_extruder_list(), and update_sync_status().

image_printer

wxStaticBitmap* Slic3r::GUI::Sidebar::priv::image_printer = nullptr

Referenced by layout_printer().

image_printer_bed

wxStaticBitmap* Slic3r::GUI::Sidebar::priv::image_printer_bed = nullptr

is_switching_diameter

bool Slic3r::GUI::Sidebar::priv::is_switching_diameter {false}

{false};

Referenced by sync_extruder_list().

label_nozzle_title

Label* Slic3r::GUI::Sidebar::priv::label_nozzle_title = nullptr

label_nozzle_type

Label* Slic3r::GUI::Sidebar::priv::label_nozzle_type = nullptr

last_sync_dev_id

std::string Slic3r::GUI::Sidebar::priv::last_sync_dev_id

Referenced by update_sync_status().

left_extruder

ExtruderGroup* Slic3r::GUI::Sidebar::priv::left_extruder = nullptr

Referenced by layout_printer(), switch_diameter(), sync_extruder_list(), update_extruder_separator_icon(), and update_sync_status().

m_bpButton_add_filament

ScalableButton* Slic3r::GUI::Sidebar::priv::m_bpButton_add_filament

m_bpButton_ams_filament

ScalableButton* Slic3r::GUI::Sidebar::priv::m_bpButton_ams_filament

m_bpButton_del_filament

ScalableButton* Slic3r::GUI::Sidebar::priv::m_bpButton_del_filament

m_bpButton_set_filament

ScalableButton* Slic3r::GUI::Sidebar::priv::m_bpButton_set_filament

m_btn_add_mixed_filament

wxPanel* Slic3r::GUI::Sidebar::priv::m_btn_add_mixed_filament {nullptr}

{nullptr};  // "+ Add Mixed Filament" full-width button

m_btn_mixed_add

ScalableButton* Slic3r::GUI::Sidebar::priv::m_btn_mixed_add {nullptr}

{nullptr};

m_btn_mixed_del

ScalableButton* Slic3r::GUI::Sidebar::priv::m_btn_mixed_del {nullptr}

{nullptr};

m_btn_mixed_del_all

ScalableButton* Slic3r::GUI::Sidebar::priv::m_btn_mixed_del_all {nullptr}

{nullptr};

m_filament_area_wrapper

wxPanel* Slic3r::GUI::Sidebar::priv::m_filament_area_wrapper

m_filament_icon

ScalableButton* Slic3r::GUI::Sidebar::priv::m_filament_icon = nullptr

m_flushing_volume_btn

Button* Slic3r::GUI::Sidebar::priv::m_flushing_volume_btn = nullptr

m_menu_filament_id

int Slic3r::GUI::Sidebar::priv::m_menu_filament_id = -1

m_mixed_filament_broken

bool Slic3r::GUI::Sidebar::priv::m_mixed_filament_broken {false}

{false};

m_mixed_scroll_area

wxScrolledWindow* Slic3r::GUI::Sidebar::priv::m_mixed_scroll_area {nullptr}

{nullptr};       // independent scrollbar for mixed rows

m_object_list

ObjectList* Slic3r::GUI::Sidebar::priv::m_object_list { nullptr }

{ nullptr };

Referenced by jump_to_object().

m_panel_filament_content

wxScrolledWindow* Slic3r::GUI::Sidebar::priv::m_panel_filament_content

m_panel_filament_separator

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_filament_separator

m_panel_filament_title

StaticBox* Slic3r::GUI::Sidebar::priv::m_panel_filament_title

m_panel_mixed_content

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_mixed_content {nullptr}

{nullptr};

m_panel_mixed_title

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_mixed_title {nullptr}

{nullptr};       // title row: "Mixed Filament" + add/del buttons

m_panel_mixed_warning

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_mixed_warning {nullptr}

{nullptr};     // red bar for broken/mismatched mixes

m_panel_print_content

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_print_content

m_panel_print_title

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_print_title

m_panel_printer_content

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_printer_content = nullptr

Referenced by layout_printer(), and update_extruder_separator_icon().

m_panel_printer_separator

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_printer_separator = nullptr

m_panel_printer_title

StaticBox* Slic3r::GUI::Sidebar::priv::m_panel_printer_title = nullptr

m_panel_project_title

wxPanel* Slic3r::GUI::Sidebar::priv::m_panel_project_title

m_printer_bbl_sync

ScalableButton* Slic3r::GUI::Sidebar::priv::m_printer_bbl_sync = nullptr

Referenced by flush_printer_sync(), layout_printer(), and update_sync_status().

m_printer_connect

ScalableButton* Slic3r::GUI::Sidebar::priv::m_printer_connect = nullptr

Referenced by layout_printer().

m_printer_icon

ScalableButton* Slic3r::GUI::Sidebar::priv::m_printer_icon = nullptr

m_printer_setting

ScalableButton* Slic3r::GUI::Sidebar::priv::m_printer_setting = nullptr

m_purge_mode_btn

Button* Slic3r::GUI::Sidebar::priv::m_purge_mode_btn = nullptr

m_scrolledWindow_filament_content

wxScrolledWindow* Slic3r::GUI::Sidebar::priv::m_scrolledWindow_filament_content

m_search_bar

StaticBox* Slic3r::GUI::Sidebar::priv::m_search_bar = nullptr

Referenced by can_search().

m_search_item

TextInput* Slic3r::GUI::Sidebar::priv::m_search_item = nullptr

Referenced by can_search().

m_sizer_mixed_filaments

wxBoxSizer* Slic3r::GUI::Sidebar::priv::m_sizer_mixed_filaments {nullptr}

{nullptr};   // two-column, mirrors sizer_filaments

m_staticline1

wxStaticLine* Slic3r::GUI::Sidebar::priv::m_staticline1

m_staticline2

wxStaticLine* Slic3r::GUI::Sidebar::priv::m_staticline2

m_staticText_filament_count

wxStaticText* Slic3r::GUI::Sidebar::priv::m_staticText_filament_count

m_staticText_filament_settings

wxStaticText* Slic3r::GUI::Sidebar::priv::m_staticText_filament_settings

m_staticText_print_title

wxStaticText* Slic3r::GUI::Sidebar::priv::m_staticText_print_title

m_text_mixed_title

StaticLine* Slic3r::GUI::Sidebar::priv::m_text_mixed_title {nullptr}

{nullptr};

m_text_mixed_warning

wxStaticText* Slic3r::GUI::Sidebar::priv::m_text_mixed_warning {nullptr}

{nullptr};

m_text_printer_settings

wxStaticText* Slic3r::GUI::Sidebar::priv::m_text_printer_settings = nullptr

Referenced by layout_printer().

object_layers

ObjectLayers* Slic3r::GUI::Sidebar::priv::object_layers { nullptr }

{ nullptr };

object_settings

ObjectSettings* Slic3r::GUI::Sidebar::priv::object_settings { nullptr }

{ nullptr };

Referenced by ~priv().

panel_nozzle_dia

StaticBox* Slic3r::GUI::Sidebar::priv::panel_nozzle_dia = nullptr

Referenced by layout_printer(), and update_sync_status().

panel_printer_bed

StaticBox* Slic3r::GUI::Sidebar::priv::panel_printer_bed = nullptr

Referenced by layout_printer(), and update_sync_status().

panel_printer_preset

StaticBox* Slic3r::GUI::Sidebar::priv::panel_printer_preset = nullptr

Referenced by layout_printer(), and update_sync_status().

plater

Plater* Slic3r::GUI::Sidebar::priv::plater

Referenced by priv(), FromDIP(), switch_diameter_to(), and sync_extruder_list().

right_extruder

ExtruderGroup* Slic3r::GUI::Sidebar::priv::right_extruder = nullptr

Referenced by layout_printer(), switch_diameter(), sync_extruder_list(), and update_sync_status().

scrolled

wxPanel* Slic3r::GUI::Sidebar::priv::scrolled = nullptr

Referenced by show_preset_comboboxes().

searcher

Search::OptionsSearcher Slic3r::GUI::Sidebar::priv::searcher

single_extruder

ExtruderGroup* Slic3r::GUI::Sidebar::priv::single_extruder = nullptr

Referenced by layout_printer(), switch_diameter(), sync_extruder_list(), and update_sync_status().

sizer_filaments

wxBoxSizer* Slic3r::GUI::Sidebar::priv::sizer_filaments = nullptr

sizer_params

wxBoxSizer* Slic3r::GUI::Sidebar::priv::sizer_params

timer_sync_printer

wxTimer* Slic3r::GUI::Sidebar::priv::timer_sync_printer = new wxTimer()

Referenced by flush_printer_sync().

vsizer_printer

wxSizer* Slic3r::GUI::Sidebar::priv::vsizer_printer = nullptr

Referenced by layout_printer().

---

The documentation for this struct was generated from the following file:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Plater.cpp