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

Inheritance diagram for Slic3r::GUI::Sidebar:

Collaboration diagram for Slic3r::GUI::Sidebar:

Classes
struct	priv

Public Types
enum	DockingState { None , Left , Right }

Public Member Functions
	Sidebar (Plater *parent)
	Sidebar (Sidebar &&)=delete
	Sidebar (const Sidebar &)=delete
Sidebar &	operator= (Sidebar &&)=delete
Sidebar &	operator= (const Sidebar &)=delete
	~Sidebar ()
void	on_enter_image_printer_bed (wxMouseEvent &evt)
void	on_leave_image_printer_bed (wxMouseEvent &evt)
void	on_change_color_mode (bool is_dark)
void	create_printer_preset ()
void	init_filament_combo (PlaterPresetComboBox **combo, const int filament_idx)
void	remove_unused_filament_combos (const size_t current_extruder_count)
void	update_all_preset_comboboxes ()
void	update_presets (Slic3r::Preset::Type preset_type)
const std::vector< BedType > &	get_cur_combox_bed_types ()
void	update_presets_from_to (Slic3r::Preset::Type preset_type, std::string from, std::string to)
BedType	get_cur_select_bed_type ()
std::string	get_cur_select_bed_image ()
void	set_bed_type_accord_combox (BedType bed_type)
bool	reset_bed_type_combox_choices (bool is_sidebar_init=false)
void	change_top_border_for_mode_sizer (bool increase_border)
void	update_filaments_area_height ()
void	update_filaments_counter (bool force_layout=false)
void	msw_rescale ()
void	sys_color_changed ()
void	search ()
void	jump_to_option (size_t selected)
void	jump_to_option (const std::string &opt_key, Preset::Type type, const std::wstring &category)
void	on_filament_count_change (size_t num_filaments)
void	on_filaments_delete (size_t filament_id)
void	add_filament ()
void	delete_filament (size_t filament_id=size_t(-1), int replace_filament_id=-1)
void	change_filament (size_t from_id, size_t to_id)
void	edit_filament ()
void	add_custom_filament (wxColour new_col, const std::string &preset_name=std::string(), bool skip_preset_validation=false)
bool	is_new_project_in_gcode3mf ()
void	on_bed_type_change (BedType bed_type)
void	load_ams_list (MachineObject *obj)
std::map< int, DynamicPrintConfig >	build_filament_ams_list (MachineObject *obj)
void	sync_ams_list (bool is_from_big_sync_btn=false)
bool	sync_extruder_list ()
bool	is_fila_switch_ready ()
void	reset_fila_switch ()
bool	need_auto_sync_extruder_list_after_connect_priner (const MachineObject *obj)
void	update_sync_status (const MachineObject *obj)
int	get_sidebar_pos_right_x ()
void	on_size (SimpleEvent &e)
void	on_full_screen (IntEvent &)
void	get_big_btn_sync_pos_size (wxPoint &pt, wxSize &size)
void	get_small_btn_sync_pos_size (wxPoint &pt, wxSize &size)
void	show_SEMM_buttons ()
void	enable_purge_mode_btn (bool enable)
void	set_extruder_nozzle_count (int extruder_id, int nozzle_count)
void	enable_nozzle_count_edit (bool enable)
void	update_dynamic_filament_list ()
PlaterPresetComboBox *	printer_combox ()
ObjectList *	obj_list ()
ObjectSettings *	obj_settings ()
ObjectLayers *	obj_layers ()
wxPanel *	scrolled_panel ()
wxPanel *	print_panel ()
wxPanel *	filament_panel ()
ConfigOptionsGroup *	og_freq_chng_params (const bool is_fff)
wxButton *	get_wiping_dialog_button ()
void	set_flushing_volume_warning (const bool flushing_volume_modify)
void	enable_buttons (bool enable)
void	set_btn_label (const ActionButtonType btn_type, const wxString &label) const
bool	show_reslice (bool show) const
bool	show_export (bool show) const
bool	show_send (bool show) const
bool	show_eject (bool show) const
bool	show_export_removable (bool show) const
bool	get_eject_shown () const
bool	is_multifilament ()
void	deal_btn_sync ()
void	pop_sync_nozzle_and_ams_dialog ()
void	pop_finsish_sync_ams_dialog ()
void	update_mode ()
bool	is_collapsed ()
void	collapse (bool collapse)
void	update_searcher ()
void	update_ui_from_settings ()
bool	show_object_list (bool show) const
void	finish_param_edit ()
void	auto_calc_flushing_volumes (const int filament_idx=-1, const int extruder_id=-1)
	Automatically calculates flushing volumes.
void	jump_to_object (ObjectDataViewModelNode *item)
void	can_search ()
void	show_mode_sizer (bool show)
std::vector< PlaterPresetComboBox * > &	combos_filament ()
void	clear_combos_filament_badge ()
void	udpate_combos_filament_badge ()
void	add_mixed_filament ()
int	ensure_mixed_filament (const std::vector< unsigned int > &components, const std::vector< int > &ratios)
void	edit_mixed_filament (size_t idx)
void	delete_mixed_filament_at (size_t idx)
void	remove_all_mixed_filaments ()
void	decompose_filament_color (int filament_idx)
void	recalc_filament_scroll_sizes ()
void	update_mixed_filament_list ()
bool	has_broken_mixed_filament () const
bool	has_broken_mixed_filament (const PartPlate *plate) const
void	collect_physical_filament_info (std::vector< std::string > &color_strs, std::vector< std::string > &names, std::vector< std::string > &types, std::vector< size_t > *config_indices=nullptr)
Search::OptionsSearcher &	get_searcher ()
Search::SettingsIndex &	settings_index ()
std::string &	get_search_line ()
void	update_printer_thumbnail ()
bool	need_auto_sync_after_connect_printer () const
void	set_need_auto_sync_after_connect_printer (bool need_auto_sync)

Static Public Member Functions
static bool	should_show_SEMM_buttons ()

Private Member Functions
void	update_sync_ams_btn_enable (wxUpdateUIEvent &e)
void	auto_calc_flushing_volumes_internal (const int filament_id, const int extruder_id)

Private Attributes
ConfigOptionMode	m_mode
ScalableButton *	ams_btn {nullptr}
bool	m_last_slice_state = false
SyncNozzleAndAmsDialog *	m_sna_dialog {nullptr}
FinishSyncAmsDialog *	m_fna_dialog {nullptr}
std::vector< BedType >	m_cur_combox_bed_types
std::string	m_cur_image_bed_type
int	m_last_combo_bedtype_count {0}
bool	m_begin_sync_printer_status {false}
SyncAmsInfoDialog *	m_sync_dlg {nullptr}
std::unique_ptr< priv >	p
wxBoxSizer *	m_scrolled_sizer = nullptr
bool	m_need_auto_sync_after_connect_printer {false}

Detailed Description

Member Enumeration Documentation

◆ DockingState

enum Slic3r::GUI::Sidebar::DockingState

Enumerator
None
Left
Right

    {
        None, Left, Right
    };

Constructor & Destructor Documentation

◆ Sidebar() [1/3]

Slic3r::GUI::Sidebar::Sidebar ( Plater * parent )

    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(39 * wxGetApp().em_unit(), -1)), p(new priv(parent))
{
    Choice::register_dynamic_list("support_filament", &dynamic_physical_filament_list);
    Choice::register_dynamic_list("support_interface_filament", &dynamic_physical_filament_list);
    Choice::register_dynamic_list("outer_wall_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("inner_wall_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("sparse_infill_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("internal_solid_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("top_surface_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("bottom_surface_filament_id", &dynamic_filament_list);
    Choice::register_dynamic_list("wipe_tower_filament", &dynamic_physical_filament_list);
 
    p->scrolled = new wxPanel(this);
    //    p->scrolled->SetScrollbars(0, 100, 1, 2); // ys_DELETE_after_testing. pixelsPerUnitY = 100
    // but this cause the bad layout of the sidebar, when all infoboxes appear.
    // As a result we can see the empty block at the bottom of the sidebar
    // But if we set this value to 5, layout will be better
    //p->scrolled->SetScrollRate(0, 5);
    p->scrolled->SetBackgroundColour(*wxWHITE);
 
 
    SetFont(wxGetApp().normal_font());
#ifndef __APPLE__
#ifdef _WIN32
    wxGetApp().UpdateDarkUI(this);
    wxGetApp().UpdateDarkUI(p->scrolled);
#else
    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
#endif
#endif
 
    int em = wxGetApp().em_unit();
    //BBS refine layout and styles
    // Sizer in the scrolled area
    auto* scrolled_sizer = m_scrolled_sizer = new wxBoxSizer(wxVERTICAL);
    p->scrolled->SetSizer(scrolled_sizer);
 
    wxColour title_bg = wxColour(248, 248, 248);
    wxColour inactive_text = wxColour(86, 86, 86);
    wxColour active_text = wxColour(0, 0, 0);
    wxColour static_line_col = wxColour(166, 169, 170);
 
#ifdef __WINDOWS__
    p->scrolled->SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    // add printer
    {
        /***************** 1. create printer title bar    **************/
        // 1.1 create title bar resources
        p->m_panel_printer_title = new StaticBox(p->scrolled, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxBORDER_NONE);
        p->m_panel_printer_title->SetBackgroundColor(title_bg);
        p->m_panel_printer_title->SetBackgroundColor2(0xF1F1F1);
 
        p->m_printer_icon = new ScalableButton(p->m_panel_printer_title, wxID_ANY, "printer");
        p->m_text_printer_settings = new Label(p->m_panel_printer_title, _L("Printer"), LB_PROPAGATE_MOUSE_EVENT | wxST_ELLIPSIZE_END);
 
        p->m_printer_icon->Bind(wxEVT_BUTTON, [](wxCommandEvent& e) {
            //auto wizard_t = new ConfigWizard(wxGetApp().mainframe);
            //wizard_t->run(ConfigWizard::RR_USER, ConfigWizard::SP_CUSTOM);
            });
 
        // ORCA use connect button on titlebar
        p->m_printer_connect = new ScalableButton(p->m_panel_printer_title, wxID_ANY, "monitor_signal_strong");
        p->m_printer_connect->SetToolTip(_L("Connection"));
        p->m_printer_connect->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
            PhysicalPrinterDialog dlg(this->GetParent());
            dlg.ShowModal();
        });
 
        // ORCA use sync button on titlebar
        p->m_printer_bbl_sync = new ScalableButton(p->m_panel_printer_title, wxID_ANY, "printer_sync_not");
        p->m_printer_bbl_sync->SetToolTip(_L("Synchronize nozzle information and the number of AMS"));
        p->m_printer_bbl_sync->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
            deal_btn_sync();
        });
 
        p->m_printer_setting = new ScalableButton(p->m_panel_printer_title, wxID_ANY, "settings");
        p->m_printer_setting->Bind(wxEVT_BUTTON, [](wxCommandEvent &e) {
            // p->editing_filament = -1;
            // wxGetApp().params_dialog()->Popup();
            // wxGetApp().get_tab(Preset::TYPE_FILAMENT)->restore_last_select_item();
            wxGetApp().run_wizard(ConfigWizard::RR_USER, ConfigWizard::SP_PRINTERS);
            });
 
        wxBoxSizer* h_sizer_title = new wxBoxSizer(wxHORIZONTAL);
        h_sizer_title->Add(p->m_printer_icon, 0, wxALIGN_CENTRE | wxLEFT, FromDIP(SidebarProps::TitlebarMargin()));
        h_sizer_title->AddSpacer(FromDIP(SidebarProps::ElementSpacing()));
        h_sizer_title->Add(p->m_text_printer_settings, 1, wxALIGN_CENTER | wxRIGHT, FromDIP(SidebarProps::WideSpacing()));
        //h_sizer_title->AddStretchSpacer();
        h_sizer_title->Add(p->m_printer_connect , 0, wxALIGN_CENTER | wxRIGHT, FromDIP(SidebarProps::WideSpacing())); // used larger margin to prevent accidental clicks
        h_sizer_title->Add(p->m_printer_bbl_sync, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(SidebarProps::WideSpacing())); // used larger margin to prevent accidental clicks
        h_sizer_title->Add(p->m_printer_setting, 0, wxALIGN_CENTER);
        h_sizer_title->AddSpacer(FromDIP(SidebarProps::TitlebarMargin()));
        h_sizer_title->SetMinSize(-1, 3 * em);
 
        p->m_panel_printer_title->SetSizer(h_sizer_title);
        p->m_panel_printer_title->Layout();
 
        // 1.2 Add spliters around title bar
 
        // add printer title
        scrolled_sizer->Add(p->m_panel_printer_title, 0, wxEXPAND | wxALL, 0);
        // ORCA Bind with LEFT_DOWN, since closing a dialog over the title bar can send it a stray LEFT_UP
        auto toggle_printer_section = ([this] (wxMouseEvent & e) {
            if (!p || !p->combo_printer || !p->m_text_printer_settings || !p->m_panel_printer_content || !m_scrolled_sizer)
                return;
            // ORCA Show printer name on title when its folded to inform user without expanding it again
            bool     isShown = p->m_panel_printer_content->IsShown();
            wxString title   = _L("Printer") + wxString(!isShown ? "" : ("  |  " + p->combo_printer->GetValue()));
            p->m_text_printer_settings->SetLabel(title);
            p->m_panel_printer_content->Show(!isShown);
            p->m_panel_printer_separator->Show(isShown);
            m_scrolled_sizer->Layout();
        });
        p->m_panel_printer_title->Bind(wxEVT_LEFT_DOWN  , toggle_printer_section);
        p->m_panel_printer_title->Bind(wxEVT_LEFT_DCLICK, toggle_printer_section);
        // ORCA add bottom border for seperation wile sections folded
        p->m_panel_printer_separator = new wxPanel(p->scrolled, wxID_ANY, wxDefaultPosition, wxSize(-1, FromDIP(2))); // ORCA staticline class not works without string
        p->m_panel_printer_separator->SetBackgroundColour("#FFFFFF");
        scrolled_sizer->Add(p->m_panel_printer_separator, 0, wxEXPAND);
 
        /*************************** 2. add printer content ************************/
 
        p->m_panel_printer_content = new wxPanel(p->scrolled, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
        p->m_panel_printer_content->SetBackgroundColour(wxColour(255, 255, 255));
 
        struct PanelColors {
            wxColour bg_normal = "#FFFFFF";
            wxColour bg_focus  = "#E5F0EE";
            wxColour bd_normal = "#DBDBDB";
            wxColour bd_hover  = "#009688";
            wxColour bd_focus  = "#009688";
        };
        PanelColors panel_color;
 
        p->panel_printer_preset = new StaticBox(p->m_panel_printer_content);
        p->panel_printer_preset->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
        p->panel_printer_preset->SetBorderColor(panel_color.bd_normal);
        p->panel_printer_preset->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
        p->panel_printer_preset->Bind(wxEVT_LEFT_DOWN, [this](auto & evt) {
            p->combo_printer->wxEvtHandler::ProcessEvent(evt);
        });
        // ORCA Hide Cover automatically if there is not enough space
        p->panel_printer_preset->Bind(wxEVT_SIZE, [this](auto & e) {
            auto current_width = e.GetSize().GetWidth();
            auto narrow_width  = FromDIP(235);
            auto label_width   = p->combo_printer->GetTextExtent(p->combo_printer->GetStringSelection()).GetWidth(); 
            auto min_width     = label_width + FromDIP(25  + PRINTER_PANEL_SIZE.GetWidth());
            if(((min_width < narrow_width && min_width > current_width) || (current_width < narrow_width && min_width > narrow_width)) && p->image_printer->IsShown())
                p->image_printer->Hide();
            else if((current_width > min_width || !(current_width < narrow_width)) && !p->image_printer->IsShown())
                p->image_printer->Show();
            e.Skip();
        });
 
        // hover state data for printer panel
        auto printer_preset_hovered = std::make_shared<std::unordered_set<wxWindow*>>();
 
        p->btn_edit_printer = new ScalableButton(p->panel_printer_preset, wxID_ANY, "edit");
        p->btn_edit_printer->SetToolTip(_L("Click to edit preset"));
        p->btn_edit_printer->Hide(); // hide for first launch
        p->btn_edit_printer->Bind(wxEVT_BUTTON, [this, panel_color, printer_preset_hovered](wxCommandEvent){
            p->editing_filament = -1;
            if (p->combo_printer->switch_to_tab())
                p->editing_filament = 0;
            // ORCA: FIX crash on wxGTK, directly modifying UI (self->Hide() / parent->Layout()) inside a button event can crash because callbacks are not re-entrant, leaving widgets in an inconsistent state
            wxGetApp().CallAfter([this, panel_color, printer_preset_hovered]() {
                // ORCA clicking edit button not triggers wxEVT_KILL_FOCUS wxEVT_LEAVE_WINDOW make changes manually to prevent stucked colors when opening printer settings
                if (!p || !p->panel_printer_preset || !p->btn_edit_printer)
                    return;
        p->panel_printer_preset->SetBorderColor(panel_color.bd_normal);
                printer_preset_hovered->clear();
                p->btn_edit_printer->Hide();
                p->panel_printer_preset->Layout();
            });
        });
 
        ScalableBitmap bitmap_printer(p->panel_printer_preset, "printer_placeholder", PRINTER_THUMBNAIL_SIZE.GetHeight());
        p->image_printer = new wxStaticBitmap(p->panel_printer_preset, wxID_ANY, bitmap_printer.bmp(), wxDefaultPosition, FromDIP(PRINTER_THUMBNAIL_SIZE), 0);
        p->image_printer->Bind(wxEVT_LEFT_DOWN, [this](auto &evt) {
            p->combo_printer->wxEvtHandler::ProcessEvent(evt);
        });
 
        p->combo_printer = new PlaterPresetComboBox(p->panel_printer_preset, Preset::TYPE_PRINTER);
        p->combo_printer->SetBorderWidth(0);
        p->combo_printer->SetMaxSize(wxSize(-1, FromDIP(30))); // limiting height makes badge visible
        // ORCA paint whole combobox on focus
        auto printer_focus_bg = [this, panel_color](bool focused){
            auto bg_color = StateColor::darkModeColorFor(focused ? panel_color.bg_focus : panel_color.bg_normal);
            p->panel_printer_preset->SetBackgroundColor(bg_color);
            p->panel_printer_preset->SetBorderColor(focused ? panel_color.bd_focus : panel_color.bd_normal);
            p->btn_edit_printer->SetBackgroundColour(bg_color);
            p->image_printer->SetBackgroundColour(bg_color);
            p->combo_printer->SetBackgroundColour(bg_color); // paints margins instead combo background
        };
        p->combo_printer->Bind(wxEVT_SET_FOCUS,  [printer_focus_bg](auto& e) {printer_focus_bg(true ); e.Skip();});
        p->combo_printer->Bind(wxEVT_KILL_FOCUS, [printer_focus_bg](auto& e) {printer_focus_bg(false); e.Skip();});
 
        /* ORCA This part moved to titlebar
        p->btn_connect_printer = new ScalableButton(p->panel_printer_preset, wxID_ANY, "monitor_signal_strong");
        p->btn_connect_printer->SetBackgroundColour(wxColour(255, 255, 255));
        p->btn_connect_printer->SetToolTip(_L("Connection"));
        p->btn_connect_printer->Bind(wxEVT_BUTTON, [this, combo_printer](wxCommandEvent)
            {
                PhysicalPrinterDialog dlg(this->GetParent());
                dlg.ShowModal();
            });
        */
        // ORCA use Show/Hide to gain text area instead using blank icon. also manages hover effect for border
        for (wxWindow *w : std::initializer_list<wxWindow *>{p->panel_printer_preset, p->btn_edit_printer, p->image_printer, p->combo_printer}) {
            w->Bind(wxEVT_ENTER_WINDOW, [this, w, panel_color, printer_preset_hovered](wxMouseEvent &e) {
                printer_preset_hovered->insert(w);
                if(!p->combo_printer->HasFocus())
                    p->panel_printer_preset->SetBorderColor(panel_color.bd_hover);
                e.Skip();
            });
            w->Bind(wxEVT_LEAVE_WINDOW, [this, w, panel_color, printer_preset_hovered](wxMouseEvent &e) {
                printer_preset_hovered->erase(w);
                if (printer_preset_hovered->empty() && !p->combo_printer->HasFocus())
                    p->panel_printer_preset->SetBorderColor(panel_color.bd_normal);
                e.Skip();
            });
        }
        // Perform show/hide in wxEVT_IDLE after enter/leave events have settled.
        // This prevents the extraneous enter/leave events generated by the
        // layout change itself from causing a feedback loop.
        Bind(wxEVT_IDLE, [this, printer_preset_hovered](wxIdleEvent &e) {
            auto hovered = !printer_preset_hovered->empty();
            if (p->btn_edit_printer->IsShown() != hovered) {
                if (hovered) {
                    p->btn_edit_printer->Show();
                } else {
                    p->btn_edit_printer->Hide();
                }
                p->panel_printer_preset->Layout();
            }
        });
 
        // ORCA unified Nozzle diameter selection
        p->panel_nozzle_dia = new StaticBox(p->m_panel_printer_content);
        p->panel_nozzle_dia->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
        p->panel_nozzle_dia->SetBorderColor(panel_color.bd_normal);
        p->panel_nozzle_dia->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
        p->panel_nozzle_dia->Bind(wxEVT_LEFT_DOWN, [this](auto & evt) {
            p->combo_nozzle_dia->wxEvtHandler::ProcessEvent(evt);
        });
 
        // "Variant", not "Nozzle": picking one switches the printer preset (see panel_nozzle_dia).
        // TRN Sidebar label of the printer variant (nozzle) selector; picking one switches the printer preset.
        p->label_nozzle_title = new Label(p->panel_nozzle_dia, _L("Variant"), LB_PROPAGATE_MOUSE_EVENT);
        p->label_nozzle_title->SetFont(Label::Body_10);
 
        p->combo_nozzle_dia = new ComboBox(p->panel_nozzle_dia, wxID_ANY, wxString(""), wxDefaultPosition, wxDefaultSize, 0, nullptr, wxCB_READONLY);
        p->combo_nozzle_dia->SetBorderWidth(0);
        p->combo_nozzle_dia->GetDropDown().SetUseContentWidth(true);
        p->combo_nozzle_dia->SetMinSize(FromDIP(wxSize(PRINTER_PANEL_SIZE.GetWidth() - 4, 26))); // requires a static value in here
        p->combo_nozzle_dia->SetMaxSize(FromDIP(wxSize(PRINTER_PANEL_SIZE.GetWidth() - 4, 26))); // using -1 with wxEXPAND has issues
        p->combo_nozzle_dia->Bind(wxEVT_COMBOBOX, [this](auto &e) {
            // This box is the machine-variant selector, so it switches the printer preset directly
            // instead of feeding an extruder card's combo. Deferred, because switching preset
            // rebuilds this very combo.
            const wxString diameter = p->combo_nozzle_dia->GetValue();
            p->combo_nozzle_dia->CallAfter([this, diameter]() {
                p->is_switching_diameter = true;
                p->switch_diameter_to(diameter);
                p->is_switching_diameter = false;
            });
            e.Skip();
        });
        // ORCA paint whole combobox on focus
        auto nozzle_focus_bg = [this, panel_color](bool focused){
            auto bg_color = StateColor::darkModeColorFor(focused ? panel_color.bg_focus : panel_color.bg_normal);
            p->panel_nozzle_dia->SetBackgroundColor(bg_color);
            p->panel_nozzle_dia->SetBorderColor(focused ? panel_color.bd_focus : panel_color.bd_normal);
            p->label_nozzle_title->SetBackgroundColour(bg_color);
            p->label_nozzle_type->SetBackgroundColour(bg_color);
            p->combo_nozzle_dia->SetBackgroundColour(bg_color); // paints margins instead combo background
        };
        p->combo_nozzle_dia->Bind(wxEVT_SET_FOCUS,  [nozzle_focus_bg](auto& e) {nozzle_focus_bg(true ); e.Skip();});
        p->combo_nozzle_dia->Bind(wxEVT_KILL_FOCUS, [nozzle_focus_bg](auto& e) {nozzle_focus_bg(false); e.Skip();});
 
        p->label_nozzle_type = new Label(p->panel_nozzle_dia, _L("Brass"), LB_PROPAGATE_MOUSE_EVENT | wxST_ELLIPSIZE_END | wxALIGN_CENTRE_HORIZONTAL);
        p->label_nozzle_type->SetFont(Label::Body_10);
        p->label_nozzle_type->SetMinSize(FromDIP(wxSize(56, -1)));
        p->label_nozzle_type->SetMaxSize(FromDIP(wxSize(56, -1)));
 
        // highlight border on hover
        auto nozzle_dia_hovered = std::make_shared<std::unordered_set<wxWindow*>>();
        for (wxWindow *w : std::initializer_list<wxWindow *>{p->panel_nozzle_dia, p->label_nozzle_title, p->label_nozzle_type, p->combo_nozzle_dia}) {
            w->Bind(wxEVT_ENTER_WINDOW, [this, w, panel_color, nozzle_dia_hovered](wxMouseEvent &e) {
                nozzle_dia_hovered->insert(w);
                if(!p->combo_nozzle_dia->HasFocus())
                    p->panel_nozzle_dia->SetBorderColor(panel_color.bd_hover);
                e.Skip();
            });
            w->Bind(wxEVT_LEAVE_WINDOW, [this, w, panel_color, nozzle_dia_hovered](wxMouseEvent &e) {
                nozzle_dia_hovered->erase(w);
                if (nozzle_dia_hovered->empty() && !p->combo_nozzle_dia->HasFocus())
                    p->panel_nozzle_dia->SetBorderColor(panel_color.bd_normal);
                e.Skip();
            });
        }
 
        wxGridSizer *nozzle_dia_sizer = new wxGridSizer(3, 1, FromDIP(2), 0);
        nozzle_dia_sizer->Add(p->label_nozzle_title, 1, wxALIGN_CENTER | wxTOP   , FromDIP(2));
        nozzle_dia_sizer->Add(p->combo_nozzle_dia  , 0, wxALIGN_CENTER);
        nozzle_dia_sizer->Add(p->label_nozzle_type , 1, wxALIGN_CENTER | wxBOTTOM, FromDIP(1));
 
        p->panel_nozzle_dia->SetSizer(nozzle_dia_sizer);
 
        // Bed type selection
        p->panel_printer_bed = new StaticBox(p->m_panel_printer_content);
        p->panel_printer_bed->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
        p->panel_printer_bed->SetBorderColor(panel_color.bd_normal);
        p->panel_printer_bed->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
        p->panel_printer_bed->Bind(wxEVT_LEFT_DOWN, [this](auto &evt) {
            on_leave_image_printer_bed(evt);
            p->combo_printer_bed->wxEvtHandler::ProcessEvent(evt);
        });
 
        //ScalableButton *wiki_bed = new ScalableButton(p->panel_printer_bed, wxID_ANY, "help");
        //wiki_bed->Bind(wxEVT_BUTTON, [](wxCommandEvent) {
        //    wxLaunchDefaultBrowser("https://wiki.bambulab.com/en/x1/manual/compatibility-and-parameter-settings-of-filaments");
        //});
 
        ScalableBitmap bitmap_bed(p->panel_printer_bed, "printer_placeholder", PRINTER_THUMBNAIL_SIZE.GetHeight());
        p->image_printer_bed = new wxStaticBitmap(p->panel_printer_bed, wxID_ANY, bitmap_bed.bmp(), wxDefaultPosition, wxDefaultSize, 0);
        p->image_printer_bed->Bind(wxEVT_LEFT_DOWN, [this](auto &evt) {
            on_leave_image_printer_bed(evt);
            p->combo_printer_bed->wxEvtHandler::ProcessEvent(evt);
        });
 
        p->combo_printer_bed = new ComboBox(p->panel_printer_bed, wxID_ANY, wxString(""), wxDefaultPosition, wxDefaultSize, 0, nullptr, wxCB_READONLY);
        p->combo_printer_bed->SetBorderWidth(0);
        p->combo_printer_bed->GetDropDown().SetUseContentWidth(true);
        p->combo_printer_bed->SetMinSize(FromDIP(wxSize(18,-1))); // ORCA show only arrow
        p->combo_printer_bed->SetMaxSize(FromDIP(wxSize(18,-1))); // ORCA show only arrow
        reset_bed_type_combox_choices(true);
 
        p->combo_printer_bed->Bind(wxEVT_COMBOBOX, [this](auto &e) {
            auto image_path        = get_cur_select_bed_image();
            p->image_printer_bed->SetBitmap(create_scaled_bitmap(image_path, this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
            e.Skip();
        });
 
        // ORCA paint whole combobox on focus
        auto bed_focus_bg = [this, panel_color](bool focused){
            auto bg_color = StateColor::darkModeColorFor(focused ? panel_color.bg_focus : panel_color.bg_normal);
            p->panel_printer_bed->SetBackgroundColor(bg_color);
            p->panel_printer_bed->SetBorderColor(focused ? panel_color.bd_focus : panel_color.bd_normal);
            p->image_printer_bed->SetBackgroundColour(bg_color);
            p->combo_printer_bed->SetBackgroundColour(bg_color); // paints margins instead combo background
        };
        p->combo_printer_bed->Bind(wxEVT_SET_FOCUS,  [bed_focus_bg](auto& e) {bed_focus_bg(true ); e.Skip();});
        p->combo_printer_bed->Bind(wxEVT_KILL_FOCUS, [bed_focus_bg](auto& e) {bed_focus_bg(false); e.Skip();});
 
        // highlight border on hover
        auto printer_bed_hovered = std::make_shared<std::unordered_set<wxWindow*>>();
        for (wxWindow *w : std::initializer_list<wxWindow *>{p->panel_printer_bed, p->image_printer_bed, p->combo_printer_bed}) {
            w->Bind(wxEVT_ENTER_WINDOW, [this, w, panel_color, printer_bed_hovered](wxMouseEvent &e) {
                printer_bed_hovered->insert(w);
                if(!p->combo_printer_bed->HasFocus())
                    p->panel_printer_bed->SetBorderColor(panel_color.bd_hover);
                if(w == p->image_printer_bed && !p->combo_printer_bed->is_drop_down()) // dont trigger while combo open
                    on_enter_image_printer_bed(e);
                e.Skip();
            });
            w->Bind(wxEVT_LEAVE_WINDOW, [this, w, panel_color, printer_bed_hovered](wxMouseEvent &e) {
                printer_bed_hovered->erase(w);
                if (printer_bed_hovered->empty() && !p->combo_printer_bed->HasFocus())
                    p->panel_printer_bed->SetBorderColor(panel_color.bd_normal);
                if(w == p->image_printer_bed)
                    on_leave_image_printer_bed(e);
                e.Skip();
            });
        }
 
        wxBoxSizer *bed_type_sizer = new wxBoxSizer(wxHORIZONTAL);
        bed_type_sizer->Add(p->combo_printer_bed, 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
        bed_type_sizer->Add(p->image_printer_bed, 0, wxALL | wxALIGN_CENTER_VERTICAL, FromDIP(2));
 
        p->panel_printer_bed->SetSizer(bed_type_sizer);
 
        AppConfig *app_config = wxGetApp().app_config;
        std::string str_bed_type = app_config->get("curr_bed_type");
        int bed_type_value = atoi(str_bed_type.c_str());
        // hotfix: btDefault is added as the first one in BedType, and app_config should not be btDefault
        if (bed_type_value == 0) {
            app_config->set("curr_bed_type", "1");
            bed_type_value = 1;
        }
 
        int bed_type_idx = bed_type_value - 1;
        p->combo_printer_bed->Select(bed_type_idx);
 
        auto& project_config = wxGetApp().preset_bundle->project_config;
        /*const t_config_enum_values* keys_map = print_config_def.get("curr_bed_type")->enum_keys_map;
        BedType bed_type = btCount;
        for (auto item : *keys_map) {
            if (item.first == str_bed_type)
                bed_type = (BedType)item.second;
        }*/
        BedType bed_type = (BedType)bed_type_value;
        project_config.set_key_value("curr_bed_type", new ConfigOptionEnum<BedType>(bed_type));
 
        /* ORCA THIS PART MOVED TO TITLEBAR
        // Sync printer information
        btn_sync = new Button(p->m_panel_printer_content, _L("Sync info"), "printer_sync", 0, 32);
        //btn_sync->SetFont(Label::Body_8);
        btn_sync->SetToolTip(_L("Synchronize nozzle information and the number of AMS"));
        btn_sync->SetCornerRadius(8);
        StateColor btn_sync_bg_col(
                std::pair<wxColour, int>(wxColour("#CECECE"), StateColor::Pressed),
                std::pair<wxColour, int>(wxColour("#F8F8F8"), StateColor::Hovered),
                std::pair<wxColour, int>(wxColour("#F8F8F8"), StateColor::Normal));
        StateColor btn_sync_bd_col(
                std::pair<wxColour, int>(wxColour("#009688"), StateColor::Pressed),
                std::pair<wxColour, int>(wxColour("#009688"), StateColor::Hovered),
                std::pair<wxColour, int>(wxColour("#EEEEEE"), StateColor::Normal));
        btn_sync->SetBackgroundColor(btn_sync_bg_col);
        btn_sync->SetBorderColor(btn_sync_bd_col);
        btn_sync->SetCanFocus(false);
        btn_sync->SetPaddingSize({FromDIP(6), FromDIP(12)});
        btn_sync->SetMinSize(BTN_SYNC_SIZE);
        btn_sync->SetMaxSize(BTN_SYNC_SIZE);
        btn_sync->SetVertical();
        btn_sync->Bind(wxEVT_UPDATE_UI, &Sidebar::update_sync_ams_btn_enable, this);
        btn_sync->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
            deal_btn_sync();
        });
        p->btn_sync_printer = btn_sync;
        */
        p->timer_sync_printer->Bind(wxEVT_TIMER, [this] (wxTimerEvent & e) {
            p->flush_printer_sync();
        });
       
 
        p->left_extruder  = new ExtruderGroup(p->m_panel_printer_content, 0, _L("Left Nozzle"));
        p->right_extruder = new ExtruderGroup(p->m_panel_printer_content, 1, _L("Right Nozzle"));
        p->single_extruder = new ExtruderGroup(p->m_panel_printer_content, -1, _L("Nozzle"));
        // manuallySetNozzleCount refreshes the badge and the plater itself; it is a no-op unless the
        // printer has a multi-nozzle extruder (and the edit button is only enabled then, see
        // enable_nozzle_count_edit).
        p->left_extruder->SetOnHoverClick([]() { GUI::manuallySetNozzleCount(0); });
        p->right_extruder->SetOnHoverClick([]() { GUI::manuallySetNozzleCount(1); });
        p->single_extruder->SetEditEnabled(false);
        // Orca: keep the floating switcher icon aligned with the left extruder's AMS row when the
        // extruder card is resized (the overlay is absolutely positioned, not managed by a sizer).
        p->left_extruder->Bind(wxEVT_SIZE, [this](wxSizeEvent &evt) {
            if (p->extruder_separator_icon && p->extruder_separator_icon->IsShown()) {
                wxPoint left_box_pos  = p->left_extruder->GetPosition();
                wxPoint ams_local_pos = p->left_extruder->hsizer_ams->GetPosition();
                wxSize  left_size     = p->left_extruder->sizer->GetSize();
                wxSize  ams_size      = p->left_extruder->hsizer_ams->GetSize();
                wxSize  icon_size     = p->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) - icon_size.GetWidth() / 2;
                int     center_y      = ams_abs_y + (ams_size.GetHeight() - icon_size.GetHeight()) / 2 - icon_size.GetHeight() / 2;
                p->extruder_separator_icon->SetPosition(wxPoint(center_x, center_y));
                if (p->m_panel_printer_content)
                    p->m_panel_printer_content->Refresh();
            }
            evt.Skip();
        });
        auto switch_diameter = [this](wxCommandEvent & evt) {
            auto extruder = dynamic_cast<ExtruderGroup *>(dynamic_cast<ComboBox *>(evt.GetEventObject())->GetParent());
            p->is_switching_diameter = true;
            p->switch_diameter(extruder == p->single_extruder);
            p->is_switching_diameter = false;
        };
        p->left_extruder->combo_diameter->Bind(wxEVT_COMBOBOX, switch_diameter);
        p->right_extruder->combo_diameter->Bind(wxEVT_COMBOBOX, switch_diameter);
        p->single_extruder->combo_diameter->Bind(wxEVT_COMBOBOX, switch_diameter);
 
        p->vsizer_printer = new wxBoxSizer(wxVERTICAL);
        p->layout_printer(true, true);
        p->m_panel_printer_content->SetSizer(p->vsizer_printer);
        p->m_panel_printer_content->Layout();
        scrolled_sizer->Add(p->m_panel_printer_content, 0, wxEXPAND, 0);
    }
 
    {
 
    // Orca: Sidebar - Filament titlebar UI
    // add filament title
    p->m_panel_filament_title = new StaticBox(p->scrolled, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxBORDER_NONE);
    p->m_panel_filament_title->SetBackgroundColor(title_bg);
    p->m_panel_filament_title->SetBackgroundColor2(0xF1F1F1);
    // ORCA Bind with LEFT_DOWN, since closing a dialog over the title bar can send it a stray LEFT_UP
    auto toggle_filament_section = ([this](wxMouseEvent &e) {
        if (!p || !p->m_filament_area_wrapper || !m_scrolled_sizer || !p->m_bpButton_set_filament || !p->m_purge_mode_btn || !p->m_flushing_volume_btn || !p->m_bpButton_add_filament || !ams_btn)
            return;
        // ORCA exclude area of del button from titlebar collapse/expand feature to fix undesired collapse when user spams del filament button
        // also block fold/unfold feature when user clicks to spacing between icons
        int exclude_pt = p->m_bpButton_set_filament->GetPosition().x; // maximum fixed item
        if      (p->m_purge_mode_btn->IsShown())        exclude_pt = p->m_purge_mode_btn->GetPosition().x;
        else if (p->m_flushing_volume_btn->IsShown())   exclude_pt = p->m_flushing_volume_btn->GetPosition().x;
        else if (p->m_bpButton_add_filament->IsShown()) exclude_pt = p->m_bpButton_add_filament->GetPosition().x - FromDIP(30); // reserve spacing for delete button
        else if (ams_btn->IsShown())                    exclude_pt = ams_btn->GetPosition().x;
        if (e.GetPosition().x > exclude_pt)
            return;
        bool isShown = p->m_filament_area_wrapper->IsShown();
        p->m_filament_area_wrapper->Show(!isShown);
        p->m_panel_filament_separator->Show(isShown);
        m_scrolled_sizer->Layout();
 
        CallAfter([this]{update_filaments_counter(true);}); // call after all UI processing done
    });
    p->m_panel_filament_title->Bind(wxEVT_LEFT_DOWN  , toggle_filament_section);
    p->m_panel_filament_title->Bind(wxEVT_LEFT_DCLICK, toggle_filament_section);
 
    wxBoxSizer* bSizer39;
    bSizer39 = new wxBoxSizer( wxHORIZONTAL );
    p->m_filament_icon = new ScalableButton(p->m_panel_filament_title, wxID_ANY, "filament");
    p->m_staticText_filament_settings = new Label(p->m_panel_filament_title, _L("Project Filaments"), LB_PROPAGATE_MOUSE_EVENT);
    bSizer39->Add(p->m_filament_icon, 0, wxALIGN_CENTER | wxLEFT, FromDIP(SidebarProps::TitlebarMargin()));
    bSizer39->Add(p->m_staticText_filament_settings, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(SidebarProps::ElementSpacing()));
    bSizer39->SetMinSize(-1, FromDIP(30));
 
    p->m_staticText_filament_count = new Label(p->m_panel_filament_title, "(0)", LB_PROPAGATE_MOUSE_EVENT);
    bSizer39->Add(p->m_staticText_filament_count, 0, wxALIGN_CENTER );
    bSizer39->Add(FromDIP(10), 0, 0, 0, 0);
 
    p->m_panel_filament_title->SetSizer( bSizer39 );
    p->m_panel_filament_title->Layout();
    scrolled_sizer->Add(p->m_panel_filament_title, 0, wxEXPAND | wxALL, 0);
    // ORCA add bottom border for seperation wile sections folded
    p->m_panel_filament_separator = new wxPanel(p->scrolled, wxID_ANY, wxDefaultPosition, wxSize(-1, FromDIP(2))); // ORCA staticline class not works without string
    p->m_panel_filament_separator->SetBackgroundColour("#FFFFFF");
    scrolled_sizer->Add(p->m_panel_filament_separator, 0, wxEXPAND);
 
    bSizer39->AddStretchSpacer(1);
 
    p->m_purge_mode_btn = new Button(p->m_panel_filament_title, _L("Purge mode"));
    p->m_purge_mode_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Compact);
 
    p->m_purge_mode_btn->Bind(wxEVT_BUTTON, [](wxCommandEvent &e) {
        auto &preset_bundle         = *wxGetApp().preset_bundle;
        auto support_fast_purge_opt = preset_bundle.printers.get_edited_preset().config.option<ConfigOptionBool>("support_fast_purge_mode");
        bool support_fast_purge     = support_fast_purge_opt ? support_fast_purge_opt->value : false;
        auto dlg_type               = support_fast_purge ? PurgeModeDialogType::FastMode : PurgeModeDialogType::MultiNozzle;
        PurgeModeDialog dlg(static_cast<wxWindow *>(wxGetApp().mainframe), dlg_type);
        if (dlg.ShowModal() == wxID_OK) {
            preset_bundle.project_config.set_key_value("prime_volume_mode", new ConfigOptionEnum<PrimeVolumeMode>(dlg.get_selected_mode()));
            wxGetApp().plater()->update();
        }
    });
 
    bSizer39->Add(p->m_purge_mode_btn, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(4));
    bSizer39->Hide(p->m_purge_mode_btn); // hidden on launch; shown only for printers that support purge mode selection
 
    // BBS
    // add wiping dialog
    //wiping_dialog_button->SetFont(wxGetApp().normal_font());
    p->m_flushing_volume_btn = new Button(p->m_panel_filament_title, _L("Flushing volumes"));
    p->m_flushing_volume_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Compact);
    p->m_flushing_volume_btn->SetId(wxID_RESET);
    auto has_modify = is_flush_config_modified();
    set_flushing_volume_warning(has_modify);
 
    p->m_flushing_volume_btn->Bind(wxEVT_BUTTON, ([parent, this](wxCommandEvent &e) {
            open_flushing_dialog(parent, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, parent));
            p->plater->get_view3D_canvas3D()->reload_scene(true);
            p->plater->update();
        }));
 
    bSizer39->Add(p->m_flushing_volume_btn, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(4));
    bSizer39->Hide(p->m_flushing_volume_btn); // ORCA Ensure button is hidden on launch while 1 filament exist
 
    ScalableButton* add_btn = new ScalableButton(p->m_panel_filament_title, wxID_ANY, "add_filament");
    add_btn->SetToolTip(_L("Add one filament"));
    add_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e){
        add_filament();
        update_filaments_counter();
    });
    p->m_bpButton_add_filament = add_btn;
 
    // ORCA Moved add button after delete button to prevent add button position change when remove icon automatically hidden
 
    ScalableButton* del_btn = new ScalableButton(p->m_panel_filament_title, wxID_ANY, "delete_filament");
    del_btn->SetToolTip(_L("Remove last filament"));
    del_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
        delete_filament();
        update_filaments_counter();
    });
    p->m_bpButton_del_filament = del_btn;
 
    bSizer39->Add(del_btn, 0, wxALIGN_CENTER | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
    bSizer39->Add(add_btn, 0, wxALIGN_CENTER | wxLEFT, FromDIP(SidebarProps::IconSpacing())); // ORCA Moved add button after delete button to prevent add button position change when remove icon automatically hidden
 
    bSizer39->Hide(p->m_bpButton_del_filament); // ORCA Ensure button is hidden on launch while 1 filament exist
 
    ams_btn = new ScalableButton(p->m_panel_filament_title, wxID_ANY, "ams_fila_sync", wxEmptyString, wxDefaultSize, wxDefaultPosition,
                                                 wxBU_EXACTFIT | wxNO_BORDER, false, 16); // ORCA match icon size with other icons as 16x16
    ams_btn->SetToolTip(_L("Synchronize filament list from AMS"));
    ams_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
        sync_ams_list();
    });
 
    ams_btn->Bind(wxEVT_UPDATE_UI, &Sidebar::update_sync_ams_btn_enable, this);
    p->m_bpButton_ams_filament = ams_btn;
 
    bSizer39->Add(ams_btn, 0, wxALIGN_CENTER | wxLEFT, FromDIP(SidebarProps::WideSpacing()));
    //bSizer39->Add(FromDIP(10), 0, 0, 0, 0 );
 
    ScalableButton* set_btn = new ScalableButton(p->m_panel_filament_title, wxID_ANY, "settings");
    set_btn->SetToolTip(_L("Set filaments to use"));
    set_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
        p->editing_filament = -1;
        // wxGetApp().params_dialog()->Popup();
        // wxGetApp().get_tab(Preset::TYPE_FILAMENT)->restore_last_select_item();
        wxGetApp().run_wizard(ConfigWizard::RR_USER, ConfigWizard::SP_FILAMENTS);
        });
    p->m_bpButton_set_filament = set_btn;
 
    bSizer39->Add(set_btn, 0, wxALIGN_CENTER | wxLEFT, FromDIP(SidebarProps::WideSpacing()));
    bSizer39->AddSpacer(FromDIP(SidebarProps::TitlebarMargin()));
 
    // ---- Wrapper panel for collapse/expand of all filament content ----
    p->m_filament_area_wrapper = new wxPanel(p->scrolled, wxID_ANY);
    p->m_filament_area_wrapper->SetBackgroundColour(*wxWHITE);
    auto* wrapper_sizer = new wxBoxSizer(wxVERTICAL);
 
    // add filament content
    p->m_panel_filament_content = new wxScrolledWindow(p->m_filament_area_wrapper, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );
    p->m_panel_filament_content->SetScrollRate(0, FromDIP(20));
    //p->m_panel_filament_content->SetMaxSize(wxSize{-1, FromDIP(174)});
    p->m_panel_filament_content->SetBackgroundColour(wxColour(255, 255, 255));
 
    //wxBoxSizer* bSizer_filament_content;
    //bSizer_filament_content = new wxBoxSizer( wxHORIZONTAL );
 
    // Orca: Sidebar - Filament content UI: setup filament selection combos panel layout
    // Creates a two-column grid layout for filament selection dropdowns within the scrollable panel
    p->sizer_filaments = new wxBoxSizer(wxHORIZONTAL);
    p->sizer_filaments->Add(new wxBoxSizer(wxVERTICAL), 1, wxEXPAND);
    p->sizer_filaments->Add(new wxBoxSizer(wxVERTICAL), 1, wxEXPAND);
 
    p->combos_filament.push_back(nullptr);
 
    /* first filament item */
    init_filament_combo(&p->combos_filament[0], 0);
 
    //bSizer_filament_content->Add(p->sizer_filaments, 1, wxALIGN_CENTER | wxALL);
    wxSizer *sizer_filaments2 = new wxBoxSizer(wxVERTICAL);
    sizer_filaments2->Add(p->sizer_filaments, 0, wxEXPAND, 0);
    p->m_panel_filament_content->SetSizer(sizer_filaments2);
    p->m_panel_filament_content->Layout();
    
    update_filaments_area_height(); // ORCA
 
    wrapper_sizer->Add(p->m_panel_filament_content, 0, wxEXPAND);
 
    // ---- Mixed-color filament section ----
    // A mixed filament is a virtual slot realized from 2-3 physical filaments at slicing time.
    // Everything here stays hidden until at least two physical filaments exist, so a single
    // filament setup looks exactly as before.
    {
    // 1) "+ Add Mixed Filament" button, shown only while no mixed filament exists yet.
    p->m_btn_add_mixed_filament = new wxPanel(p->m_filament_area_wrapper, wxID_ANY);
    p->m_btn_add_mixed_filament->SetBackgroundColour(StateColor::darkModeColorFor(wxColour("#F8F8F8")));
    p->m_btn_add_mixed_filament->SetMinSize(wxSize(-1, FromDIP(23)));
    {
        auto* btn_sizer = new wxBoxSizer(wxHORIZONTAL);
        auto* icon_add  = new ScalableButton(p->m_btn_add_mixed_filament, wxID_ANY, "add_filament", wxEmptyString,
                                             wxDefaultSize, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, false, 16);
        auto* add_label = new wxStaticText(p->m_btn_add_mixed_filament, wxID_ANY, _L("Add Mixed Filament"),
                                           wxDefaultPosition, wxDefaultSize, 0);
        add_label->SetFont(::Label::Body_13);
        btn_sizer->AddStretchSpacer();
        btn_sizer->Add(icon_add, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(4));
        btn_sizer->Add(add_label, 0, wxALIGN_CENTER_VERTICAL);
        btn_sizer->AddStretchSpacer();
        p->m_btn_add_mixed_filament->SetSizer(btn_sizer);
        p->m_btn_add_mixed_filament->SetCursor(wxCursor(wxCURSOR_HAND));
        // Whole panel is the hit target, so forward clicks from the children too.
        auto on_click = [this](wxMouseEvent&) { add_mixed_filament(); };
        p->m_btn_add_mixed_filament->Bind(wxEVT_LEFT_UP, on_click);
        add_label->Bind(wxEVT_LEFT_UP, on_click);
        icon_add->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { add_mixed_filament(); });
    }
    wrapper_sizer->Add(p->m_btn_add_mixed_filament, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP | wxBOTTOM, FromDIP(8));
 
    // 2) Title row with add / remove buttons, shown once a mixed filament exists.
    p->m_panel_mixed_title = new wxPanel(p->m_filament_area_wrapper, wxID_ANY);
    p->m_panel_mixed_title->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    {
        auto* title_sizer = new wxBoxSizer(wxHORIZONTAL);
        p->m_text_mixed_title = new StaticLine(p->m_panel_mixed_title, false, _L("Mixed Filament"));
        p->m_text_mixed_title->SetFont(::Label::Head_14);
        p->m_text_mixed_title->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#363636")));
        title_sizer->Add(p->m_text_mixed_title, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::TitlebarMargin()));
 
        p->m_btn_mixed_del = new ScalableButton(p->m_panel_mixed_title, wxID_ANY, "delete_filament");
        p->m_btn_mixed_del->SetToolTip(_L("Remove last mixed filament"));
        p->m_btn_mixed_del->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
            auto* plater_ptr = dynamic_cast<Plater*>(GetParent());
            if (!plater_ptr) return;
            auto mixed_indices = plater_ptr->mixed_filament_config_indices();
            if (!mixed_indices.empty())
                delete_mixed_filament_at(mixed_indices.size() - 1);
        });
        title_sizer->Add(p->m_btn_mixed_del, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
 
        p->m_btn_mixed_del_all = new ScalableButton(p->m_panel_mixed_title, wxID_ANY, "delete_all_filaments");
        p->m_btn_mixed_del_all->SetToolTip(_L("Remove all mixed filaments"));
        p->m_btn_mixed_del_all->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { remove_all_mixed_filaments(); });
        title_sizer->Add(p->m_btn_mixed_del_all, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
 
        p->m_btn_mixed_add = new ScalableButton(p->m_panel_mixed_title, wxID_ANY, "add_filament");
        p->m_btn_mixed_add->SetToolTip(_L("Add mixed filament"));
        p->m_btn_mixed_add->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { add_mixed_filament(); });
        title_sizer->Add(p->m_btn_mixed_add, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::IconSpacing()));
        title_sizer->AddSpacer(FromDIP(SidebarProps::TitlebarMargin()));
 
        p->m_panel_mixed_title->SetSizer(title_sizer);
    }
    wrapper_sizer->Add(p->m_panel_mixed_title, 0, wxEXPAND | wxTOP | wxBOTTOM, FromDIP(8));
 
    // 3) Mixed filament rows, in their own scroll area so a long mixed list does not
    //    push the physical filament list off screen.
    p->m_mixed_scroll_area = new wxScrolledWindow(p->m_filament_area_wrapper, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    p->m_mixed_scroll_area->SetScrollRate(0, FromDIP(20));
    p->m_mixed_scroll_area->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    {
        auto* mix_scroll_sizer = new wxBoxSizer(wxVERTICAL);
        p->m_panel_mixed_content = new wxPanel(p->m_mixed_scroll_area, wxID_ANY);
        p->m_panel_mixed_content->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
 
        // Two columns, same idiom as sizer_filaments.
        p->m_sizer_mixed_filaments = new wxBoxSizer(wxHORIZONTAL);
        p->m_sizer_mixed_filaments->Add(new wxBoxSizer(wxVERTICAL), 1, wxEXPAND);
        p->m_sizer_mixed_filaments->Add(new wxBoxSizer(wxVERTICAL), 1, wxEXPAND);
 
        auto* sizer_mixed2 = new wxBoxSizer(wxVERTICAL);
        sizer_mixed2->Add(p->m_sizer_mixed_filaments, 0, wxEXPAND, 0);
        p->m_panel_mixed_content->SetSizer(sizer_mixed2);
        mix_scroll_sizer->Add(p->m_panel_mixed_content, 0, wxEXPAND | wxBOTTOM, FromDIP(8));
        p->m_mixed_scroll_area->SetSizer(mix_scroll_sizer);
    }
    p->m_mixed_scroll_area->EnableScrolling(false, true);
    p->m_mixed_scroll_area->ShowScrollbars(wxSHOW_SB_NEVER, wxSHOW_SB_DEFAULT);
    p->m_mixed_scroll_area->Bind(wxEVT_SIZE, [this](wxSizeEvent& e) {
        int w = p->m_mixed_scroll_area->GetClientSize().GetWidth();
        if (w > 0)
            p->m_mixed_scroll_area->SetVirtualSize(w, p->m_mixed_scroll_area->GetVirtualSize().GetHeight());
        e.Skip();
    });
    wrapper_sizer->Add(p->m_mixed_scroll_area, 0, wxEXPAND, 0);
 
    // 4) Warning bar for mixes whose components were deleted or whose types disagree.
    p->m_panel_mixed_warning = new wxPanel(p->m_filament_area_wrapper, wxID_ANY);
    p->m_panel_mixed_warning->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    {
        auto* warn_sizer = new wxBoxSizer(wxHORIZONTAL);
        p->m_text_mixed_warning = new wxStaticText(p->m_panel_mixed_warning, wxID_ANY,
            _L("Mixed filament has invalid or mismatched components. Please re-edit affected entries."));
        p->m_text_mixed_warning->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#D01B1B")));
        p->m_text_mixed_warning->SetFont(::Label::Body_12);
        p->m_text_mixed_warning->Wrap(FromDIP(360));
        warn_sizer->Add(p->m_text_mixed_warning, 1, wxALL, FromDIP(6));
        p->m_panel_mixed_warning->SetSizer(warn_sizer);
    }
    wrapper_sizer->Add(p->m_panel_mixed_warning, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(8));
 
    // Hidden until update_mixed_filament_list() decides otherwise.
    p->m_btn_add_mixed_filament->Hide();
    p->m_panel_mixed_title->Hide();
    p->m_mixed_scroll_area->Hide();
    p->m_panel_mixed_content->Hide();
    p->m_panel_mixed_warning->Hide();
    }
    // ---- End mixed-color filament section ----
 
    p->m_filament_area_wrapper->SetSizer(wrapper_sizer);
    p->m_filament_area_wrapper->Layout();
    scrolled_sizer->Add(p->m_filament_area_wrapper, 0, wxEXPAND | wxTOP | wxBOTTOM, FromDIP(SidebarProps::ContentMarginV())); // ORCA use vertical margin on parent otherwise it shows scrollbar even on 1 filament
    // ---- End filament area ----
    }
 
    {
    //add project title
    auto params_panel = ((MainFrame*)parent->GetParent())->m_param_panel;
    if (params_panel) {
        params_panel->get_top_panel()->Reparent(p->scrolled);
        auto spliter_1 = new ::StaticLine(p->scrolled);
        spliter_1->SetLineColour("#A6A9AA");
        scrolled_sizer->Add(spliter_1, 0, wxEXPAND);
        scrolled_sizer->Add(params_panel->get_top_panel(), 0, wxEXPAND);
        auto spliter_2 = new ::StaticLine(p->scrolled);
        spliter_2->SetLineColour("#CECECE");
        scrolled_sizer->Add(spliter_2, 0, wxEXPAND);
    }
 
    //add project content
    p->sizer_params = new wxBoxSizer(wxVERTICAL);
 
    // ORCA: Update search box to modern style
    p->m_search_bar = new StaticBox(p->scrolled);
    p->m_search_bar->SetCornerRadius(0);
    p->m_search_bar->SetBorderColor(wxColour("#CECECE"));
 
    p->m_search_item = new TextInput(p->m_search_bar, wxEmptyString, wxEmptyString, "", wxDefaultPosition, wxDefaultSize, 0 | wxBORDER_NONE);
    p->m_search_item->SetIcon(*BitmapCache().load_svg("search", FromDIP(16), FromDIP(16))); // ORCA: Add search icon to search box
 
    wxTextCtrl* text_ctrl = p->m_search_item->GetTextCtrl();
    text_ctrl->SetHint(_L("Search plate, object and part."));
    text_ctrl->SetForegroundColour(wxColour("#262E30"));
    text_ctrl->SetFont(Label::Body_13);
    text_ctrl->SetSize(wxSize(-1, FromDIP(16))); // Centers text vertically
 
    text_ctrl->Bind(wxEVT_SET_FOCUS, [this](wxFocusEvent& e) {
        if (p->dia->IsShown()) {
            e.Skip();
            return;
        }
        p->m_search_bar->SetBorderColor(wxColour("#009688"));
        wxPoint pos = this->p->m_search_bar->ClientToScreen(wxPoint(0, 0));
#ifndef __WXGTK__
        pos.y += this->p->m_search_bar->GetRect().height;
#else
        this->p->m_search_item->Enable(false);
#endif
        p->dia->SetPosition(pos);
        p->dia->Popup();
        e.Skip(); // required to show caret
    });
 
    auto search_sizer = new wxBoxSizer(wxHORIZONTAL);
    search_sizer->Add(new wxWindow(p->m_search_bar, wxID_ANY, wxDefaultPosition, wxSize(0, 0)), 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(1));
    search_sizer->Add(p->m_search_item, 1, wxEXPAND | wxALL, FromDIP(2));
    p->m_search_bar->SetSizer(search_sizer);
    p->m_search_bar->Layout();
    search_sizer->Fit(p->m_search_bar);
 
    p->m_object_list = new ObjectList(p->scrolled);
    p->m_object_list->SetBackgroundColour(*wxWHITE);
    p->m_object_list->Bind(wxCUSTOMEVT_EXIT_SEARCH, [this](wxCommandEvent&) {
#ifdef __WXGTK__
        this->p->m_search_item->Enable(true);
#endif
        this->p->m_search_bar->SetBorderColor(wxColour("#CECECE"));
        this->p->m_search_item->GetTextCtrl()->SetValue(""); // reset value when close
    });
 
    p->sizer_params->Add(p->m_search_bar, 0, wxALL | wxEXPAND, 0);
    p->sizer_params->Add(p->m_object_list, 1, wxEXPAND | wxTOP, 0);
    scrolled_sizer->Add(p->sizer_params, 2, wxEXPAND | wxLEFT, 0);
    p->m_object_list->Hide();
    p->m_search_bar->Hide();
    // Frequently Object Settings
    p->object_settings = new ObjectSettings(p->scrolled);
 
    p->dia = new Search::SearchObjectDialog(p->m_object_list, p->scrolled->GetParent(), p->m_search_item);
#if !NEW_OBJECT_SETTING
    p->object_settings->Hide();
    p->sizer_params->Add(p->object_settings->get_sizer(), 0, wxEXPAND | wxTOP, 5 * em / 10);
#else
    if (params_panel) {
        params_panel->Reparent(p->scrolled);
        scrolled_sizer->Add(params_panel, 3, wxEXPAND);
    }
#endif
    }
 
    p->object_layers = new ObjectLayers(p->scrolled);
    p->object_layers->Hide();
    p->sizer_params->Add(p->object_layers->get_sizer(), 0, wxEXPAND | wxTOP, 0);
 
    auto *sizer = new wxBoxSizer(wxVERTICAL);
    sizer->Add(p->scrolled, 1, wxEXPAND);
    SetSizer(sizer);
}

References _L, add_filament(), add_mixed_filament(), ams_btn, ScalableBitmap::bmp(), Label::Body_10, Label::Body_12, Label::Body_13, Compact, Confirm, Slic3r::GUI::SidebarProps::ContentMarginV(), create_scaled_bitmap(), StateColor::darkModeColorFor(), deal_btn_sync(), delete_filament(), delete_mixed_filament_at(), Slic3r::GUI::dynamic_filament_list, Slic3r::GUI::dynamic_physical_filament_list, Slic3r::GUI::SidebarProps::ElementSpacing(), em_unit(), Slic3r::GUI::FastMode, Slic3r::AppConfig::get(), get_cur_select_bed_image(), Slic3r::GUI::PurgeModeDialog::get_selected_mode(), Label::Head_14, Slic3r::GUI::SidebarProps::IconSpacing(), init_filament_combo(), is_flush_config_modified(), LB_PROPAGATE_MOUSE_EVENT, Slic3r::load_svg(), m_scrolled_sizer, Slic3r::GUI::manuallySetNozzleCount(), Slic3r::GUI::Plater::mixed_filament_config_indices(), Slic3r::GUI::MultiNozzle, Slic3r::GUI::ObjectList, on_enter_image_printer_bed(), on_leave_image_printer_bed(), open_flushing_dialog(), p, PRINTER_PANEL_RADIUS, PRINTER_PANEL_SIZE, PRINTER_THUMBNAIL_SIZE, Slic3r::GUI::Choice::register_dynamic_list(), remove_all_mixed_filaments(), reset_bed_type_combox_choices(), Slic3r::GUI::ConfigWizard::RR_USER, Slic3r::AppConfig::set(), set_flushing_volume_warning(), Slic3r::GUI::DPIAware::ShowModal(), Slic3r::GUI::ConfigWizard::SP_FILAMENTS, Slic3r::GUI::ConfigWizard::SP_PRINTERS, sync_ams_list(), Slic3r::GUI::SidebarProps::TitlebarMargin(), Slic3r::Preset::TYPE_PRINTER, update_filaments_area_height(), update_filaments_counter(), update_sync_ams_btn_enable(), Slic3r::ConfigOptionSingle< T >::value, Slic3r::GUI::SidebarProps::WideSpacing(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Referenced by Sidebar(), Sidebar(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Sidebar() [2/3]

Slic3r::GUI::Sidebar::Sidebar ( Sidebar && )

delete

References Sidebar().

Here is the call graph for this function:

◆ Sidebar() [3/3]

Slic3r::GUI::Sidebar::Sidebar ( const Sidebar & )

delete

References Sidebar().

Here is the call graph for this function:

◆ ~Sidebar()

Slic3r::GUI::Sidebar::~Sidebar ( )

3644{}

Member Function Documentation

◆ add_custom_filament()

void Slic3r::GUI::Sidebar::add_custom_filament	(	wxColour	new_col,
		const std::string &	preset_name = std::string(),
		bool	skip_preset_validation = false )

                                                                                        {
    if (is_new_project_in_gcode3mf()) { return; }
    if (p->combos_filament.size() >= MAXIMUM_EXTRUDER_NUMBER) return;
    if (wxGetApp().preset_bundle->filament_presets.size() >= MAXIMUM_EXTRUDER_NUMBER) return;
 
    // Mixed-color slots are kept at the tail of the filament arrays, so a new physical
    // filament has to be inserted just after the last physical one rather than appended.
    // Count actual colour slots, not filament_presets or the combos: the extruder-count spinner
    // reaches this before the sidebar has rebuilt, and update_multi_material_filament_presets()
    // can have grown filament_presets alone.
    auto       *bundle         = wxGetApp().preset_bundle;
    size_t      insert_pos     = bundle->num_physical_filaments();
    size_t      total          = insert_pos + bundle->num_mixed_filaments();
    int         filament_count = (int)(total + 1);
    std::string new_color      = new_col.GetAsString(wxC2S_HTML_SYNTAX).ToStdString();
    bundle->set_num_filaments(filament_count, new_color);
 
    // Maintain physical-first ordering: rotate the new slot from end to insert_pos.
    // No mixed slots -> insert_pos == total -> every rotate below is a no-op.
    if (insert_pos < total) {
        auto& presets = wxGetApp().preset_bundle->filament_presets;
        std::rotate(presets.begin() + insert_pos, presets.begin() + total, presets.end());
 
        auto& project_config = wxGetApp().preset_bundle->project_config;
        auto& ams_mc = wxGetApp().preset_bundle->ams_multi_color_filment;
 
        auto rotate_strings = [&](const char* key) {
            if (auto* opt = project_config.option<ConfigOptionStrings>(key))
                if (opt->values.size() > total)
                    std::rotate(opt->values.begin() + insert_pos, opt->values.begin() + total, opt->values.end());
        };
        auto rotate_ints = [&](const char* key) {
            if (auto* opt = project_config.option<ConfigOptionInts>(key))
                if (opt->values.size() > total)
                    std::rotate(opt->values.begin() + insert_pos, opt->values.begin() + total, opt->values.end());
        };
        auto rotate_bools = [&](const char* key) {
            if (auto* opt = project_config.option<ConfigOptionBools>(key))
                if (opt->values.size() > total)
                    std::rotate(opt->values.begin() + insert_pos, opt->values.begin() + total, opt->values.end());
        };
 
        rotate_strings("filament_colour");
        rotate_strings("filament_multi_colour");
        rotate_strings("filament_colour_type");
        rotate_ints("filament_map");
        rotate_ints("filament_nozzle_map");
        rotate_ints("filament_volume_map");
        rotate_bools("filament_is_mixed");
        rotate_strings("filament_mixed_components");
        rotate_strings("filament_mixed_sublayer_ratios");
        rotate_bools("filament_mixed_gradient");
        rotate_strings("filament_mixed_gradient_range");
        rotate_strings("filament_mixed_gradient_curve");
        rotate_bools("filament_mixed_gradient_per_part");
 
        if (ams_mc.size() > total)
            std::rotate(ams_mc.begin() + insert_pos, ams_mc.begin() + total, ams_mc.end());
 
        // Remap object/volume extruder IDs and paint data: anything >= insert_pos+1 (1-based) shifts up by 1
        int threshold_1based = (int)(insert_pos + 1);
        auto ebt_threshold = EnforcerBlockerType(threshold_1based);
        for (auto* obj : wxGetApp().plater()->model().objects) {
            if (obj->config.has("extruder")) {
                int ext = obj->config.extruder();
                if (ext >= threshold_1based)
                    obj->config.set("extruder", ext + 1);
            }
            for (auto* vol : obj->volumes) {
                if (vol->config.has("extruder")) {
                    int ext = vol->config.extruder();
                    if (ext >= threshold_1based)
                        vol->config.set("extruder", ext + 1);
                }
                vol->mmu_segmentation_facets.shift_states_above(*vol, ebt_threshold, +1);
            }
        }
    }
 
    if (!preset_name.empty() &&
        wxGetApp().preset_bundle->filaments.find_preset(preset_name, false) &&
        insert_pos < wxGetApp().preset_bundle->filament_presets.size()) {
        wxGetApp().preset_bundle->filament_presets[insert_pos] = preset_name;
    }
 
    wxGetApp().plater()->get_partplate_list().on_filament_added(filament_count);
    wxGetApp().plater()->on_filament_count_change(filament_count);
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
    auto_calc_flushing_volumes(insert_pos);
}

References auto_calc_flushing_volumes(), is_new_project_in_gcode3mf(), MAXIMUM_EXTRUDER_NUMBER, p, Slic3r::GUI::plater(), and Slic3r::Preset::TYPE_PRINT.

Referenced by add_filament(), decompose_filament_color(), and Slic3r::GUI::Tab::on_value_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_filament()

void Slic3r::GUI::Sidebar::add_filament ( )

                           {
    if (p->combos_filament.size() >= MAXIMUM_EXTRUDER_NUMBER) return;
    wxColour    new_col        = Plater::get_next_color_for_filament();
    add_custom_filament(new_col);
 
    auto filament_list = p->m_panel_filament_content;
    if(!filament_list->IsShown()){
        filament_list->Show(); // ORCA show list if its folded
        m_scrolled_sizer->Layout();
    }
    filament_list->Scroll(-1, INT_MAX); // ORCA scroll to end of list on changes to inform user about filament count
}

References add_custom_filament(), Slic3r::GUI::Plater::get_next_color_for_filament(), m_scrolled_sizer, MAXIMUM_EXTRUDER_NUMBER, and p.

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_mixed_filament()

void Slic3r::GUI::Sidebar::add_mixed_filament ( )

{
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return;
 
    size_t num_physical = p->combos_filament.size();
    if (num_physical < 2) return;
    if (wxGetApp().preset_bundle->filament_presets.size() >= size_t(EnforcerBlockerType::ExtruderMax)) return;
 
    std::vector<std::string> color_strs, names, types;
    collect_physical_filament_info(color_strs, names, types);
 
    MixedFilamentDialog dlg(this, color_strs, names, types);
    if (dlg.ShowModal() == wxID_OK) {
        auto result = dlg.get_result();
        create_mixed_filament_from_result(this, result, color_strs);
    }
}

References collect_physical_filament_info(), Slic3r::GUI::create_mixed_filament_from_result(), Slic3r::ExtruderMax, Slic3r::GUI::MixedFilamentDialog::get_result(), p, Slic3r::GUI::plater(), and Slic3r::GUI::DPIAware::ShowModal().

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ auto_calc_flushing_volumes()

void Slic3r::GUI::Sidebar::auto_calc_flushing_volumes	(	const int	filament_idx = -1,
		const int	extruder_id = -1 )

Automatically calculates flushing volumes.

Parameters

filament_idx	Specifies the filament index to calculate. -1 indicates all filament indices.
extruder_id	Specifies the extruder id to calculate. -1 indicates all extruders indices.

                                                                                      {
 
    std::vector<int> filament_indices;
    std::vector<int> extruder_indices;
 
    auto& preset_bundle = wxGetApp().preset_bundle;
    auto filament_ptr = preset_bundle->project_config.option<ConfigOptionStrings>("filament_colour");
    int filament_count = filament_ptr ? filament_ptr->size() : 0;
    int extruder_count = preset_bundle->get_printer_extruder_count();
 
    if (filament_idx < 0) {
        filament_indices.resize(filament_count);
        std::iota(filament_indices.begin(), filament_indices.end(), 0);
    }
    else {
        filament_indices.emplace_back(filament_idx);
    }
 
    if (extruder_id < 0) {
        extruder_indices.resize(extruder_count);
        std::iota(extruder_indices.begin(), extruder_indices.end(), 0);
    }
    else {
        extruder_indices.emplace_back(extruder_id);
    }
 
    for (auto eidx : extruder_indices) {
        for (auto fidx : filament_indices) {
            auto_calc_flushing_volumes_internal(fidx, eidx);
        }
    }
 
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
    wxGetApp().plater()->update_project_dirty_from_presets();
    wxPostEvent(this, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, this));
    auto has_modify = is_flush_config_modified();
    set_flushing_volume_warning(has_modify);
    p->plater->update();
}

References auto_calc_flushing_volumes_internal(), is_flush_config_modified(), p, set_flushing_volume_warning(), and Slic3r::ConfigOptionVector< T >::size().

Referenced by add_custom_filament(), Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), and sync_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ auto_calc_flushing_volumes_internal()

void Slic3r::GUI::Sidebar::auto_calc_flushing_volumes_internal	(	const int	filament_id,
		const int	extruder_id )

private

{
    auto& preset_bundle = wxGetApp().preset_bundle;
    // A mixed-colour slot is virtual and is never flushed to or from: leave its row and column
    // alone (the flushing dialog hides them and only compares physical slots).
    if (modify_id >= 0 && preset_bundle->is_mixed_filament((size_t)modify_id))
        return;
    auto& project_config = preset_bundle->project_config;
    const auto& full_config = wxGetApp().preset_bundle->full_config();
    auto& ams_multi_color_filament = preset_bundle->ams_multi_color_filment;
    size_t extruder_nums = preset_bundle->get_printer_extruder_count();
    int nozzle_flush_dataset = full_config.option<ConfigOptionIntsNullable>("nozzle_flush_dataset")->values[extruder_id];
    std::vector<double> init_matrix = get_flush_volumes_matrix((project_config.option<ConfigOptionFloats>("flush_volumes_matrix"))->values, extruder_id, extruder_nums);
 
    const std::vector<int>& min_flush_volumes = get_min_flush_volumes(full_config, extruder_id);
 
    const auto* flush_multi_opt = project_config.option<ConfigOptionFloats>("flush_multiplier");
    float flush_multiplier = flush_multi_opt ? (float)flush_multi_opt->get_at(extruder_id) : 1.f;
    std::vector<double> matrix = init_matrix;
    int m_max_flush_volume = Slic3r::g_max_flush_volume;
    unsigned int m_number_of_extruders = (int)(sqrt(init_matrix.size()) + 0.001);
 
    const std::vector<std::string> extruder_colours = wxGetApp().plater()->get_extruder_colors_from_plater_config();
    std::vector<std::vector<wxColour>> multi_colours;
 
    // Support for multi-color filament
    for (int i = 0; i < extruder_colours.size(); ++i) {
        std::vector<wxColour> single_filament;
        if (i < ams_multi_color_filament.size()) {
            if (!ams_multi_color_filament[i].empty()) {
                std::vector<std::string> colors = ams_multi_color_filament[i];
                for (int j = 0; j < colors.size(); ++j) {
                    single_filament.push_back(wxColour(colors[j]));
                }
                multi_colours.push_back(single_filament);
                continue;
            }
        }
 
        single_filament.push_back(wxColour(extruder_colours[i]));
        multi_colours.push_back(single_filament);
    }
 
    if (modify_id >= 0 && modify_id < multi_colours.size()) {
        for (int i = 0; i < multi_colours.size(); ++i) {
            if (preset_bundle->is_mixed_filament((size_t)i))
                continue;
            // from to modify
            int from_idx = i;
            if (from_idx != modify_id) {
                Slic3r::FlushVolCalculator calculator(min_flush_volumes[from_idx], m_max_flush_volume, nozzle_flush_dataset);
                int flushing_volume = 0;
                bool is_from_support = is_support_filament(from_idx);
                bool is_to_support = is_support_filament(modify_id);
                if (is_to_support) {
                    flushing_volume = Slic3r::g_flush_volume_to_support;
                }
                else {
                    for (int j = 0; j < multi_colours[from_idx].size(); ++j) {
                        const wxColour& from = multi_colours[from_idx][j];
                        for (int k = 0; k < multi_colours[modify_id].size(); ++k) {
                            const wxColour& to = multi_colours[modify_id][k];
                            int volume = calculator.calc_flush_vol(from.Alpha(), from.Red(), from.Green(), from.Blue(), to.Alpha(), to.Red(), to.Green(), to.Blue());
                            flushing_volume = std::max(flushing_volume, volume);
                        }
                    }
                    if (is_from_support)
                        flushing_volume = std::max(flushing_volume, Slic3r::g_min_flush_volume_from_support);
                }
                matrix[m_number_of_extruders * from_idx + modify_id] = flushing_volume;
            }
 
            // modify to to
            int to_idx = i;
            if (to_idx != modify_id) {
                Slic3r::FlushVolCalculator calculator(min_flush_volumes[modify_id], m_max_flush_volume, nozzle_flush_dataset);
                bool is_from_support = is_support_filament(modify_id);
                bool is_to_support = is_support_filament(to_idx);
                int flushing_volume = 0;
                if (is_to_support) {
                    flushing_volume = Slic3r::g_flush_volume_to_support;
                }
                else {
                    for (int j = 0; j < multi_colours[modify_id].size(); ++j) {
                        const wxColour& from = multi_colours[modify_id][j];
                        for (int k = 0; k < multi_colours[to_idx].size(); ++k) {
                            const wxColour& to = multi_colours[to_idx][k];
                            int volume = calculator.calc_flush_vol(from.Alpha(), from.Red(), from.Green(), from.Blue(), to.Alpha(), to.Red(), to.Green(), to.Blue());
                            flushing_volume = std::max(flushing_volume, volume);
                        }
                    }
                    if (is_from_support)
                        flushing_volume = std::max(flushing_volume, Slic3r::g_min_flush_volume_from_support);
 
                    matrix[m_number_of_extruders * modify_id + to_idx] = flushing_volume;
                }
            }
        }
    }
    set_flush_volumes_matrix((project_config.option<ConfigOptionFloats>("flush_volumes_matrix"))->values, matrix, extruder_id, extruder_nums);
}

References Slic3r::FlushVolCalculator::calc_flush_vol(), Slic3r::empty(), Slic3r::flush_multiplier(), Slic3r::g_flush_volume_to_support, Slic3r::g_max_flush_volume, Slic3r::g_min_flush_volume_from_support, Slic3r::get_flush_volumes_matrix(), Slic3r::GUI::get_min_flush_volumes(), Slic3r::GUI::is_support_filament(), and Slic3r::set_flush_volumes_matrix().

Referenced by auto_calc_flushing_volumes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_filament_ams_list()

std::map< int, DynamicPrintConfig > Slic3r::GUI::Sidebar::build_filament_ams_list ( MachineObject * obj )

Build a map of filament configurations from the connected printer's AMS (Automatic Material System).

Data Flow Architecture:

This function reads pre-populated state from MachineObject - it does NOT directly call NetworkAgent APIs. The data pipeline is:

Printer Device (MQTT/LAN messages) ↓ NetworkAgent (receives JSON, triggers OnMessageFn callbacks) ↓ MachineObject::parse_json() (updates device state) ├── vt_slot (std::vector<DevAmsTray>) - virtual tray data for external filament └── DevFilaSystem → DevAms → DevAmsTray - AMS unit hierarchy ↓ build_filament_ams_list() [THIS FUNCTION] - aggregates into DynamicPrintConfig maps

Data Sources:

obj->vt_slot: Virtual trays for external/manual filament loading (when ams_support_virtual_tray is true)
obj->GetFilaSystem()->GetAmsList(): Map of AMS units, each containing multiple DevAmsTray slots

Return Value:

Map key encoding:
- Virtual trays: 0x10000 + vt_tray.id (first/main extruder), or just vt_tray.id (secondary)
- AMS trays: 0x10000 + (ams_id * 4 + slot_id) (main extruder), or (ams_id * 4 + slot_id) (secondary)
- The 0x10000 flag indicates the main/right extruder
Map value: DynamicPrintConfig with filament properties (id, type, color, etc.)

Parameters

obj	The MachineObject representing the connected printer (nullable)

Returns: Map of tray indices to filament configurations

{
    std::map<int, DynamicPrintConfig> filament_ams_list;
    if (!obj) return filament_ams_list;
 
    // For pull-mode agents (e.g., HTTP REST API), refresh DevFilaSystem first
    auto* agent = wxGetApp().getDeviceManager()->get_agent();
    if (agent && agent->get_filament_sync_mode() == FilamentSyncMode::pull) {
        if (!agent->fetch_filament_info(obj->get_dev_id())) {
            return filament_ams_list;
        }
    }
 
    auto build_tray_config = [](DevAmsTray const &tray, std::string const &name, std::string ams_id, std::string slot_id) {
        BOOST_LOG_TRIVIAL(info) << boost::format("build_filament_ams_list: name %1% setting_id %2% type %3% color %4%")
                    % name % tray.setting_id % tray.m_fila_type % tray.color;
        DynamicPrintConfig tray_config;
        tray_config.set_key_value("filament_id", new ConfigOptionStrings{tray.setting_id});
        tray_config.set_key_value("tag_uid", new ConfigOptionStrings{tray.tag_uid});
        tray_config.set_key_value("ams_id", new ConfigOptionStrings{ams_id});
        tray_config.set_key_value("slot_id", new ConfigOptionStrings{slot_id});
        tray_config.set_key_value("filament_type", new ConfigOptionStrings{tray.m_fila_type});
        tray_config.set_key_value("tray_name", new ConfigOptionStrings{ name });
        tray_config.set_key_value("filament_colour", new ConfigOptionStrings{into_u8(wxColour("#" + tray.color).GetAsString(wxC2S_HTML_SYNTAX))});
        tray_config.set_key_value("filament_multi_colour", new ConfigOptionStrings{});
        tray_config.set_key_value("filament_colour_type", new ConfigOptionStrings{std::to_string(tray.ctype)});
        tray_config.set_key_value("filament_exist", new ConfigOptionBools{tray.is_exists});
        tray_config.set_key_value("filament_slot_placeholder", new ConfigOptionBools{tray.is_slot_placeholder});
        std::optional<FilamentBaseInfo> info;
        if (wxGetApp().preset_bundle) {
            info = wxGetApp().preset_bundle->get_filament_by_filament_id(tray.setting_id);
        }
        tray_config.set_key_value("filament_is_support", new ConfigOptionBools{ info.has_value() ? info->is_support : false});
        for (int i = 0; i < tray.cols.size(); ++i) {
            tray_config.opt<ConfigOptionStrings>("filament_multi_colour")->values.push_back(into_u8(wxColour("#" + tray.cols[i]).GetAsString(wxC2S_HTML_SYNTAX)));
        }
        return tray_config;
    };
 
    if (obj->ams_support_virtual_tray) {
        int extruder = 0x10000; // Main (first) extruder at right
        for (auto & vt_tray : obj->vt_slot) {
            filament_ams_list.emplace(extruder + stoi(vt_tray.id), build_tray_config(vt_tray, "Ext",vt_tray.id, "0"));//254 or 255
            extruder = 0;
        }
    }
 
    auto get_ams_name = [](int ams_id, int slot_id)->std::string {
        if (ams_id >= 0 && ams_id < 26) {
            char slot_name = slot_id + '1';
            return std::string(1, 'A' + ams_id) + std::string(1, slot_name);
        } else if (ams_id >= 128 && ams_id < 153) {
            return "HT-" + std::string(1, 'A' + (ams_id - 128));
        } else {
            assert(false);
        }
        return std::string();
    };
 
    auto list = obj->GetFilaSystem()->GetAmsList();
    for (auto ams : list) {
        int ams_id   = std::stoi(ams.first);
        int extruder = ams.second->GetExtruderId() ? 0 : 0x10000; // Main (first) extruder at right
        for (auto tray : ams.second->GetTrays()) {
            int  slot_id = std::stoi(tray.first);
            filament_ams_list.emplace(extruder + (ams_id * 4 + slot_id),
                                      build_tray_config(*tray.second, get_ams_name(ams_id, slot_id), std::to_string(ams_id), std::to_string(slot_id)));
        }
    }
    return filament_ams_list;
}

Referenced by load_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_search()

void Slic3r::GUI::Sidebar::can_search ( )

{
    p->can_search();
}

References p.

◆ change_filament()

void Slic3r::GUI::Sidebar::change_filament	(	size_t	from_id,
		size_t	to_id )

{
    // Merging a physical filament into a mixed one that lists it as a component would delete
    // the very filament the mix depends on, leaving it broken. Warn before doing so.
    auto& pb = *wxGetApp().preset_bundle;
    bool from_is_physical = !pb.is_mixed_filament(from_id);
    bool to_is_mixed = pb.is_mixed_filament(to_id);
 
    if (from_is_physical && to_is_mixed) {
        auto* comp_opt = pb.project_config.option<ConfigOptionStrings>("filament_mixed_components");
        if (comp_opt && to_id < comp_opt->values.size()) {
            auto comps = Slic3r::parse_mixed_components(comp_opt->values[to_id]);
            unsigned int from_1based = (unsigned int)from_id + 1;
            bool target_uses_source = false;
            for (unsigned int c : comps) {
                if (c == from_1based) {
                    target_uses_source = true;
                    break;
                }
            }
            if (target_uses_source) {
                int ret = wxMessageBox(
                    _L("The target mixed filament uses this physical filament as a component. "
                       "Merging will remove this physical filament and may invalidate the mixed filament. Continue?"),
                    _L("Warning"),
                    wxOK | wxCANCEL | wxICON_WARNING);
                if (ret != wxOK)
                    return;
            }
        }
    }
 
    delete_filament(from_id, int(to_id));
}

References _L, delete_filament(), and Slic3r::parse_mixed_components().

Referenced by sync_ams_list(), and update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_top_border_for_mode_sizer()

void Slic3r::GUI::Sidebar::change_top_border_for_mode_sizer ( bool increase_border )

{
    // BBS
#if 0
    if (p->mode_sizer) {
        p->mode_sizer->set_items_flag(increase_border ? wxTOP : 0);
        p->mode_sizer->set_items_border(increase_border ? int(0.5 * wxGetApp().em_unit()) : 0);
    }
#endif
}

References em_unit(), and p.

Here is the call graph for this function:

◆ clear_combos_filament_badge()

void Slic3r::GUI::Sidebar::clear_combos_filament_badge ( )

{
    auto &combos_filament = p->combos_filament;
    for (auto &c : combos_filament) { // clear flag
        c->set_sync_badge(false);
    }
}

References combos_filament(), and p.

Referenced by sync_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collapse()

void Slic3r::GUI::Sidebar::collapse ( bool collapse )

6854{ p->plater->collapse_sidebar(collapse); }

Slic3r::GUI::Sidebar::collapse

void collapse(bool collapse)

Definition Plater.cpp:6854

References collapse(), and p.

Referenced by collapse(), and get_eject_shown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_physical_filament_info()

void Slic3r::GUI::Sidebar::collect_physical_filament_info	(	std::vector< std::string > &	color_strs,
		std::vector< std::string > &	names,
		std::vector< std::string > &	types,
		std::vector< size_t > *	config_indices = nullptr )

{
    color_strs.clear();
    names.clear();
    types.clear();
    if (config_indices)
        config_indices->clear();
 
    size_t num_physical = p->combos_filament.size();
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
    std::vector<size_t> physical_indices;
    const size_t total = wxGetApp().preset_bundle->filament_presets.size();
    physical_indices.reserve(num_physical);
    for (size_t i = 0; i < total && physical_indices.size() < num_physical; ++i) {
        if (!is_mixed_opt || i >= is_mixed_opt->values.size() || !is_mixed_opt->values[i])
            physical_indices.push_back(i);
    }
    while (physical_indices.size() < num_physical)
        physical_indices.push_back(physical_indices.size());
    if (config_indices)
        *config_indices = physical_indices;
 
    auto* colours_opt = project_config.option<ConfigOptionStrings>("filament_colour");
    if (colours_opt) {
        for (size_t i = 0; i < num_physical; ++i) {
            const size_t cfg_idx = physical_indices[i];
            if (cfg_idx < colours_opt->values.size())
                color_strs.push_back(colours_opt->values[cfg_idx]);
        }
    }
 
    for (size_t i = 0; i < num_physical; ++i) {
        auto* combo = p->combos_filament[i];
        names.push_back(into_u8(combo ? combo->GetValue() : wxString::Format(_L("Filament %d"), int(i + 1))));
    }
 
    auto& preset_bundle = *wxGetApp().preset_bundle;
    for (size_t i = 0; i < num_physical; ++i) {
        const size_t cfg_idx = physical_indices[i];
        Preset* preset = nullptr;
        if (cfg_idx < preset_bundle.filament_presets.size())
            preset = preset_bundle.filaments.find_preset(preset_bundle.filament_presets[cfg_idx]);
        std::string ft;
        if (preset) {
            std::string display_type;
            ft = preset->config.get_filament_type(display_type);
        }
        if (ft.empty()) ft = "PLA";
        types.push_back(ft);
    }
}

References _L, Slic3r::Preset::config, Slic3r::DynamicPrintConfig::get_filament_type(), Slic3r::GUI::into_u8(), and p.

Referenced by add_mixed_filament(), decompose_filament_color(), edit_mixed_filament(), and ensure_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ combos_filament()

std::vector< PlaterPresetComboBox * > & Slic3r::GUI::Sidebar::combos_filament ( )

{
    return p->combos_filament;
}

References p.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), clear_combos_filament_badge(), Slic3r::GUI::create_mixed_filament_from_result(), on_filament_count_change(), on_filaments_delete(), sync_ams_list(), and udpate_combos_filament_badge().

Here is the caller graph for this function:

◆ create_printer_preset()

void Slic3r::GUI::Sidebar::create_printer_preset ( )

{
    CreatePrinterPresetDialog dlg(wxGetApp().mainframe);
    int                       res = dlg.ShowModal();
    if (wxID_OK == res) {
        wxGetApp().load_current_presets();
        wxGetApp().mainframe->update_side_preset_ui();
        update_ui_from_settings();
        update_all_preset_comboboxes();
        CreatePresetSuccessfulDialog success_dlg(wxGetApp().mainframe, SuccessType::PRINTER);
        int                          res = success_dlg.ShowModal();
        if (res == wxID_OK) {
            p->editing_filament = -1;
            if (p->combo_printer->switch_to_tab()) p->editing_filament = 0;
        }
    }
}

References p, Slic3r::GUI::PRINTER, Slic3r::GUI::DPIAware::ShowModal(), update_all_preset_comboboxes(), and update_ui_from_settings().

Here is the call graph for this function:

◆ deal_btn_sync()

void Slic3r::GUI::Sidebar::deal_btn_sync ( )

                            {
    m_begin_sync_printer_status = true;
    bool only_external_material;
    // Manual "sync machine" button: is_manual=true so an H2C pops the MultiNozzleSyncDialog to pick a nozzle option.
    auto ok = p->sync_extruder_list(only_external_material, true);
    if (ok) {
        pop_sync_nozzle_and_ams_dialog();
    }
    m_begin_sync_printer_status = false;
    wxGetApp().plater()->update_machine_sync_status();
}

References m_begin_sync_printer_status, p, and pop_sync_nozzle_and_ams_dialog().

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decompose_filament_color()

void Slic3r::GUI::Sidebar::decompose_filament_color ( int filament_idx )

{
    if (filament_idx == kSidebarContextMenuFilamentId)
        filament_idx = p->m_menu_filament_id;
    if (filament_idx < 0)
        return;
 
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* colours_opt = project_config.option<ConfigOptionStrings>("filament_colour");
    if (!colours_opt || static_cast<size_t>(filament_idx) >= colours_opt->values.size())
        return;
 
    wxColour target_color(colours_opt->values[filament_idx]);
 
    std::vector<std::string> color_strs, names, types;
    std::vector<size_t> physical_config_indices;
    collect_physical_filament_info(color_strs, names, types, &physical_config_indices);
 
    // Build decompose-specific types: ColorDecomposeDialog needs "PLA Basic"
    // distinction (for CMYW/RYBW card visibility), while collect_physical_filament_info
    // now returns coarse filament_type (e.g. "PLA" for all PLA variants).
    std::vector<std::string> decompose_types;
    {
        auto& pb = *wxGetApp().preset_bundle;
        for (size_t i = 0; i < physical_config_indices.size(); ++i) {
            const size_t ci = physical_config_indices[i];
            Preset* pr = (ci < pb.filament_presets.size())
                ? pb.filaments.find_preset(pb.filament_presets[ci]) : nullptr;
            decompose_types.push_back(filament_type_for_color_decompose(pr));
        }
    }
 
    size_t source_physical_idx = size_t(-1);
    for (size_t i = 0; i < physical_config_indices.size(); ++i) {
        if (physical_config_indices[i] == static_cast<size_t>(filament_idx)) {
            source_physical_idx = i;
            break;
        }
    }
 
    ColorDecomposeDialog dlg(this,
                             source_physical_idx == size_t(-1) ? -1 : static_cast<int>(source_physical_idx),
                             target_color, color_strs, names, decompose_types,
                             wxGetApp().preset_bundle->filament_presets.size(),
                             static_cast<size_t>(EnforcerBlockerType::ExtruderMax),
                             physical_config_indices);
    int modal_res = dlg.ShowModal();
    if (modal_res == wxID_OK) {
        ColorDecomposeResult dialog_result = dlg.get_result();
        MixedFilamentResult mixed_result;
        std::vector<DecomposeMissingComponent> missing_components;
        if (!prepare_decompose_mixed_result(dialog_result, static_cast<size_t>(filament_idx), source_physical_idx,
                                            color_strs, decompose_types, physical_config_indices, mixed_result, missing_components))
            return;
 
        if (!confirm_create_decompose_missing_components(this, missing_components))
            return;
 
        for (const DecomposeMissingComponent& missing : missing_components) {
            size_t before_count = p->combos_filament.size();
            add_custom_filament(wxColour(missing.official_component.color_hex), missing.preset_name, true);
            size_t after_count = p->combos_filament.size();
            if (after_count <= before_count)
                return;
            set_created_standard_component_metadata(before_count, missing.official_component);
            if (missing.component_idx < mixed_result.components.size())
                mixed_result.components[missing.component_idx] = static_cast<unsigned int>(before_count + 1);
        }
 
        if (!missing_components.empty()) {
            collect_physical_filament_info(color_strs, names, types, &physical_config_indices);
        }
 
        create_mixed_filament_from_result(this, mixed_result, color_strs);
    }
}

References add_custom_filament(), collect_physical_filament_info(), Slic3r::GUI::MixedFilamentResult::components, Slic3r::GUI::confirm_create_decompose_missing_components(), Slic3r::GUI::create_mixed_filament_from_result(), Slic3r::ExtruderMax, Slic3r::GUI::filament_type_for_color_decompose(), Slic3r::GUI::ColorDecomposeDialog::get_result(), Slic3r::GUI::kSidebarContextMenuFilamentId, p, Slic3r::GUI::prepare_decompose_mixed_result(), Slic3r::GUI::set_created_standard_component_metadata(), and Slic3r::GUI::DPIAware::ShowModal().

Here is the call graph for this function:

◆ delete_filament()

void Slic3r::GUI::Sidebar::delete_filament	(	size_t	filament_id = size_t(-1),
		int	replace_filament_id = -1 )

                                                                         {
    if (is_new_project_in_gcode3mf()) { return; }
    if (p->combos_filament.size() <= 1) return;
 
    size_t filament_count = p->combos_filament.size() - 1;
    if (filament_id == size_t(-2)) {
        filament_id = p->m_menu_filament_id;
    }
    if (filament_id == size_t(-1)) {
        filament_id = filament_count;
    }
 
    // Mixed (virtual) slots have no combo of their own, so their config index lies past
    // filament_count; bound explicit ids by the total slot count instead.
    size_t total_filaments = wxGetApp().preset_bundle->filament_presets.size();
    if (filament_id > filament_count && filament_id >= total_filaments)
        return;
 
    bool is_mixed = (filament_id >= p->combos_filament.size());
 
    if (!is_mixed) {
        if (wxGetApp().preset_bundle->is_the_only_edited_filament(filament_id) || (filament_id == 0)) {
            wxGetApp().get_tab(Preset::TYPE_FILAMENT)->select_preset(wxGetApp().preset_bundle->filament_presets[0], false, "", true);
        }
 
        if (p->editing_filament == filament_id || p->editing_filament >= filament_count) {
            p->editing_filament = -1;
        }
    }
 
    // update_num_filaments() shrinks filament_is_mixed along with the other per-filament arrays,
    // so snapshot it first — the paint cleanup below needs to know which slots were mixed
    // *before* the delete to avoid discarding assignments to still-valid mixed slots.
    std::vector<unsigned char> is_mixed_snapshot;
    if (auto* opt = wxGetApp().preset_bundle->project_config.option<ConfigOptionBools>("filament_is_mixed"))
        is_mixed_snapshot = opt->values;
 
    wxGetApp().preset_bundle->update_num_filaments(filament_id);
 
    // filament_count only counts physical combos, so with mixed slots present it is not the
    // new number of slots; recompute from the shrunk preset list for the downstream updates.
    size_t total_after_delete = wxGetApp().preset_bundle->filament_presets.size();
    wxGetApp().plater()->get_partplate_list().on_filament_deleted(total_after_delete, filament_id);
    wxGetApp().plater()->on_filaments_delete(total_after_delete, filament_id, replace_filament_id > (int)filament_id ? (replace_filament_id - 1) : replace_filament_id, is_mixed_snapshot);
    wxGetApp().get_tab(Preset::TYPE_PRINT)->update();
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
 
    wxGetApp().plater()->update();
 
    auto filament_list = p->m_panel_filament_content;
    if(!filament_list->IsShown()){
        filament_list->Show(); // ORCA show list if its folded
        m_scrolled_sizer->Layout();
    }
 
    filament_list->Scroll(-1, INT_MAX); // ORCA scroll to end of list on changes to inform user about filament count
}

References is_new_project_in_gcode3mf(), m_scrolled_sizer, p, Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::TYPE_PRINT.

Referenced by Sidebar(), change_filament(), delete_mixed_filament_at(), and Slic3r::GUI::Tab::on_value_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_mixed_filament_at()

void Slic3r::GUI::Sidebar::delete_mixed_filament_at ( size_t idx )

{
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return;
 
    auto mixed_indices = plater->mixed_filament_config_indices();
    if (panel_idx >= mixed_indices.size()) return;
    size_t cfg_idx = mixed_indices[panel_idx];
 
    delete_filament(cfg_idx, -1);
}

References delete_filament(), and Slic3r::GUI::plater().

Referenced by Sidebar(), remove_all_mixed_filaments(), and update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edit_filament()

void Slic3r::GUI::Sidebar::edit_filament ( )

{
    p->editing_filament = -1;
    if (p->m_menu_filament_id >= 0 && p->m_menu_filament_id < p->combos_filament.size()
            && p->combos_filament[p->m_menu_filament_id]->switch_to_tab())
        p->editing_filament = p->m_menu_filament_id; // sync with TabPresetComboxBox's m_filament_idx
}

References p.

◆ edit_mixed_filament()

void Slic3r::GUI::Sidebar::edit_mixed_filament ( size_t idx )

{
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return;
 
    auto mixed_indices = plater->mixed_filament_config_indices();
    if (panel_idx >= mixed_indices.size()) return;
    size_t cfg_idx = mixed_indices[panel_idx];
 
    std::vector<std::string> color_strs, names, types;
    collect_physical_filament_info(color_strs, names, types);
 
    auto& project_config = wxGetApp().preset_bundle->project_config;
    MixedFilamentResult existing;
    auto* components_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    auto* ratios_opt = project_config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
 
    // Parse existing components
    if (components_opt && cfg_idx < components_opt->values.size()) {
        const std::string& cs = components_opt->values[cfg_idx];
        std::istringstream iss(cs);
        std::string tok;
        while (std::getline(iss, tok, ',')) {
            unsigned int v = 0;
            if (std::sscanf(tok.c_str(), "%u", &v) == 1)
                existing.components.push_back(v);
        }
    }
    // Parse existing ratios
    if (ratios_opt && cfg_idx < ratios_opt->values.size()) {
        CNumericLocalesSetter c_locale_setter;
        const std::string& rs = ratios_opt->values[cfg_idx];
        std::istringstream iss(rs);
        std::string tok;
        while (std::getline(iss, tok, ',')) {
            float v = 0;
            if (std::sscanf(tok.c_str(), "%f", &v) == 1)
                existing.ratios.push_back((int)(v * 100 + 0.5f));
        }
    }
    if (existing.components.size() < 2) {
        existing.components = {1, 2};
        existing.ratios = {50, 50};
    } else if (existing.ratios.size() != existing.components.size()) {
        BOOST_LOG_TRIVIAL(warning) << "Mixed filament edit: ratio count ("
            << existing.ratios.size() << ") != component count ("
            << existing.components.size()
            << "), resetting to even distribution";
        int n = (int)existing.components.size();
        existing.ratios.assign(n, 100 / n);
        existing.ratios[0] += 100 - (100 / n) * n;
    }
 
    // Read gradient settings
    auto* grad_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient");
    if (grad_opt && cfg_idx < grad_opt->values.size())
        existing.gradient_enabled = grad_opt->values[cfg_idx];
    auto* grad_range_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_range");
    if (existing.gradient_enabled && grad_range_opt && cfg_idx < grad_range_opt->values.size()) {
        CNumericLocalesSetter c_locale_setter;
        float v0 = 0, v1 = 0;
        if (std::sscanf(grad_range_opt->values[cfg_idx].c_str(), "%f,%f", &v0, &v1) == 2)
            existing.gradient_direction = (v0 > v1) ? 0 : 1;
    }
    auto* grad_curve_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_curve");
    if (existing.gradient_enabled && grad_curve_opt && cfg_idx < grad_curve_opt->values.size()) {
        auto curve = Slic3r::parse_gradient_curve(grad_curve_opt->values[cfg_idx]);
        existing.gradient_curve = curve.points;
    }
    auto* per_part_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient_per_part");
    if (existing.gradient_enabled && per_part_opt && cfg_idx < per_part_opt->values.size())
        existing.per_part_gradient = per_part_opt->values[cfg_idx];
 
    MixedFilamentDialog dlg(this, existing, color_strs, names, types);
    if (dlg.ShowModal() == wxID_OK) {
        auto result = dlg.get_result();
        if (result.components.size() < 2 || result.ratios.size() < 2) return;
 
        // Serialize components
        std::string comp_str;
        for (size_t i = 0; i < result.components.size(); ++i) {
            if (i > 0) comp_str += ",";
            comp_str += std::to_string(result.components[i]);
        }
        components_opt->values[cfg_idx] = comp_str;
 
        // Serialize ratios
        int ratio_sum = 0;
        for (int r : result.ratios) ratio_sum += r;
        if (ratio_sum <= 0) ratio_sum = 100;
 
        std::string ratio_str;
        {
            CNumericLocalesSetter c_locale_setter;
            for (size_t i = 0; i < result.ratios.size(); ++i) {
                if (i > 0) ratio_str += ",";
                char buf[32];
                std::snprintf(buf, sizeof(buf), "%.4f", (float)result.ratios[i] / ratio_sum);
                ratio_str += buf;
            }
        }
        ratios_opt->values[cfg_idx] = ratio_str;
 
        // Gradient settings — ensure keys exist in dynamic config
        if (!project_config.option("filament_mixed_gradient"))
            project_config.set_key_value("filament_mixed_gradient", new ConfigOptionBools({false}));
        if (!project_config.option("filament_mixed_gradient_range"))
            project_config.set_key_value("filament_mixed_gradient_range", new ConfigOptionStrings({""}) );
        if (!project_config.option("filament_mixed_gradient_curve"))
            project_config.set_key_value("filament_mixed_gradient_curve", new ConfigOptionStrings({""}) );
        if (!project_config.option("filament_mixed_gradient_per_part"))
            project_config.set_key_value("filament_mixed_gradient_per_part", new ConfigOptionBools({false}));
 
        {
            auto* grad_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient");
            while (grad_opt->values.size() <= cfg_idx) grad_opt->values.push_back(false);
            grad_opt->values[cfg_idx] = result.gradient_enabled;
        }
        {
            auto* grad_range_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_range");
            while (grad_range_opt->values.size() <= cfg_idx) grad_range_opt->values.push_back("");
            if (result.gradient_enabled && result.components.size() == 2) {
                const char* fmt = (result.gradient_direction == 0) ? "0.9000,0.1000" : "0.1000,0.9000";
                grad_range_opt->values[cfg_idx] = fmt;
            } else {
                grad_range_opt->values[cfg_idx] = "";
            }
        }
        {
            auto* grad_curve_opt = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_curve");
            while (grad_curve_opt->values.size() <= cfg_idx) grad_curve_opt->values.push_back("");
            grad_curve_opt->values[cfg_idx] = serialize_mixed_gradient_curve_if_custom(result);
        }
        {
            auto* per_part_opt = project_config.option<ConfigOptionBools>("filament_mixed_gradient_per_part");
            while (per_part_opt->values.size() <= cfg_idx) per_part_opt->values.push_back(false);
            per_part_opt->values[cfg_idx] = result.gradient_enabled && result.per_part_gradient;
        }
 
        // Compute blended color
        std::string blended = blend_mixed_color(result.components, result.ratios, color_strs);
        auto* colours_opt = project_config.option<ConfigOptionStrings>("filament_colour");
        if (colours_opt && cfg_idx < colours_opt->values.size())
            colours_opt->values[cfg_idx] = blended;
 
        auto* multi_colour_opt = project_config.option<ConfigOptionStrings>("filament_multi_colour");
        if (multi_colour_opt && cfg_idx < multi_colour_opt->values.size())
            multi_colour_opt->values[cfg_idx] = blended;
 
        // The edited slot keeps its index, so nothing else refreshes the per-feature filament
        // lists - and its blended colour and type are what they show for it.
        update_mixed_filament_list();
        update_dynamic_filament_list();
        wxGetApp().plater()->update_project_dirty_from_presets();
        wxPostEvent(this, SimpleEvent(EVT_SCHEDULE_BACKGROUND_PROCESS, this));
    }
}

References Slic3r::GUI::blend_mixed_color(), collect_physical_filament_info(), Slic3r::GUI::MixedFilamentResult::components, Slic3r::GUI::MixedFilamentDialog::get_result(), Slic3r::GUI::MixedFilamentResult::gradient_curve, Slic3r::GUI::MixedFilamentResult::gradient_direction, Slic3r::GUI::MixedFilamentResult::gradient_enabled, Slic3r::parse_gradient_curve(), Slic3r::GUI::MixedFilamentResult::per_part_gradient, Slic3r::GUI::plater(), Slic3r::GUI::MixedFilamentResult::ratios, Slic3r::GUI::serialize_mixed_gradient_curve_if_custom(), Slic3r::GUI::DPIAware::ShowModal(), Slic3r::ConfigOptionVector< T >::size(), update_dynamic_filament_list(), update_mixed_filament_list(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by update_mixed_filament_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_buttons()

void Slic3r::GUI::Sidebar::enable_buttons ( bool enable )

{
#if 0
    p->btn_reslice->Enable(enable);
    p->btn_export_gcode->Enable(enable);
    p->btn_send_gcode->Enable(enable);
//    p->btn_eject_device->Enable(enable);
    p->btn_export_gcode_removable->Enable(enable);
#endif
}

References p.

◆ enable_nozzle_count_edit()

void Slic3r::GUI::Sidebar::enable_nozzle_count_edit ( bool enable )

{
    if (!p)
        return;
    p->left_extruder->SetEditEnabled(enable);
    p->right_extruder->SetEditEnabled(enable);
}

References p.

◆ enable_purge_mode_btn()

void Slic3r::GUI::Sidebar::enable_purge_mode_btn ( bool enable )

{
    if (!p || !p->m_purge_mode_btn)
        return;
    p->m_purge_mode_btn->Show(enable);
    wxGetApp().CallAfter([this]() {
        p->m_panel_filament_title->Layout();
        this->Layout();
    });
}

References p.

◆ ensure_mixed_filament()

int Slic3r::GUI::Sidebar::ensure_mixed_filament	(	const std::vector< unsigned int > &	components,
		const std::vector< int > &	ratios )

{
    if (components.size() < 2 || components.size() != ratios.size())
        return -1;
    if (p->combos_filament.size() < 2)
        return -1;
    if (std::accumulate(ratios.begin(), ratios.end(), 0) <= 0)
        return -1;
 
    if (const int existing = find_fixed_mixed_filament(wxGetApp().preset_bundle->project_config, components, ratios);
        existing >= 0)
        return existing;
 
    if (wxGetApp().preset_bundle->filament_presets.size() >= size_t(EnforcerBlockerType::ExtruderMax))
        return -1;
 
    std::vector<std::string> color_strs, names, types;
    collect_physical_filament_info(color_strs, names, types);
 
    MixedFilamentResult result;
    result.components = components;
    result.ratios     = ratios;
    const size_t created_at = wxGetApp().preset_bundle->filament_presets.size();
    if (!create_mixed_filament_from_result(this, result, color_strs))
        return -1;
    return int(created_at);
}

References collect_physical_filament_info(), Slic3r::GUI::MixedFilamentResult::components, Slic3r::GUI::create_mixed_filament_from_result(), Slic3r::ExtruderMax, Slic3r::find_fixed_mixed_filament(), p, and Slic3r::GUI::MixedFilamentResult::ratios.

Here is the call graph for this function:

◆ filament_panel()

wxPanel * Slic3r::GUI::Sidebar::filament_panel ( )

{
    return p->m_panel_filament_content;
}

References p.

◆ finish_param_edit()

void Slic3r::GUI::Sidebar::finish_param_edit ( )

6889{ p->editing_filament = -1; }

References p.

◆ get_big_btn_sync_pos_size()

void Slic3r::GUI::Sidebar::get_big_btn_sync_pos_size	(	wxPoint &	pt,
		wxSize &	size )

{
    size = p->m_printer_bbl_sync->GetSize();
    pt = p->m_printer_bbl_sync->GetScreenPosition();
}

References p.

◆ get_cur_combox_bed_types()

const std::vector< BedType > & Slic3r::GUI::Sidebar::get_cur_combox_bed_types ( )

inline

195{ return m_cur_combox_bed_types; }

Slic3r::GUI::Sidebar::m_cur_combox_bed_types

std::vector< BedType > m_cur_combox_bed_types

Definition Plater.hpp:164

References m_cur_combox_bed_types.

◆ get_cur_select_bed_image()

std::string Slic3r::GUI::Sidebar::get_cur_select_bed_image ( )

{
    auto select_bed_type   = get_cur_select_bed_type();
    //auto series_suffix_str = m_cur_image_bed_type.empty() ? "" : ("_" + m_cur_image_bed_type);
    auto image_path        = bed_type_thumbnails[select_bed_type];// + series_suffix_str;
    return image_path;
}

References Slic3r::GUI::bed_type_thumbnails, and get_cur_select_bed_type().

Referenced by Sidebar(), msw_rescale(), on_enter_image_printer_bed(), and update_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_cur_select_bed_type()

BedType Slic3r::GUI::Sidebar::get_cur_select_bed_type ( )

                                         {
    int selection = p->combo_printer_bed->GetSelection();
    if (selection < 0 && selection >= m_cur_combox_bed_types.size()) {
        p->combo_printer_bed->SetSelection(0);
        selection = 0;
    }
    auto select_bed_type = m_cur_combox_bed_types[selection];
    return select_bed_type;
}

References m_cur_combox_bed_types, and p.

Referenced by get_cur_select_bed_image().

Here is the caller graph for this function:

◆ get_eject_shown()

bool Slic3r::GUI::Sidebar::get_eject_shown ( ) const

References collapse().

Here is the call graph for this function:

◆ get_search_line()

std::string & Slic3r::GUI::Sidebar::get_search_line ( )

{
    return p->searcher.search_string();
}

References p.

◆ get_searcher()

Search::OptionsSearcher & Slic3r::GUI::Sidebar::get_searcher ( )

{
    return p->searcher;
}

References p.

◆ get_sidebar_pos_right_x()

int Slic3r::GUI::Sidebar::get_sidebar_pos_right_x ( )

{
    return this->GetScreenPosition().x + this->GetSize().x;
}

◆ get_small_btn_sync_pos_size()

void Slic3r::GUI::Sidebar::get_small_btn_sync_pos_size	(	wxPoint &	pt,
		wxSize &	size )

                                                                   {
    size = ams_btn->GetSize();
    pt   = ams_btn->GetScreenPosition();
}

References ams_btn.

Referenced by pop_finsish_sync_ams_dialog(), and pop_sync_nozzle_and_ams_dialog().

Here is the caller graph for this function:

◆ get_wiping_dialog_button()

wxButton * Slic3r::GUI::Sidebar::get_wiping_dialog_button ( )

{
#if 0
    return p->frequently_changed_parameters->get_wiping_dialog_button();
#endif
    return NULL;
}

References p.

◆ has_broken_mixed_filament() [1/2]

bool Slic3r::GUI::Sidebar::has_broken_mixed_filament ( ) const

{
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return false;
    return has_broken_mixed_filament(plater->get_partplate_list().get_curr_plate());
}

References has_broken_mixed_filament(), and Slic3r::GUI::plater().

Referenced by has_broken_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_broken_mixed_filament() [2/2]

bool Slic3r::GUI::Sidebar::has_broken_mixed_filament ( const PartPlate * plate ) const

{
    if (!plate) return false;
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return false;
 
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
    auto* comp_strs_opt = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    if (!is_mixed_opt || !comp_strs_opt) return false;
 
    size_t num_physical = p->combos_filament.size();
    auto broken_slots = check_mixed_filament_integrity(is_mixed_opt->values, comp_strs_opt->values, num_physical);
 
    // Type consistency check
    {
        std::vector<std::string> physical_types;
        auto& preset_bundle = *wxGetApp().preset_bundle;
        for (size_t i = 0; i < num_physical; ++i) {
            std::string ft;
            if (i < preset_bundle.filament_presets.size()) {
                auto* preset = preset_bundle.filaments.find_preset(preset_bundle.filament_presets[i]);
                if (preset) {
                    std::string display_type;
                    ft = preset->config.get_filament_type(display_type);
                }
            }
            if (ft.empty()) ft = "PLA";
            physical_types.push_back(ft);
        }
        auto type_mismatch_slots = check_mixed_filament_type_consistency(
            is_mixed_opt->values, comp_strs_opt->values, physical_types);
        broken_slots.insert(broken_slots.end(), type_mismatch_slots.begin(), type_mismatch_slots.end());
    }
 
    if (broken_slots.empty()) return false;
 
    std::set<size_t> broken_1based;
    for (size_t s : broken_slots) broken_1based.insert(s + 1);
 
    // Scan model objects on the given plate for raw extruder assignments
    // (don't use get_extruders() which expands mixed slots)
    for (auto& entry : plater->model().objects) {
        if (!plate->contain_instance_totally(entry, 0))
            continue;
        // Check object-level extruder
        int obj_ext = entry->config.has("extruder") ? entry->config.extruder() : 1;
        if (broken_1based.count((size_t)obj_ext))
            return true;
        for (auto* vol : entry->volumes) {
            // Check volume-level extruder
            int vol_ext = vol->config.has("extruder") ? vol->config.extruder() : obj_ext;
            if (broken_1based.count((size_t)vol_ext))
                return true;
            // Check color painting data (mmu segmentation facets)
            if (vol->is_model_part() && !vol->mmu_segmentation_facets.empty()) {
                for (size_t broken_slot : broken_1based) {
                    if (vol->mmu_segmentation_facets.has_facets(*vol, EnforcerBlockerType(broken_slot)))
                        return true;
                }
            }
        }
        // Check height range modifier extruder overrides
        for (auto& [range, cfg] : entry->layer_config_ranges) {
            if (cfg.has("extruder")) {
                int layer_ext = cfg.option("extruder")->getInt();
                if (layer_ext > 0 && broken_1based.count((size_t)layer_ext))
                    return true;
            }
        }
    }
 
    return false;
}

References Slic3r::check_mixed_filament_integrity(), Slic3r::check_mixed_filament_type_consistency(), Slic3r::GUI::PartPlate::contain_instance_totally(), p, Slic3r::GUI::plater(), Slic3r::range(), and Slic3r::ConfigOptionVector< unsigned char >::values.

Here is the call graph for this function:

◆ init_filament_combo()

void Slic3r::GUI::Sidebar::init_filament_combo	(	PlaterPresetComboBox **	combo,
		const int	filament_idx )

{
    *combo = new PlaterPresetComboBox(p->m_panel_filament_content, Slic3r::Preset::TYPE_FILAMENT);
    (*combo)->set_filament_idx(filament_idx);
 
    auto combo_and_btn_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    // BBS:  filament double columns
 
    // int em = wxGetApp().em_unit();
    if ((filament_idx % 2) == 0) // Dont add right column item. this one create equal spacing on left, right & middle
        combo_and_btn_sizer->AddSpacer(FromDIP((filament_idx % 2) == 0 ? 12 : 3)); // Content Margin
 
    (*combo)->clr_picker->SetLabel(wxString::Format("%d", filament_idx + 1));
    combo_and_btn_sizer->Add((*combo)->clr_picker, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(SidebarProps::ElementSpacing()) - FromDIP(2)); // ElementSpacing - 2 (from combo box))
    combo_and_btn_sizer->Add(*combo, 1, wxALL | wxEXPAND, FromDIP(2))->SetMinSize({-1, 30 * wxGetApp().em_unit() / 10}); // ORCA ensure height matches with PlaterPresetComboBox
 
    /* BBS hide del_btn
    ScalableButton* del_btn = new ScalableButton(p->m_panel_filament_content, wxID_ANY, "delete_filament");
    del_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e){
        int extruder_count = std::max(1, (int)p->combos_filament.size() - 1);
 
        update_objects_list_filament_column(std::max(1, extruder_count - 1));
        on_filament_count_change(extruder_count);
        wxGetApp().preset_bundle->printers.get_edited_preset().set_num_extruders(extruder_count);
        wxGetApp().preset_bundle->update_multi_material_filament_presets();
    });
 
    combo_and_btn_sizer->Add(32 * em / 10, 0, 0, 0, 0);
    combo_and_btn_sizer->Add(del_btn, 0, wxALIGN_CENTER_VERTICAL, 5 * em / 10);
    */
    ScalableButton* edit_btn = new ScalableButton(p->m_panel_filament_content, wxID_ANY, "menu_filament");
    edit_btn->SetToolTip(_L("Click to edit preset"));
 
    PlaterPresetComboBox* combobox = (*combo);
    edit_btn->Bind(wxEVT_BUTTON, [this, edit_btn, combobox, filament_idx](wxCommandEvent) {
        bool single_or_bbl     = should_show_SEMM_buttons();
        bool is_multi_material = p->combos_filament.size() > 1;
        if(single_or_bbl && is_multi_material) {
           // MULTI MATERIAL Show menu
            auto menu = p->plater->filament_action_menu(filament_idx);
            wxPoint pt { 0, edit_btn->GetSize().GetHeight() + FromDIP(2) };
            pt = edit_btn->ClientToScreen(pt);
            pt = wxGetApp().mainframe->ScreenToClient(pt);
            p->m_menu_filament_id = filament_idx;
            p->plater->PopupMenu(menu, (int) pt.x, pt.y);
        }
        else {
            // SINGLE MATERIAL / MULTI EXTRUDER / TOOLCHANGER / IDEX Opens Dialog directly
            p->editing_filament = filament_idx;
            combobox->switch_to_tab();
        }
    });
    combobox->edit_btn = edit_btn;
 
    combo_and_btn_sizer->Add(edit_btn, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::ElementSpacing()) - FromDIP(2)); // ElementSpacing - 2 (from combo box))
 
    combo_and_btn_sizer->AddSpacer(FromDIP(SidebarProps::ContentMargin()));
 
    // BBS:  filament double columns
    auto side = filament_idx % 2;
    auto /***/sizer_filaments = this->p->sizer_filaments->GetItem(side)->GetSizer();
    if (side == 1 && filament_idx > 1) sizer_filaments->Remove(filament_idx / 2);
    sizer_filaments->Add(combo_and_btn_sizer, 1, wxEXPAND);
    if (side == 0 && filament_idx > 0) {
        sizer_filaments = this->p->sizer_filaments->GetItem(1)->GetSizer();
        sizer_filaments->AddStretchSpacer(1);
    }
}

References _L, Slic3r::GUI::SidebarProps::ContentMargin(), Slic3r::GUI::PlaterPresetComboBox::edit_btn, Slic3r::GUI::SidebarProps::ElementSpacing(), p, should_show_SEMM_buttons(), Slic3r::GUI::PlaterPresetComboBox::switch_to_tab(), and Slic3r::Preset::TYPE_FILAMENT.

Referenced by Sidebar(), and on_filament_count_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_collapsed()

bool Slic3r::GUI::Sidebar::is_collapsed ( )

6852{ return p->plater->is_sidebar_collapsed(); }

References p.

◆ is_fila_switch_ready()

bool Slic3r::GUI::Sidebar::is_fila_switch_ready ( )

{
    return p->is_fila_switch_ready();
}

References p.

Referenced by Slic3r::GUI::Sidebar::priv::sync_extruder_list(), and Slic3r::GUI::Sidebar::priv::update_sync_status().

Here is the caller graph for this function:

◆ is_multifilament()

bool Slic3r::GUI::Sidebar::is_multifilament ( )

{
    return p->combos_filament.size() > 1;
}

References p.

◆ is_new_project_in_gcode3mf()

bool Slic3r::GUI::Sidebar::is_new_project_in_gcode3mf ( )

{
    // A .gcode previewed with its own settings shows them here too, and is closed the same way.
    if (p->plater->using_exported_file() || p->plater->gcode_settings_loaded()) {
        auto          filename = p->plater->get_preview_only_filename();
        auto          text     = wxString::Format(_L("After completing your operation, %s project will be closed and create a new project."), filename);
        MessageDialog dlg(wxGetApp().plater(), text, _L("Warning"),
                          wxOK | wxICON_WARNING);
        dlg.ShowModal();
        p->plater->new_project();
        return true;
    }
    return false;
}

References _L, p, Slic3r::GUI::plater(), and Slic3r::GUI::DPIAware::ShowModal().

Referenced by add_custom_filament(), and delete_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ jump_to_object()

void Slic3r::GUI::Sidebar::jump_to_object ( ObjectDataViewModelNode * item )

{
    p->jump_to_object(item);
}

References p.

◆ jump_to_option() [1/2]

void Slic3r::GUI::Sidebar::jump_to_option	(	const std::string &	opt_key,
		Preset::Type	type,
		const std::wstring &	category )

{
    //const Search::Option& opt = p->searcher.get_option(opt_key, type);
    if (type == Preset::TYPE_PRINT) {
        auto tab = dynamic_cast<TabPrintModel*>(wxGetApp().params_panel()->get_current_tab());
        if (tab && tab->has_key(opt_key)) {
            tab->activate_option(opt_key, category);
            return;
        }
        wxGetApp().params_panel()->switch_to_global();
    }
    wxGetApp().get_tab(type)->activate_option(opt_key, category);
}

References Slic3r::Preset::TYPE_PRINT.

◆ jump_to_option() [2/2]

void Slic3r::GUI::Sidebar::jump_to_option ( size_t selected )

{
    const Search::Option& opt = p->searcher.get_option(selected);
    jump_to_option(opt.opt_key(), opt.type, opt.category);
 
    // Switch to the Settings NotePad
//    wxGetApp().mainframe->select_tab();
}

References jump_to_option(), and p.

Referenced by jump_to_option().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_ams_list()

void Slic3r::GUI::Sidebar::load_ams_list ( MachineObject * obj )

{
    std::map<int, DynamicPrintConfig> filament_ams_list;
 
    // build_filament_ams_list handles both subscription-based and non-subscription-based agents:
    // - For non-subscription agents, it calls fetch_filament_info() first to populate DevFilaSystem
    // - Then it always reads from DevFilaSystem to build the filament list
    if (obj) {
        filament_ams_list = build_filament_ams_list(obj);
    }
 
    const std::string& device = obj ? obj->get_dev_id() : "";
    const bool same_device = p->ams_list_device == device;
 
    // Keep sync metadata out of the device payload, but preserve it across a
    // subscription refresh when the physical filament in a slot is unchanged.
    // Otherwise the refreshed configs differ only by the missing
    // filament_changed key, causing combo boxes to rebuild and lose their
    // transient post-sync badges.
    auto &previous_filament_ams_list = wxGetApp().preset_bundle->filament_ams_list;
    for (auto &entry : filament_ams_list) {
        auto previous = previous_filament_ams_list.find(entry.first);
        const auto *previous_changed = previous == previous_filament_ams_list.end() ? nullptr :
                                       dynamic_cast<const ConfigOptionBool *>(previous->second.option("filament_changed"));
        if (!same_device || previous_changed == nullptr ||
            previous->second.opt_string("filament_id", 0u) != entry.second.opt_string("filament_id", 0u)) {
            continue;
        }
        entry.second.set_key_value("filament_changed",
                                   new ConfigOptionBool{previous_changed->value});
    }
 
    bool device_change     = !same_device;
    if (device_change) {
        p->ams_list_device = device;
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% items") % filament_ams_list.size();
    if (wxGetApp().preset_bundle->filament_ams_list == filament_ams_list && !device_change)
    {
        return;
    }
    wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
 
    for (auto c : p->combos_filament){
        c->set_sync_badge(false);
        c->update();
    }
 
    if (!device_change) {
        size_t combo_index = 0;
        for (const auto &entry : filament_ams_list) {
            const auto &tray = entry.second;
            const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
            const bool is_placeholder = tray.has("filament_slot_placeholder") &&
                                         tray.opt_bool("filament_slot_placeholder", 0u);
            if (!has_filament && !is_placeholder) {
                continue;
            }
            if (combo_index >= p->combos_filament.size()) {
                break;
            }
            const auto *filament_changed = dynamic_cast<const ConfigOptionBool *>(tray.option("filament_changed"));
            p->combos_filament[combo_index]->set_sync_badge(
                has_filament && !is_placeholder && filament_changed != nullptr && filament_changed->value);
            ++combo_index;
        }
    }
 
    p->combo_printer->update();
}

References build_filament_ams_list(), Slic3r::MachineObject::get_dev_id(), and p.

Here is the call graph for this function:

◆ msw_rescale()

void Slic3r::GUI::Sidebar::msw_rescale ( )

{
    SetMinSize(wxSize(39 * wxGetApp().em_unit(), -1));
    p->m_panel_printer_title->GetSizer()->SetMinSize(-1, 3 * wxGetApp().em_unit());
    p->m_panel_filament_title->GetSizer()
        ->SetMinSize(-1, 3 * wxGetApp().em_unit());
    p->m_printer_icon->msw_rescale();
    p->m_printer_connect->msw_rescale();
    p->m_printer_bbl_sync->msw_rescale();
    p->m_printer_icon->msw_rescale();
    p->m_printer_setting->msw_rescale();
 
    p->panel_printer_preset->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
    p->panel_printer_preset->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
    p->image_printer->SetSize(FromDIP(PRINTER_THUMBNAIL_SIZE));
    update_printer_thumbnail();
    p->combo_printer->Rescale();
    p->combo_printer->SetMaxSize(wxSize(-1, FromDIP(30))); // limiting height makes badge visible
    p->btn_edit_printer->msw_rescale();
 
    p->panel_nozzle_dia->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
    p->panel_nozzle_dia->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
    p->combo_nozzle_dia->Rescale();
 
    p->panel_printer_bed->SetMinSize(FromDIP(PRINTER_PANEL_SIZE));
    p->panel_printer_bed->SetCornerRadius(FromDIP(PRINTER_PANEL_RADIUS));
    p->combo_printer_bed->Rescale();
    p->combo_printer_bed->SetMinSize(FromDIP(wxSize(18,-1))); // ORCA show only arrow
    p->combo_printer_bed->SetMaxSize(FromDIP(wxSize(18,-1))); // ORCA show only arrow
    bool isDual     = static_cast<wxBoxSizer *>(p->panel_printer_preset->GetSizer())->GetOrientation() == wxVERTICAL;
    auto image_path = get_cur_select_bed_image();
    p->image_printer_bed->SetBitmap(create_scaled_bitmap(image_path, this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
    if (p->big_bed_image_popup){ // ORCA force rebuild frame. current wxwidget version not supports wxBITMAP_SCALE_FILL flag on wxStaticBitmap
                                 // also     wxImage scaledImage = bit_map.ConvertToImage(); scaledImage.Rescale(FromDIP(m_image_px), FromDIP(m_image_px), wxIMAGE_QUALITY_HIGH);
                                 // didnt worked as expected and it requires use on set_bitmap. so that will try to scale everytime
        p->big_bed_image_popup->Destroy();
        p->big_bed_image_popup = nullptr;
    }
 
    p->m_filament_icon->msw_rescale();
    p->m_bpButton_add_filament->msw_rescale();
    p->m_bpButton_del_filament->msw_rescale();
    p->m_bpButton_ams_filament->msw_rescale();
    p->m_bpButton_set_filament->msw_rescale();
    p->m_purge_mode_btn->Rescale();
    p->m_flushing_volume_btn->Rescale();
    set_flushing_volume_warning(is_flush_config_modified()); // ORCA reapply appearance
 
    //BBS
    p->left_extruder->Rescale();
    p->right_extruder->Rescale();
    p->single_extruder->Rescale();
 
    //p->btn_sync_printer->SetPaddingSize({FromDIP(6), FromDIP(12)});
    //p->btn_sync_printer->SetMinSize(BTN_SYNC_SIZE);
    //p->btn_sync_printer->Rescale();
#if 0
    if (p->mode_sizer)
        p->mode_sizer->msw_rescale();
#endif
 
    //for (PlaterPresetComboBox* combo : std::vector<PlaterPresetComboBox*> { p->combo_print,
    //                                                            //p->combo_sla_print,
    //                                                            //p->combo_sla_material,
    //                                                            //p->combo_printer
    //                                                            } )
    //    combo->msw_rescale();
 
    for (PlaterPresetComboBox* combo : p->combos_filament)
        combo->msw_rescale();
 
    p->m_panel_filament_content->Layout();
    update_filaments_area_height(); // ORCA resize after combos scaled
 
    // BBS
    //p->frequently_changed_parameters->msw_rescale();
    //obj_list()->msw_rescale();
    // BBS TODO: add msw_rescale for newly added windows
    // BBS
    //p->object_manipulation->msw_rescale();
    p->object_settings->msw_rescale();
    p->m_search_item->Rescale();
    p->m_search_item->GetTextCtrl()->SetSize(wxSize(-1, FromDIP(16)));
    p->m_search_bar->Layout();
 
    // BBS
#if 0
    p->object_info->msw_rescale();
 
    p->btn_send_gcode->msw_rescale();
//    p->btn_eject_device->msw_rescale();
    p->btn_export_gcode_removable->msw_rescale();
#ifdef _WIN32
    const int scaled_height = p->btn_export_gcode_removable->GetBitmapHeight();
#else
    const int scaled_height = p->btn_export_gcode_removable->GetBitmapHeight() + 4;
#endif
    p->btn_export_gcode->SetMinSize(wxSize(-1, scaled_height));
    p->btn_reslice     ->SetMinSize(wxSize(-1, scaled_height));
#endif
    p->scrolled->Layout();
 
    p->searcher.dlg_msw_rescale();
}

References create_scaled_bitmap(), em_unit(), get_cur_select_bed_image(), is_flush_config_modified(), Slic3r::GUI::PlaterPresetComboBox::msw_rescale(), p, PRINTER_PANEL_RADIUS, PRINTER_PANEL_SIZE, PRINTER_THUMBNAIL_SIZE, set_flushing_volume_warning(), update_filaments_area_height(), and update_printer_thumbnail().

Here is the call graph for this function:

◆ need_auto_sync_after_connect_printer()

bool Slic3r::GUI::Sidebar::need_auto_sync_after_connect_printer ( ) const

inline

322{ return m_need_auto_sync_after_connect_printer; }

Slic3r::GUI::Sidebar::m_need_auto_sync_after_connect_printer

bool m_need_auto_sync_after_connect_printer

Definition Plater.hpp:333

References m_need_auto_sync_after_connect_printer.

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

Here is the caller graph for this function:

◆ need_auto_sync_extruder_list_after_connect_priner()

bool Slic3r::GUI::Sidebar::need_auto_sync_extruder_list_after_connect_priner ( const MachineObject * obj )

{
    if(!obj)
        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);
    if (machine_print_name != target_model_id) {
        return false;
    }
 
    if (preset_bundle->get_printer_extruder_count() <= 1 || !obj->is_multi_extruders())
        return false;
 
    return true;
}

References Slic3r::PresetBundle::get_printer_extruder_count(), Slic3r::Preset::get_printer_type(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::MachineObject::get_show_printer_type(), Slic3r::MachineObject::is_multi_extruders(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::MonitorPanel::on_machine_selected().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ obj_layers()

ObjectLayers * Slic3r::GUI::Sidebar::obj_layers ( )

{
    return p->object_layers;
}

References p.

Referenced by sys_color_changed().

Here is the caller graph for this function:

◆ obj_list()

ObjectList * Slic3r::GUI::Sidebar::obj_list ( )

{
    // BBS
    //return obj_list();
    return p->m_object_list;
}

References p.

Here is the caller graph for this function:

◆ obj_settings()

ObjectSettings * Slic3r::GUI::Sidebar::obj_settings ( )

{
    return p->object_settings;
}

References p.

Referenced by Slic3r::GUI::ObjectList::update_settings_item_and_selection().

Here is the caller graph for this function:

◆ og_freq_chng_params()

ConfigOptionsGroup * Slic3r::GUI::Sidebar::og_freq_chng_params ( const bool is_fff )

{
    // BBS
#if 0
    return p->frequently_changed_parameters->get_og(is_fff);
#endif
    return NULL;
}

References p.

◆ on_bed_type_change()

void Slic3r::GUI::Sidebar::on_bed_type_change ( BedType bed_type )

{
    // Orca: Map BedType to the current combo list (some printers filter types).
 
    if (p->combo_printer_bed == nullptr)
        return;
 
    for (size_t i = 0; i < m_cur_combox_bed_types.size(); ++i) {
        if (m_cur_combox_bed_types[i] == bed_type) {
            p->combo_printer_bed->SetSelection(int(i));
            return;
        }
    }
 
    if (!m_cur_combox_bed_types.empty())
        p->combo_printer_bed->SetSelection(0);
}

References m_cur_combox_bed_types, and p.

Referenced by Slic3r::GUI::Plater::on_bed_type_change().

Here is the caller graph for this function:

◆ on_change_color_mode()

void Slic3r::GUI::Sidebar::on_change_color_mode ( bool is_dark )

                                               {
    const ModelObjectPtrs &mos = wxGetApp().model().objects;
    for (int i = 0; i < mos.size(); i++) {
        wxGetApp().obj_list()->update_info_items(i,nullptr,false,true);
    }
 
}

References is_dark().

Here is the call graph for this function:

◆ on_enter_image_printer_bed()

void Slic3r::GUI::Sidebar::on_enter_image_printer_bed ( wxMouseEvent & evt )

                                                          {
    //p->image_printer_bed->Bind(wxEVT_LEAVE_WINDOW, &Sidebar::on_leave_image_printer_bed, this);
    auto    pos  = p->panel_printer_bed->GetScreenPosition();
    auto    rect = p->panel_printer_bed->GetRect();
    wxPoint temp_pos(pos.x + rect.GetWidth() +  FromDIP(3), pos.y);
    if (p->big_bed_image_popup == nullptr)
        p->big_bed_image_popup = new ImageDPIFrame();
    auto image_path        = get_cur_select_bed_image();
    p->big_bed_image_popup->set_bitmap(create_scaled_bitmap("big_" + image_path, p->big_bed_image_popup, p->big_bed_image_popup->get_image_px()));
    p->big_bed_image_popup->set_title(p->combo_printer_bed->GetString(p->combo_printer_bed->GetSelection()));
    p->big_bed_image_popup->SetCanFocus(false);
    p->big_bed_image_popup->SetPosition(temp_pos);
    p->big_bed_image_popup->on_show();
}

References create_scaled_bitmap(), get_cur_select_bed_image(), p, and Slic3r::GUI::wxMouseEvent.

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_filament_count_change()

void Slic3r::GUI::Sidebar::on_filament_count_change ( size_t num_filaments )

{
    // num_filaments counts every slot; mixed-color slots are virtual and get no combo of
    // their own (they are rendered by update_mixed_filament_list instead), so the physical
    // subset drives the combo list.
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto* is_mixed_opt = project_config.option<ConfigOptionBools>("filament_is_mixed");
 
    std::vector<size_t> physical_indices;
    for (size_t i = 0; i < num_filaments; ++i) {
        if (!is_mixed_opt || i >= is_mixed_opt->values.size() || !is_mixed_opt->values[i])
            physical_indices.push_back(i);
    }
    const size_t num_physical = physical_indices.size();
 
    auto& choices = combos_filament();
 
    if (num_physical == choices.size()) {
        // The ctor pre-creates one combo, so a single-filament project hits this guard before
        // any layout pass has sized the scroll areas; refresh them here as well.
        // Adding a mixed slot also lands here, since only the virtual count changed, so the
        // per-feature filament lists - which do list mixed slots - have to be refreshed too.
        recalc_filament_scroll_sizes();
        update_mixed_filament_list();
        update_dynamic_filament_list();
        return;
    }
 
    if (choices.size() == 1 || num_physical == 1)
        choices[0]->GetDropDown().Invalidate();
 
    wxWindowUpdateLocker noUpdates_scrolled_panel(this);
 
    size_t i = choices.size();
    while (i < num_physical)
    {
        PlaterPresetComboBox* choice/*{ nullptr }*/;
        init_filament_combo(&choice, physical_indices[i]);
        int last_selection = choices.back()->GetSelection();
        choices.push_back(choice);
 
        // initialize selection
        choice->update();
        choice->SetSelection(last_selection);
        ++i;
    }
 
    // remove unused choices if any
    remove_unused_filament_combos(num_physical);
 
    show_SEMM_buttons(); // ORCA
 
    update_filaments_area_height();  // ORCA
    recalc_filament_scroll_sizes();
    update_mixed_filament_list();
 
    Layout();
    p->m_panel_filament_title->Refresh();
    update_ui_from_settings();
    update_dynamic_filament_list();
}

References combos_filament(), init_filament_combo(), p, recalc_filament_scroll_sizes(), remove_unused_filament_combos(), ComboBox::SetSelection(), show_SEMM_buttons(), Slic3r::GUI::PlaterPresetComboBox::update(), update_dynamic_filament_list(), update_filaments_area_height(), update_mixed_filament_list(), and update_ui_from_settings().

Referenced by Slic3r::GUI::Plater::on_filament_count_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_filaments_delete()

void Slic3r::GUI::Sidebar::on_filaments_delete ( size_t filament_id )

{
    auto &choices = combos_filament();
 
    // A mixed (virtual) slot has no combo of its own, so there is no combo UI to remove —
    // but the shared refresh below must still run so the mixed filament panel drops its row.
    if (filament_id < choices.size()) {
        if (choices.size() == 1)
            choices[0]->GetDropDown().Invalidate();
 
        wxWindowUpdateLocker noUpdates_scrolled_panel(this);
 
        // delete UI item
        {
            const int last            = p->combos_filament.size() - 1;
            auto      sizer_filaments = this->p->sizer_filaments->GetItem(last % 2)->GetSizer();
            sizer_filaments->Remove(last / 2);
 
            PlaterPresetComboBox* to_delete_combox = p->combos_filament[filament_id];
            (*p->combos_filament[last]).Destroy();
            p->combos_filament.pop_back();
 
            // BBS:  filament double columns
            auto sizer_filaments0 = this->p->sizer_filaments->GetItem((size_t) 0)->GetSizer();
            auto sizer_filaments1 = this->p->sizer_filaments->GetItem(1)->GetSizer();
            if (p->combos_filament.size() < 2) {
                sizer_filaments1->Clear();
            } else {
                size_t c0 = sizer_filaments0->GetChildren().GetCount();
                size_t c1 = sizer_filaments1->GetChildren().GetCount();
                if (c0 < c1)
                    sizer_filaments1->Remove(c1 - 1);
                else if (c0 > c1)
                    sizer_filaments1->AddStretchSpacer(1);
            }
        }
 
        show_SEMM_buttons(); // ORCA
 
        for (size_t idx = filament_id ; idx < p->combos_filament.size(); ++idx) {
            p->combos_filament[idx]->update();
        }
    }
 
    update_filaments_area_height(); // ORCA
    recalc_filament_scroll_sizes();
    update_mixed_filament_list();
 
    Layout();
    p->m_panel_filament_title->Refresh();
    update_ui_from_settings();
    update_dynamic_filament_list();
}

References combos_filament(), p, recalc_filament_scroll_sizes(), show_SEMM_buttons(), update_dynamic_filament_list(), update_filaments_area_height(), update_mixed_filament_list(), and update_ui_from_settings().

Referenced by Slic3r::GUI::Plater::on_filaments_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_full_screen()

void Slic3r::GUI::Sidebar::on_full_screen ( IntEvent & e )

                                        {
    if (m_sna_dialog) { m_sna_dialog->on_full_screen(e); }
    if (m_fna_dialog) { m_fna_dialog->on_full_screen(e); }
}

References m_fna_dialog, and m_sna_dialog.

◆ on_leave_image_printer_bed()

void Slic3r::GUI::Sidebar::on_leave_image_printer_bed ( wxMouseEvent & evt )

                                                          {
    //auto pos_x = evt.GetX();
    //auto pos_y = evt.GetY();
    //auto rect  = p->image_printer_bed->GetRect();
    //if ((pos_x <= 0 || pos_y <= 0 || pos_x >= rect.GetWidth()) && p->big_bed_image_popup) {
    if (p->big_bed_image_popup) {
        bool was_visible = p->big_bed_image_popup->IsShown();
        p->big_bed_image_popup->on_hide();
        if(!p->combo_printer_bed->is_drop_down() && was_visible)
            p->combo_printer_bed->SetFocus();     // set focus back to bed type combo. this prevents weird look if focus on other item
    }
}

References p, and Slic3r::GUI::wxMouseEvent.

Referenced by Sidebar().

Here is the caller graph for this function:

◆ on_size()

void Slic3r::GUI::Sidebar::on_size ( SimpleEvent & e )

                                    {
    if (m_sna_dialog && m_sna_dialog->IsShown()) {
        pop_sync_nozzle_and_ams_dialog();
    }
    if (m_fna_dialog && m_fna_dialog->IsShown()) {
        pop_finsish_sync_ams_dialog();
    }
}

References m_fna_dialog, m_sna_dialog, pop_finsish_sync_ams_dialog(), and pop_sync_nozzle_and_ams_dialog().

Here is the call graph for this function:

◆ operator=() [1/2]

Sidebar & Slic3r::GUI::Sidebar::operator= ( const Sidebar & )

delete

References Sidebar(), is_dark(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

◆ operator=() [2/2]

Sidebar & Slic3r::GUI::Sidebar::operator= ( Sidebar && )

delete

References Sidebar().

Here is the call graph for this function:

◆ pop_finsish_sync_ams_dialog()

void Slic3r::GUI::Sidebar::pop_finsish_sync_ams_dialog ( )

{
    wxTheApp->CallAfter([this]() {
        wxPoint small_btn_pt;
        wxSize  small_btn_size;
        get_small_btn_sync_pos_size(small_btn_pt, small_btn_size);
 
        FinishSyncAmsDialog::InputInfo temp_fsa_info;
        temp_fsa_info.dialog_pos.y                       = small_btn_pt.y;
        setup_dialog_position(temp_fsa_info);
        temp_fsa_info.ams_btn_pos                        = small_btn_pt + wxPoint(small_btn_size.x / 2, small_btn_size.y / 2);
        if (m_sna_dialog) { m_sna_dialog->on_hide(); }
        if (m_fna_dialog) {
            m_fna_dialog->Destroy();
            m_fna_dialog = nullptr;
        }
        m_fna_dialog = new FinishSyncAmsDialog(temp_fsa_info);
        m_fna_dialog->on_show();
    });
 
}

References Slic3r::GUI::FinishSyncAmsDialog::InputInfo::ams_btn_pos, Slic3r::GUI::FinishSyncAmsDialog::InputInfo::dialog_pos, get_small_btn_sync_pos_size(), m_fna_dialog, m_sna_dialog, and Slic3r::GUI::setup_dialog_position().

Referenced by on_size(), and sync_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pop_sync_nozzle_and_ams_dialog()

void Slic3r::GUI::Sidebar::pop_sync_nozzle_and_ams_dialog ( )

                                             {
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " begin pop_sync_nozzle_and_ams_dialog";
    auto agent = wxGetApp().getAgent();
    if (!agent || agent->get_filament_sync_mode() == FilamentSyncMode::none) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament synchronization is not supported; skipping dialog";
        return;
    }
    wxTheApp->CallAfter([this]() {
        SyncNozzleAndAmsDialog::InputInfo temp_na_info;
        wxPoint                           big_btn_pt;
        wxSize                            big_btn_size;
        wxGetApp().plater()->sidebar().get_big_btn_sync_pos_size(big_btn_pt, big_btn_size);
        temp_na_info.dialog_pos = big_btn_pt + wxPoint(big_btn_size.x, big_btn_size.y) + wxPoint(FromDIP(big_btn_size.x / 10.f - 5), FromDIP(big_btn_size.y / 10.f));
 
        temp_na_info.dialog_pos.y += FromDIP(2);
        setup_dialog_position(temp_na_info);
 
        wxPoint small_btn_pt;
        wxSize  small_btn_size;
        get_small_btn_sync_pos_size(small_btn_pt, small_btn_size);
        temp_na_info.ams_btn_pos = small_btn_pt + wxPoint(small_btn_size.x / 2, small_btn_size.y / 2);
        if (m_fna_dialog) { m_fna_dialog->on_hide(); }
        if (m_sna_dialog) {
            m_sna_dialog->Destroy();
            m_sna_dialog = nullptr;
        }
        m_sna_dialog = new SyncNozzleAndAmsDialog(temp_na_info);
        m_sna_dialog->on_show();
    });
}

References Slic3r::GUI::SyncNozzleAndAmsDialog::InputInfo::ams_btn_pos, Slic3r::GUI::SyncNozzleAndAmsDialog::InputInfo::dialog_pos, get_small_btn_sync_pos_size(), m_fna_dialog, m_sna_dialog, Slic3r::none, and Slic3r::GUI::setup_dialog_position().

Referenced by deal_btn_sync(), and on_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_panel()

wxPanel * Slic3r::GUI::Sidebar::print_panel ( )

{
    return p->m_panel_print_content;
}

References p.

◆ printer_combox()

PlaterPresetComboBox * Slic3r::GUI::Sidebar::printer_combox ( )

{
    return p->combo_printer;
}

References p.

◆ recalc_filament_scroll_sizes()

void Slic3r::GUI::Sidebar::recalc_filament_scroll_sizes ( )

{
    if (!p->m_mixed_scroll_area || !p->m_mixed_scroll_area->GetSizer())
        return;
 
    // Same preferred-row budget the physical list uses, so both lists cap consistently.
    auto left_sizer  = p->sizer_filaments->GetItem((size_t) 0)->GetSizer();
    auto combo_sizer = left_sizer->GetItem((size_t) 0)->GetSizer();
    const int row_h  = combo_sizer ? combo_sizer->GetSize().GetHeight() : 0;
    int preferred_rows = std::ceil(0.5 * std::stoi(wxGetApp().app_config->get("filaments_area_preferred_count")));
    const int max_h = (row_h > 0) ? preferred_rows * row_h : -1;
 
    auto content_size = p->m_mixed_scroll_area->GetSizer()->GetMinSize();
    if (max_h > 0 && content_size.y > max_h) {
        p->m_mixed_scroll_area->SetMaxSize({-1, max_h});
        content_size.y = max_h;
    } else {
        p->m_mixed_scroll_area->SetMaxSize({-1, -1});
    }
    p->m_mixed_scroll_area->SetMinSize({0, content_size.y});
}

References p.

Referenced by on_filament_count_change(), on_filaments_delete(), and update_mixed_filament_list().

Here is the caller graph for this function:

◆ remove_all_mixed_filaments()

void Slic3r::GUI::Sidebar::remove_all_mixed_filaments ( )

{
    auto *plater = dynamic_cast<Plater *>(GetParent());
    if (plater == nullptr)
        return;
    const size_t count = plater->mixed_filament_config_indices().size();
    if (count == 0)
        return;
 
    // Worth a confirmation: this drops filament slots the model may be painted with, and anything
    // painted in one falls back to a plain filament.
    MessageDialog dlg(this, format_wxstr(_L_PLURAL("Remove %1% mixed filament?", "Remove all %1% mixed filaments?", count), count), _L("Mixed Filament"),
                      wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION);
    if (dlg.ShowModal() != wxID_YES)
        return;
 
    // Back to front: delete_mixed_filament_at() indexes the list as it stands, so removing from the end
    // leaves the indices of everything still to go untouched.
    for (size_t i = count; i-- > 0;)
        delete_mixed_filament_at(i);
}

References _L, _L_PLURAL, count, delete_mixed_filament_at(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::plater(), and Slic3r::GUI::DPIAware::ShowModal().

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_unused_filament_combos()

void Slic3r::GUI::Sidebar::remove_unused_filament_combos ( const size_t current_extruder_count )

{
    if (current_extruder_count >= p->combos_filament.size())
        return;
    while (p->combos_filament.size() > current_extruder_count) {
        const int last = p->combos_filament.size() - 1;
        auto sizer_filaments = this->p->sizer_filaments->GetItem(last % 2)->GetSizer();
        sizer_filaments->Remove(last / 2);
        (*p->combos_filament[last]).Destroy();
        p->combos_filament.pop_back();
    }
    // BBS:  filament double columns
    auto sizer_filaments0 = this->p->sizer_filaments->GetItem((size_t)0)->GetSizer();
    auto sizer_filaments1 = this->p->sizer_filaments->GetItem(1)->GetSizer();
    if (current_extruder_count < 2) {
        sizer_filaments1->Clear();
    } else {
        size_t c0 = sizer_filaments0->GetChildren().GetCount();
        size_t c1 = sizer_filaments1->GetChildren().GetCount();
        if (c0 < c1)
            sizer_filaments1->Remove(c1 - 1);
        else if (c0 > c1)
            sizer_filaments1->AddStretchSpacer(1);
    }
}

References p.

Referenced by on_filament_count_change().

Here is the caller graph for this function:

◆ reset_bed_type_combox_choices()

bool Slic3r::GUI::Sidebar::reset_bed_type_combox_choices ( bool is_sidebar_init = false )

{
    if (!p->combo_printer_bed) {
        return false;
    }
 
    auto pm = p->plater->get_curr_printer_model();
    if (pm) {
        if (m_cur_image_bed_type != pm->image_bed_type) {
            m_cur_image_bed_type = pm->image_bed_type;
        }
    }
    if (m_last_combo_bedtype_count != 0 && pm) {
        auto cur_count = (int) BedType::btCount - 1 - pm->not_support_bed_types.size();
        if (cur_count == m_last_combo_bedtype_count) {//no change
            return false;
        }
    }
    const ConfigOptionDef *bed_type_def = print_config_def.get("curr_bed_type");
    p->combo_printer_bed->Clear();
    m_cur_combox_bed_types.clear();
    if (pm &&bed_type_def && bed_type_def->enum_keys_map) {
        int index = 0;
        for (auto item : bed_type_def->enum_labels) {
            index++;
            bool find = std::find(pm->not_support_bed_types.begin(), pm->not_support_bed_types.end(), item) != pm->not_support_bed_types.end();
            if (find) {
                continue;
            }
            m_cur_combox_bed_types.emplace_back(BedType(index));//BedType //btPC =1
            p->combo_printer_bed->AppendString(_L(item));
        }
    }
    else {
        m_cur_image_bed_type = "";
        int index = 0;
        for (auto item : bed_type_def->enum_labels) {
            index++;
            m_cur_combox_bed_types.emplace_back(BedType(index)); // BedType //btPC =1
            p->combo_printer_bed->AppendString(_L(item));
        }
    }
    m_last_combo_bedtype_count = p->combo_printer_bed->GetCount();
    if (!is_sidebar_init) {
        p->plater->get_partplate_list().check_all_plate_local_bed_type(m_cur_combox_bed_types);
    }
    return true;
}

References _L, Slic3r::btCount, Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, m_cur_combox_bed_types, m_cur_image_bed_type, m_last_combo_bedtype_count, p, and Slic3r::print_config_def.

Referenced by Sidebar(), and update_all_preset_comboboxes().

Here is the caller graph for this function:

◆ reset_fila_switch()

void Slic3r::GUI::Sidebar::reset_fila_switch ( )

{
    p->update_extruder_separator_icon(false, false);
}

References p.

◆ scrolled_panel()

wxPanel * Slic3r::GUI::Sidebar::scrolled_panel ( )

{
    return p->scrolled;
}

References p.

◆ search()

void Slic3r::GUI::Sidebar::search ( )

{
    p->searcher.search();
}

References p.

◆ set_bed_type_accord_combox()

void Slic3r::GUI::Sidebar::set_bed_type_accord_combox ( BedType bed_type )

                                                         {
    for (size_t i = 0; i < m_cur_combox_bed_types.size(); i++) {
        if (m_cur_combox_bed_types[i] == bed_type) {
            p->combo_printer_bed->SelectAndNotify(i);
            return;
        }
    }
    p->combo_printer_bed->SelectAndNotify(0);
}

References m_cur_combox_bed_types, and p.

Referenced by update_all_preset_comboboxes().

Here is the caller graph for this function:

◆ set_btn_label()

void Slic3r::GUI::Sidebar::set_btn_label	(	const ActionButtonType	btn_type,
		const wxString &	label ) const

{
    switch (btn_type)
    {
        case ActionButtonType::abReslice:   p->btn_reslice->SetLabelText(label);        break;
        case ActionButtonType::abExport:    p->btn_export_gcode->SetLabelText(label);   break;
        case ActionButtonType::abSendGCode: /*p->btn_send_gcode->SetLabelText(label);*/     break;
    }
}

References Slic3r::GUI::abExport, Slic3r::GUI::abReslice, Slic3r::GUI::abSendGCode, and p.

◆ set_extruder_nozzle_count()

void Slic3r::GUI::Sidebar::set_extruder_nozzle_count	(	int	extruder_id,
		int	nozzle_count )

{
    if (!p)
        return;
    if (extruder_id == 0) {
        p->left_extruder->SetCount(nozzle_count);
        p->single_extruder->SetCount(nozzle_count);
    } else if (extruder_id == 1) {
        p->right_extruder->SetCount(nozzle_count);
    }
}

References p.

◆ set_flushing_volume_warning()

void Slic3r::GUI::Sidebar::set_flushing_volume_warning ( const bool flushing_volume_modify )

{
    if(flushing_volume_modify){
        p->m_flushing_volume_btn->SetStyle(ButtonStyle::Regular, ButtonType::Compact);
        p->m_flushing_volume_btn->SetBorderColor(wxColour("#FF6F00"));
    }
    else
        p->m_flushing_volume_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Compact);
}

References Compact, Confirm, p, and Regular.

Referenced by Sidebar(), auto_calc_flushing_volumes(), Slic3r::GUI::Plater::load_project(), msw_rescale(), and sys_color_changed().

Here is the caller graph for this function:

◆ set_need_auto_sync_after_connect_printer()

void Slic3r::GUI::Sidebar::set_need_auto_sync_after_connect_printer ( bool need_auto_sync )

inline

323{ m_need_auto_sync_after_connect_printer = need_auto_sync; }

References m_need_auto_sync_after_connect_printer.

Referenced by Slic3r::GUI::MonitorPanel::on_machine_selected(), and Slic3r::GUI::MainFrame::update_layout().

Here is the caller graph for this function:

◆ settings_index()

Search::SettingsIndex & Slic3r::GUI::Sidebar::settings_index ( )

{
    return p->searcher.index();
}

References p.

◆ should_show_SEMM_buttons()

bool Slic3r::GUI::Sidebar::should_show_SEMM_buttons ( )

static

{
    PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
    bool is_bbl_vendor = preset_bundle.is_bbl_vendor();
    auto cfg = preset_bundle.printers.get_edited_preset().config;
 
    return cfg.opt_bool("single_extruder_multi_material") || is_bbl_vendor;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::DynamicConfig::opt_bool(), and Slic3r::PresetBundle::printers.

Referenced by Slic3r::GUI::MenuFactory::create_filament_action_menu(), init_filament_combo(), Slic3r::GUI::GLCanvas3D::is_flushing_matrix_error(), and show_SEMM_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_eject()

bool Slic3r::GUI::Sidebar::show_eject ( bool show ) const

◆ show_export()

bool Slic3r::GUI::Sidebar::show_export ( bool show ) const

6709{ return p->btn_export_gcode->Show(show); }

References p.

◆ show_export_removable()

bool Slic3r::GUI::Sidebar::show_export_removable ( bool show ) const

6711{ return p->btn_export_gcode_removable->Show(show); }

References p.

◆ show_mode_sizer()

void Slic3r::GUI::Sidebar::show_mode_sizer ( bool show )

{
    //p->mode_sizer->Show(show);
}

◆ show_object_list()

bool Slic3r::GUI::Sidebar::show_object_list ( bool show ) const

{
    p->m_search_bar->Show(show);
    if (!p->m_object_list->Show(show))
        return false;
    if (!show)
        p->object_layers->Show(false);
    else
        p->m_object_list->part_selection_changed();
    p->scrolled->Layout();
    return true;
}

References p.

◆ show_reslice()

bool Slic3r::GUI::Sidebar::show_reslice ( bool show ) const

6708{ return p->btn_reslice->Show(show); }

References p.

◆ show_SEMM_buttons()

void Slic3r::GUI::Sidebar::show_SEMM_buttons ( )

{
    // ORCA
    if (!p || p->combos_filament.empty() || !p->m_bpButton_add_filament || !p->m_bpButton_del_filament || !p->m_flushing_volume_btn)
        return;
    
    bool is_multi_material = p->combos_filament.size() > 1;
    bool single_or_bbl     = should_show_SEMM_buttons();
    bool is_single = single_or_bbl && !is_multi_material; // SINGLE EXTRUDER / BBL WITH 1 MATERIAL
    bool is_multi  = single_or_bbl && is_multi_material;  // MULTI MATERIAL WITH SINGLE EXTRUDER
    bool is_fixed  = !is_single && !is_multi;             // MULTI EXTRUDER / TOOLCHANGER / IDEX WITH FIXED MATERIAL
 
    p->m_bpButton_add_filament->Show(single_or_bbl);
    p->m_bpButton_del_filament->Show(is_multi);
    p->m_flushing_volume_btn->Show(  is_multi);
 
    if (is_multi) {
        for (auto &c : p->combos_filament)
            c->edit_btn->SetBitmap_("menu_filament");
    }
    else if (is_single || is_fixed) {
        for (auto &c : p->combos_filament)
            c->edit_btn->SetBitmap_("edit");
    }
 
    Layout();
}

References p, and should_show_SEMM_buttons().

Referenced by on_filament_count_change(), on_filaments_delete(), and update_all_preset_comboboxes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_send()

bool Slic3r::GUI::Sidebar::show_send ( bool show ) const

6710{ return p->btn_send_gcode->Show(show); }

References p.

◆ sync_ams_list()

void Slic3r::GUI::Sidebar::sync_ams_list ( bool is_from_big_sync_btn = false )

{
    wxBusyCursor cursor;
    // Force load ams list
    auto obj = wxGetApp().getDeviceManager()->get_selected_machine();
    if (!obj)
        return;
    GUI::wxGetApp().sidebar().load_ams_list(obj);
 
    auto & list = wxGetApp().preset_bundle->filament_ams_list;
    if (list.empty()) {
        auto printer_name = p->plater->get_selected_printer_name_in_combox();
        p->plater->pop_warning_and_go_to_device_page(printer_name, Plater::PrinterWarningType::NOT_CONNECTED, _L("Sync printer information"));
        return;
    }
    bool exist_at_list_one_filament =false;
    for (auto &cur : list) {
        auto temp_config    = cur.second;
        auto filament_type  = temp_config.opt_string("filament_type", 0u);
        auto filament_color = temp_config.opt_string("filament_colour", 0u);
        if (!filament_type.empty() || temp_config.opt_bool("filament_exist", 0u)) {
            exist_at_list_one_filament = true;
            break;
        }
    }
    if (!exist_at_list_one_filament) {
        if (!obj->is_filament_installed()) {
            p->plater->pop_warning_and_go_to_device_page("", Plater::PrinterWarningType::UNINSTALL_FILAMENT, _L("Sync printer information"));
            return;
        }
        p->plater->pop_warning_and_go_to_device_page("", Plater::PrinterWarningType::EMPTY_FILAMENT, _L("Sync printer information"));
        return;
    }
    if (!wxGetApp().plater()->is_same_printer_for_connected_and_selected()) {
        return;
    }
    std::string ams_filament_ids = wxGetApp().app_config->get("ams_filament_ids", p->ams_list_device);
    std::vector<std::string> list2;
    if (!ams_filament_ids.empty()) {
        boost::algorithm::split(list2, ams_filament_ids, boost::algorithm::is_any_of(","));
    }
    wxGetApp().plater()->update_all_plate_thumbnails(true);//preview thumbnail for sync_dlg
    SyncAmsInfoDialog::SyncInfo temp_info;
    temp_info.use_dialog_pos = false;
    temp_info.cancel_text_to_later = is_from_big_sync_btn;
    if (m_sync_dlg == nullptr) {
        m_sync_dlg = new SyncAmsInfoDialog(this, temp_info);
    } else {
        m_sync_dlg->set_info(temp_info);
    }
    int dlg_res{(int) wxID_CANCEL};
    if (m_sync_dlg->is_need_show()) {
        m_sync_dlg->deal_only_exist_ext_spool(obj);
        if (m_sync_dlg->is_dirty_filament()) {
            wxGetApp().get_tab(Preset::TYPE_FILAMENT)->select_preset(wxGetApp().preset_bundle->filament_presets[0], false, "", false, true);
            wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
            update_dynamic_filament_list();
        }
        m_sync_dlg->set_check_dirty_fialment(false);
        dlg_res = m_sync_dlg->ShowModal();
    } else {
        dlg_res =(int) wxID_YES;
    }
    if (dlg_res == wxID_CANCEL)
        return;
    auto sync_result = m_sync_dlg->get_result();
    if (!sync_result.is_same_printer) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "check error: sync_result.is_same_printer value is false";
        return;
    }
    list2.resize(list.size());
    auto iter = list.begin();
    for (int i = 0; i < list.size(); ++i, ++iter) {
        auto & ams = iter->second;
        auto filament_id = ams.opt_string("filament_id", 0u);
        ams.set_key_value("filament_changed", new ConfigOptionBool{dlg_res == wxID_YES || list2[i] != filament_id});
        list2[i] = filament_id;
    }
 
    // BBS:Record consumables information before synchronization
    std::vector<std::string> color_before_sync;
    std::vector<bool>   is_support_before;
    DynamicPrintConfig& project_config = wxGetApp().preset_bundle->project_config;
    ConfigOptionStrings* color_opt = project_config.option<ConfigOptionStrings>("filament_colour");
    for (int i = 0; i < p->combos_filament.size(); ++i) {
        is_support_before.push_back(is_support_filament(i));
        color_before_sync.push_back(color_opt->values[i]);
    }
    MergeFilamentInfo merge_info;
    std::vector<std::pair<DynamicPrintConfig *,std::string>> unknowns;
    auto enable_append  = wxGetApp().app_config->get_bool("enable_append_color_by_sync_ams");
    auto sync_color_only = wxGetApp().app_config->get("sync_ams_filament_mode") == "1";
    auto n              = wxGetApp().preset_bundle->sync_ams_list(unknowns, !sync_result.direct_sync, sync_result.sync_maps, enable_append, merge_info, sync_color_only);
    wxString detail;
    for (auto & uk : unknowns) {
        auto tray_name     = uk.first->opt_string("tray_name", 0u);
        auto filament_type = uk.first->opt_string("filament_type", 0u);
        detail += from_u8("\n- " + tray_name + "(" + filament_type + ") ") + _L(uk.second);
    }
    if (n == 0) {
        MessageDialog dlg(this,
            _L("There are no compatible filaments, and sync is not performed.") + detail,
            _L("Sync filaments with AMS"), wxOK);
        dlg.ShowModal();
        return;
    }
    // Replace unknown filament IDs with the resolved preset's filament_id
    auto &filaments        = wxGetApp().preset_bundle->filaments;
    auto &filament_presets = wxGetApp().preset_bundle->filament_presets;
    for (size_t i = 0; i < list2.size() && i < filament_presets.size(); ++i) {
        if (list2[i] == UNKNOWN_FILAMENT_ID) {
            const Preset *resolved = filaments.find_preset(filament_presets[i]);
            if (resolved)
                list2[i] = resolved->filament_id;
        }
    }
    ams_filament_ids = boost::algorithm::join(list2, ",");
    wxGetApp().app_config ->set("ams_filament_ids", p->ams_list_device, ams_filament_ids);
    if (!unknowns.empty()) {
        MessageDialog dlg(this,
            _L("There are some unknown or incompatible filaments mapped to generic preset.\nPlease update Orca Slicer or restart Orca Slicer to check if there is an update to system presets.") + detail,
            _L("Sync filaments with AMS"), wxOK);
        dlg.ShowModal();
    }
    if (!sync_color_only) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "on_filament_count_change";
        wxGetApp().plater()->on_filament_count_change(n);
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "finish on_filament_count_change";
    }
    for (auto& c : p->combos_filament)
        c->update();
    // Expand filament list
    update_filaments_area_height(); // ORCA
 
    // BBS:Synchronized consumables information
    // auto calculation of flushing volumes
    for (int i = 0; i < p->combos_filament.size(); ++i) {
        if (i >= color_before_sync.size()) {
            auto_calc_flushing_volumes(i);
        }
        else if(color_before_sync[i] != color_opt->values[i] && wxGetApp().app_config->get("auto_calculate_flush") != "disabled"){
            auto_calc_flushing_volumes(i);
        }
        else if(is_support_filament(i) !=is_support_before[i] && wxGetApp().app_config->get("auto_calculate_flush") == "all"){
            auto_calc_flushing_volumes(i);
        }
    }
    Layout();
 
    // For full sync, preset selection/list update may rebuild combo widgets.
    // For color-only, keep current presets untouched and refresh colors only.
    if (!sync_color_only) {
        wxGetApp().get_tab(Preset::TYPE_FILAMENT)->select_preset(wxGetApp().preset_bundle->filament_presets[0]);
        wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
        update_dynamic_filament_list();
    } else {
        wxGetApp().plater()->update_filament_colors_in_full_config();
        for (auto &c : p->combos_filament)
            c->update();
        obj_list()->update_filament_colors();
        update_dynamic_filament_list();
    }
 
    auto badge_combox_filament = [sync_color_only](PlaterPresetComboBox *c) {
        auto tip     = sync_color_only ? _L("Only filament color information has been synchronized from printer.") :
                                         _L("Filament type and color information have been synchronized, but slot information is not included.");
        c->SetToolTip(tip);
        c->set_sync_badge(true);
    };
    { // badge ams filament
        clear_combos_filament_badge();
        if (sync_result.direct_sync) {
            // A placeholder contributes a preserved project filament to the
            // overwrite result, but it is not AMS-sourced and must not get a
            // sync badge. Non-placeholder empty trays are omitted entirely.
            size_t combo_index = 0;
            for (const auto &entry : wxGetApp().preset_bundle->filament_ams_list) {
                const auto &tray = entry.second;
                const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
                const bool is_placeholder = tray.has("filament_slot_placeholder") &&
                                             tray.opt_bool("filament_slot_placeholder", 0u);
                if (!has_filament && !is_placeholder) {
                    continue;
                }
                if (combo_index >= p->combos_filament.size()) {
                    break;
                }
                if (is_placeholder) {
                    p->combos_filament[combo_index]->set_sync_badge(false);
                } else {
                    badge_combox_filament(p->combos_filament[combo_index]);
                }
                ++combo_index;
            }
        }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "prepare enable_merge_color_by_sync_ams";
    if (!merge_info.is_empty() && wxGetApp().app_config->get_bool("enable_merge_color_by_sync_ams")) { // merge same color and preset filament//use same ams
        auto reduce_index = [](MergeFilamentInfo &merge_info,int value) {
            for (size_t i = 0; i < merge_info.merges.size(); i++) {
                auto &cur = merge_info.merges[i];
                for (size_t j = 0; j < cur.size(); j++) {
                    if (value < cur[j]) {
                        cur[j] = cur[j] - 1;
                    }
                }
            }
        };
        std::vector<bool> sync_ams_badges;
        for (auto iter : sync_result.sync_maps) {
            sync_ams_badges.push_back(false);
            if (iter.second.ams_id == "" || iter.second.slot_id == "") {
                continue;
            }
            sync_ams_badges.back() = true;
        }
 
        for (size_t i = 0; i < merge_info.merges.size(); i++) {
            auto& cur = merge_info.merges[i];
            for (int j = cur.size() -1; j >= 1 ; j--) {
                auto last_index = cur[j];
                change_filament(last_index, cur[0]);
                cur.erase(cur.begin() + j);
                sync_ams_badges.erase(sync_ams_badges.begin() + last_index);
                reduce_index(merge_info, last_index);
            }
        }
        for (size_t i = 0; i < sync_ams_badges.size(); i++) {
            if (sync_ams_badges[i] == true) {
                if (i < p->combos_filament.size()) {
                    auto &c = p->combos_filament[i];
                    badge_combox_filament(c);
                } else {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "check error: p->combos_filament array out of bound";
                }
            }
        }
    } else {
        for (auto iter : sync_result.sync_maps) {
            if (iter.second.ams_id == "" || iter.second.slot_id == "") {
                continue;
            }
            auto temp_index = iter.first;
            if (temp_index < p->combos_filament.size() && temp_index >= 0) {
                auto &c        = p->combos_filament[temp_index];
                badge_combox_filament(c);
            }
        }
    }
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "begin pop_finsish_sync_ams_dialog";
    pop_finsish_sync_ams_dialog();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "finish pop_finsish_sync_ams_dialog";
}

References _L, auto_calc_flushing_volumes(), Slic3r::GUI::SyncAmsInfoDialog::SyncInfo::cancel_text_to_later, change_filament(), clear_combos_filament_badge(), combos_filament(), Slic3r::GUI::Plater::EMPTY_FILAMENT, Slic3r::Preset::filament_id, Slic3r::filament_type(), Slic3r::GUI::from_u8(), Slic3r::MergeFilamentInfo::is_empty(), Slic3r::GUI::is_support_filament(), m_sync_dlg, Slic3r::MergeFilamentInfo::merges, Slic3r::GUI::Plater::NOT_CONNECTED, obj_list(), Slic3r::ConfigBase::option(), p, Slic3r::GUI::plater(), pop_finsish_sync_ams_dialog(), Slic3r::GUI::DPIAware::ShowModal(), Slic3r::Preset::TYPE_FILAMENT, Slic3r::GUI::Plater::UNINSTALL_FILAMENT, UNKNOWN_FILAMENT_ID, update_dynamic_filament_list(), Slic3r::GUI::ObjectList::update_filament_colors(), update_filaments_area_height(), Slic3r::GUI::SyncAmsInfoDialog::SyncInfo::use_dialog_pos, and Slic3r::ConfigOptionVector< T >::values.

Referenced by Sidebar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sync_extruder_list()

bool Slic3r::GUI::Sidebar::sync_extruder_list ( )

{
    bool only_external_material;
    return p->sync_extruder_list(only_external_material);
}

References p.

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

Here is the caller graph for this function:

◆ sys_color_changed()

void Slic3r::GUI::Sidebar::sys_color_changed ( )

{
    wxWindowUpdateLocker noUpdates(this);
 
#if 0
    for (wxWindow* win : std::vector<wxWindow*>{ this, p->sliced_info->GetStaticBox(), p->object_info->GetStaticBox(), p->btn_reslice, p->btn_export_gcode })
        wxGetApp().UpdateDarkUI(win);
    p->object_info->msw_rescale();
 
    for (wxWindow* win : std::vector<wxWindow*>{ p->scrolled, p->presets_panel })
        wxGetApp().UpdateAllStaticTextDarkUI(win);
#endif
    //p->btn_sync_printer->SetIcon("printer_sync");
    p->m_printer_bbl_sync->msw_rescale();
    p->m_printer_connect->msw_rescale();
    // for (wxWindow* btn : std::vector<wxWindow*>{ p->btn_reslice, p->btn_export_gcode })
    //    wxGetApp().UpdateDarkUI(btn, true);
    p->m_printer_icon->msw_rescale();
    p->m_printer_setting->msw_rescale();
    p->m_printer_setting->msw_rescale();
    p->m_filament_icon->msw_rescale();
    p->m_bpButton_add_filament->msw_rescale();
    p->m_bpButton_del_filament->msw_rescale();
    p->m_bpButton_ams_filament->msw_rescale();
    p->m_bpButton_set_filament->msw_rescale();
    p->m_purge_mode_btn->Rescale();
    p->m_flushing_volume_btn->Rescale();
    set_flushing_volume_warning(is_flush_config_modified()); // ORCA reapply appearance
 
    // BBS
#if 0
    if (p->mode_sizer)
        p->mode_sizer->msw_rescale();
    p->frequently_changed_parameters->sys_color_changed();
#endif
    p->object_settings->sys_color_changed();
 
    //BBS: remove print related combos
#if 0
    for (PlaterPresetComboBox* combo : std::vector<PlaterPresetComboBox*>{  p->combo_print,
                                                                p->combo_sla_print,
                                                                p->combo_sla_material,
                                                                p->combo_printer })
        combo->sys_color_changed();
#endif
    p->combo_printer->sys_color_changed();
    for (PlaterPresetComboBox* combo : p->combos_filament)
        combo->sys_color_changed();
 
    if (p->big_bed_image_popup) // ORCA
        p->big_bed_image_popup->sys_color_changed();
 
    p->btn_edit_printer->msw_rescale();
    p->image_printer->SetSize(FromDIP(PRINTER_THUMBNAIL_SIZE));
    p->image_printer_bed->SetSize(FromDIP(PRINTER_THUMBNAIL_SIZE));
 
    for (ExtruderGroup *ext : {p->left_extruder, p->right_extruder, p->single_extruder})
        if (ext)
            ext->sys_color_changed();
 
    // call a kill focus event to ensure new colors applied
    for (ComboBox* combo : std::vector<ComboBox*>{p->combo_printer, p->combo_nozzle_dia, p->combo_printer_bed}){
        wxFocusEvent fakeEvent(wxEVT_KILL_FOCUS);
        fakeEvent.SetEventObject(combo);
        combo->HandleWindowEvent(fakeEvent);
    }
 
    // BBS
    obj_list()->sys_color_changed();
    obj_layers()->sys_color_changed();
    // BBS
    //p->object_manipulation->sys_color_changed();
 
    // btn...->msw_rescale() updates icon on button, so use it
    //p->btn_send_gcode->msw_rescale();
//    p->btn_eject_device->msw_rescale();
    //p->btn_export_gcode_removable->msw_rescale();
 
    p->scrolled->Layout();
 
    // Mixed rows are custom-drawn, so they need rebuilding for the new theme colours.
    update_mixed_filament_list();
 
    p->searcher.dlg_sys_color_changed();
}

References is_flush_config_modified(), obj_layers(), obj_list(), p, PRINTER_THUMBNAIL_SIZE, set_flushing_volume_warning(), Slic3r::GUI::ObjectLayers::sys_color_changed(), Slic3r::GUI::ObjectList::sys_color_changed(), Slic3r::GUI::PlaterPresetComboBox::sys_color_changed(), and update_mixed_filament_list().

Here is the call graph for this function:

◆ udpate_combos_filament_badge()

void Slic3r::GUI::Sidebar::udpate_combos_filament_badge ( )

                                           {
    auto &combos_filament = p->combos_filament;
    for (auto &c : combos_filament) {
        c->update_badge_according_flag();
    }
 
}

References combos_filament(), and p.

Here is the call graph for this function:

◆ update_all_preset_comboboxes()

void Slic3r::GUI::Sidebar::update_all_preset_comboboxes ( )

{
    PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
    const auto print_tech = preset_bundle.printers.get_edited_preset().printer_technology();
 
    bool is_bbl_vendor = preset_bundle.is_bbl_vendor();
 
    auto p_mainframe = wxGetApp().mainframe;
    auto cfg = preset_bundle.printers.get_edited_preset().config;
    const bool use_printer_agents = wxGetApp().app_config->get_bool("use_printer_agents");
    const bool use_native_device_tab = preset_bundle.use_bbl_device_tab() || use_printer_agents;
 
    if (preset_bundle.use_bbl_network()) {
        //only show connection button for not-BBL printer
        //p->btn_connect_printer->Hide();
        p->m_printer_connect->Hide();
        //only show sync-ams button for BBL printer
        p->m_bpButton_ams_filament->Show();
        //update print button default value for bbl or third-party printer
        p_mainframe->set_print_button_to_default(MainFrame::PrintSelectType::ePrintPlate);
    } else {
        //p->btn_connect_printer->Show();
        // ORCA: hide the physical-printer connection button when printer agents are enabled
        p->m_printer_connect->Show(!use_printer_agents);
 
        // ORCA: show/hide sync-ams button based on filament sync mode
        auto agent = wxGetApp().getAgent();
        if (agent && agent->get_filament_sync_mode() != FilamentSyncMode::none)
            p->m_bpButton_ams_filament->Show();
        else
            p->m_bpButton_ams_filament->Hide();
 
        // Orca: with "Support 3MF as gcode" (use_3mf) the local export is a .gcode.3mf bundle, so when no
        // printer host/IP is configured the default action is "Export plate sliced file" (mirrors the
        // print dropdown) instead of "Export G-code file".
        auto print_btn_type = cfg.opt_bool("use_3mf") ? MainFrame::PrintSelectType::eExportSlicedFile
                                                      : MainFrame::PrintSelectType::eExportGcode;
        wxString url = from_u8(PrintHost::get_print_host_webui(&cfg));
        wxString apikey;
        if(url.empty())
            url = file_url_from_path(boost::filesystem::path(resources_dir()) / "web/orca/missing_connection.html");
        else {
            const auto host_type = cfg.option<ConfigOptionEnum<PrintHostType>>("host_type")->value;
            if (cfg.has("printhost_apikey") && (host_type != htSimplyPrint))
                apikey = cfg.opt_string("printhost_apikey");
            print_btn_type = (preset_bundle.is_bbl_vendor() || wxGetApp().app_config->get_bool("use_printer_agents"))
                                 ? MainFrame::PrintSelectType::ePrintPlate
                                 : MainFrame::PrintSelectType::eSendGcode;
        }
 
        if (use_printer_agents)
            p_mainframe->load_printer_url();
        else if (!use_native_device_tab)
            p_mainframe->load_printer_url(url, apikey);
 
 
        p_mainframe->set_print_button_to_default(print_btn_type);
 
    }
 
    if (cfg.opt_bool("pellet_modded_printer")) {
    p->m_staticText_filament_settings->SetLabel(_L("Pellets"));
        p->m_filament_icon->SetBitmap_("pellets");
    } else {
    p->m_staticText_filament_settings->SetLabel(_L("Filament"));
        p->m_filament_icon->SetBitmap_("filament");
    }
 
    show_SEMM_buttons();
 
    //p->m_staticText_filament_settings->Update();
 
    if (is_bbl_vendor || cfg.opt_bool("support_multi_bed_types")) {
        p->combo_printer_bed->Enable();
        // Orca: don't update bed type if loading project
        if (!p->plater->is_loading_project()) {
            bool has_changed = reset_bed_type_combox_choices();
            bool flag         = m_begin_sync_printer_status && !has_changed;
            if (!(flag)) {
                auto str_bed_type = wxGetApp().app_config->get_printer_setting(wxGetApp().preset_bundle->printers.get_selected_preset_name(),
                                                                               "curr_bed_type");
                if (!str_bed_type.empty()) {
                    int bed_type_value = atoi(str_bed_type.c_str());
                    if (bed_type_value <= 0 || bed_type_value >= btCount) {
                        bed_type_value = preset_bundle.printers.get_edited_preset().get_default_bed_type(&preset_bundle);
                    }
 
                   set_bed_type_accord_combox((BedType) bed_type_value);
                } else {
                    BedType bed_type = preset_bundle.printers.get_edited_preset().get_default_bed_type(&preset_bundle);
                    set_bed_type_accord_combox(bed_type);
                }
            } else {
                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ":no need reset_bed_type_combox_choices";
            }
        }
    } else {
        // m_bed_type_list->SelectAndNotify(btPEI - 1);
        BedType bed_type = preset_bundle.printers.get_edited_preset().get_default_bed_type(&preset_bundle);
        set_bed_type_accord_combox(bed_type);
        p->combo_printer_bed->Disable();
    }
 
    // ORCA Hide plate selector if not supported by printer
    p->panel_printer_bed->Show(is_bbl_vendor || cfg.opt_bool("support_multi_bed_types"));
 
    // Update the print choosers to only contain the compatible presets, update the dirty flags.
    //BBS
 
    // Update the printer choosers, update the dirty flags.
    //p->combo_printer->update();
    // Update the filament choosers to only contain the compatible presets, update the color preview,
    // update the dirty flags.
    if (print_tech == ptFFF) {
        for (PlaterPresetComboBox* cb : p->combos_filament)
            cb->update();
    }
 
    if (p->combo_printer) {
        p->combo_printer->update();
        update_printer_thumbnail();
    }
 
    p_mainframe->show_device(use_native_device_tab);
    p_mainframe->m_tabpanel->SetSelection(p_mainframe->m_tabpanel->GetSelection());
}

References _L, Slic3r::btCount, Slic3r::Preset::config, Slic3r::GUI::MainFrame::eExportGcode, Slic3r::GUI::MainFrame::eExportSlicedFile, Slic3r::GUI::MainFrame::ePrintPlate, Slic3r::GUI::MainFrame::eSendGcode, Slic3r::GUI::file_url_from_path(), Slic3r::GUI::from_u8(), Slic3r::Preset::get_default_bed_type(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PrintHost::get_print_host_webui(), Slic3r::PresetCollection::get_selected_preset_name(), Slic3r::htSimplyPrint, Slic3r::PresetBundle::is_bbl_vendor(), m_begin_sync_printer_status, Slic3r::none, p, Slic3r::Preset::printer_technology(), Slic3r::PresetBundle::printers, Slic3r::ptFFF, reset_bed_type_combox_choices(), Slic3r::resources_dir(), set_bed_type_accord_combox(), show_SEMM_buttons(), Slic3r::GUI::PlaterPresetComboBox::update(), update_printer_thumbnail(), Slic3r::PresetBundle::use_bbl_device_tab(), and Slic3r::PresetBundle::use_bbl_network().

Referenced by create_printer_preset(), Slic3r::GUI::Plater::normalize_bed_types(), and update_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_dynamic_filament_list()

void Slic3r::GUI::Sidebar::update_dynamic_filament_list ( )

{
    dynamic_filament_list.update();
    dynamic_physical_filament_list.update();
}

References Slic3r::GUI::dynamic_filament_list, and Slic3r::GUI::dynamic_physical_filament_list.

Referenced by Slic3r::anonymous_namespace{PluginHostPresets.cpp}::bind_filament_target(), edit_mixed_filament(), on_filament_count_change(), on_filaments_delete(), sync_ams_list(), and update_presets().

Here is the caller graph for this function:

◆ update_filaments_area_height()

void Slic3r::GUI::Sidebar::update_filaments_area_height ( )

{
    // ORCA use a height with user preference
    auto left_sizer          = p->sizer_filaments->GetItem((size_t) 0)->GetSizer();
    auto combo_sizer         = left_sizer->GetItem((size_t) 0)->GetSizer();
    int  preferred_rows      = std::ceil(0.5 * std::stoi(wxGetApp().app_config->get("filaments_area_preferred_count")));
    auto height_with_borders = combo_sizer->GetSize().GetHeight(); // gets height from sizer instead static numbers
    p->m_panel_filament_content->SetMaxSize(wxSize{-1, preferred_rows * height_with_borders});
 
    // fixes wxScrolledWindow not shrinks its height to content size
    auto min_size = p->m_panel_filament_content->GetSizer()->GetMinSize();
    if (min_size.y > p->m_panel_filament_content->GetMaxHeight())
        min_size.y = p->m_panel_filament_content->GetMaxHeight();
    p->m_panel_filament_content->SetMinSize({-1, min_size.y});
 
    update_filaments_counter();
}

References p, and update_filaments_counter().

Referenced by Sidebar(), msw_rescale(), on_filament_count_change(), on_filaments_delete(), and sync_ams_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_filaments_counter()

void Slic3r::GUI::Sidebar::update_filaments_counter ( bool force_layout = false )

{
    int  current_count       = p->combos_filament.size();
    int  preferred_count     = std::stoi(wxGetApp().app_config->get("filaments_area_preferred_count"));
    bool isShown             = p->m_panel_filament_content->IsShown();
    auto counter             = p->m_staticText_filament_count;
 
    counter->SetLabel("(" + std::to_string(current_count) + ")"); // update counter on every change
    if(current_count > preferred_count || !isShown)
        counter->Show();
    else if (isShown) // hide when list is visible and short enough
        counter->Hide();
 
    if(force_layout)
        m_scrolled_sizer->Layout();
}

References m_scrolled_sizer, and p.

Referenced by Sidebar(), and update_filaments_area_height().

Here is the caller graph for this function:

◆ update_mixed_filament_list()

void Slic3r::GUI::Sidebar::update_mixed_filament_list ( )

{
    auto* plater = dynamic_cast<Plater*>(GetParent());
    if (!plater) return;
 
    wxWindowUpdateLocker noUpdates(this);
 
    const wxColour mc_bg     = StateColor::darkModeColorFor(*wxWHITE);
    const wxColour mc_border = StateColor::darkModeColorFor(wxColour("#DBDBDB")); // same color with filament combo box border
    const wxColour mc_text   = StateColor::darkModeColorFor(wxColour("#262E30"));
    const wxColour mc_dim    = StateColor::darkModeColorFor(wxColour("#ACACAC"));
 
    auto& project_config = wxGetApp().preset_bundle->project_config;
    auto mixed_indices = plater->mixed_filament_config_indices();
    size_t num_physical = p->combos_filament.size();
 
    auto* is_mixed_opt    = project_config.option<ConfigOptionBools>("filament_is_mixed");
    auto* components_opt  = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    auto* ratios_opt      = project_config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
    auto* colours_opt     = project_config.option<ConfigOptionStrings>("filament_colour");
    auto* grad_opt        = project_config.option<ConfigOptionBools>("filament_mixed_gradient");
    auto* grad_range_opt  = project_config.option<ConfigOptionStrings>("filament_mixed_gradient_range");
 
    bool can_mix = (num_physical >= 2);
    bool has_mixed = can_mix && !mixed_indices.empty();
 
    // Check integrity of mixed filament component references
    std::vector<size_t> broken_slots;
    if (is_mixed_opt && components_opt)
        broken_slots = check_mixed_filament_integrity(is_mixed_opt->values, components_opt->values, num_physical);
    std::set<size_t> broken_set(broken_slots.begin(), broken_slots.end());
 
    // Type consistency check
    if (is_mixed_opt && components_opt) {
        std::vector<std::string> physical_types;
        auto& preset_bundle = *wxGetApp().preset_bundle;
        for (size_t i = 0; i < num_physical; ++i) {
            std::string ft;
            if (i < preset_bundle.filament_presets.size()) {
                auto* preset = preset_bundle.filaments.find_preset(preset_bundle.filament_presets[i]);
                if (preset) {
                    std::string display_type;
                    ft = preset->config.get_filament_type(display_type);
                }
            }
            if (ft.empty()) ft = "PLA";
            physical_types.push_back(ft);
        }
        auto type_mismatch_slots = check_mixed_filament_type_consistency(
            is_mixed_opt->values, components_opt->values, physical_types);
        for (size_t s : type_mismatch_slots)
            broken_set.insert(s);
        broken_slots.insert(broken_slots.end(), type_mismatch_slots.begin(), type_mismatch_slots.end());
    }
 
    bool at_limit = (wxGetApp().preset_bundle->filament_presets.size() >= size_t(EnforcerBlockerType::ExtruderMax));
    p->m_btn_add_mixed_filament->Show(can_mix && !has_mixed && !at_limit);
    p->m_panel_mixed_title->Show(has_mixed);
    p->m_mixed_scroll_area->Show(has_mixed);
    p->m_panel_mixed_content->Show(has_mixed);
    if (p->m_btn_mixed_add)
        p->m_btn_mixed_add->Enable(!at_limit);
    p->m_panel_mixed_warning->Show(false);
 
    // Show/dismiss 3D canvas notification for broken mixed filaments
    auto*       notify        = plater->get_notification_manager();
    GLCanvas3D* view3d_canvas = plater->get_view3D_canvas3D();
    if(view3d_canvas && view3d_canvas->is_initialized() && notify){
        if (has_mixed && !broken_set.empty()) {
            notify->push_notification(NotificationType::BBLMixedFilamentBroken,
                NotificationManager::NotificationLevel::ErrorNotificationLevel,
                _u8L("Mixed filament has invalid or mismatched components. Please re-edit affected entries."));
        } else {
            notify->close_notification_of_type(NotificationType::BBLMixedFilamentBroken);
        }
    }
 
    if (has_mixed) {
        auto* left_col  = p->m_sizer_mixed_filaments->GetItem(size_t(0))->GetSizer();
        auto* right_col = p->m_sizer_mixed_filaments->GetItem(size_t(1))->GetSizer();
        left_col->Clear(true);
        right_col->Clear(true);
 
        std::vector<std::string> physical_colors;
        if (colours_opt) {
            for (size_t i = 0; i < num_physical && i < colours_opt->values.size(); ++i)
                physical_colors.push_back(colours_opt->values[i]);
        }
 
        auto make_swatch_panel = [this](wxWindow* parent, const wxColour& col, unsigned int num) -> wxPanel* {
            int swatch_sz = FromDIP(20);
            auto* panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(swatch_sz, swatch_sz));
            panel->SetMinSize(wxSize(swatch_sz, swatch_sz));
            bool is_dark = wxGetApp().dark_mode();
            panel->Bind(wxEVT_PAINT, [panel, col, num, is_dark](wxPaintEvent&) {
                wxPaintDC dc(panel);
                wxSize sz = panel->GetClientSize();
                dc.SetBackground(wxBrush(col));
                dc.Clear();
                if (!is_dark && col.Red() > 224 && col.Green() > 224 && col.Blue() > 224) {
                    dc.SetPen(wxPen(wxColour(130, 130, 128), 1));
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
                }
                if (is_dark && col.Red() < 45 && col.Green() < 45 && col.Blue() < 45) {
                    dc.SetPen(wxPen(wxColour(207, 207, 207), 1));
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
                }
                wxString txt = wxString::Format("%u", num);
                dc.SetFont(::Label::Body_14);
                wxSize txt_sz = dc.GetTextExtent(txt);
                dc.SetTextForeground(col.GetLuminance() > 0.5 ? wxColour(50, 58, 61) : *wxWHITE);
                dc.DrawText(txt, (sz.GetWidth() - txt_sz.GetWidth()) / 2,
                                 (sz.GetHeight() - txt_sz.GetHeight()) / 2);
            });
            return panel;
        };
 
        for (size_t i = 0; i < mixed_indices.size(); ++i) {
            size_t cfg_idx = mixed_indices[i];
            auto* combo_and_btn_sizer = new wxBoxSizer(wxHORIZONTAL);
            
            if (i == 0 || i % 2 == 0) // dont add left margin for right column items so all horizontal margins will be equal like on filaments section
                combo_and_btn_sizer->AddSpacer(FromDIP(SidebarProps::ContentMargin()));
 
            // Parse components and ratios from config strings (supports 2-N components)
            std::vector<unsigned int> comp_ids;
            std::vector<int> comp_ratios;
            if (components_opt && cfg_idx < components_opt->values.size()) {
                std::istringstream iss(components_opt->values[cfg_idx]);
                std::string tok;
                while (std::getline(iss, tok, ',')) {
                    unsigned int v = 0;
                    if (std::sscanf(tok.c_str(), "%u", &v) == 1)
                        comp_ids.push_back(v);
                }
            }
            if (ratios_opt && cfg_idx < ratios_opt->values.size()) {
                CNumericLocalesSetter c_locale_setter;
                std::istringstream iss(ratios_opt->values[cfg_idx]);
                std::string tok;
                while (std::getline(iss, tok, ',')) {
                    float v = 0;
                    if (std::sscanf(tok.c_str(), "%f", &v) == 1)
                        comp_ratios.push_back((int)(v * 100 + 0.5f));
                }
            }
            if (!comp_ids.empty() && comp_ratios.size() != comp_ids.size()) {
                BOOST_LOG_TRIVIAL(warning) << "Mixed filament slot " << cfg_idx
                    << ": ratio count (" << comp_ratios.size()
                    << ") != component count (" << comp_ids.size()
                    << "), resetting to even distribution";
                int n = (int)comp_ids.size();
                comp_ratios.assign(n, 100 / n);
                comp_ratios[0] += 100 - (100 / n) * n;
            }
 
            bool is_broken = broken_set.count(cfg_idx) > 0;
 
            // Recalculate mixed color based on current physical colors
            if (!is_broken && !comp_ids.empty() && comp_ids.size() == comp_ratios.size()) {
                std::string new_mixed_color = blend_mixed_color(comp_ids, comp_ratios, physical_colors);
 
                if (colours_opt && cfg_idx < colours_opt->values.size() && colours_opt->values[cfg_idx] != new_mixed_color) {
                    colours_opt->values[cfg_idx] = new_mixed_color;
 
                    auto* multi_colour_opt = project_config.option<ConfigOptionStrings>("filament_multi_colour");
                    if (multi_colour_opt && cfg_idx < multi_colour_opt->values.size()) {
                        multi_colour_opt->values[cfg_idx] = new_mixed_color;
                    }
                }
            }
 
            bool is_gradient = false;
            int  gradient_direction = 0;
            if (grad_opt && cfg_idx < grad_opt->values.size())
                is_gradient = grad_opt->values[cfg_idx];
            if (is_gradient && grad_range_opt && cfg_idx < grad_range_opt->values.size()) {
                CNumericLocalesSetter c_locale_setter;
                float v0 = 0, v1 = 0;
                if (std::sscanf(grad_range_opt->values[cfg_idx].c_str(), "%f,%f", &v0, &v1) == 2)
                    gradient_direction = (v0 > v1) ? 0 : 1;
            }
 
            std::string mix_color_str = (colours_opt && cfg_idx < colours_opt->values.size())
                ? colours_opt->values[cfg_idx] : "#888888";
            wxColour mix_col(mix_color_str);
            unsigned int mix_num = (unsigned int)(cfg_idx + 1);
 
            // The swatch fades bottom to top over the model's height, sampled the same way
            // the slicer builds the sublayers, so it matches the editor's Effect Preview. The
            // ramp comes back empty for every slot that is not a two component gradient mix.
            const int swatch_sz = FromDIP(20);
            const std::vector<wxColour> gradient_ramp = mixed_gradient_ramp(project_config, cfg_idx, swatch_sz);
 
            if (!gradient_ramp.empty()) {
                auto* grad_panel = new wxPanel(p->m_panel_mixed_content, wxID_ANY,
                                               wxDefaultPosition, wxSize(swatch_sz, swatch_sz));
                grad_panel->SetMinSize(wxSize(swatch_sz, swatch_sz));
                grad_panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
                grad_panel->Bind(wxEVT_PAINT, [grad_panel, gradient_ramp, mix_num](wxPaintEvent&) {
                    wxBufferedPaintDC dc(grad_panel);
                    wxSize sz = grad_panel->GetClientSize();
                    fill_gradient_ramp_rect(dc, wxRect(0, 0, sz.GetWidth(), sz.GetHeight()), gradient_ramp);
                    wxString txt = wxString::Format("%u", mix_num);
                    dc.SetFont(::Label::Body_14);
                    wxSize txt_sz = dc.GetTextExtent(txt);
                    // The number sits at the swatch's middle, so take its contrast from the
                    // colour printed at mid height rather than from either endpoint.
                    dc.SetTextForeground(gradient_ramp[gradient_ramp.size() / 2].GetLuminance() > 0.5 ? wxColour(50, 58, 61) : *wxWHITE);
                    dc.DrawText(txt, (sz.GetWidth() - txt_sz.GetWidth()) / 2,
                                     (sz.GetHeight() - txt_sz.GetHeight()) / 2);
                });
                grad_panel->Bind(wxEVT_LEFT_UP, [this, i](wxMouseEvent&) { edit_mixed_filament(i); }); // ORCA also open edit color dialog with clicking swatch
                combo_and_btn_sizer->Add(grad_panel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(SidebarProps::ElementSpacing()) - FromDIP(2)); // ElementSpacing - 2 (from combo box))
            } else {
                auto swatch_panel = make_swatch_panel(p->m_panel_mixed_content, mix_col, mix_num);
                swatch_panel->Bind(wxEVT_LEFT_UP, [this, i](wxMouseEvent&) { edit_mixed_filament(i); }); // ORCA also open edit color dialog with clicking swatch
                combo_and_btn_sizer->Add(swatch_panel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(SidebarProps::ElementSpacing()) - FromDIP(2)); // ElementSpacing - 2 (from combo box))
            }
 
            auto* content_panel = new wxPanel(p->m_panel_mixed_content, wxID_ANY);
            content_panel->SetBackgroundColour(mc_bg);
            content_panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
 
            // Pre-compute all values the paint lambda needs (avoid capturing `this` for FromDIP)
            int cp_pad        = FromDIP(4);
            int cp_swatch_sz  = FromDIP(20);
            int cp_sep_margin = FromDIP(3);
            int cp_pct_left   = FromDIP(2);
            int cp_gap        = FromDIP(2);
            int cp_pct_gap    = FromDIP(4);
            bool cp_is_dark   = wxGetApp().dark_mode();
 
            // Build per-component colour list for the lambda
            std::vector<wxColour> cp_colours;
            std::vector<bool>     cp_valid;
            std::vector<unsigned int> cp_ids = comp_ids;
            std::vector<int>          cp_ratios = comp_ratios;
            bool cp_is_gradient = is_gradient;
            int  cp_gradient_dir = gradient_direction;
            for (size_t ci = 0; ci < comp_ids.size(); ++ci) {
                bool valid = (comp_ids[ci] >= 1 && comp_ids[ci] <= physical_colors.size());
                cp_valid.push_back(valid);
                cp_colours.push_back(valid ? wxColour(physical_colors[comp_ids[ci] - 1]) : wxColour("#D9D9D9"));
            }
 
            // Reorder for gradient display: from -> to
            std::vector<unsigned int> draw_ids;
            std::vector<int>          draw_ratios;
            std::vector<wxColour>     draw_colours;
            std::vector<bool>         draw_valid;
            if (cp_is_gradient && cp_ids.size() == 2) {
                int fi = (cp_gradient_dir == 0) ? 0 : 1;
                int ti = 1 - fi;
                draw_ids     = { cp_ids[fi], cp_ids[ti] };
                draw_ratios  = { cp_ratios.size() > (size_t)fi ? cp_ratios[fi] : 0,
                                 cp_ratios.size() > (size_t)ti ? cp_ratios[ti] : 0 };
                draw_colours = { cp_colours[fi], cp_colours[ti] };
                draw_valid   = { cp_valid[fi], cp_valid[ti] };
            } else {
                draw_ids     = cp_ids;
                draw_ratios  = cp_ratios;
                draw_colours = cp_colours;
                draw_valid   = cp_valid;
            }
 
            content_panel->Bind(wxEVT_PAINT, [content_panel, mc_bg, mc_border, mc_text, mc_dim,
                                               cp_pad, cp_swatch_sz, cp_sep_margin, cp_pct_left,
                                               cp_gap, cp_pct_gap, cp_is_dark,
                                               cp_is_gradient,
                                               draw_ids, draw_ratios, draw_colours, draw_valid](wxPaintEvent&) {
                wxBufferedPaintDC dc(content_panel);
                wxSize sz = content_panel->GetClientSize();
 
                dc.SetBrush(wxBrush(mc_bg));
                dc.SetPen(wxPen(mc_border, 1));
                dc.DrawRectangle(0, 0, sz.GetWidth(), sz.GetHeight());
 
                dc.SetFont(::Label::Body_13);
                int x = cp_pad;
                int y_swatch = (sz.GetHeight() - cp_swatch_sz) / 2;
                int text_h = dc.GetTextExtent(wxT("A")).GetHeight();
                int y_text = y_swatch + (cp_swatch_sz - text_h) / 2;
                int avail = sz.GetWidth() - cp_pad;
                wxString ellipsis = wxT("...");
                int ellipsis_w = dc.GetTextExtent(ellipsis).GetWidth();
 
                auto fits = [&](int needed) -> bool {
                    return (x + needed) <= (avail - ellipsis_w);
                };
 
                size_t n = draw_ids.size();
                for (size_t ci = 0; ci < n; ++ci) {
                    // Separator: "+" or arrow
                    if (ci > 0) {
                        wxString sep = cp_is_gradient ? wxT("\u2192") : wxT("+");
                        int sep_w = dc.GetTextExtent(sep).GetWidth() + cp_sep_margin * 2;
                        if (!fits(sep_w + cp_swatch_sz)) {
                            dc.SetTextForeground(mc_text);
                            dc.DrawText(ellipsis, x, y_text);
                            break;
                        }
                        dc.SetTextForeground(mc_text);
                        dc.DrawText(sep, x + cp_sep_margin, y_text);
                        x += sep_w;
                    }
 
                    // Swatch
                    if (!fits(cp_swatch_sz)) {
                        dc.SetTextForeground(mc_text);
                        dc.DrawText(ellipsis, x, y_text);
                        break;
                    }
 
                    if (draw_valid[ci]) {
                        wxColour col = draw_colours[ci];
                        dc.SetBrush(wxBrush(col));
                        dc.SetPen(*wxTRANSPARENT_PEN);
                        dc.DrawRectangle(x, y_swatch, cp_swatch_sz, cp_swatch_sz);
                        if (!cp_is_dark && col.Red() > 224 && col.Green() > 224 && col.Blue() > 224) {
                            dc.SetPen(wxPen(wxColour(130, 130, 128), 1));
                            dc.SetBrush(*wxTRANSPARENT_BRUSH);
                            dc.DrawRectangle(x, y_swatch, cp_swatch_sz, cp_swatch_sz);
                        }
                        if (cp_is_dark && col.Red() < 45 && col.Green() < 45 && col.Blue() < 45) {
                            dc.SetPen(wxPen(wxColour(207, 207, 207), 1));
                            dc.SetBrush(*wxTRANSPARENT_BRUSH);
                            dc.DrawRectangle(x, y_swatch, cp_swatch_sz, cp_swatch_sz);
                        }
                        dc.SetFont(::Label::Body_14);
                        wxString num = wxString::Format("%u", draw_ids[ci]);
                        wxSize num_sz = dc.GetTextExtent(num);
                        dc.SetTextForeground(col.GetLuminance() > 0.5 ? wxColour(50, 58, 61) : *wxWHITE);
                        dc.DrawText(num, x + (cp_swatch_sz - num_sz.GetWidth()) / 2,
                                         y_swatch + (cp_swatch_sz - num_sz.GetHeight()) / 2);
                        dc.SetFont(::Label::Body_13);
                    } else {
                        dc.SetBrush(wxBrush(mc_bg));
                        dc.SetPen(wxPen(mc_dim, 1));
                        dc.DrawRectangle(x, y_swatch, cp_swatch_sz, cp_swatch_sz);
                        wxString dash = wxT("\u2014");
                        wxSize dash_sz = dc.GetTextExtent(dash);
                        dc.SetTextForeground(mc_dim);
                        dc.DrawText(dash, x + (cp_swatch_sz - dash_sz.GetWidth()) / 2,
                                          y_swatch + (cp_swatch_sz - dash_sz.GetHeight()) / 2);
                    }
                    x += cp_swatch_sz + cp_gap;
 
                    // Ratio text (skip for gradient)
                    if (!cp_is_gradient) {
                        int r = (ci < draw_ratios.size()) ? draw_ratios[ci] : 0;
                        wxString pct = wxString::Format("%d%%", r);
                        int pct_w = dc.GetTextExtent(pct).GetWidth();
                        if (!fits(pct_w)) {
                            dc.SetTextForeground(mc_text);
                            dc.DrawText(ellipsis, x, y_text);
                            break;
                        }
                        dc.SetTextForeground(mc_text);
                        dc.DrawText(pct, x + cp_pct_left, y_text);
                        x += pct_w + cp_pct_gap;
                    }
                }
            });
 
            // Tooltip: always show full info
            {
                wxString tip;
                for (size_t ci = 0; ci < draw_ids.size(); ++ci) {
                    if (ci > 0) tip += cp_is_gradient ? wxT(" \u2192 ") : wxT(" + ");
                    int r = (ci < draw_ratios.size()) ? draw_ratios[ci] : 0;
                    tip += wxString::Format("%u (%d%%)", draw_ids[ci], r);
                }
                content_panel->SetToolTip(tip);
            }
 
            // Repaint on resize so truncation updates
            content_panel->Bind(wxEVT_SIZE, [content_panel](wxSizeEvent& e) {
                content_panel->Refresh();
                e.Skip();
            });
 
            content_panel->SetCursor(wxCursor(wxCURSOR_HAND));
            size_t panel_idx = i;
            content_panel->Bind(wxEVT_LEFT_UP, [this, panel_idx](wxMouseEvent&) { edit_mixed_filament(panel_idx); });
 
            combo_and_btn_sizer->Add(content_panel, 1, wxALL | wxEXPAND, FromDIP(2))->SetMinSize({-1, FromDIP(30)});
 
            auto* menu_btn = new ScalableButton(p->m_panel_mixed_content, wxID_ANY,
                is_broken ? "error" : "menu_filament");
            menu_btn->SetToolTip(is_broken ? _L("Mixed filament has broken component references") : _L("Edit / Delete / Merge"));
            menu_btn->Bind(wxEVT_BUTTON, [this, panel_idx, cfg_idx](wxCommandEvent&) {
                wxMenu menu;
 
                auto* edit_item = menu.Append(wxID_ANY, _L("Edit"));
                menu.Bind(wxEVT_MENU, [this, panel_idx](wxCommandEvent&) {
                    edit_mixed_filament(panel_idx);
                }, edit_item->GetId());
 
                wxMenu* sub_menu = new wxMenu();
                std::vector<wxBitmap*> icons = get_extruder_color_icons(true);
                int filaments_cnt = icons.size();
                for (int j = 0; j < filaments_cnt; ++j) {
                    if ((size_t)j == cfg_idx)
                        continue;
 
                    wxString item_name;
                    bool is_target_mixed = wxGetApp().preset_bundle->is_mixed_filament(j);
                    if (is_target_mixed) {
                        item_name = wxString::Format(_L("Filament %d"), j + 1);
                    } else {
                        auto preset = wxGetApp().preset_bundle->filaments.find_preset(
                            wxGetApp().preset_bundle->filament_presets[j]);
                        item_name = preset ? from_u8(preset->label(false))
                                           : wxString::Format(_L("Filament %d"), j + 1);
                    }
 
                    auto* mi = new wxMenuItem(sub_menu, wxID_ANY, item_name);
#ifndef __linux__
                    mi->SetBitmap(*icons[j]);
#endif
                    sub_menu->Append(mi);
                    sub_menu->Bind(wxEVT_MENU, [this, cfg_idx, j](wxCommandEvent&) {
                        change_filament(cfg_idx, j);
                    }, mi->GetId());
                }
                if (filaments_cnt > 1)
                    menu.AppendSubMenu(sub_menu, _L("Merge with"));
                else
                    delete sub_menu;
 
                menu.AppendSeparator(); // ORCA use seperator for reducing accidental clicks to delete
 
                // ORCA use delete item on end of menu to prevent accidental clicks. clicking to submenus(merge) already not allowed by OS
                auto* del_item = menu.Append(wxID_ANY, _L("Delete"));
                menu.Bind(wxEVT_MENU, [this, panel_idx](wxCommandEvent&) {
                    delete_mixed_filament_at(panel_idx);
                }, del_item->GetId());
 
                PopupMenu(&menu);
            });
            combo_and_btn_sizer->Add(menu_btn, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(SidebarProps::ElementSpacing()) - FromDIP(2)); // ElementSpacing - 2 (from combo box))
 
            combo_and_btn_sizer->Add(FromDIP(SidebarProps::ContentMargin()), 0, 0, 0, 0);
 
            int side = i % 2;
            auto* col = (side == 0) ? left_col : right_col;
            if (side == 1 && i > 1) col->Remove(i / 2);
            col->Add(combo_and_btn_sizer, 1, wxEXPAND);
            if (side == 0 && i > 0) {
                right_col->AddStretchSpacer(1);
            }
        }
    }
 
    recalc_filament_scroll_sizes();
 
    p->m_panel_filament_content->FitInside();
    p->m_mixed_scroll_area->FitInside();
    p->scrolled->Layout();
    m_scrolled_sizer->Layout();
    p->scrolled->Layout();
 
    size_t total = wxGetApp().preset_bundle->filament_presets.size();
    obj_list()->update_objects_list_filament_column(total);
 
    // Sync mixed filament colors into the config used by 3D view rendering.
    plater->update_filament_colors_in_full_config();
    obj_list()->update_filament_colors();
 
    // Check if any broken mixed filament is used by objects on current plate.
    // Scan raw extruder assignments (object / volume / height-range / painting)
    // instead of get_extruders() which expands mixed slots and loses their IDs.
    p->m_mixed_filament_broken = false;
    if (!broken_slots.empty()) {
        std::set<size_t> broken_1based;
        for (size_t s : broken_slots) broken_1based.insert(s + 1);
 
        auto* curr_plate = plater->get_partplate_list().get_curr_plate();
        if (curr_plate) {
            for (auto& obj : plater->model().objects) {
                if (!curr_plate->contain_instance_totally(obj, 0))
                    continue;
                // Check object-level extruder
                int obj_ext = obj->config.has("extruder") ? obj->config.extruder() : 1;
                if (broken_1based.count((size_t)obj_ext)) {
                    p->m_mixed_filament_broken = true;
                    break;
                }
                bool found = false;
                for (auto* vol : obj->volumes) {
                    // Check volume-level extruder
                    int vol_ext = vol->config.has("extruder") ? vol->config.extruder() : obj_ext;
                    if (broken_1based.count((size_t)vol_ext)) { found = true; break; }
                    // Check color painting data (mmu segmentation facets)
                    if (vol->is_model_part() && !vol->mmu_segmentation_facets.empty()) {
                        for (size_t broken_slot : broken_1based) {
                            if (vol->mmu_segmentation_facets.has_facets(*vol, EnforcerBlockerType(broken_slot)))
                                { found = true; break; }
                        }
                        if (found) break;
                    }
                }
                if (found) { p->m_mixed_filament_broken = true; break; }
                // Check height range modifier extruder overrides
                for (auto& [range, cfg] : obj->layer_config_ranges) {
                    if (cfg.has("extruder")) {
                        int layer_ext = cfg.option("extruder")->getInt();
                        if (layer_ext > 0 && broken_1based.count((size_t)layer_ext))
                            { found = true; break; }
                    }
                }
                if (found) { p->m_mixed_filament_broken = true; break; }
            }
        }
    }
 
    if (plater->canvas3D()) {
        plater->canvas3D()->set_as_dirty();
        plater->get_view3D_canvas3D()->reload_scene(false);
    }
 
    if (p->m_mixed_filament_broken) {
        auto* mf = wxGetApp().mainframe;
        if (mf)
            mf->update_slice_print_status(MainFrame::eEventObjectUpdate, false);
    }
 
    if (auto *tab = dynamic_cast<TabPrintPlate *>(wxGetApp().plate_tab))
        tab->update_mixed_filament_seq_state();
 
}

References _L, _u8L, Slic3r::GUI::BBLMixedFilamentBroken, Slic3r::GUI::blend_mixed_color(), Label::Body_13, Label::Body_14, change_filament(), Slic3r::check_mixed_filament_integrity(), Slic3r::check_mixed_filament_type_consistency(), Slic3r::GUI::SidebarProps::ContentMargin(), StateColor::darkModeColorFor(), delete_mixed_filament_at(), edit_mixed_filament(), Slic3r::GUI::MainFrame::eEventObjectUpdate, Slic3r::GUI::SidebarProps::ElementSpacing(), Slic3r::ConfigOptionVector< T >::empty(), Slic3r::GUI::NotificationManager::ErrorNotificationLevel, Slic3r::ExtruderMax, Slic3r::GUI::fill_gradient_ramp_rect(), Slic3r::GUI::from_u8(), get_extruder_color_icons(), is_dark(), Slic3r::GUI::GLCanvas3D::is_initialized(), m_scrolled_sizer, Slic3r::GUI::mixed_gradient_ramp(), obj_list(), p, Slic3r::GUI::plater(), Slic3r::range(), recalc_filament_scroll_sizes(), Slic3r::GUI::sep, Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< unsigned char >::size(), Slic3r::GUI::ObjectList::update_filament_colors(), Slic3r::GUI::ObjectList::update_objects_list_filament_column(), Slic3r::ConfigOptionVector< T >::values, Slic3r::ConfigOptionVector< unsigned char >::values, and Slic3r::GUI::wxMouseEvent.

Referenced by Slic3r::GUI::create_mixed_filament_from_result(), edit_mixed_filament(), on_filament_count_change(), on_filaments_delete(), and sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_mode()

void Slic3r::GUI::Sidebar::update_mode ( )

{
    m_mode = wxGetApp().get_mode();
 
    //BBS: remove print related combos
    update_searcher();
 
    wxWindowUpdateLocker noUpdates(this);
 
    // BBS
    //obj_list()->get_sizer()->Show(m_mode > comSimple);
 
    obj_list()->unselect_objects();
    obj_list()->update_selections();
//    obj_list()->update_object_menu();
 
    Layout();
}

References m_mode, obj_list(), Slic3r::GUI::ObjectList::unselect_objects(), update_searcher(), and Slic3r::GUI::ObjectList::update_selections().

Here is the call graph for this function:

◆ update_presets()

void Slic3r::GUI::Sidebar::update_presets ( Slic3r::Preset::Type preset_type )

{
    PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
    const auto print_tech = preset_bundle.printers.get_edited_preset().printer_technology();
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": enter, preset_type %1%")%preset_type;
    switch (preset_type) {
    case Preset::TYPE_FILAMENT:
    {
        // BBS
#if 0
        const size_t extruder_cnt = print_tech != ptFFF ? 1 :
                                dynamic_cast<ConfigOptionFloats*>(preset_bundle.printers.get_edited_preset().config.option("nozzle_diameter"))->values.size();
        const size_t filament_cnt = p->combos_filament.size() > extruder_cnt ? extruder_cnt : p->combos_filament.size();
#else
        const size_t filament_cnt = p->combos_filament.size();
#endif
        const std::string &name = preset_bundle.filaments.get_selected_preset_name();
        if (p->editing_filament >= 0) {
            preset_bundle.set_filament_preset(p->editing_filament, name);
        } else if (filament_cnt == 1) {
            // Single filament printer, synchronize the filament presets.
            Preset *preset = preset_bundle.filaments.find_preset(name, false);
            if (preset) {
                if (preset->is_compatible) preset_bundle.set_filament_preset(0, name);
            }
 
        }
 
        for (size_t i = 0; i < filament_cnt; i++)
            p->combos_filament[i]->update();
 
        update_dynamic_filament_list();
        break;
    }
 
    case Preset::TYPE_PRINT:
        //wxGetApp().mainframe->m_param_panel;
        //p->combo_print->update();
        {
        Tab* print_tab = wxGetApp().get_tab(Preset::TYPE_PRINT);
        if (print_tab) {
            print_tab->get_combo_box()->update();
        }
        break;
        }
    case Preset::TYPE_SLA_PRINT:
        ;// p->combo_sla_print->update();
        break;
 
    case Preset::TYPE_SLA_MATERIAL:
        ;// p->combo_sla_material->update();
        break;
 
    case Preset::TYPE_PRINTER:
    {
        update_all_preset_comboboxes();
        p->show_preset_comboboxes();
 
        /* update bed shape */
        Tab* printer_tab = wxGetApp().get_tab(Preset::TYPE_PRINTER);
        if (printer_tab) {
            printer_tab->update();
            printer_tab->on_preset_loaded();
        }
 
        Preset& printer_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
 
        if (auto printer_structure_opt = printer_preset.config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure")) {
            wxGetApp().plater()->get_current_canvas3D()->get_arrange_settings().align_to_y_axis = (printer_structure_opt->value == PrinterStructure::psI3);
        }
        else
            wxGetApp().plater()->get_current_canvas3D()->get_arrange_settings().align_to_y_axis = false;
 
        // Update dual extrudes
        auto* nozzle_diameter = dynamic_cast<const ConfigOptionFloats*>(printer_preset.config.option("nozzle_diameter"));
        auto extruder_variants = printer_preset.config.option<ConfigOptionStrings>("extruder_variant_list");
        std::string printer_model = printer_preset.config.option<ConfigOptionString>("printer_model")->value;
 
        bool isBBL = preset_bundle.is_bbl_vendor();
        bool is_dual_extruder = extruder_variants->size() == 2;
        // why: agent mode drives the native device tab, so the sidebar lays out like BBL
        // (no physical-printer connect button).
        p->layout_printer(preset_bundle.use_bbl_network() || wxGetApp().app_config->get_bool("use_printer_agents"),
                          isBBL && is_dual_extruder);
 
        // Update nozzle titles from printer config (e.g. "Main Nozzle" / "Auxiliary Nozzle" for N6)
        // UI left = DEPUTY_EXTRUDER_ID(1), UI right = MAIN_EXTRUDER_ID(0)
        if (is_dual_extruder) {
            std::string printer_type = printer_preset.get_printer_type(wxGetApp().preset_bundle);
            auto left_title  = DevPrinterConfigUtil::get_toolhead_display_name(printer_type, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase);
            auto right_title = DevPrinterConfigUtil::get_toolhead_display_name(printer_type, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase);
            p->left_extruder->SetTitle(_L(left_title));
            p->right_extruder->SetTitle(_L(right_title));
        }
 
        auto extruders_def = printer_preset.config.def()->get("extruder_type");
        auto extruders = printer_preset.config.option<ConfigOptionEnumsGeneric>("extruder_type");
        auto nozzle_volumes_def = wxGetApp().preset_bundle->project_config.def()->get("nozzle_volume_type");
        auto nozzle_volumes = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
        auto diameters = wxGetApp().preset_bundle->printers.diameters_of_selected_printer();
        auto diameter = printer_preset.config.opt_string("printer_variant");
        auto extruder_max_nozzle_count = printer_preset.config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
        const bool has_flow_variant = preset_bundle.support_different_extruders();
        auto update_extruder_variant = [printer_model, extruders_def, extruders, nozzle_volumes_def, nozzle_volumes, extruder_variants,diameter,extruder_max_nozzle_count,has_flow_variant](ExtruderGroup & extruder, size_t row, int index) {
            ComboBox *combo_flow = extruder.rows[row].flow;
            combo_flow->Clear();
            // A profile may leave the per-extruder lists shorter than the nozzle count (they are
            // padded when the printer is loaded, but a hand-written preset need not be).
            if (index >= int(extruder_variants->values.size()) || index >= int(extruders->values.size()) ||
                index >= int(nozzle_volumes->values.size())) {
                combo_flow->Hide();
                return;
            }
            auto type = extruders_def->enum_labels[extruders->values[index]];
            int select = -1;
            for (size_t i = 0; i < nozzle_volumes_def->enum_labels.size(); ++i) {
                // get_at falls back to the first entry when a profile defines no per-extruder value,
                // so extruders without an explicit sub-nozzle count never offer Hybrid. A nullable-int
                // nil is INT_MAX (> 1) and would otherwise falsely pass the gate, so exclude it too.
                if (boost::algorithm::contains(extruder_variants->values[index], type + " " + nozzle_volumes_def->enum_labels[i]) ||
                    (extruder_max_nozzle_count->get_at(index) > 1 && extruder_max_nozzle_count->get_at(index) != ConfigOptionIntsNullable::nil_value() &&
                    nozzle_volumes_def->enum_keys_map->at(nozzle_volumes_def->enum_values[i]) == nvtHybrid)) {
                    auto cur_volume_type = nozzle_volumes_def->enum_keys_map->at(nozzle_volumes_def->enum_values[i]);
                    // Defensive: profiles restrict E3D to 0.4 / 0.6; keep it out elsewhere.
                    if (cur_volume_type == NozzleVolumeType::nvtE3DHighFlow && diameter != "0.4" && diameter != "0.6")
                        continue;
                    if (cur_volume_type == NozzleVolumeType::nvtHighFlow && (diameter == "0.2" ||
                        is_skip_high_flow_printer(printer_model)))
                        continue;
                    // The client data is the enum value, not the label position: E3D High Flow is 5
                    // but sits at position 4, and a position would write an invalid type.
                    if (nozzle_volumes->values[index] == cur_volume_type)
                        select = combo_flow->GetCount();
                    combo_flow->Append(_L(nozzle_volumes_def->enum_labels[i]), {}, (void*)(intptr_t)cur_volume_type);
                }
            }
            if (select == -1)
                select = combo_flow->GetCount() - 1;
            combo_flow->SetSelection(select);
            // No flow variant for this printer or extruder: the diameter keeps the whole row.
            combo_flow->Show(has_flow_variant && combo_flow->GetCount() > 0);
        };
 
        auto update_extruder_diameter = [&diameters, &nozzle_diameter, &diameter](int extruder_index,ExtruderGroup & extruder) {
            extruder.combo_diameter->Clear();
            if (extruder_index >= int(nozzle_diameter->values.size()))
                return;
            int select = -1;
            // ORCA get the actual nozzle diameter from printer config
            auto nozzle_dia = get_diameter_string(nozzle_diameter->values[extruder_index]);
            // Named variants such as "0.4HS" and "0.4 High Flow" share a physical diameter.
            // Retain the variant selection unless the diameter was customized.
            const bool keep_variant = diameter.substr(0, diameter.find_first_not_of("0123456789.")) == nozzle_dia &&
                                      std::find(diameters.begin(), diameters.end(), diameter) != diameters.end();
            const std::string &selected_variant = keep_variant ? diameter : nozzle_dia;
            // ORCA try to add nozzle diameter from config if list is empty. fixes blank nozzle combo box when preset has no alias
            if(!diameters.empty() && diameters[0].empty() && !nozzle_dia.empty()){
                diameters[0] = nozzle_dia;
            }
            // Orca: Check if the actual nozzle diameter exists in the list, if not add it as a custom option
            if (std::find(diameters.begin(), diameters.end(), nozzle_dia) == diameters.end() && !nozzle_dia.empty()) {
                diameters.push_back(nozzle_dia);
            }
            for (size_t i = 0; i < diameters.size(); ++i) {
                if (diameters[i] == selected_variant)
                    select = extruder.combo_diameter->GetCount();
                extruder.combo_diameter->Append(diameters[i], {});
            }
            extruder.combo_diameter->SetSelection(select);
            extruder.diameter = nozzle_dia;
        };
        auto image_path = get_cur_select_bed_image();
        const bool multi_extruder_rows = p->single_extruder->NozzleRowCount() > 1;
        if (is_dual_extruder && !multi_extruder_rows) {
            std::string printer_type = printer_preset.get_printer_type(wxGetApp().preset_bundle);
            p->left_extruder->SetTitle(_L(DevPrinterConfigUtil::get_toolhead_display_name(printer_type, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase)));
            p->right_extruder->SetTitle(_L(DevPrinterConfigUtil::get_toolhead_display_name(printer_type, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase)));
            AMSCountPopupWindow::UpdateAMSCount(0, p->left_extruder);
            AMSCountPopupWindow::UpdateAMSCount(1, p->right_extruder);
            update_extruder_variant(*p->left_extruder, 0, 0);
            update_extruder_variant(*p->right_extruder, 0, 1);
            //if (!p->is_switching_diameter) {
                update_extruder_diameter(0, *p->left_extruder);
                update_extruder_diameter(1, *p->right_extruder);
            //}
            p->image_printer_bed->SetBitmap(create_scaled_bitmap(image_path, this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
        } else {
            AMSCountPopupWindow::UpdateAMSCount(0, p->single_extruder);
            for (size_t row = 0; row < p->single_extruder->NozzleRowCount(); ++row)
                update_extruder_variant(*p->single_extruder, row, int(row));
            //if (!p->is_switching_diameter)
                update_extruder_diameter(0, *p->single_extruder);
            // The card reads the nozzles out, the variant box above is what switches the machine.
            p->single_extruder->SetRowDiameters(nozzle_diameter->values);
            if (multi_extruder_rows) {
                // The hidden left/right cards keep mirroring the first extruders' diameters: the
                // device sync path (a connected Bambu printer or a printer agent) still reads them.
                update_extruder_diameter(0, *p->left_extruder);
                update_extruder_diameter(1, *p->right_extruder);
            }
 
            // ORCA sync unified nozzle combo box
            p->combo_nozzle_dia->Clear();
            for (size_t i = 0; i < diameters.size(); ++i)
                p->combo_nozzle_dia->Append(diameters[i], {});
            // Prefer the variant the preset names: a mixed-nozzle machine reads "0.4+0.6", which is
            // no single extruder's diameter.
            const int variant = p->combo_nozzle_dia->FindString(diameter);
            p->combo_nozzle_dia->SetSelection(variant != wxNOT_FOUND ? variant : (*p->single_extruder).combo_diameter->GetSelection());
            
            // ORCA update nozzle type
            const auto& full_config = wxGetApp().preset_bundle->full_config();
            wxString nozzle_type = "-";
            const ConfigOptionEnumsGenericNullable* cfg_nozzle_type = full_config.option<ConfigOptionEnumsGenericNullable>("nozzle_type");
            if(cfg_nozzle_type != nullptr){
                std::vector<NozzleType> nozzle_types(cfg_nozzle_type->size());
                for (size_t idx = 0; idx < cfg_nozzle_type->size(); ++idx)
                    nozzle_types[idx] = NozzleType(cfg_nozzle_type->values[idx]);
                // NEEDFIX this part can be replaced with shorter names
                nozzle_type = nozzle_types[0] == ntHardenedSteel   ? _L("Hardened Steel") :
                              nozzle_types[0] == ntStainlessSteel  ? _L("Stainless Steel") :
                              nozzle_types[0] == ntTungstenCarbide ? _L("Tungsten Carbide") :
                              nozzle_types[0] == ntBrass           ? _L("Brass")
                                                                   : wxString("-"); // Undefined
            }
            p->label_nozzle_type->SetLabel(nozzle_type);
            p->label_nozzle_type->SetToolTip(nozzle_type == "-" ? "" : nozzle_type);
 
            p->image_printer_bed->SetBitmap(create_scaled_bitmap(image_path, this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
        }
 
        if (GUI::wxGetApp().plater())
            GUI::wxGetApp().plater()->update_machine_sync_status();
 
        Layout();
 
        break;
    }
 
    default: break;
    }
 
    // Synchronize config.ini with the current selections.
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": exit.");
}

References _L, ComboBox::Append(), Slic3r::Preset::config, create_scaled_bitmap(), Slic3r::DynamicPrintConfig::def(), DEPUTY_EXTRUDER_ID, Slic3r::ConfigOptionVector< int >::empty(), Slic3r::extruder_max_nozzle_count(), Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::ConfigDef::get(), Slic3r::GUI::Tab::get_combo_box(), get_cur_select_bed_image(), Slic3r::GUI::get_diameter_string(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::Preset::get_printer_type(), Slic3r::PresetCollection::get_selected_preset_name(), Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), ComboBox::GetCount(), Slic3r::PresetBundle::is_bbl_vendor(), Slic3r::Preset::is_compatible, Slic3r::GUI::is_skip_high_flow_printer(), MAIN_EXTRUDER_ID, Slic3r::ConfigOptionIntsTempl< true >::nil_value(), Slic3r::Nozzle, Slic3r::nozzle_diameter(), Slic3r::nozzle_type(), Slic3r::ntBrass, Slic3r::ntHardenedSteel, Slic3r::ntStainlessSteel, Slic3r::ntTungstenCarbide, Slic3r::nvtE3DHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::GUI::Tab::on_preset_loaded(), Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), p, Slic3r::GUI::plater(), Slic3r::Preset::printer_technology(), PRINTER_THUMBNAIL_SIZE, Slic3r::PresetBundle::printers, Slic3r::psI3, Slic3r::ptFFF, Slic3r::PresetBundle::set_filament_preset(), ComboBox::SetSelection(), Slic3r::ConfigOptionVector< int >::size(), Slic3r::PresetBundle::support_different_extruders(), Slic3r::TitleCase, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::Preset::TYPE_SLA_MATERIAL, Slic3r::Preset::TYPE_SLA_PRINT, Slic3r::GUI::Tab::update(), Slic3r::GUI::TabPresetComboBox::update(), update_all_preset_comboboxes(), update_dynamic_filament_list(), Slic3r::GUI::AMSCountPopupWindow::UpdateAMSCount(), Slic3r::PresetBundle::use_bbl_network(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by Slic3r::GUI::TabPrinter::build_unregular_pages(), and Slic3r::GUI::Plater::load_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_presets_from_to()

void Slic3r::GUI::Sidebar::update_presets_from_to	(	Slic3r::Preset::Type	preset_type,
		std::string	from,
		std::string	to )

{
    PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": enter, preset_type %1%, from %2% to %3%")%preset_type %from %to;
 
    switch (preset_type) {
    case Preset::TYPE_FILAMENT:
    {
        const size_t filament_cnt = p->combos_filament.size();
        for (auto it = preset_bundle.filament_presets.begin(); it != preset_bundle.filament_presets.end(); it++)
        {
            if ((*it).compare(from) == 0) {
                (*it) = to;
            }
        }
        for (size_t i = 0; i < filament_cnt; i++)
            p->combos_filament[i]->update();
        break;
    }
 
    default: break;
    }
 
    // Synchronize config.ini with the current selections.
    wxGetApp().preset_bundle->export_selections(*wxGetApp().app_config);
 
    BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << boost::format(": exit!");
}

References Slic3r::PresetBundle::filament_presets, p, and Slic3r::Preset::TYPE_FILAMENT.

◆ update_printer_thumbnail()

void Slic3r::GUI::Sidebar::update_printer_thumbnail ( )

{
    auto& preset_bundle = wxGetApp().preset_bundle;
    Preset & selected_preset = preset_bundle->printers.get_edited_preset();
    std::string printer_type    = selected_preset.get_current_printer_type(preset_bundle);
    if (printer_thumbnails.find(printer_type) != printer_thumbnails.end()) // Use known cache first
        p->image_printer->SetBitmap(create_scaled_bitmap(printer_thumbnails[printer_type], this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
    else {
        /* ORCA this part check images folder for BBL covers but not checks file existence and causes crash on Linux
        *       BBL covers already exist on profile folder so no need to use this section
        try {
            // No cache, try dedicated printer preview
            p->image_printer->SetBitmap(create_scaled_bitmap("printer_preview_" + printer_type, this, 48));
            // Success, cache it
            printer_thumbnails[printer_type] = "printer_preview_" + printer_type;
            return;
        } catch (...) {}
        */
 
        // Orca: try to use the printer model cover as the thumbnail
        const auto model_name = selected_preset.config.opt_string("printer_model");
        std::string cover_file = model_name + "_cover.png";
        for (auto vendor_profile : preset_bundle->vendors) {
            for (auto vendor_model : vendor_profile.second.models) {
                if (vendor_model.name == model_name) {
                    // Try to find the printer cover
                    boost::filesystem::path cover_path = boost::filesystem::absolute(boost::filesystem::path(resources_dir()) /
                                                                                     "/profiles/" / vendor_profile.second.id / cover_file)
                                                             .make_preferred();
                    if (boost::filesystem::exists(cover_path)) {
                        try {
                            p->image_printer->SetBitmap(create_scaled_bitmap(cover_path.string(), this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
                            printer_thumbnails[printer_type] = cover_path.string(); // Cache the path so we don't look up again
                            return;
                        } catch (...) {}
                    }
                }
            }
        }
        p->image_printer->SetBitmap(create_scaled_bitmap("printer_placeholder", this, PRINTER_THUMBNAIL_SIZE.GetHeight()));
        printer_thumbnails[printer_type] = "printer_placeholder"; // Avoid unnecessary try
    }
}

References Slic3r::Preset::config, create_scaled_bitmap(), Slic3r::Preset::get_current_printer_type(), Slic3r::DynamicConfig::opt_string(), p, PRINTER_THUMBNAIL_SIZE, Slic3r::GUI::printer_thumbnails, and Slic3r::resources_dir().

Referenced by msw_rescale(), and update_all_preset_comboboxes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_searcher()

void Slic3r::GUI::Sidebar::update_searcher ( )

{
    p->searcher.init(get_search_inputs(m_mode));
}

References Slic3r::GUI::get_search_inputs(), m_mode, and p.

Referenced by update_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_sync_ams_btn_enable()

void Slic3r::GUI::Sidebar::update_sync_ams_btn_enable ( wxUpdateUIEvent & e )

private

 {
     if (m_last_slice_state != p->plater->is_background_process_slicing()) {
         m_last_slice_state = p->plater->is_background_process_slicing();
         //btn_sync->Enable(!m_last_slice_state);
         p->m_printer_bbl_sync->Enable(!m_last_slice_state);
         ams_btn->Enable(!m_last_slice_state);
         Refresh();
     }
 }

References ams_btn, m_last_slice_state, and p.

Referenced by Sidebar().

Here is the caller graph for this function:

◆ update_sync_status()

void Slic3r::GUI::Sidebar::update_sync_status ( const MachineObject * obj )

{
    p->update_sync_status(obj);
}

References p.

Referenced by Slic3r::GUI::MonitorPanel::on_machine_selected().

Here is the caller graph for this function:

◆ update_ui_from_settings()

void Slic3r::GUI::Sidebar::update_ui_from_settings ( )

{
    // BBS
    //p->object_manipulation->update_ui_from_settings();
    // update Cut gizmo, if it's open
    p->plater->canvas3D()->update_gizmos_on_off_state();
    p->plater->set_current_canvas_as_dirty();
    p->plater->get_current_canvas3D()->request_extra_frame();
#if 0
    p->object_list->apply_volumes_order();
#endif
}

References p.

Referenced by create_printer_preset(), on_filament_count_change(), and on_filaments_delete().

Here is the caller graph for this function:

Member Data Documentation

◆ ams_btn

ScalableButton* Slic3r::GUI::Sidebar::ams_btn {nullptr}

private

160{nullptr};

Referenced by Sidebar(), get_small_btn_sync_pos_size(), and update_sync_ams_btn_enable().

◆ m_begin_sync_printer_status

bool Slic3r::GUI::Sidebar::m_begin_sync_printer_status {false}

private

167{false};

Referenced by deal_btn_sync(), and update_all_preset_comboboxes().

◆ m_cur_combox_bed_types

std::vector<BedType> Slic3r::GUI::Sidebar::m_cur_combox_bed_types

private

Referenced by get_cur_combox_bed_types(), get_cur_select_bed_type(), on_bed_type_change(), reset_bed_type_combox_choices(), and set_bed_type_accord_combox().

◆ m_cur_image_bed_type

std::string Slic3r::GUI::Sidebar::m_cur_image_bed_type

private

Referenced by reset_bed_type_combox_choices().

◆ m_fna_dialog

FinishSyncAmsDialog* Slic3r::GUI::Sidebar::m_fna_dialog {nullptr}

private

163{nullptr};

Referenced by on_full_screen(), on_size(), pop_finsish_sync_ams_dialog(), and pop_sync_nozzle_and_ams_dialog().

◆ m_last_combo_bedtype_count

int Slic3r::GUI::Sidebar::m_last_combo_bedtype_count {0}

private

166{0};

Referenced by reset_bed_type_combox_choices().

◆ m_last_slice_state

bool Slic3r::GUI::Sidebar::m_last_slice_state = false

private

Referenced by update_sync_ams_btn_enable().

◆ m_mode

ConfigOptionMode Slic3r::GUI::Sidebar::m_mode

private

Referenced by update_mode(), and update_searcher().

◆ m_need_auto_sync_after_connect_printer

bool Slic3r::GUI::Sidebar::m_need_auto_sync_after_connect_printer {false}

private

333{false};

Referenced by need_auto_sync_after_connect_printer(), and set_need_auto_sync_after_connect_printer().

◆ m_scrolled_sizer

wxBoxSizer* Slic3r::GUI::Sidebar::m_scrolled_sizer = nullptr

private

Referenced by Sidebar(), add_filament(), delete_filament(), update_filaments_counter(), and update_mixed_filament_list().

◆ m_sna_dialog

SyncNozzleAndAmsDialog* Slic3r::GUI::Sidebar::m_sna_dialog {nullptr}

private

162{nullptr};

Referenced by on_full_screen(), on_size(), pop_finsish_sync_ams_dialog(), and pop_sync_nozzle_and_ams_dialog().

◆ m_sync_dlg

SyncAmsInfoDialog* Slic3r::GUI::Sidebar::m_sync_dlg {nullptr}

private

168{nullptr};

Referenced by sync_ams_list().

◆ p

std::unique_ptr<priv> Slic3r::GUI::Sidebar::p

private

Referenced by Sidebar(), add_custom_filament(), add_filament(), add_mixed_filament(), auto_calc_flushing_volumes(), can_search(), change_top_border_for_mode_sizer(), clear_combos_filament_badge(), collapse(), collect_physical_filament_info(), combos_filament(), create_printer_preset(), deal_btn_sync(), decompose_filament_color(), delete_filament(), edit_filament(), enable_buttons(), enable_nozzle_count_edit(), enable_purge_mode_btn(), ensure_mixed_filament(), filament_panel(), finish_param_edit(), get_big_btn_sync_pos_size(), get_cur_select_bed_type(), get_search_line(), get_searcher(), get_wiping_dialog_button(), has_broken_mixed_filament(), init_filament_combo(), is_collapsed(), is_fila_switch_ready(), is_multifilament(), is_new_project_in_gcode3mf(), jump_to_object(), jump_to_option(), load_ams_list(), msw_rescale(), obj_layers(), obj_list(), obj_settings(), og_freq_chng_params(), on_bed_type_change(), on_enter_image_printer_bed(), on_filament_count_change(), on_filaments_delete(), on_leave_image_printer_bed(), print_panel(), printer_combox(), recalc_filament_scroll_sizes(), remove_unused_filament_combos(), reset_bed_type_combox_choices(), reset_fila_switch(), scrolled_panel(), search(), set_bed_type_accord_combox(), set_btn_label(), set_extruder_nozzle_count(), set_flushing_volume_warning(), settings_index(), show_export(), show_export_removable(), show_object_list(), show_reslice(), show_SEMM_buttons(), show_send(), sync_ams_list(), sync_extruder_list(), sys_color_changed(), udpate_combos_filament_badge(), update_all_preset_comboboxes(), update_filaments_area_height(), update_filaments_counter(), update_mixed_filament_list(), update_presets(), update_presets_from_to(), update_printer_thumbnail(), update_searcher(), update_sync_ams_btn_enable(), update_sync_status(), and update_ui_from_settings().

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

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

	OrcaSlicer latest OrcaSlicer

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DockingState

Constructor & Destructor Documentation

◆ Sidebar() [1/3]

◆ Sidebar() [2/3]

◆ Sidebar() [3/3]

◆ ~Sidebar()

Member Function Documentation

◆ add_custom_filament()

◆ add_filament()

◆ add_mixed_filament()

◆ auto_calc_flushing_volumes()

◆ auto_calc_flushing_volumes_internal()

◆ build_filament_ams_list()

Data Flow Architecture:

◆ can_search()

◆ change_filament()

◆ change_top_border_for_mode_sizer()

◆ clear_combos_filament_badge()

◆ collapse()

◆ collect_physical_filament_info()

◆ combos_filament()

◆ create_printer_preset()

◆ deal_btn_sync()

◆ decompose_filament_color()

◆ delete_filament()

◆ delete_mixed_filament_at()

◆ edit_filament()

◆ edit_mixed_filament()

◆ enable_buttons()

◆ enable_nozzle_count_edit()

◆ enable_purge_mode_btn()

◆ ensure_mixed_filament()

◆ filament_panel()

◆ finish_param_edit()

◆ get_big_btn_sync_pos_size()

◆ get_cur_combox_bed_types()

◆ get_cur_select_bed_image()

◆ get_cur_select_bed_type()

◆ get_eject_shown()

◆ get_search_line()

◆ get_searcher()

◆ get_sidebar_pos_right_x()

◆ get_small_btn_sync_pos_size()

◆ get_wiping_dialog_button()

◆ has_broken_mixed_filament() [1/2]

◆ has_broken_mixed_filament() [2/2]

◆ init_filament_combo()

◆ is_collapsed()

◆ is_fila_switch_ready()

◆ is_multifilament()

◆ is_new_project_in_gcode3mf()

◆ jump_to_object()

◆ jump_to_option() [1/2]

◆ jump_to_option() [2/2]

◆ load_ams_list()

◆ msw_rescale()

◆ need_auto_sync_after_connect_printer()

◆ need_auto_sync_extruder_list_after_connect_priner()

◆ obj_layers()

◆ obj_list()

◆ obj_settings()

◆ og_freq_chng_params()

◆ on_bed_type_change()

◆ on_change_color_mode()

◆ on_enter_image_printer_bed()

◆ on_filament_count_change()

◆ on_filaments_delete()

◆ on_full_screen()

◆ on_leave_image_printer_bed()

◆ on_size()

◆ operator=() [1/2]

◆ operator=() [2/2]