Slic3r::GUI::CalibrationPresetPage Class Reference

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

Inheritance diagram for Slic3r::GUI::CalibrationPresetPage:

Collaboration diagram for Slic3r::GUI::CalibrationPresetPage:

Public Member Functions
	CalibrationPresetPage (wxWindow *parent, CalibMode cali_mode, bool custom_range=false, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
void	create_page (wxWindow *parent)
void	update_print_status_msg (wxString msg, bool is_warning)
wxString	format_text (wxString &m_msg)
void	stripWhiteSpace (std::string &str)
void	update_priner_status_msg (wxString msg, bool is_warning)
void	update (MachineObject *obj) override
void	update_flow_ratio_type (FlowRatioCalibrationType type)
void	on_device_connected (MachineObject *obj) override
void	update_print_error_info (int code, const std::string &msg, const std::string &extra)
void	set_cali_filament_mode (CalibrationFilamentMode mode) override
void	set_cali_method (CalibrationMethod method) override
void	on_cali_start_job ()
void	on_cali_finished_job ()
void	on_cali_cancel_job ()
void	init_with_machine (MachineObject *obj)
void	sync_ams_info (MachineObject *obj)
void	select_default_compatible_filament ()
int	get_index_by_tray_id (int tray_id)
std::vector< FilamentComboBox * >	get_selected_filament_combobox ()
std::map< int, Preset * >	get_selected_filaments ()
std::map< int, DynamicPrintConfig >	get_filament_ams_list () const
void	get_preset_info (float &nozzle_dia, BedType &plate_type)
void	get_cali_stage (CaliPresetStage &stage, float &value)
std::shared_ptr< ProgressIndicator >	get_sending_progress_bar ()
Preset *	get_printer_preset (MachineObject *obj, float nozzle_value)
Preset *	get_print_preset ()
std::string	get_print_preset_name ()
wxArrayString	get_custom_range_values ()
CalibMode	get_pa_cali_method ()
CaliPresetPageStatus	get_page_status ()
MachineObject *	get_current_object ()
void	msw_rescale () override
void	on_sys_color_changed () override
int	get_extruder_id_by_tray_id (int tray_id)
float	get_nozzle_diameter (int extruder_id) const
NozzleVolumeType	get_nozzle_volume_type (int extruder_id) const
ExtruderType	get_extruder_type (int extruder_id) const
CaliPageType	get_page_type ()
CalibrationWizardPage *	get_prev_page ()
CalibrationWizardPage *	get_next_page ()
void	set_prev_page (CalibrationWizardPage *prev)
void	set_next_page (CalibrationWizardPage *next)
CalibrationWizardPage *	chain (CalibrationWizardPage *next)
virtual void	on_reset_page ()

Protected Member Functions
void	create_selection_panel (wxWindow *parent)
void	create_filament_list_panel (wxWindow *parent)
wxBoxSizer *	create_ams_items_sizer (MachineObject *obj, wxPanel *ams_preview_panel, std::vector< AMSPreview * > &ams_preview_list, std::vector< AMSinfo > &ams_info, int nozzle_id)
void	init_selection_values ()
void	update_filament_combobox (std::string ams_id="")
void	on_select_nozzle (wxCommandEvent &evt)
void	on_select_plate_type (wxCommandEvent &evt)
void	on_choose_ams (wxCommandEvent &event)
void	on_choose_ext_spool (wxCommandEvent &event)
void	on_select_tray (wxCommandEvent &event)
void	on_switch_ams (std::string ams_id="")
void	on_recommend_input_value ()
void	check_filament_compatible ()
bool	is_filaments_compatiable (const std::map< int, Preset * > &prests)
bool	is_filament_in_blacklist (int tray_id, Preset *preset, std::string &error_tips)
bool	is_filaments_compatiable (const std::map< int, Preset * > &prests, int &bed_temp, std::string &incompatiable_filament_name, std::string &error_tips)
float	get_nozzle_value ()
void	update_plate_type_collection (CalibrationMethod method)
void	update_combobox_filaments (MachineObject *obj)
void	update_show_status ()
void	update_sync_button_status ()
bool	is_nozzle_info_synced () const
void	show_status (CaliPresetPageStatus status)
void	Enable_Send_Button (bool enable)
bool	need_check_sdcard (MachineObject *obj)
CaliPresetPageStatus	get_status ()
void	update_multi_extruder_filament_combobox (const std::string &ams_id, int nozzle_id)
void	create_multi_extruder_filament_list_panel (wxWindow *parent)
void	on_select_nozzle_volume_type (wxCommandEvent &evt, size_t extruder_id)

Protected Attributes
CaliPageStepGuide *	m_step_panel { nullptr }
CaliComboBox *	m_pa_cali_method_combox {nullptr}
CaliPresetCaliStagePanel *	m_cali_stage_panel { nullptr }
wxPanel *	m_selection_panel { nullptr }
wxPanel *	m_filament_from_panel { nullptr }
Label *	m_filament_list_tips { nullptr }
wxPanel *	m_multi_ams_panel { nullptr }
wxPanel *	m_filament_list_panel { nullptr }
CaliPresetWarningPanel *	m_warning_panel { nullptr }
CaliPresetCustomRangePanel *	m_custom_range_panel { nullptr }
CaliPresetTipsPanel *	m_tips_panel { nullptr }
CaliPageSendingPanel *	m_sending_panel { nullptr }
wxBoxSizer *	m_top_sizer
ComboBox *	m_comboBox_nozzle_dia
ComboBox *	m_comboBox_nozzle_volume
ComboBox *	m_comboBox_bed_type
ComboBox *	m_comboBox_process
Label *	m_nozzle_diameter_tips {nullptr}
std::vector< BedType >	m_displayed_bed_types
Button *	m_btn_sync {nullptr}
Label *	m_sync_button_text
wxPanel *	m_single_nozzle_info_panel {nullptr}
wxPanel *	m_multi_nozzle_info_panel {nullptr}
wxPanel *	m_multi_exutrder_filament_list_panel {nullptr}
ComboBox *	m_left_comboBox_nozzle_dia
ComboBox *	m_right_comboBox_nozzle_dia
ComboBox *	m_left_comboBox_nozzle_volume
ComboBox *	m_right_comboBox_nozzle_volume
wxPanel *	m_main_ams_preview_panel {nullptr}
wxPanel *	m_deputy_ams_preview_panel {nullptr}
wxBoxSizer *	m_main_ams_items_sizer {nullptr}
wxBoxSizer *	m_deputy_ams_items_sizer {nullptr}
std::vector< AMSPreview * >	m_main_ams_preview_list
std::vector< AMSPreview * >	m_deputy_ams_preview_list
FilamentComboBoxList	m_main_filament_comboBox_list
FilamentComboBoxList	m_deputy_filament_comboBox_list
std::unordered_map< int, int >	m_ams_id_to_extruder_id_map
std::vector< ExtruderType >	m_extrder_types
std::vector< NozzleVolumeType >	m_extruder_nozzle_types
bool	m_main_extruder_on_left {true}
wxBoxSizer *	m_multi_extruder_ams_panel_sizer
wxBoxSizer *	m_multi_exturder_ams_sizer
wxStaticBoxSizer *	m_main_sizer
wxStaticBoxSizer *	m_deputy_sizer
wxStaticBoxSizer *	m_left_nozzle_volume_type_sizer
wxStaticBoxSizer *	m_right_nozzle_volume_type_sizer
ScalableButton *	m_ams_sync_button
FilamentComboBoxList	m_filament_comboBox_list
std::vector< AMSPreview * >	m_ams_preview_list
std::map< int, DynamicPrintConfig >	filament_ams_list
CaliPresetPageStatus	m_page_status { CaliPresetPageStatus::CaliPresetStatusInit }
bool	m_stop_update_page_status { false }
bool	m_show_custom_range { false }
bool	m_has_filament_incompatible { false }
MachineObject *	curr_obj { nullptr }
CalibMode	m_cali_mode
CaliPageType	m_page_type
CalibrationFilamentMode	m_cali_filament_mode
CalibrationMethod	m_cali_method { CalibrationMethod::CALI_METHOD_MANUAL }
wxWindow *	m_parent { nullptr }
CaliPageCaption *	m_page_caption { nullptr }
CaliPageActionPanel *	m_action_panel { nullptr }
Label *	m_statictext_printer_msg { nullptr }

Private Attributes
CalibrationWizardPage *	m_prev_page {nullptr}
CalibrationWizardPage *	m_next_page {nullptr}

Detailed Description

Constructor & Destructor Documentation

CalibrationPresetPage()

Slic3r::GUI::CalibrationPresetPage::CalibrationPresetPage	(	wxWindow *	parent,
		CalibMode	cali_mode,
		bool	custom_range = false,
		wxWindowID	id = wxID_ANY,
		const wxPoint &	pos = wxDefaultPosition,
		const wxSize &	size = wxDefaultSize,
		long	style = wxTAB_TRAVERSAL )

    : CalibrationWizardPage(parent, id, pos, size, style)
    , m_show_custom_range(custom_range)
{
    SetBackgroundColour(*wxWHITE);
 
    m_cali_mode = cali_mode;
    m_page_type = CaliPageType::CALI_PAGE_PRESET;
    m_cali_filament_mode = CalibrationFilamentMode::CALI_MODEL_SINGLE;
    m_top_sizer = new wxBoxSizer(wxVERTICAL);
    m_extrder_types.resize(2, ExtruderType::etDirectDrive);
    m_extruder_nozzle_types.resize(2, NozzleVolumeType::nvtHighFlow);
 
    create_page(this);
 
    this->SetSizer(m_top_sizer);
    m_top_sizer->Fit(this);
}

References Slic3r::GUI::CalibrationWizardPage::CalibrationWizardPage(), Slic3r::GUI::CALI_MODEL_SINGLE, Slic3r::GUI::CALI_PAGE_PRESET, create_page(), Slic3r::etDirectDrive, Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode, Slic3r::GUI::CalibrationWizardPage::m_cali_mode, m_extrder_types, m_extruder_nozzle_types, Slic3r::GUI::CalibrationWizardPage::m_page_type, m_show_custom_range, m_top_sizer, Slic3r::nvtHighFlow, and style.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

chain()

CalibrationWizardPage * Slic3r::GUI::CalibrationWizardPage::chain ( CalibrationWizardPage * next )

inlineinherited

    {
        set_next_page(next);
        next->set_prev_page(this);
        return next;
    }

References CalibrationWizardPage(), set_next_page(), and set_prev_page().

Here is the call graph for this function:

check_filament_compatible()

void Slic3r::GUI::CalibrationPresetPage::check_filament_compatible ( )

protected

{
    std::map<int, Preset*> selected_filaments = get_selected_filaments();
    std::string incompatiable_filament_name;
    std::string error_tips;
    int bed_temp = 0;
 
    std::vector<Preset *> selected_filaments_list;
    for (auto &item : selected_filaments)
        selected_filaments_list.push_back(item.second);
 
    if (!is_filaments_compatiable(selected_filaments, bed_temp, incompatiable_filament_name, error_tips)) {
        m_tips_panel->set_params(0, 0, 0.0f);
        if (!error_tips.empty()) {
            wxString tips = from_u8(error_tips);
            m_warning_panel->set_warning(tips);
        } else {
            wxString tips = wxString::Format(_L("%s is not compatible with %s"), m_comboBox_bed_type->GetValue(), incompatiable_filament_name);
            m_warning_panel->set_warning(tips);
        }
        m_has_filament_incompatible = true;
        update_show_status();
    } else {
        m_tips_panel->set_params(0, bed_temp, 0);
        m_warning_panel->set_warning("");
        m_has_filament_incompatible = false;
        update_show_status();
    }
 
    Layout();
}

References _L, Slic3r::GUI::from_u8(), get_selected_filaments(), is_filaments_compatiable(), m_comboBox_bed_type, m_has_filament_incompatible, m_tips_panel, m_warning_panel, and update_show_status().

Referenced by on_select_plate_type(), on_select_tray(), and select_default_compatible_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

create_ams_items_sizer()

wxBoxSizer * Slic3r::GUI::CalibrationPresetPage::create_ams_items_sizer ( MachineObject * obj, wxPanel * ams_preview_panel, std::vector< AMSPreview * > & ams_preview_list, std::vector< AMSinfo > & ams_info, int nozzle_id )

protected

                                                                                                                                                                                              {
    /* clear ams_preview_list */
    for (auto &item : ams_preview_list) {
        delete item;
    }
    ams_preview_list.clear();
 
    /* create ams_preview_list */
    auto ams_items_sizer = new wxBoxSizer(wxHORIZONTAL);
    for (auto &info : ams_info) {
        auto preview_ams_item = new AMSPreview(ams_preview_panel, wxID_ANY, info, info.ams_type);
        preview_ams_item->UpdateInfo(info);
        preview_ams_item->Open();
        ams_preview_list.push_back(preview_ams_item);
        std::string ams_id = preview_ams_item->get_ams_id();
        bool is_single = !obj->is_multi_extruders();
        preview_ams_item->Bind(wxEVT_LEFT_DOWN, [this, ams_id, nozzle_id, is_single](wxMouseEvent &e) {
            if(is_single){
                update_filament_combobox(ams_id);
            } else{
                update_multi_extruder_filament_combobox(ams_id, nozzle_id);
            }
            e.Skip();
        });
        ams_items_sizer->Add(preview_ams_item, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(6));
    }
    return ams_items_sizer;
}

References Slic3r::MachineObject::is_multi_extruders(), update_filament_combobox(), update_multi_extruder_filament_combobox(), and Slic3r::GUI::wxMouseEvent.

Referenced by sync_ams_info().

Here is the call graph for this function:

Here is the caller graph for this function:

create_filament_list_panel()

void Slic3r::GUI::CalibrationPresetPage::create_filament_list_panel ( wxWindow * parent )

protected

{
    auto panel_sizer = new wxBoxSizer(wxVERTICAL);
 
    m_filament_list_tips = new Label(parent, _L("Tips for calibration material:\n- Materials that can share same hot bed temperature\n- Different filament brand and family (Brand = Bambu, Family = Basic, Matte)"));
    m_filament_list_tips->Hide();
    m_filament_list_tips->SetFont(Label::Body_13);
    m_filament_list_tips->SetForegroundColour(wxColour(145, 145, 145));
    m_filament_list_tips->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
    panel_sizer->Add(m_filament_list_tips, 0, wxBOTTOM, FromDIP(10));
 
    // Preview item
    m_multi_ams_panel = new wxPanel(parent);
    panel_sizer->Add(m_multi_ams_panel);
 
    auto filament_fgSizer = new wxFlexGridSizer(2, 2, FromDIP(10), CALIBRATION_FGSIZER_HGAP);
    for (int i = 0; i < 4; i++) {
        auto filament_comboBox_sizer = new wxBoxSizer(wxHORIZONTAL);
        wxRadioButton* radio_btn = new wxRadioButton(m_filament_list_panel, wxID_ANY, "");
        CheckBox* check_box = new CheckBox(m_filament_list_panel);
        check_box->SetBackgroundColour(*wxWHITE);
        FilamentComboBox* fcb = new FilamentComboBox(m_filament_list_panel, i);
        fcb->SetRadioBox(radio_btn);
        fcb->SetCheckBox(check_box);
        fcb->set_select_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
        filament_comboBox_sizer->Add(radio_btn, 0, wxALIGN_CENTER);
        filament_comboBox_sizer->Add(check_box, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(8));
        filament_comboBox_sizer->Add(fcb, 0, wxALIGN_CENTER);
        filament_fgSizer->Add(filament_comboBox_sizer, 0);
 
        fcb->Bind(EVT_CALI_TRAY_CHANGED, &CalibrationPresetPage::on_select_tray, this);
 
        radio_btn->Bind(wxEVT_RADIOBUTTON, [this](wxCommandEvent& evt) {
            wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
            event.SetEventObject(this);
            wxPostEvent(this, event);
            });
        check_box->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent& evt) {
            wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
            event.SetEventObject(this);
            wxPostEvent(this, event);
            evt.Skip();
            });
        m_filament_comboBox_list.push_back(fcb);
 
        if (i == 0)
            radio_btn->SetValue(true);
    }
    panel_sizer->Add(filament_fgSizer, 0);
 
    parent->SetSizer(panel_sizer);
    panel_sizer->Fit(parent);
}

References _L, Label::Body_13, Slic3r::GUI::CALI_MODEL_SINGLE, CALIBRATION_FGSIZER_HGAP, CALIBRATION_TEXT_MAX_LENGTH, m_filament_comboBox_list, m_filament_list_panel, m_filament_list_tips, m_multi_ams_panel, on_select_tray(), Slic3r::GUI::FilamentComboBox::set_select_mode(), Slic3r::GUI::FilamentComboBox::SetCheckBox(), and Slic3r::GUI::FilamentComboBox::SetRadioBox().

Referenced by create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

create_multi_extruder_filament_list_panel()

void Slic3r::GUI::CalibrationPresetPage::create_multi_extruder_filament_list_panel ( wxWindow * parent )

protected

{
    m_multi_extruder_ams_panel_sizer = new wxBoxSizer(wxVERTICAL);
 
    m_filament_list_tips = new Label(
        parent,
        _L("Tips for calibration material:\n- Materials that can share same hot bed temperature\n- Different filament brand and family (Brand = Bambu, Family = Basic, Matte)"));
    m_filament_list_tips->Hide();
    m_filament_list_tips->SetFont(Label::Body_13);
    m_filament_list_tips->SetForegroundColour(wxColour(145, 145, 145));
    m_filament_list_tips->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
    m_multi_extruder_ams_panel_sizer->Add(m_filament_list_tips, 0, wxBOTTOM, FromDIP(10));
 
    {
        // 1. Preview item
        m_main_sizer              = new wxStaticBoxSizer(wxVERTICAL, parent, "Main");
        m_main_ams_preview_panel  = new wxPanel(parent);
        m_main_sizer->Add(m_main_ams_preview_panel);
 
        // 2. AMS item
        m_main_ams_items_sizer = new wxBoxSizer(wxVERTICAL);
        for (int i = 0; i < 4; i++) { // 4 slots
            auto           filament_comboBox_sizer = new wxBoxSizer(wxHORIZONTAL);
            wxRadioButton *radio_btn               = new wxRadioButton(m_multi_exutrder_filament_list_panel, wxID_ANY, "");
            CheckBox *     check_box               = new CheckBox(m_multi_exutrder_filament_list_panel);
            check_box->SetBackgroundColour(*wxWHITE);
            FilamentComboBox *fcb = new FilamentComboBox(m_multi_exutrder_filament_list_panel, i + 4);
            fcb->SetRadioBox(radio_btn);
            fcb->SetCheckBox(check_box);
            fcb->set_select_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
            filament_comboBox_sizer->Add(radio_btn, 0, wxALIGN_CENTER);
            filament_comboBox_sizer->Add(check_box, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(8));
            filament_comboBox_sizer->Add(fcb, 0, wxALIGN_CENTER);
            m_main_ams_items_sizer->Add(filament_comboBox_sizer, 0);
 
            fcb->Bind(EVT_CALI_TRAY_CHANGED, &CalibrationPresetPage::on_select_tray, this);
            m_main_filament_comboBox_list.emplace_back(fcb);
 
            radio_btn->Bind(wxEVT_RADIOBUTTON, [this](wxCommandEvent &evt) {
                wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
                event.SetEventObject(this);
                wxPostEvent(this, event);
            });
            check_box->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent &evt) {
                wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
                event.SetEventObject(this);
                wxPostEvent(this, event);
                evt.Skip();
            });
 
            if (i == 0)
                radio_btn->SetValue(true);
        }
 
        m_main_sizer->Add(m_main_ams_items_sizer, 1, wxEXPAND | wxALL, 10);
    }
 
    {
        // 1. Preview item
        m_deputy_sizer             = new wxStaticBoxSizer(wxVERTICAL, parent, "Deputy");
        m_deputy_ams_preview_panel = new wxPanel(parent);
        m_deputy_sizer->Add(m_deputy_ams_preview_panel);
 
        // 2. AMS item
        m_deputy_ams_items_sizer = new wxBoxSizer(wxVERTICAL);
        for (int i = 0; i < 4; ++i) {  // 4 slots
            auto           filament_comboBox_sizer = new wxBoxSizer(wxHORIZONTAL);
            wxRadioButton *radio_btn               = new wxRadioButton(m_multi_exutrder_filament_list_panel, wxID_ANY, "");
            CheckBox *     check_box               = new CheckBox(m_multi_exutrder_filament_list_panel);
            check_box->SetBackgroundColour(*wxWHITE);
            FilamentComboBox *fcb = new FilamentComboBox(m_multi_exutrder_filament_list_panel, i);
            fcb->SetRadioBox(radio_btn);
            fcb->SetCheckBox(check_box);
            fcb->set_select_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
            filament_comboBox_sizer->Add(radio_btn, 0, wxALIGN_CENTER);
            filament_comboBox_sizer->Add(check_box, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(8));
            filament_comboBox_sizer->Add(fcb, 0, wxALIGN_CENTER);
            m_deputy_ams_items_sizer->Add(filament_comboBox_sizer, 0);
 
            fcb->Bind(EVT_CALI_TRAY_CHANGED, &CalibrationPresetPage::on_select_tray, this);
            m_deputy_filament_comboBox_list.emplace_back(fcb);
 
            radio_btn->Bind(wxEVT_RADIOBUTTON, [this](wxCommandEvent &evt) {
                wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
                event.SetEventObject(this);
                wxPostEvent(this, event);
            });
            check_box->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent &evt) {
                wxCommandEvent event(EVT_CALI_TRAY_CHANGED);
                event.SetEventObject(this);
                wxPostEvent(this, event);
                evt.Skip();
            });
        }
 
        m_deputy_sizer->Add(m_deputy_ams_items_sizer, 1, wxEXPAND | wxALL, 10);
    }
 
    m_multi_exturder_ams_sizer = new wxBoxSizer(wxHORIZONTAL);
    if (m_main_extruder_on_left) {
        m_main_sizer->GetStaticBox()->SetLabel(_L("Left Nozzle"));
        m_deputy_sizer->GetStaticBox()->SetLabel(_L("Right Nozzle"));
        m_multi_exturder_ams_sizer->Add(m_main_sizer, 1, wxALL | wxALIGN_BOTTOM, 10);
        m_multi_exturder_ams_sizer->Add(m_deputy_sizer, 1, wxALL | wxALIGN_BOTTOM, 10);
    }
    else {
        m_main_sizer->GetStaticBox()->SetLabel(_L("Right Nozzle"));
        m_deputy_sizer->GetStaticBox()->SetLabel(_L("Left Nozzle"));
        m_multi_exturder_ams_sizer->Add(m_deputy_sizer, 1, wxEXPAND | wxALL, 10);
        m_multi_exturder_ams_sizer->Add(m_main_sizer, 1, wxEXPAND | wxALL, 10);
    }
    m_multi_extruder_ams_panel_sizer->Add(m_multi_exturder_ams_sizer);
 
    parent->SetSizer(m_multi_extruder_ams_panel_sizer);
    m_multi_extruder_ams_panel_sizer->Fit(parent);
}

References _L, Label::Body_13, Slic3r::GUI::CALI_MODEL_SINGLE, CALIBRATION_TEXT_MAX_LENGTH, m_deputy_ams_items_sizer, m_deputy_ams_preview_panel, m_deputy_filament_comboBox_list, m_deputy_sizer, m_filament_list_tips, m_main_ams_items_sizer, m_main_ams_preview_panel, m_main_extruder_on_left, m_main_filament_comboBox_list, m_main_sizer, m_multi_extruder_ams_panel_sizer, m_multi_exturder_ams_sizer, m_multi_exutrder_filament_list_panel, on_select_tray(), Slic3r::GUI::FilamentComboBox::set_select_mode(), Slic3r::GUI::FilamentComboBox::SetCheckBox(), and Slic3r::GUI::FilamentComboBox::SetRadioBox().

Referenced by create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

create_page()

void Slic3r::GUI::CalibrationPresetPage::create_page

(

wxWindow *

parent

)

{
    m_page_caption = new CaliPageCaption(parent, m_cali_mode);
    m_page_caption->show_prev_btn(true);
    m_top_sizer->Add(m_page_caption, 0, wxEXPAND, 0);
 
    if (m_cali_mode == CalibMode::Calib_Flow_Rate) {
        wxArrayString steps;
        steps.Add(_L("Preset"));
        steps.Add(_L("Calibration1"));
        steps.Add(_L("Calibration2"));
        steps.Add(_L("Record Factor"));
        m_step_panel = new CaliPageStepGuide(parent, steps);
        m_step_panel->set_steps(0);
    }
    else {
        wxArrayString steps;
        steps.Add(_L("Preset"));
        steps.Add(_L("Calibration"));
        steps.Add(_L("Record Factor"));
        m_step_panel = new CaliPageStepGuide(parent, steps);
        m_step_panel->set_steps(0);
    }
 
    m_top_sizer->Add(m_step_panel, 0, wxEXPAND, 0);
 
    m_cali_stage_panel = new CaliPresetCaliStagePanel(parent);
    m_cali_stage_panel->set_parent(this);
    m_top_sizer->Add(m_cali_stage_panel, 0);
 
    m_selection_panel = new wxPanel(parent);
    m_selection_panel->SetBackgroundColour(*wxWHITE);
    create_selection_panel(m_selection_panel);
    init_selection_values();
 
    m_filament_list_panel = new wxPanel(parent);
    m_filament_list_panel->SetBackgroundColour(*wxWHITE);
    create_filament_list_panel(m_filament_list_panel);
 
    m_multi_exutrder_filament_list_panel = new wxPanel(parent);
    m_multi_exutrder_filament_list_panel->SetBackgroundColour(*wxWHITE);
    create_multi_extruder_filament_list_panel(m_multi_exutrder_filament_list_panel);
 
    if (m_cali_mode == CalibMode::Calib_PA_Line || m_cali_mode == CalibMode::Calib_PA_Pattern) {
        wxArrayString pa_cali_modes;
        pa_cali_modes.push_back(_L("Line"));
        pa_cali_modes.push_back(_L("Pattern"));
        m_pa_cali_method_combox = new CaliComboBox(parent, _L("Method"), pa_cali_modes);
    }
    
    m_warning_panel = new CaliPresetWarningPanel(parent);
 
    m_tips_panel = new CaliPresetTipsPanel(parent);
 
    m_sending_panel = new CaliPageSendingPanel(parent);
    m_sending_panel->get_sending_progress_bar()->set_cancel_callback_fina([this]() {
        on_cali_cancel_job();
        });
    m_sending_panel->Bind(EVT_SHOW_ERROR_FAIL_SEND, [this](auto &event){on_cali_cancel_job();});
    m_sending_panel->Hide();
 
    m_custom_range_panel = new CaliPresetCustomRangePanel(parent);
 
    m_action_panel = new CaliPageActionPanel(parent, m_cali_mode, CaliPageType::CALI_PAGE_PRESET);
 
    m_statictext_printer_msg = new Label(this, wxEmptyString, wxALIGN_CENTER_HORIZONTAL);
    m_statictext_printer_msg->SetFont(::Label::Body_13);
    m_statictext_printer_msg->Hide();
 
    m_top_sizer->Add(m_selection_panel, 0);
    m_top_sizer->Add(m_filament_list_panel, 0);
    m_top_sizer->Add(m_multi_exutrder_filament_list_panel, 0);
    if (m_pa_cali_method_combox)
        m_top_sizer->Add(m_pa_cali_method_combox, 0);
    m_top_sizer->Add(m_custom_range_panel, 0);
    m_top_sizer->AddSpacer(FromDIP(15));
    m_top_sizer->Add(m_warning_panel, 0);
    m_top_sizer->Add(m_tips_panel, 0);
    m_top_sizer->AddSpacer(PRESET_GAP);
    m_top_sizer->Add(m_sending_panel, 0, wxALIGN_CENTER);
    m_top_sizer->Add(m_statictext_printer_msg, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_top_sizer->Add(m_action_panel, 0, wxEXPAND, 0);
 
    Bind(EVT_CALI_TRAY_CHANGED, &CalibrationPresetPage::on_select_tray, this);
}

References _L, Label::Body_13, Slic3r::GUI::CALI_PAGE_PRESET, Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, create_filament_list_panel(), create_multi_extruder_filament_list_panel(), create_selection_panel(), init_selection_values(), Slic3r::GUI::CalibrationWizardPage::m_action_panel, Slic3r::GUI::CalibrationWizardPage::m_cali_mode, m_cali_stage_panel, m_custom_range_panel, m_filament_list_panel, m_multi_exutrder_filament_list_panel, m_pa_cali_method_combox, Slic3r::GUI::CalibrationWizardPage::m_page_caption, m_selection_panel, m_sending_panel, Slic3r::GUI::CalibrationWizardPage::m_statictext_printer_msg, m_step_panel, m_tips_panel, m_top_sizer, m_warning_panel, on_cali_cancel_job(), on_select_tray(), and PRESET_GAP.

Referenced by CalibrationPresetPage().

Here is the call graph for this function:

Here is the caller graph for this function:

create_selection_panel()

void Slic3r::GUI::CalibrationPresetPage::create_selection_panel ( wxWindow * parent )

protected

{
    auto panel_sizer = new wxBoxSizer(wxVERTICAL);
 
    auto sync_button_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_btn_sync = new Button(parent, "", "ams_nozzle_sync");
    m_btn_sync->SetToolTip(_L("Synchronize nozzle and AMS information"));
    m_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));
    m_btn_sync->SetBackgroundColor(btn_sync_bg_col);
    m_btn_sync->SetBorderColor(btn_sync_bd_col);
    m_btn_sync->SetCanFocus(false);
    m_btn_sync->SetPaddingSize({FromDIP(6), FromDIP(12)});
    m_btn_sync->SetMinSize(SYNC_BUTTON_SIZE);
    m_btn_sync->SetMaxSize(SYNC_BUTTON_SIZE);
    m_btn_sync->SetVertical();
    m_btn_sync->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
        if (!curr_obj) {
            MessageDialog msg_dlg(nullptr, _L("Please connect the printer first before synchronizing."), wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
        BOOST_LOG_TRIVIAL(info) << "CalibrationPresetPage: sync_nozzle_info - machine object status:"
                                << " dev_id = " << curr_obj->get_dev_id()
                                << ", print_type = " << curr_obj->printer_type
                                << ", printer_status = " << curr_obj->print_status
                                << ", cali_finished = " << curr_obj->cali_finished
                                << ", cali_version = " << curr_obj->cali_version
                                << ", cache_flow_ratio = " << curr_obj->cache_flow_ratio
                                << ", sub_task_name = " << curr_obj->subtask_name
                                << ", gcode_file_name = " << curr_obj->m_gcode_file;
 
        for (const CaliPresetInfo &preset_info : curr_obj->selected_cali_preset) {
            BOOST_LOG_TRIVIAL(info) << "CalibrationPresetPage: sync_nozzle_info - selected preset: "
                                    << "tray_id = " << preset_info.tray_id
                                    << ", nozzle_diameter = " << preset_info.nozzle_diameter
                                    << ", filament_id = " << preset_info.filament_id
                                    << ", settring_id = " << preset_info.setting_id
                                    << ", name = " << preset_info.name;
        }
 
        for (const auto& extruder : curr_obj->GetExtderSystem()->GetExtruders()) {
            if (extruder.GetNozzleType() == NozzleType::ntUndefine) {
                wxString msg = extruder.GetExtId() == 0 ?
                    _L("Printer right nozzle information has not been set. Please configure it before proceeding with the calibration.") :
                    _L("Printer left nozzle information has not been set. Please configure it before proceeding with the calibration.");
                MessageDialog msg_dlg(nullptr, msg, wxEmptyString, wxICON_WARNING | wxOK);
                msg_dlg.ShowModal();
                break;
            }
        }
        on_device_connected(curr_obj);
    });
 
    m_sync_button_text = new Label(parent, _L("AMS and nozzle information are synced"));
    m_sync_button_text->SetFont(Label::Head_14);
    m_sync_button_text->Wrap(-1);
    sync_button_sizer->Add(m_btn_sync);
    sync_button_sizer->AddSpacer(FromDIP(20));
    sync_button_sizer->Add(m_sync_button_text, 0, wxALIGN_CENTER_VERTICAL | wxALL, 0);
    panel_sizer->Add(sync_button_sizer);
    panel_sizer->AddSpacer(PRESET_GAP);
 
    // single extruder
    {
        m_single_nozzle_info_panel = new wxPanel(parent);
        m_single_nozzle_info_panel->SetBackgroundColour(*wxWHITE);
        auto single_nozzle_sizer = new wxBoxSizer(wxVERTICAL);
        auto nozzle_combo_text = new Label(m_single_nozzle_info_panel, _L("Nozzle Diameter"));
        nozzle_combo_text->SetFont(Label::Head_14);
        nozzle_combo_text->Wrap(-1);
 
        single_nozzle_sizer->Add(nozzle_combo_text, 0, wxALL, 0);
        single_nozzle_sizer->AddSpacer(FromDIP(10));
        m_comboBox_nozzle_dia = new ComboBox(m_single_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
        single_nozzle_sizer->Add(m_comboBox_nozzle_dia, 0, wxALL, 0);
 
        m_nozzle_diameter_tips = new Label(m_single_nozzle_info_panel, "");
        m_nozzle_diameter_tips->Hide();
        m_nozzle_diameter_tips->SetFont(Label::Body_13);
        // m_nozzle_diameter_tips->SetForegroundColour(wxColour(100, 100, 100));
        m_nozzle_diameter_tips->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
        single_nozzle_sizer->Add(m_nozzle_diameter_tips, 0, wxALL, 0);
        single_nozzle_sizer->AddSpacer(PRESET_GAP);
 
        auto nozzle_volume_type_text = new Label(m_single_nozzle_info_panel, _L("Nozzle Flow"));
        nozzle_volume_type_text->SetFont(Label::Head_14);
        nozzle_volume_type_text->Wrap(-1);
 
        m_comboBox_nozzle_volume = new ComboBox(m_single_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
        m_comboBox_nozzle_volume->Disable();
 
        single_nozzle_sizer->Add(nozzle_volume_type_text, 0, wxALL, 0);
        single_nozzle_sizer->AddSpacer(FromDIP(5));
        single_nozzle_sizer->Add(m_comboBox_nozzle_volume, 0, wxALL, 0);
        single_nozzle_sizer->AddSpacer(FromDIP(5));
        single_nozzle_sizer->AddSpacer(PRESET_GAP);
 
        m_single_nozzle_info_panel->SetSizer(single_nozzle_sizer);
        panel_sizer->Add(m_single_nozzle_info_panel);
    }
 
    // multi extruder
    {
        m_multi_nozzle_info_panel = new wxPanel(parent);
        m_multi_nozzle_info_panel->SetBackgroundColour(*wxWHITE);
        auto nozzle_volume_sizer = new wxBoxSizer(wxVERTICAL);
        auto nozzle_info_text = new Label(m_multi_nozzle_info_panel, _L("Nozzle Info"));
        nozzle_info_text->SetFont(Label::Head_14);
        nozzle_info_text->Wrap(-1);
        nozzle_volume_sizer->Add(nozzle_info_text, 0, wxALL, 0);
        //nozzle_volume_sizer->AddSpacer(FromDIP(10));
 
        wxBoxSizer *      type_sizer  = new wxBoxSizer(wxHORIZONTAL);
        m_left_nozzle_volume_type_sizer  = new wxStaticBoxSizer(wxVERTICAL, m_multi_nozzle_info_panel, _L("Left Nozzle"));
        {
            //wxBoxSizer *nozzle_diameter_sizer = new wxBoxSizer(wxHORIZONTAL);
            auto        nozzle_diameter_text  = new Label(m_multi_nozzle_info_panel, _L("Nozzle Diameter"));
            nozzle_diameter_text->SetFont(Label::Head_14);
            nozzle_diameter_text->Wrap(-1);
 
            m_left_comboBox_nozzle_dia = new ComboBox(m_multi_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_FILAMENT_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
            m_left_comboBox_nozzle_dia->Disable();
 
            m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_left_nozzle_volume_type_sizer->Add(nozzle_diameter_text, 0, wxLEFT | wxRIGHT, 10);
            m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_left_nozzle_volume_type_sizer->Add(m_left_comboBox_nozzle_dia, 0, wxLEFT | wxRIGHT, 10);
            m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
 
            //wxBoxSizer *nozzle_volume_sizer   = new wxBoxSizer(wxHORIZONTAL);
            auto        nozzle_volume_type_text = new Label(m_multi_nozzle_info_panel, _L("Nozzle Flow"));
            nozzle_volume_type_text->SetFont(Label::Head_14);
            nozzle_volume_type_text->Wrap(-1);
 
            m_left_comboBox_nozzle_volume = new ComboBox(m_multi_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_FILAMENT_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
            m_left_comboBox_nozzle_volume->Disable();
 
            m_left_nozzle_volume_type_sizer->Add(nozzle_volume_type_text, 0, wxLEFT | wxRIGHT, 10);
            m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_left_nozzle_volume_type_sizer->Add(m_left_comboBox_nozzle_volume, 0, wxLEFT | wxRIGHT, 10);
            m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
 
            //m_left_nozzle_volume_type_sizer->Add(nozzle_diameter_sizer);
            //m_left_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            //m_left_nozzle_volume_type_sizer->Add(nozzle_volume_sizer);
        }
 
        m_right_nozzle_volume_type_sizer = new wxStaticBoxSizer(wxVERTICAL, m_multi_nozzle_info_panel, _L("Right Nozzle"));
        {
            //wxBoxSizer *nozzle_diameter_sizer = new wxBoxSizer(wxHORIZONTAL);
            auto        nozzle_diameter_text  = new Label(m_multi_nozzle_info_panel, _L("Nozzle Diameter"));
            nozzle_diameter_text->SetFont(Label::Head_14);
            nozzle_diameter_text->Wrap(-1);
 
            m_right_comboBox_nozzle_dia = new ComboBox(m_multi_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_FILAMENT_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
            m_right_comboBox_nozzle_dia->Disable();
 
            m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_right_nozzle_volume_type_sizer->Add(nozzle_diameter_text, 0, wxLEFT | wxRIGHT, 10);
            m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_right_nozzle_volume_type_sizer->Add(m_right_comboBox_nozzle_dia, 0, wxLEFT | wxRIGHT, 10);
            m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
 
            //wxBoxSizer *nozzle_volume_sizer     = new wxBoxSizer(wxHORIZONTAL);
            auto        nozzle_volume_type_text = new Label(m_multi_nozzle_info_panel, _L("Nozzle Flow"));
            nozzle_volume_type_text->SetFont(Label::Head_14);
            nozzle_volume_type_text->Wrap(-1);
 
            m_right_comboBox_nozzle_volume = new ComboBox(m_multi_nozzle_info_panel, wxID_ANY, "", wxDefaultPosition, CALIBRATION_FILAMENT_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
            m_right_comboBox_nozzle_volume->Disable();
 
            m_right_nozzle_volume_type_sizer->Add(nozzle_volume_type_text, 0, wxLEFT | wxRIGHT, 10);
            m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            m_right_nozzle_volume_type_sizer->Add(m_right_comboBox_nozzle_volume, 0, wxLEFT | wxRIGHT, 10);
            m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
 
            //m_right_nozzle_volume_type_sizer->Add(nozzle_diameter_sizer);
            //m_right_nozzle_volume_type_sizer->AddSpacer(FromDIP(5));
            //m_right_nozzle_volume_type_sizer->Add(nozzle_volume_sizer);
        }
 
        type_sizer->Add(m_left_nozzle_volume_type_sizer, 1, wxEXPAND | wxRIGHT, 10);
        type_sizer->Add(m_right_nozzle_volume_type_sizer, 1, wxEXPAND, 0);
 
        nozzle_volume_sizer->Add(type_sizer);
        nozzle_volume_sizer->AddSpacer(PRESET_GAP);
 
        m_multi_nozzle_info_panel->SetSizer(nozzle_volume_sizer);
        panel_sizer->Add(m_multi_nozzle_info_panel);
 
        m_multi_nozzle_info_panel->Hide();
    }
 
    auto plate_type_combo_text = new Label(parent, _L("Plate Type"));
    plate_type_combo_text->SetFont(Label::Head_14);
    plate_type_combo_text->Wrap(-1);
    panel_sizer->Add(plate_type_combo_text, 0, wxALL, 0);
    panel_sizer->AddSpacer(FromDIP(10));
    m_comboBox_bed_type = new ComboBox(parent, wxID_ANY, "", wxDefaultPosition, CALIBRATION_COMBOX_SIZE, 0, nullptr, wxCB_READONLY);
    panel_sizer->Add(m_comboBox_bed_type, 0, wxALL, 0);
 
    panel_sizer->AddSpacer(PRESET_GAP);
 
    m_filament_from_panel = new wxPanel(parent);
    m_filament_from_panel->Hide();
    auto filament_from_sizer = new wxBoxSizer(wxVERTICAL);
    auto filament_from_text = new Label(m_filament_from_panel, _L("Filament position"));
    filament_from_text->SetFont(Label::Head_14);
    filament_from_sizer->Add(filament_from_text, 0);
 
    m_filament_from_panel->SetSizer(filament_from_sizer);
    panel_sizer->Add(m_filament_from_panel, 0, wxBOTTOM, PRESET_GAP);
 
    auto filament_for_title_sizer = new wxBoxSizer(wxHORIZONTAL);
    auto filament_for_text = new Label(parent, _L("Filament For Calibration"));
    filament_for_text->SetFont(Label::Head_14);
    filament_for_title_sizer->Add(filament_for_text, 0, wxALIGN_CENTER);
    filament_for_title_sizer->AddSpacer(FromDIP(25));
    m_ams_sync_button = new ScalableButton(parent, wxID_ANY, "ams_fila_sync", wxEmptyString, wxDefaultSize, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, false, 18);
    m_ams_sync_button->SetBackgroundColour(*wxWHITE);
    m_ams_sync_button->SetToolTip(_L("Synchronize filament list from AMS"));
    filament_for_title_sizer->Add(m_ams_sync_button, 0, wxALIGN_CENTER);
    panel_sizer->Add(filament_for_title_sizer);
    panel_sizer->AddSpacer(FromDIP(6));
 
    parent->SetSizer(panel_sizer);
    panel_sizer->Fit(parent);
 
    m_ams_sync_button->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
        sync_ams_info(curr_obj);
    });
 
    m_comboBox_nozzle_dia->Bind(wxEVT_COMBOBOX, &CalibrationPresetPage::on_select_nozzle, this);
 
    m_comboBox_bed_type->Bind(wxEVT_COMBOBOX, &CalibrationPresetPage::on_select_plate_type, this);
}

References _L, Label::Body_13, CALIBRATION_COMBOX_SIZE, CALIBRATION_FILAMENT_COMBOX_SIZE, CALIBRATION_TEXT_MAX_LENGTH, curr_obj, Slic3r::CaliPresetInfo::filament_id, Label::Head_14, StateColor::Hovered, m_ams_sync_button, m_btn_sync, m_comboBox_bed_type, m_comboBox_nozzle_dia, m_comboBox_nozzle_volume, m_filament_from_panel, m_left_comboBox_nozzle_dia, m_left_comboBox_nozzle_volume, m_left_nozzle_volume_type_sizer, m_multi_nozzle_info_panel, m_nozzle_diameter_tips, m_right_comboBox_nozzle_dia, m_right_comboBox_nozzle_volume, m_right_nozzle_volume_type_sizer, m_single_nozzle_info_panel, m_sync_button_text, Slic3r::CaliPresetInfo::name, StateColor::Normal, Slic3r::CaliPresetInfo::nozzle_diameter, Slic3r::ntUndefine, on_device_connected(), on_select_nozzle(), on_select_plate_type(), PRESET_GAP, StateColor::Pressed, Slic3r::CaliPresetInfo::setting_id, Slic3r::GUI::DPIAware< P >::ShowModal(), sync_ams_info(), SYNC_BUTTON_SIZE, and Slic3r::CaliPresetInfo::tray_id.

Referenced by create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

Enable_Send_Button()

void Slic3r::GUI::CalibrationPresetPage::Enable_Send_Button ( bool enable )

protected

{
    m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_CALI, enable);
}

References Slic3r::GUI::CALI_ACTION_CALI, and Slic3r::GUI::CalibrationWizardPage::m_action_panel.

Referenced by on_cali_cancel_job(), on_cali_finished_job(), on_cali_start_job(), and show_status().

Here is the caller graph for this function:

format_text()

wxString Slic3r::GUI::CalibrationPresetPage::format_text

(

wxString &

m_msg

)

{
    if (wxGetApp().app_config->get("language") != "zh_CN") { return m_msg; }
 
    wxString out_txt = m_msg;
    wxString count_txt = "";
    int      new_line_pos = 0;
 
    for (int i = 0; i < m_msg.length(); i++) {
        auto text_size = m_statictext_printer_msg->GetTextExtent(count_txt);
        if (text_size.x < (FromDIP(600))) {
            count_txt += m_msg[i];
        }
        else {
            out_txt.insert(i - 1, '\n');
            count_txt = "";
        }
    }
    return out_txt;
}

References Slic3r::GUI::CalibrationWizardPage::m_statictext_printer_msg.

Referenced by update_priner_status_msg().

Here is the caller graph for this function:

get_cali_stage()

void Slic3r::GUI::CalibrationPresetPage::get_cali_stage	(	CaliPresetStage &	stage,
		float &	value )

{
    m_cali_stage_panel->get_cali_stage(stage, value);
 
    if (stage != CaliPresetStage::CALI_MANUAL_STAGE_2) {
        std::map<int, Preset*> selected_filaments = get_selected_filaments();
        if (!selected_filaments.empty()) {
            const ConfigOptionFloatsNullable* flow_ratio_opt = selected_filaments.begin()->second->config.option<ConfigOptionFloatsNullable>("filament_flow_ratio");
            if (flow_ratio_opt) {
                m_cali_stage_panel->set_flow_ratio_value(flow_ratio_opt->get_at(0));
                value = flow_ratio_opt->get_at(0);
            }
        }
    }
}

References Slic3r::GUI::CALI_MANUAL_STAGE_2, Slic3r::ConfigOptionVector< double >::get_at(), get_selected_filaments(), and m_cali_stage_panel.

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info().

Here is the call graph for this function:

Here is the caller graph for this function:

get_current_object()

MachineObject * Slic3r::GUI::CalibrationPresetPage::get_current_object ( )

inline

{ return curr_obj; }

References curr_obj.

get_custom_range_values()

wxArrayString Slic3r::GUI::CalibrationPresetPage::get_custom_range_values

(

)

{
    if (m_custom_range_panel) {
        return m_custom_range_panel->get_values();
    }
    return wxArrayString();
}

References m_custom_range_panel.

Referenced by Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_extruder_id_by_tray_id()

int Slic3r::GUI::CalibrationPresetPage::get_extruder_id_by_tray_id

(

int

tray_id

)

{
    // An AMS behind a Filament Track Switch feeds both extruders, so the extruder is the one
    // whose panel the filament was selected in.
    if (curr_obj && curr_obj->is_multi_extruders()) {
        for (FilamentComboBox *fcb : get_selected_filament_combobox()) {
            if (fcb->get_tray_id() != tray_id)
                continue;
            const bool is_deputy = std::find(m_deputy_filament_comboBox_list.begin(), m_deputy_filament_comboBox_list.end(), fcb) !=
                                   m_deputy_filament_comboBox_list.end();
            return is_deputy ? DEPUTY_EXTRUDER_ID : MAIN_EXTRUDER_ID;
        }
    }
 
    int ams_id = tray_id / 4, slot_id, unused_tray_id;
    if (curr_obj)
        get_tray_ams_and_slot_id(curr_obj, tray_id, ams_id, slot_id, unused_tray_id);
    if (m_ams_id_to_extruder_id_map.find(ams_id) != m_ams_id_to_extruder_id_map.end()) {
        return m_ams_id_to_extruder_id_map[ams_id];
    }
 
    return 0;
}

References curr_obj, DEPUTY_EXTRUDER_ID, get_selected_filament_combobox(), Slic3r::GUI::get_tray_ams_and_slot_id(), m_ams_id_to_extruder_id_map, m_deputy_filament_comboBox_list, and MAIN_EXTRUDER_ID.

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_extruder_type()

ExtruderType Slic3r::GUI::CalibrationPresetPage::get_extruder_type

(

int

extruder_id

)

const

{
    if (curr_obj) {
        int extruder_idx = 0;
        if (curr_obj->is_multi_extruders()) {
            if (extruder_id == RIGHT_EXTRUDER_ID) {
                extruder_idx = 1;
            }
        }
        if (m_extrder_types.size() > extruder_idx)
            return m_extrder_types[extruder_idx];
    }
    return ExtruderType::etDirectDrive;
}

References curr_obj, Slic3r::etDirectDrive, m_extrder_types, and RIGHT_EXTRUDER_ID.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_filament_ams_list()

std::map< int, DynamicPrintConfig > Slic3r::GUI::CalibrationPresetPage::get_filament_ams_list ( ) const

inline

{ return filament_ams_list; }

References filament_ams_list.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_index_by_tray_id()

int Slic3r::GUI::CalibrationPresetPage::get_index_by_tray_id

(

int

tray_id

)

{
    std::vector<FilamentComboBox*> fcb_list = get_selected_filament_combobox();
    for (auto fcb : fcb_list) {
        if (fcb->get_tray_id() == tray_id) {
            return fcb->get_index();
        }
    }
    return -1;
}

References get_selected_filament_combobox().

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_page()

CalibrationWizardPage * Slic3r::GUI::CalibrationWizardPage::get_next_page ( )

inlineinherited

{ return m_next_page; }

References CalibrationWizardPage(), and m_next_page.

Here is the call graph for this function:

get_nozzle_diameter()

float Slic3r::GUI::CalibrationPresetPage::get_nozzle_diameter

(

int

extruder_id

)

const

{
    float nozzle_dia = -1.f;
    if (!curr_obj)
        return nozzle_dia;
 
    if (curr_obj->is_multi_extruders()) {
        if (extruder_id == LEFT_EXTRUDER_ID) {
            if (m_left_comboBox_nozzle_dia->GetSelection() >= 0 && m_left_comboBox_nozzle_dia->GetSelection() < NOZZLE_LIST_COUNT) {
                nozzle_dia = nozzle_diameter_list[m_left_comboBox_nozzle_dia->GetSelection()];
            }
        } else if (extruder_id == RIGHT_EXTRUDER_ID) {
            if (m_right_comboBox_nozzle_dia->GetSelection() >= 0 && m_right_comboBox_nozzle_dia->GetSelection() < NOZZLE_LIST_COUNT) {
                nozzle_dia = nozzle_diameter_list[m_right_comboBox_nozzle_dia->GetSelection()];
            }
        }
    }
    else if (m_comboBox_nozzle_dia->GetSelection() >= 0 && m_comboBox_nozzle_dia->GetSelection() < NOZZLE_LIST_COUNT) {
        nozzle_dia = nozzle_diameter_list[m_comboBox_nozzle_dia->GetSelection()];
    }
 
    return nozzle_dia;
}

References curr_obj, LEFT_EXTRUDER_ID, m_comboBox_nozzle_dia, m_left_comboBox_nozzle_dia, m_right_comboBox_nozzle_dia, Slic3r::GUI::nozzle_diameter_list, NOZZLE_LIST_COUNT, and RIGHT_EXTRUDER_ID.

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info(), is_nozzle_info_synced(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_nozzle_value()

float Slic3r::GUI::CalibrationPresetPage::get_nozzle_value ( )

protected

{
    double nozzle_value = 0.0;
    wxString nozzle_value_str = m_comboBox_nozzle_dia->GetValue();
    try {
        nozzle_value_str.ToDouble(&nozzle_value);
    }
    catch (...) {
        ;
    }
 
    return nozzle_value;
}

References m_comboBox_nozzle_dia.

Referenced by get_print_preset(), and update_combobox_filaments().

Here is the caller graph for this function:

get_nozzle_volume_type()

NozzleVolumeType Slic3r::GUI::CalibrationPresetPage::get_nozzle_volume_type

(

int

extruder_id

)

const

{
    if (curr_obj) {
        if (curr_obj->is_multi_extruders()) {
            if (extruder_id == LEFT_EXTRUDER_ID) {
                return NozzleVolumeType(intptr_t(m_left_comboBox_nozzle_volume->GetClientData(m_left_comboBox_nozzle_volume->GetSelection())));
            } else if (extruder_id == RIGHT_EXTRUDER_ID) {
                return NozzleVolumeType(intptr_t(m_right_comboBox_nozzle_volume->GetClientData(m_right_comboBox_nozzle_volume->GetSelection())));
            }
        }
        else
            return NozzleVolumeType(intptr_t(m_comboBox_nozzle_volume->GetClientData(m_comboBox_nozzle_volume->GetSelection())));
    }
    return NozzleVolumeType::nvtStandard;
}

References curr_obj, LEFT_EXTRUDER_ID, m_comboBox_nozzle_volume, m_left_comboBox_nozzle_volume, m_right_comboBox_nozzle_volume, Slic3r::nvtStandard, and RIGHT_EXTRUDER_ID.

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info(), is_nozzle_info_synced(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_pa_cali_method()

CalibMode Slic3r::GUI::CalibrationPresetPage::get_pa_cali_method

(

)

{
    if (m_pa_cali_method_combox) {
        int selected_mode = m_pa_cali_method_combox->get_selection();
        if (selected_mode == PA_LINE) {
            return CalibMode::Calib_PA_Line;
        }
        else if (selected_mode == PA_PATTERN) {
            return CalibMode::Calib_PA_Pattern;
        }
    }
    return CalibMode::Calib_PA_Line;
}

References Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, m_pa_cali_method_combox, Slic3r::GUI::PA_LINE, and Slic3r::GUI::PA_PATTERN.

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_page_status()

CaliPresetPageStatus Slic3r::GUI::CalibrationPresetPage::get_page_status ( )

inline

{ return m_page_status; }

References m_page_status.

get_page_type()

CaliPageType Slic3r::GUI::CalibrationWizardPage::get_page_type ( )

inlineinherited

{ return m_page_type; }

References m_page_type.

Referenced by Slic3r::GUI::CalibrationWizard::on_cali_go_home().

Here is the caller graph for this function:

get_preset_info()

void Slic3r::GUI::CalibrationPresetPage::get_preset_info	(	float &	nozzle_dia,
		BedType &	plate_type )

{
    if (m_comboBox_nozzle_dia->GetSelection() >=0 && m_comboBox_nozzle_dia->GetSelection() < NOZZLE_LIST_COUNT) {
        nozzle_dia = nozzle_diameter_list[m_comboBox_nozzle_dia->GetSelection()];
    } else {
        nozzle_dia = -1.0f;
    }
 
    if (m_comboBox_bed_type->GetSelection() >= 0)
        plate_type = static_cast<BedType>(m_displayed_bed_types[m_comboBox_bed_type->GetSelection()]);
}

References m_comboBox_bed_type, m_comboBox_nozzle_dia, m_displayed_bed_types, Slic3r::GUI::nozzle_diameter_list, and NOZZLE_LIST_COUNT.

Referenced by Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_prev_page()

CalibrationWizardPage * Slic3r::GUI::CalibrationWizardPage::get_prev_page ( )

inlineinherited

{ return m_prev_page; }

References CalibrationWizardPage(), and m_prev_page.

Here is the call graph for this function:

get_print_preset()

Preset * Slic3r::GUI::CalibrationPresetPage::get_print_preset

(

)

{
    Preset* printer_preset = get_printer_preset(curr_obj, get_nozzle_value());
 
    Preset* print_preset = nullptr;
    wxArrayString print_items;
 
    // get default print profile
    std::string default_print_profile_name;
    if (printer_preset && printer_preset->config.has("default_print_profile")) {
        default_print_profile_name = printer_preset->config.opt_string("default_print_profile");
    }
 
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (preset_bundle) {
        for (auto print_it = preset_bundle->prints.begin(); print_it != preset_bundle->prints.end(); print_it++) {
            if (print_it->name == default_print_profile_name) {
                print_preset = &(*print_it);
                BOOST_LOG_TRIVIAL(trace) << "CaliPresetPage: get_print_preset = " << print_preset->name;
            }
        }
    }
 
    return print_preset;
}

References Slic3r::PresetCollection::begin(), Slic3r::Preset::config, curr_obj, Slic3r::PresetCollection::end(), get_nozzle_value(), get_printer_preset(), Slic3r::ConfigOptionResolver::has(), Slic3r::Preset::name, Slic3r::DynamicConfig::opt_string(), Slic3r::PresetBundle::prints, and Slic3r::trace().

Referenced by get_print_preset_name(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_preset_name()

std::string Slic3r::GUI::CalibrationPresetPage::get_print_preset_name

(

)

{
    Preset* print_preset = get_print_preset();
    if (print_preset)
        return print_preset->name;
    return "";
}

References get_print_preset(), and Slic3r::Preset::name.

Here is the call graph for this function:

get_printer_preset()

Preset * Slic3r::GUI::CalibrationPresetPage::get_printer_preset	(	MachineObject *	obj,
		float	nozzle_value )

{
    if (!obj) return nullptr;
 
    Preset* printer_preset = nullptr;
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    for (auto printer_it = preset_bundle->printers.begin(); printer_it != preset_bundle->printers.end(); printer_it++) {
        // only use system printer preset
        if (!printer_it->is_system) continue;
 
        ConfigOption* printer_nozzle_opt = printer_it->config.option("nozzle_diameter");
        ConfigOptionFloats *printer_nozzle_vals = nullptr;
        if (printer_nozzle_opt)
            printer_nozzle_vals = dynamic_cast<ConfigOptionFloats*>(printer_nozzle_opt);
        std::string model_id = printer_it->get_current_printer_type(preset_bundle);
 
        std::string printer_type = obj->printer_type;
        if (obj->is_support_upgrade_kit && obj->installed_upgrade_kit) { printer_type = "C12"; }
        if (model_id.compare(printer_type) == 0
            && printer_nozzle_vals
            && abs(printer_nozzle_vals->get_at(0) - nozzle_value) < 1e-3) {
            printer_preset = &(*printer_it);
        }
    }
 
    return printer_preset;
}

References Slic3r::PresetCollection::begin(), Slic3r::PresetCollection::end(), Slic3r::ConfigOptionVector< double >::get_at(), Slic3r::MachineObject::installed_upgrade_kit, Slic3r::MachineObject::is_support_upgrade_kit, Slic3r::MachineObject::printer_type, and Slic3r::PresetBundle::printers.

Referenced by get_print_preset(), init_selection_values(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), and update_combobox_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

get_selected_filament_combobox()

std::vector< FilamentComboBox * > Slic3r::GUI::CalibrationPresetPage::get_selected_filament_combobox

(

)

{
    std::vector<FilamentComboBox*> fcb_list;
 
    if (curr_obj && curr_obj->is_multi_extruders()) {
        if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_MULITI) {
            for (auto &fcb : m_main_filament_comboBox_list) {
                if (fcb->GetCheckBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
            for (auto &fcb : m_deputy_filament_comboBox_list) {
                if (fcb->GetCheckBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
        } else if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_SINGLE) {
            for (auto &fcb : m_main_filament_comboBox_list) {
                if (fcb->GetRadioBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
            for (auto &fcb : m_deputy_filament_comboBox_list) {
                if (fcb->GetRadioBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
        }
    }
    else {
        if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_MULITI) {
            for (auto &fcb : m_filament_comboBox_list) {
                if (fcb->GetCheckBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
        } else if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_SINGLE) {
            for (auto &fcb : m_filament_comboBox_list) {
                if (fcb->GetRadioBox()->GetValue()) {
                    fcb_list.push_back(fcb);
                }
            }
        }
    }
 
    return fcb_list;
}

References Slic3r::GUI::CALI_MODEL_MULITI, Slic3r::GUI::CALI_MODEL_SINGLE, curr_obj, Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode, m_deputy_filament_comboBox_list, m_filament_comboBox_list, and m_main_filament_comboBox_list.

Referenced by get_extruder_id_by_tray_id(), get_index_by_tray_id(), and get_selected_filaments().

Here is the caller graph for this function:

get_selected_filaments()

std::map< int, Preset * > Slic3r::GUI::CalibrationPresetPage::get_selected_filaments

(

)

{
    std::map<int, Preset*> out;
    std::vector<FilamentComboBox*> fcb_list = get_selected_filament_combobox();
 
    for (int i = 0; i < fcb_list.size(); i++) {
        Preset* preset = const_cast<Preset*>(fcb_list[i]->GetComboBox()->get_selected_preset());
        // valid tray id
        if (fcb_list[i]->get_tray_id() >= 0) {
            out.emplace(std::make_pair(fcb_list[i]->get_tray_id(), preset));
        }
    }
    
 
    return out;
}

References get_selected_filament_combobox().

Referenced by Slic3r::GUI::CalibrationWizard::cache_preset_info(), check_filament_compatible(), get_cali_stage(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), and on_recommend_input_value().

Here is the call graph for this function:

Here is the caller graph for this function:

get_sending_progress_bar()

std::shared_ptr< ProgressIndicator > Slic3r::GUI::CalibrationPresetPage::get_sending_progress_bar ( )

inline

                                                                {
        return m_sending_panel->get_sending_progress_bar();
    }

References m_sending_panel.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the caller graph for this function:

get_status()

CaliPresetPageStatus Slic3r::GUI::CalibrationPresetPage::get_status ( )

inlineprotected

{ return m_page_status; }

References m_page_status.

init_selection_values()

void Slic3r::GUI::CalibrationPresetPage::init_selection_values ( )

protected

{
    // init nozzle diameter and nozzle volume
    {
        m_comboBox_nozzle_dia->Clear();
        for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
            m_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
        }
        m_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
 
        fill_nozzle_volume_combo(m_comboBox_nozzle_volume);
    }
 
    Preset* cur_printer_preset = get_printer_preset(curr_obj, 0.4);
 
    m_comboBox_bed_type->Clear();
    m_displayed_bed_types.clear();
 
    // init plate type
    int curr_selection = 0;
    const ConfigOptionDef* bed_type_def = print_config_def.get("curr_bed_type");
    if (bed_type_def && bed_type_def->enum_keys_map) {
        int select_index = 0;
        int bed_type_value = 0;
        for (auto item : bed_type_def->enum_labels) {
            bed_type_value++;
            if (cur_printer_preset) {
                const VendorProfile::PrinterModel *pm = PresetUtils::system_printer_model(*cur_printer_preset);
                if (pm) {
                    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;
                    }
                }
            }
 
            if (item == "Textured PEI Plate") {
                curr_selection = select_index;
            }
 
            m_comboBox_bed_type->AppendString(_L(item));
            m_displayed_bed_types.emplace_back(BedType(bed_type_value));
            select_index++;
        }
        m_comboBox_bed_type->SetSelection(curr_selection);
    }
 
    // left
    {
        m_left_comboBox_nozzle_dia->Clear();
        for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
            m_left_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
        }
        m_left_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
 
        fill_nozzle_volume_combo(m_left_comboBox_nozzle_volume);
    }
 
    // right
    {
        m_right_comboBox_nozzle_dia->Clear();
        for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
            m_right_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
        }
        m_right_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
 
        fill_nozzle_volume_combo(m_right_comboBox_nozzle_volume);
    }
}

References _L, curr_obj, Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, Slic3r::GUI::fill_nozzle_volume_combo(), get_printer_preset(), m_comboBox_bed_type, m_comboBox_nozzle_dia, m_comboBox_nozzle_volume, m_displayed_bed_types, m_left_comboBox_nozzle_dia, m_left_comboBox_nozzle_volume, m_right_comboBox_nozzle_dia, m_right_comboBox_nozzle_volume, Slic3r::VendorProfile::PrinterModel::not_support_bed_types, Slic3r::GUI::nozzle_diameter_list, NOZZLE_LIST_COUNT, NOZZLE_LIST_DEFAULT, Slic3r::print_config_def, and Slic3r::PresetUtils::system_printer_model().

Referenced by create_page(), and on_device_connected().

Here is the call graph for this function:

Here is the caller graph for this function:

init_with_machine()

void Slic3r::GUI::CalibrationPresetPage::init_with_machine

(

MachineObject *

obj

)

{
    if (!obj) return;
 
    auto get_nozzle_diameter_list_index = [&obj](int extruder_id) -> int {
        for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
            if (abs(obj->GetExtderSystem()->GetNozzleDiameter(extruder_id) - nozzle_diameter_list[i]) < 1e-3) {
                return i;
            }
        }
        return -1;
    };
 
    //set flow ratio calibration type
    m_cali_stage_panel->set_flow_ratio_calibration_type(obj->flow_ratio_calibration_type);
    // set nozzle value from machine
    bool nozzle_is_set = false;
    for (int i = 0; i < NOZZLE_LIST_COUNT; i++) {
        if (abs(obj->GetExtderSystem()->GetNozzleDiameter(0) - nozzle_diameter_list[i]) < 1e-3) {
            if (m_comboBox_nozzle_dia->GetCount() > i) {
                m_comboBox_nozzle_dia->SetSelection(i);
                nozzle_is_set = true;
            }
        }
    }
 
    if (nozzle_is_set) {
        wxCommandEvent event(wxEVT_COMBOBOX);
        event.SetEventObject(this);
        wxPostEvent(m_comboBox_nozzle_dia, event);
        m_comboBox_nozzle_dia->SetToolTip(_L("The nozzle diameter has been synchronized from the printer Settings"));
    } else {
        m_comboBox_nozzle_dia->SetToolTip(wxEmptyString);
        // set default to 0.4
        if (m_comboBox_nozzle_dia->GetCount() > NOZZLE_LIST_DEFAULT)
            m_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
    }
 
    if (obj->is_multi_extruders()) {
        for (size_t i = 0; i < obj->GetExtderSystem()->GetTotalExtderCount(); ++i) {
            if (i == LEFT_EXTRUDER_ID) {
                int index = get_nozzle_diameter_list_index(LEFT_EXTRUDER_ID);
                if ((index != -1) && m_left_comboBox_nozzle_dia->GetCount() > index) {
                    m_left_comboBox_nozzle_dia->SetSelection(index);
                    wxCommandEvent event(wxEVT_COMBOBOX);
                    event.SetEventObject(this);
                    wxPostEvent(m_left_comboBox_nozzle_dia, event);
                    m_left_comboBox_nozzle_dia->SetToolTip(_L("The nozzle diameter has been synchronized from the printer Settings"));
                }
                else {
                    m_left_comboBox_nozzle_dia->SetToolTip(wxEmptyString);
                    if (m_left_comboBox_nozzle_dia->GetCount() > NOZZLE_LIST_DEFAULT)
                        m_left_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
                }
 
                if (obj->GetExtderSystem()->GetNozzleFlowType(i) != NozzleFlowType::NONE_FLOWTYPE) {
                    select_nozzle_volume(m_left_comboBox_nozzle_volume, DevNozzle::ToNozzleVolumeType(obj->GetExtderSystem()->GetNozzleFlowType(i)));
                } else {
                    m_left_comboBox_nozzle_volume->SetSelection(0);
                }
            }
            else if (i == RIGHT_EXTRUDER_ID) {
                int index = get_nozzle_diameter_list_index(RIGHT_EXTRUDER_ID);
                if ((index != -1) && m_right_comboBox_nozzle_dia->GetCount() > index) {
                    m_right_comboBox_nozzle_dia->SetSelection(index);
                    wxCommandEvent event(wxEVT_COMBOBOX);
                    event.SetEventObject(this);
                    wxPostEvent(m_right_comboBox_nozzle_dia, event);
                    m_right_comboBox_nozzle_dia->SetToolTip(_L("The nozzle diameter has been synchronized from the printer Settings"));
                } else {
                    m_right_comboBox_nozzle_dia->SetToolTip(wxEmptyString);
                    if (m_right_comboBox_nozzle_dia->GetCount() > NOZZLE_LIST_DEFAULT)
                        m_right_comboBox_nozzle_dia->SetSelection(NOZZLE_LIST_DEFAULT);
                }
 
                if (obj->GetExtderSystem()->GetNozzleFlowType(i) != NozzleFlowType::NONE_FLOWTYPE) {
                    select_nozzle_volume(m_right_comboBox_nozzle_volume, DevNozzle::ToNozzleVolumeType(obj->GetExtderSystem()->GetNozzleFlowType(i)));
                } else {
                    m_right_comboBox_nozzle_volume->SetSelection(0);
                }
            }
        }
 
        if (!obj->is_main_extruder_on_left() && m_main_extruder_on_left) {
            m_multi_exturder_ams_sizer->Detach(m_main_sizer);
            m_multi_exturder_ams_sizer->Detach(m_deputy_sizer);
 
            m_main_sizer->GetStaticBox()->SetLabel(_L("Right Nozzle"));
            m_deputy_sizer->GetStaticBox()->SetLabel(_L("Left Nozzle"));
            m_multi_exturder_ams_sizer->Add(m_deputy_sizer, 1, wxEXPAND | wxALL, 10);
            m_multi_exturder_ams_sizer->Add(m_main_sizer, 1, wxEXPAND | wxALL, 10);
 
            m_main_extruder_on_left = false;
        }
        else if (obj->is_main_extruder_on_left() && !m_main_extruder_on_left) {
            m_multi_exturder_ams_sizer->Detach(m_main_sizer);
            m_multi_exturder_ams_sizer->Detach(m_deputy_sizer);
 
            m_main_sizer->GetStaticBox()->SetLabel(_L("Left Nozzle"));
            m_deputy_sizer->GetStaticBox()->SetLabel(_L("Right Nozzle"));
            m_multi_exturder_ams_sizer->Add(m_main_sizer, 1, wxEXPAND | wxALL, 10);
            m_multi_exturder_ams_sizer->Add(m_deputy_sizer, 1, wxEXPAND | wxALL, 10);
 
            m_main_extruder_on_left = true;
        }
 
        m_single_nozzle_info_panel->Hide();
        m_multi_nozzle_info_panel->Show();
        m_multi_exutrder_filament_list_panel->Show();
        m_filament_list_panel->Hide();
    }
    else {
        if ((obj->GetExtderSystem()->GetTotalExtderCount() > 0) && (obj->GetExtderSystem()->GetNozzleFlowType(0) != NozzleFlowType::NONE_FLOWTYPE))
        {
            select_nozzle_volume(m_comboBox_nozzle_volume, DevNozzle::ToNozzleVolumeType(obj->GetExtderSystem()->GetNozzleFlowType(0)));
        } else {
            m_comboBox_nozzle_volume->SetSelection(0);
        }
 
        m_single_nozzle_info_panel->Show();
        m_multi_nozzle_info_panel->Hide();
        m_multi_exutrder_filament_list_panel->Hide();
        m_filament_list_panel->Show();
    }
 
    Layout();
 
    // init filaments for calibration
    sync_ams_info(obj);
}

References _L, Slic3r::MachineObject::flow_ratio_calibration_type, Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleDiameter(), Slic3r::DevExtderSystem::GetNozzleFlowType(), Slic3r::DevExtderSystem::GetTotalExtderCount(), Slic3r::MachineObject::is_main_extruder_on_left(), Slic3r::MachineObject::is_multi_extruders(), LEFT_EXTRUDER_ID, m_cali_stage_panel, m_comboBox_nozzle_dia, m_comboBox_nozzle_volume, m_deputy_sizer, m_filament_list_panel, m_left_comboBox_nozzle_dia, m_left_comboBox_nozzle_volume, m_main_extruder_on_left, m_main_sizer, m_multi_exturder_ams_sizer, m_multi_exutrder_filament_list_panel, m_multi_nozzle_info_panel, m_right_comboBox_nozzle_dia, m_right_comboBox_nozzle_volume, m_single_nozzle_info_panel, Slic3r::NONE_FLOWTYPE, Slic3r::GUI::nozzle_diameter_list, NOZZLE_LIST_COUNT, NOZZLE_LIST_DEFAULT, RIGHT_EXTRUDER_ID, Slic3r::GUI::select_nozzle_volume(), sync_ams_info(), and Slic3r::DevNozzle::ToNozzleVolumeType().

Referenced by on_device_connected().

Here is the call graph for this function:

Here is the caller graph for this function:

is_filament_in_blacklist()

bool Slic3r::GUI::CalibrationPresetPage::is_filament_in_blacklist ( int tray_id, Preset * preset, std::string & error_tips )

protected

{
    if (!curr_obj)
        return true;
 
    int ams_id;
    int slot_id;
    int out_tray_id;
    get_tray_ams_and_slot_id(curr_obj, tray_id, ams_id, slot_id, out_tray_id);
 
    if (wxGetApp().app_config->get("skip_ams_blacklist_check") != "true") {
        DevFilaBlacklist::CheckFilamentInfo check_info;
        check_info.dev_id   = curr_obj->get_dev_id();
        check_info.model_id = curr_obj->printer_type;
        check_info.fila_id  = preset->filament_id;
        preset->get_filament_type(check_info.fila_type);
        check_info.ams_id   = ams_id;
        check_info.slot_id  = slot_id;
        check_info.has_filament_switch = curr_obj->GetFilaSwitch()->IsInstalled();
        // fila_name intentionally left empty: the engine recovers it from the selected AMS slot,
        // preserving the name-match behavior.
 
        auto vendor = dynamic_cast<ConfigOptionStrings*> (preset->config.option("filament_vendor"));
        if (vendor && (vendor->values.size() > 0)) {
            check_info.fila_vendor = vendor->values[0];
        }
 
        const auto &result = DevFilaBlacklist::check_filaments_in_blacklist(check_info);
 
        if (const auto &prohibition_items = result.get_items_by_action("prohibition"); !prohibition_items.empty()) {
            wxString combined_msg;
            for (const auto &item : prohibition_items) { combined_msg += item.info_msg + "\n"; }
            error_tips = combined_msg.ToUTF8().data();
            return false;
        }
 
        if (const auto &warning_items = result.get_items_by_action("warning"); !warning_items.empty()) {
            wxString combined_msg;
            for (const auto &item : warning_items) { combined_msg += item.info_msg + "\n"; }
            error_tips = combined_msg.ToUTF8().data();
            return true;
        }
 
        error_tips = "";
        return true;
    }
    if (devPrinterUtil::IsVirtualSlot(ams_id)) {
        if (m_cali_mode == CalibMode::Calib_PA_Line && (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO || m_cali_method == CalibrationMethod::CALI_METHOD_NEW_AUTO)) {
            std::string filamnt_type;
            preset->get_filament_type(filamnt_type);
            if (filamnt_type == "TPU") {
                error_tips = _u8L("TPU is not supported for Flow Dynamics Auto-Calibration.");
                return false;
            }
        }
    }
    return true;
}

References _u8L, Slic3r::DevFilaBlacklist::CheckFilamentInfo::ams_id, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_NEW_AUTO, Slic3r::Calib_PA_Line, Slic3r::DevFilaBlacklist::check_filaments_in_blacklist(), Slic3r::Preset::config, curr_obj, Slic3r::DevFilaBlacklist::CheckFilamentInfo::dev_id, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_id, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_type, Slic3r::DevFilaBlacklist::CheckFilamentInfo::fila_vendor, Slic3r::Preset::filament_id, Slic3r::Preset::get_filament_type(), Slic3r::GUI::get_tray_ams_and_slot_id(), Slic3r::DevFilaBlacklist::CheckFilamentInfo::has_filament_switch, Slic3r::devPrinterUtil::IsVirtualSlot(), Slic3r::GUI::CalibrationWizardPage::m_cali_method, Slic3r::GUI::CalibrationWizardPage::m_cali_mode, Slic3r::DevFilaBlacklist::CheckFilamentInfo::model_id, Slic3r::ConfigBase::option(), and Slic3r::DevFilaBlacklist::CheckFilamentInfo::slot_id.

Referenced by is_filaments_compatiable().

Here is the call graph for this function:

Here is the caller graph for this function:

is_filaments_compatiable() [1/2]

bool Slic3r::GUI::CalibrationPresetPage::is_filaments_compatiable ( const std::map< int, Preset * > & prests )

protected

{
    std::string incompatiable_filament_name;
    std::string error_tips;
    int bed_temp = 0;
    return is_filaments_compatiable(prests, bed_temp, incompatiable_filament_name, error_tips);
}

References is_filaments_compatiable().

Referenced by check_filament_compatible(), is_filaments_compatiable(), and select_default_compatible_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

is_filaments_compatiable() [2/2]

bool Slic3r::GUI::CalibrationPresetPage::is_filaments_compatiable ( const std::map< int, Preset * > & prests, int & bed_temp, std::string & incompatiable_filament_name, std::string & error_tips )

protected

{
    if (prests.empty()) return true;
 
    bed_temp = 0;
    std::vector<std::string> filament_types;
    std::vector<int> nozzle_temperatures;
    std::vector<int> nozzle_temperature_range_lows;
    std::vector<int> nozzle_temperature_range_highs;
    for (auto &item : prests) {
        const auto& item_preset = item.second;
        if (!item_preset)
            continue;
 
        // update bed temperature
        BedType curr_bed_type = BedType(m_displayed_bed_types[m_comboBox_bed_type->GetSelection()]);
        const ConfigOptionInts *opt_bed_temp_ints = item_preset->config.option<ConfigOptionInts>(get_bed_temp_key(curr_bed_type));
        int bed_temp_int = 0;
        if (opt_bed_temp_ints) {
            bed_temp_int = opt_bed_temp_ints->get_at(0);
        }
 
        if (bed_temp_int <= 0) {
            if (!item_preset->alias.empty())
                incompatiable_filament_name = item_preset->alias;
            else
                incompatiable_filament_name = item_preset->name;
 
            return false;
        } else {
            // set for first preset
            if (bed_temp == 0)
                bed_temp = bed_temp_int;
        }
        std::string display_filament_type;
        filament_types.push_back(item_preset->config.get_filament_type(display_filament_type, 0));
 
        int nozzle_temperature = 0;
        int nozzle_temperature_range_low = 0;
        int nozzle_temperature_range_high = 0;
        if (const auto* opt_nozzle_temp = item_preset->config.option<ConfigOptionInts>("nozzle_temperature"))
            nozzle_temperature = opt_nozzle_temp->get_at(0);
        if (const auto* opt_nozzle_temp_low = item_preset->config.option<ConfigOptionInts>("nozzle_temperature_range_low"))
            nozzle_temperature_range_low = opt_nozzle_temp_low->get_at(0);
        if (const auto* opt_nozzle_temp_high = item_preset->config.option<ConfigOptionInts>("nozzle_temperature_range_high"))
            nozzle_temperature_range_high = opt_nozzle_temp_high->get_at(0);
 
        nozzle_temperatures.push_back(nozzle_temperature);
        nozzle_temperature_range_lows.push_back(nozzle_temperature_range_low);
        nozzle_temperature_range_highs.push_back(nozzle_temperature_range_high);
 
        // check is it in the filament blacklist
        if (!is_filament_in_blacklist(item.first, item_preset, error_tips))
            return false;
    }
 
    auto compatibility = Print::check_multi_filaments_compatibility(
            filament_types,
            nozzle_temperatures,
            nozzle_temperature_range_lows,
            nozzle_temperature_range_highs);
 
    if (compatibility == FilamentCompatibilityType::InvalidTemperatureRange) {
        error_tips = _u8L("Invalid recommended nozzle temperature range. The lower bound must be lower than the upper bound.");
        return false;
    }
 
    if (compatibility == FilamentCompatibilityType::HighLowMixed) {
        error_tips = _u8L("Selected nozzle temperatures are incompatible. For multi-material printing, each filament's nozzle temperature must be within the recommended nozzle temperature range of the other filaments. Otherwise, nozzle clogging or printer damage may occur.");
        return false;
    }
 
    return true;
}

References _u8L, Slic3r::Print::check_multi_filaments_compatibility(), Slic3r::curr_bed_type(), Slic3r::GUI::filament_types, Slic3r::ConfigOptionVector< int >::get_at(), Slic3r::get_bed_temp_key(), Slic3r::HighLowMixed, Slic3r::InvalidTemperatureRange, is_filament_in_blacklist(), m_comboBox_bed_type, m_displayed_bed_types, and Slic3r::nozzle_temperature_range_high().

Here is the call graph for this function:

is_nozzle_info_synced()

bool Slic3r::GUI::CalibrationPresetPage::is_nozzle_info_synced ( ) const

protected

{
    if (!curr_obj || !curr_obj->is_info_ready())
        return false;
 
 
    for (const DevExtder& extruder : curr_obj->GetExtderSystem()->GetExtruders()) {
        const int extruder_id = extruder.GetExtId();
 
        if (!curr_obj->GetExtderSystem()->NozzleDiameterMatchesOrUnknown(extruder_id, get_nozzle_diameter(extruder_id)))
            return false;
 
        if (curr_obj->is_nozzle_flow_type_supported()) {
            if (extruder.GetNozzleFlowType() == NozzleFlowType::NONE_FLOWTYPE)
                return false;
            // Map device flow -> volume type via DevNozzle::ToNozzleVolumeType so U_FLOW resolves to
            // nvtTPUHighFlow(3); the naive flow-1 would yield nvtHybrid(2). Identical to flow-1 for S/H flow.
            if (int(DevNozzle::ToNozzleVolumeType(extruder.GetNozzleFlowType())) != int(get_nozzle_volume_type(extruder_id)))
                return false;
        }
    }
 
    return true;
}

References curr_obj, get_nozzle_diameter(), get_nozzle_volume_type(), Slic3r::NONE_FLOWTYPE, and Slic3r::DevNozzle::ToNozzleVolumeType().

Referenced by update_sync_button_status().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::CalibrationPresetPage::msw_rescale ( )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    CalibrationWizardPage::msw_rescale();
    m_ams_sync_button->msw_rescale();
    for (auto& comboBox : m_filament_comboBox_list) {
        comboBox->msw_rescale();
    }
 
    for (AMSPreview *ams_item : m_main_ams_preview_list)
        ams_item->msw_rescale();
    for (AMSPreview *ams_item : m_deputy_ams_preview_list)
        ams_item->msw_rescale();
    for (AMSPreview *ams_item : m_ams_preview_list)
        ams_item->msw_rescale();
 
    m_cali_stage_panel->msw_rescale();
    m_custom_range_panel->msw_rescale();
}

References m_ams_preview_list, m_ams_sync_button, m_cali_stage_panel, m_custom_range_panel, m_deputy_ams_preview_list, m_filament_comboBox_list, m_main_ams_preview_list, and Slic3r::GUI::CalibrationWizardPage::msw_rescale().

Here is the call graph for this function:

need_check_sdcard()

bool Slic3r::GUI::CalibrationPresetPage::need_check_sdcard ( MachineObject * obj )

protected

{
    if (!obj) return false;
 
    bool need_check = false;
    if (obj->get_printer_series() == PrinterSeries::SERIES_X1) {
        if (m_cali_mode == CalibMode::Calib_Flow_Rate && m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            need_check = true;
        }
        else if (m_cali_mode == CalibMode::Calib_Vol_speed_Tower && m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL)
        {
            need_check =  true;
        }
    }
    else if (obj->get_printer_series() == PrinterSeries::SERIES_P1P) {
        if (m_cali_mode == CalibMode::Calib_Flow_Rate && m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            need_check =  true;
        }
        else if (m_cali_mode == CalibMode::Calib_Vol_speed_Tower && m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            need_check =  true;
        }
    }
    else {
        assert(false);
        return false;
    }
 
    return need_check;
}

References Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::Calib_Flow_Rate, Slic3r::Calib_Vol_speed_Tower, Slic3r::MachineObject::get_printer_series(), Slic3r::GUI::CalibrationWizardPage::m_cali_method, Slic3r::GUI::CalibrationWizardPage::m_cali_mode, SERIES_P1P, and SERIES_X1.

Here is the call graph for this function:

on_cali_cancel_job()

void Slic3r::GUI::CalibrationPresetPage::on_cali_cancel_job

(

)

{
    BOOST_LOG_TRIVIAL(info) << "CalibrationWizard::print_job: enter canceled";
    if (CalibUtils::print_worker) {
            BOOST_LOG_TRIVIAL(info) << "calibration_print_job: canceled";
        CalibUtils::print_worker->cancel_all();
        CalibUtils::print_worker->wait_for_idle();
    }
 
    m_sending_panel->reset();
    m_sending_panel->Show(false);
    update_print_status_msg(wxEmptyString, false);
    Enable_Send_Button(true);
    m_action_panel->show_button(CaliPageActionType::CALI_ACTION_CALI, true);
    Layout();
    Fit();
 
    m_stop_update_page_status = false;
}

References Slic3r::GUI::CALI_ACTION_CALI, Enable_Send_Button(), Slic3r::GUI::CalibrationWizardPage::m_action_panel, m_sending_panel, m_stop_update_page_status, Slic3r::GUI::CalibUtils::print_worker, and update_print_status_msg().

Referenced by create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_finished_job()

void Slic3r::GUI::CalibrationPresetPage::on_cali_finished_job

(

)

{
    m_sending_panel->reset();
    m_sending_panel->Show(false);
    update_print_status_msg(wxEmptyString, false);
    Enable_Send_Button(true);
    m_action_panel->show_button(CaliPageActionType::CALI_ACTION_CALI, true);
    Layout();
    Fit();
 
    m_stop_update_page_status = false;
}

References Slic3r::GUI::CALI_ACTION_CALI, Enable_Send_Button(), Slic3r::GUI::CalibrationWizardPage::m_action_panel, m_sending_panel, m_stop_update_page_status, and update_print_status_msg().

Here is the call graph for this function:

on_cali_start_job()

void Slic3r::GUI::CalibrationPresetPage::on_cali_start_job

(

)

{
    m_sending_panel->reset();
    m_sending_panel->Show();
    Enable_Send_Button(false);
    m_action_panel->show_button(CaliPageActionType::CALI_ACTION_CALI, false);
    Layout();
    Fit();
 
    m_stop_update_page_status = true;
}

References Slic3r::GUI::CALI_ACTION_CALI, Enable_Send_Button(), Slic3r::GUI::CalibrationWizardPage::m_action_panel, m_sending_panel, and m_stop_update_page_status.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

on_choose_ams()

void Slic3r::GUI::CalibrationPresetPage::on_choose_ams ( wxCommandEvent & event )

protected

{
    select_default_compatible_filament();
 
    m_filament_list_panel->Show();
    m_ams_sync_button->Show();
    Layout();
}

References m_ams_sync_button, m_filament_list_panel, and select_default_compatible_filament().

Here is the call graph for this function:

on_choose_ext_spool()

void Slic3r::GUI::CalibrationPresetPage::on_choose_ext_spool ( wxCommandEvent & event )

protected

{
    m_filament_list_panel->Hide();
    m_ams_sync_button->Hide();
    Layout();
}

References m_ams_sync_button, and m_filament_list_panel.

on_device_connected()

void Slic3r::GUI::CalibrationPresetPage::on_device_connected ( MachineObject * obj )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    init_selection_values();
    init_with_machine(obj);
    update_combobox_filaments(obj);
}

References init_selection_values(), init_with_machine(), and update_combobox_filaments().

Referenced by create_selection_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

on_recommend_input_value()

void Slic3r::GUI::CalibrationPresetPage::on_recommend_input_value ( )

protected

{
    //TODO fix this
    std::map<int, Preset *> selected_filaments = get_selected_filaments();
    if (selected_filaments.empty())
        return;
 
    if (m_cali_mode == CalibMode::Calib_PA_Line) {
 
    }
    else if (m_cali_mode == CalibMode::Calib_Flow_Rate && m_cali_stage_panel) {
        Preset *selected_filament_preset = selected_filaments.begin()->second;
        if (selected_filament_preset) {
            const ConfigOptionFloatsNullable* flow_ratio_opt = selected_filament_preset->config.option<ConfigOptionFloatsNullable>("filament_flow_ratio");
            if (flow_ratio_opt) {
                m_cali_stage_panel->set_flow_ratio_value(flow_ratio_opt->get_at(0));
            }
        }
    }
    else if (m_cali_mode == CalibMode::Calib_Vol_speed_Tower) {
        Preset* selected_filament_preset = selected_filaments.begin()->second;
        if (selected_filament_preset) {
            if (m_custom_range_panel) {
                const ConfigOptionFloats* speed_opt = selected_filament_preset->config.option<ConfigOptionFloats>("filament_max_volumetric_speed");
                if (speed_opt) {
                    double max_volumetric_speed = speed_opt->get_at(0);
                    wxArrayString values;
                    values.push_back(wxString::Format("%.2f", max_volumetric_speed - 5));
                    values.push_back(wxString::Format("%.2f", max_volumetric_speed + 5));
                    values.push_back(wxString::Format("%.2f", 0.5f));
                    m_custom_range_panel->set_values(values);
                }
            }
        }
    }
}

References Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::Calib_Vol_speed_Tower, Slic3r::Preset::config, Slic3r::ConfigOptionVector< double >::get_at(), get_selected_filaments(), Slic3r::GUI::CalibrationWizardPage::m_cali_mode, m_cali_stage_panel, m_custom_range_panel, and Slic3r::ConfigBase::option().

Referenced by on_select_tray().

Here is the call graph for this function:

Here is the caller graph for this function:

on_reset_page()

virtual void Slic3r::GUI::CalibrationWizardPage::on_reset_page ( )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::CalibrationFlowRateStartPage, and Slic3r::GUI::CalibrationPAStartPage.

{}

on_select_nozzle()

void Slic3r::GUI::CalibrationPresetPage::on_select_nozzle ( wxCommandEvent & evt )

protected

{
    update_combobox_filaments(curr_obj);
}

References curr_obj, and update_combobox_filaments().

Referenced by create_selection_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

on_select_nozzle_volume_type()

void Slic3r::GUI::CalibrationPresetPage::on_select_nozzle_volume_type ( wxCommandEvent & evt, size_t extruder_id )

protected

{
}

on_select_plate_type()

void Slic3r::GUI::CalibrationPresetPage::on_select_plate_type ( wxCommandEvent & evt )

protected

{
    select_default_compatible_filament();
    check_filament_compatible();
}

References check_filament_compatible(), and select_default_compatible_filament().

Referenced by create_selection_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

on_select_tray()

void Slic3r::GUI::CalibrationPresetPage::on_select_tray ( wxCommandEvent & event )

protected

{
    check_filament_compatible();
 
    on_recommend_input_value();
}

References check_filament_compatible(), and on_recommend_input_value().

Referenced by create_filament_list_panel(), create_multi_extruder_filament_list_panel(), and create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

on_switch_ams()

void Slic3r::GUI::CalibrationPresetPage::on_switch_ams ( std::string ams_id = "" )

protected

{
    for (auto i = 0; i < m_ams_preview_list.size(); i++) {
        AMSPreview *item = m_ams_preview_list[i];
        if (item->get_ams_id() == ams_id) {
            item->OnSelected();
        } else {
            item->UnSelected();
        }
    }
 
    update_filament_combobox(ams_id);
 
    select_default_compatible_filament();
 
    Layout();
}

References Slic3r::GUI::AMSPreview::get_ams_id(), m_ams_preview_list, Slic3r::GUI::AMSPreview::OnSelected(), select_default_compatible_filament(), Slic3r::GUI::AMSPreview::UnSelected(), and update_filament_combobox().

Referenced by sync_ams_info().

Here is the call graph for this function:

Here is the caller graph for this function:

on_sys_color_changed()

void Slic3r::GUI::CalibrationPresetPage::on_sys_color_changed ( )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    CalibrationWizardPage::on_sys_color_changed();
    m_ams_sync_button->msw_rescale();
}

References m_ams_sync_button, and Slic3r::GUI::CalibrationWizardPage::on_sys_color_changed().

Here is the call graph for this function:

select_default_compatible_filament()

void Slic3r::GUI::CalibrationPresetPage::select_default_compatible_filament

(

)

{
    if (!curr_obj)
        return;
 
    std::string ams_id;
    for (AMSPreview* ams_perview : m_ams_preview_list) {
        if (ams_perview->IsSelected()) {
            ams_id = ams_perview->get_ams_id();
            break;
        }
    }
 
    if (ams_id.empty())
        return;
 
    if (!devPrinterUtil::IsVirtualSlot(ams_id)) {
        std::map<int, Preset *> selected_filament;
        for (size_t i = 0; i < 4; ++i) {
            auto &fcb = m_filament_comboBox_list[i];
            if (!fcb->GetRadioBox()->IsEnabled())
                continue;
            int tray_id = fcb->get_tray_id();
            Preset* preset = const_cast<Preset *>(fcb->GetComboBox()->get_selected_preset());
            if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_SINGLE) {
                selected_filament.clear();
                selected_filament[tray_id] = preset;
                if (preset && is_filaments_compatiable(selected_filament)) {
                    fcb->GetRadioBox()->SetValue(true);
                    wxCommandEvent event(wxEVT_RADIOBUTTON);
                    event.SetEventObject(this);
                    wxPostEvent(fcb->GetRadioBox(), event);
                    Layout();
                    break;
                } else
                    fcb->GetRadioBox()->SetValue(false);
            } else if (m_cali_filament_mode == CalibrationFilamentMode::CALI_MODEL_MULITI) {
                if (!preset) {
                    fcb->GetCheckBox()->SetValue(false);
                    continue;
                }
                selected_filament.insert(std::make_pair(tray_id, preset));
                if (!is_filaments_compatiable(selected_filament)) {
                    selected_filament.erase(tray_id);
                    fcb->GetCheckBox()->SetValue(false);
                }
                else
                    fcb->GetCheckBox()->SetValue(true);
 
                wxCommandEvent event(wxEVT_CHECKBOX);
                event.SetEventObject(this);
                wxPostEvent(fcb->GetCheckBox(), event);
                Layout();
            }
        }
    }
    else {
        std::map<int, Preset *> selected_filament;
        Preset  *preset  = const_cast<Preset *>(m_filament_comboBox_list[0]->GetComboBox()->get_selected_preset());
        selected_filament[m_filament_comboBox_list[0]->get_tray_id()] = preset;
        if (preset && is_filaments_compatiable(selected_filament)) {
            m_filament_comboBox_list[0]->GetRadioBox()->SetValue(true);
        } else
            m_filament_comboBox_list[0]->GetRadioBox()->SetValue(false);
 
        wxCommandEvent event(wxEVT_RADIOBUTTON);
        event.SetEventObject(this);
        wxPostEvent(m_filament_comboBox_list[0]->GetRadioBox(), event);
        Layout();
    }
 
    check_filament_compatible();
}

References Slic3r::GUI::CALI_MODEL_MULITI, Slic3r::GUI::CALI_MODEL_SINGLE, check_filament_compatible(), curr_obj, is_filaments_compatiable(), Slic3r::devPrinterUtil::IsVirtualSlot(), m_ams_preview_list, Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode, and m_filament_comboBox_list.

Referenced by on_choose_ams(), on_select_plate_type(), on_switch_ams(), and update_combobox_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cali_filament_mode()

void Slic3r::GUI::CalibrationPresetPage::set_cali_filament_mode ( CalibrationFilamentMode mode )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    CalibrationWizardPage::set_cali_filament_mode(mode);
 
    for (int i = 0; i < m_filament_comboBox_list.size(); i++) {
        m_filament_comboBox_list[i]->set_select_mode(mode);
    }
 
    if (mode == CALI_MODEL_MULITI) {
        m_filament_list_tips->Show();
    }
    else {
        m_filament_list_tips->Hide();
    }
}

References Slic3r::GUI::CALI_MODEL_MULITI, m_filament_comboBox_list, m_filament_list_tips, and Slic3r::GUI::CalibrationWizardPage::set_cali_filament_mode().

Here is the call graph for this function:

set_cali_method()

void Slic3r::GUI::CalibrationPresetPage::set_cali_method ( CalibrationMethod method )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    CalibrationWizardPage::set_cali_method(method);
    if (method == CalibrationMethod::CALI_METHOD_MANUAL) {
        if (m_cali_mode == CalibMode::Calib_Flow_Rate) {
            wxArrayString steps;
            steps.Add(_L("Preset"));
            steps.Add(_L("Calibration1"));
            steps.Add(_L("Calibration2"));
            steps.Add(_L("Record Factor"));
            m_step_panel->set_steps_string(steps);
            m_step_panel->set_steps(0);
            if (m_cali_stage_panel)
                m_cali_stage_panel->Show();
 
            if (m_pa_cali_method_combox)
                m_pa_cali_method_combox->Show(false);
 
            if (m_custom_range_panel)
                m_custom_range_panel->Show(false);
        }
        else if (m_cali_mode == CalibMode::Calib_PA_Line || m_cali_mode == CalibMode::Calib_PA_Pattern) {
            if (m_cali_stage_panel)
                m_cali_stage_panel->Show(false);
 
            if (m_pa_cali_method_combox)
                m_pa_cali_method_combox->Show();
 
            if (m_custom_range_panel) {
                wxArrayString titles;
                titles.push_back(_L("From k Value"));
                titles.push_back(_L("To k Value"));
                titles.push_back(_L("Step value"));
                m_custom_range_panel->set_titles(titles);
 
                wxArrayString values;
                values.push_back(wxString::Format(wxT("%.0f"), 0));
                values.push_back(wxString::Format(wxT("%.2f"), 0.05));
                values.push_back(wxString::Format(wxT("%.3f"), 0.005));
                m_custom_range_panel->set_values(values);
 
                m_custom_range_panel->set_unit("");
                m_custom_range_panel->Show();
            }
        }
    }
    else {
        wxArrayString steps;
        steps.Add(_L("Preset"));
        steps.Add(_L("Calibration"));
        steps.Add(_L("Record Factor"));
        m_step_panel->set_steps_string(steps);
        m_step_panel->set_steps(0);
        if (m_cali_stage_panel)
            m_cali_stage_panel->Show(false);
        if (m_custom_range_panel)
            m_custom_range_panel->Show(false);
        if (m_pa_cali_method_combox)
            m_pa_cali_method_combox->Show(false);
    }
}

References _L, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::Calib_Flow_Rate, Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::GUI::CalibrationWizardPage::m_cali_mode, m_cali_stage_panel, m_custom_range_panel, m_pa_cali_method_combox, m_step_panel, and Slic3r::GUI::CalibrationWizardPage::set_cali_method().

Here is the call graph for this function:

set_next_page()

void Slic3r::GUI::CalibrationWizardPage::set_next_page ( CalibrationWizardPage * next )

inlineinherited

{ m_next_page = next; }

References CalibrationWizardPage(), and m_next_page.

Referenced by chain().

Here is the call graph for this function:

Here is the caller graph for this function:

set_prev_page()

void Slic3r::GUI::CalibrationWizardPage::set_prev_page ( CalibrationWizardPage * prev )

inlineinherited

{ m_prev_page = prev; }

References CalibrationWizardPage(), and m_prev_page.

Referenced by chain().

Here is the call graph for this function:

Here is the caller graph for this function:

show_status()

void Slic3r::GUI::CalibrationPresetPage::show_status ( CaliPresetPageStatus status )

protected

{
    if (m_stop_update_page_status)
        return;
 
    if (m_page_status != status)
        //BOOST_LOG_TRIVIAL(info) << "CalibrationPresetPage: show_status = " << status << "(" << get_print_status_info(status) << ")";
    m_page_status = status;
 
    // other
    if (status == CaliPresetPageStatus::CaliPresetStatusInit) {
        update_print_status_msg(wxEmptyString, false);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusNormal) {
        update_print_status_msg(wxEmptyString, false);
        Enable_Send_Button(true);
        Layout();
        Fit();
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusOptionalPrinterModel) {
        update_print_status_msg(PrePrintChecker::get_pre_state_msg(PrintDialogStatus::PrintStatusOptionalPrinterModel), true);
        Enable_Send_Button(true);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusNoUserLogin) {
        wxString msg_text = _L("No login account, only printers in LAN mode are displayed.");
        update_print_status_msg(msg_text, false);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusInvalidPrinter) {
        update_print_status_msg(wxEmptyString, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusConnectingServer) {
        wxString msg_text = _L("Connecting to server...");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusInUpgrading) {
        wxString msg_text = _L("Cannot send a print job while the printer is updating firmware.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusInSystemPrinting) {
        wxString msg_text = _L("The printer is executing instructions. Please restart printing after it ends.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusInPrinting) {
        wxString msg_text = _L("The printer is busy with another print job.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusLanModeNoSdcard) {
        wxString msg_text = _L("Storage needs to be inserted before printing via LAN.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusLanModeSDcardNotAvailable) {
        wxString msg_text = _L("Storage is not available or is in read-only mode.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusNoSdcard) {
        wxString msg_text = _L("Storage needs to be inserted before printing.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusNeedForceUpgrading) {
        wxString msg_text = _L("Cannot send the print job to a printer whose firmware must be updated.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusNeedConsistencyUpgrading) {
        wxString msg_text = _L("Cannot send the print job to a printer whose firmware must be updated.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusFilamentIncompatible) {
        update_print_status_msg(wxEmptyString, false);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusInConnecting) {
        wxString msg_text = _L("Connecting to printer...");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
    else if (status == CaliPresetPageStatus::CaliPresetStatusDifferentNozzleDiameters) {
        wxString msg_text = _L("Calibration only supports cases where the left and right nozzle diameters are identical.");
        update_print_status_msg(msg_text, true);
        Enable_Send_Button(false);
    }
 
    Layout();
}

References _L, Slic3r::GUI::CaliPresetStatusConnectingServer, Slic3r::GUI::CaliPresetStatusDifferentNozzleDiameters, Slic3r::GUI::CaliPresetStatusFilamentIncompatible, Slic3r::GUI::CaliPresetStatusInConnecting, Slic3r::GUI::CaliPresetStatusInit, Slic3r::GUI::CaliPresetStatusInPrinting, Slic3r::GUI::CaliPresetStatusInSystemPrinting, Slic3r::GUI::CaliPresetStatusInUpgrading, Slic3r::GUI::CaliPresetStatusInvalidPrinter, Slic3r::GUI::CaliPresetStatusLanModeNoSdcard, Slic3r::GUI::CaliPresetStatusLanModeSDcardNotAvailable, Slic3r::GUI::CaliPresetStatusNeedConsistencyUpgrading, Slic3r::GUI::CaliPresetStatusNeedForceUpgrading, Slic3r::GUI::CaliPresetStatusNormal, Slic3r::GUI::CaliPresetStatusNoSdcard, Slic3r::GUI::CaliPresetStatusNoUserLogin, Slic3r::GUI::CaliPresetStatusOptionalPrinterModel, Enable_Send_Button(), Slic3r::GUI::PrePrintChecker::get_pre_state_msg(), m_page_status, m_stop_update_page_status, Slic3r::GUI::PrintStatusOptionalPrinterModel, and update_print_status_msg().

Referenced by update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

stripWhiteSpace()

void Slic3r::GUI::CalibrationPresetPage::stripWhiteSpace

(

std::string &

str

)

{
    if (str == "") { return; }
 
    std::string::iterator cur_it;
    cur_it = str.begin();
 
    while (cur_it != str.end()) {
        if ((*cur_it) == '\n' || (*cur_it) == ' ') {
            cur_it = str.erase(cur_it);
        }
        else {
            cur_it++;
        }
    }
}

Referenced by update_priner_status_msg().

Here is the caller graph for this function:

sync_ams_info()

void Slic3r::GUI::CalibrationPresetPage::sync_ams_info

(

MachineObject *

obj

)

{
    if (!obj) return;
 
    std::map<int, DynamicPrintConfig> old_full_filament_ams_list = wxGetApp().sidebar().build_filament_ams_list(obj);
    std::map<int, DynamicPrintConfig> full_filament_ams_list;
    for (auto ams_item : old_full_filament_ams_list) {
        int key = ams_item.first & 0x0FFFF;
        if (key == VIRTUAL_TRAY_MAIN_ID || key == VIRTUAL_TRAY_DEPUTY_ID) {
            ams_item.second.set_key_value("filament_exist", new ConfigOptionBools{true});
        }
        full_filament_ams_list[key] = std::move(ams_item.second);
    }
 
    // sync filament_ams_list from obj ams list
    filament_ams_list.clear();
    for (auto& ams_item : obj->GetFilaSystem()->GetAmsList()) {
        for (auto& tray_item: ams_item.second->GetTrays()) {
            int tray_id = -1;
            if (!tray_item.second->id.empty()) {
                try {
                    tray_id = stoi(tray_item.second->id) + stoi(ams_item.second->GetAmsId()) * 4;
                }
                catch (...) {
                    ;
                }
            }
            auto filament_ams = full_filament_ams_list.find(tray_id);
            if (filament_ams != full_filament_ams_list.end()) {
                filament_ams_list[tray_id] = filament_ams->second;
            }
        }
    }
 
    // init virtual tray info. With a Filament Track Switch installed the external spools feed
    // through the switch, so they can't be calibrated as their own trays.
    if (obj->GetFilaSwitch()->IsInstalled()) {
        filament_ams_list[VIRTUAL_TRAY_MAIN_ID]   = empty_tray_config();
        filament_ams_list[VIRTUAL_TRAY_DEPUTY_ID] = empty_tray_config();
    } else {
        if (full_filament_ams_list.find(VIRTUAL_TRAY_MAIN_ID) != full_filament_ams_list.end()) {
            filament_ams_list[VIRTUAL_TRAY_MAIN_ID] = full_filament_ams_list[VIRTUAL_TRAY_MAIN_ID];
        }
 
        if (full_filament_ams_list.find(VIRTUAL_TRAY_DEPUTY_ID) != full_filament_ams_list.end()) {
            filament_ams_list[VIRTUAL_TRAY_DEPUTY_ID] = full_filament_ams_list[VIRTUAL_TRAY_DEPUTY_ID];
        }
    }
 
    // update filament from panel, display only obj has ams
    // update multi ams panel, display only obj has multi ams
    if (obj->HasAms()) {
        if (obj->is_multi_extruders()) {
            // An AMS behind a Filament Track Switch is bound to both extruders and appears in both panels.
            bool main_done   = false;
            bool deputy_done = false;
            for (auto &ams_item : obj->GetFilaSystem()->GetAmsList()) {
                const auto &extruder_set = ams_item.second->GetBindedExtruderSet();
                if (!main_done && extruder_set.count(MAIN_EXTRUDER_ID) != 0) {
                    update_multi_extruder_filament_combobox(ams_item.second->GetAmsId(), MAIN_EXTRUDER_ID);
                    main_done = true;
                }
                if (!deputy_done && extruder_set.count(DEPUTY_EXTRUDER_ID) != 0) {
                    update_multi_extruder_filament_combobox(ams_item.second->GetAmsId(), DEPUTY_EXTRUDER_ID);
                    deputy_done = true;
                }
            }
 
            if (!main_done)
                update_multi_extruder_filament_combobox(std::to_string(VIRTUAL_TRAY_MAIN_ID), 0);
 
            if (!deputy_done)
                update_multi_extruder_filament_combobox(std::to_string(VIRTUAL_TRAY_DEPUTY_ID), 1);
        }
        else {
            if (obj->GetFilaSystem()->GetAmsList().size() > 1) {
                on_switch_ams(obj->GetFilaSystem()->GetAmsList().begin()->first);
            } else {
                if (!obj->GetFilaSystem()->GetAmsList().empty())
                    update_filament_combobox(obj->GetFilaSystem()->GetAmsList().begin()->first);
            }
        }
    }
    else {
        if (obj->is_multi_extruders()) {
            update_multi_extruder_filament_combobox(std::to_string(VIRTUAL_TRAY_MAIN_ID), 0);
            update_multi_extruder_filament_combobox(std::to_string(VIRTUAL_TRAY_DEPUTY_ID), 1);
        } else {
            update_filament_combobox(std::to_string(VIRTUAL_TRAY_MAIN_ID));
        }
    }
 
    m_ams_id_to_extruder_id_map.clear();
    std::vector<AMSinfo> ams_info;
    std::vector<AMSinfo> main_ams_info;
    std::vector<AMSinfo> deputy_ams_info;
 
    const auto& ams_list = obj->GetFilaSystem()->GetAmsList();
    for (auto ams = ams_list.begin(); ams != ams_list.end(); ams++) {
        AMSinfo info;
        info.ams_id = ams->first;
        if (ams->second->IsExist()
            && info.parse_ams_info(obj, ams->second, obj->GetFilaSystem()->IsDetectRemainEnabled(), obj->is_support_ams_humidity)) {
            ams_info.push_back(info);
            for (int extruder_id : ams->second->GetBindedExtruderSet()) {
                if (extruder_id == MAIN_EXTRUDER_ID)
                    main_ams_info.push_back(info);
                else
                    deputy_ams_info.push_back(info);
            }
        }
        m_ams_id_to_extruder_id_map[stoi(info.ams_id)] = info.nozzle_id;
    }
    if (obj->is_multi_extruders()) {
        m_ams_id_to_extruder_id_map[VIRTUAL_TRAY_MAIN_ID] = 0;
        m_ams_id_to_extruder_id_map[VIRTUAL_TRAY_DEPUTY_ID] = 1;
    }
 
    /* add vt_ams info to ams info list*/
    for (const DevAmsTray& vt_tray : obj->vt_slot) {
        AMSinfo     info;
        info.parse_ext_info(obj, vt_tray);
        info.ams_type = AMSModel::EXT_AMS;
 
        if (vt_tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
            ams_info.push_back(info);
            main_ams_info.push_back(info);
        } else if (vt_tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
            deputy_ams_info.push_back(info);
        } else {
            assert(false);
        }
    }
 
    /* update ams preview */
    auto ams_items_sizer = create_ams_items_sizer(obj, m_multi_ams_panel, m_ams_preview_list, ams_info, MAIN_EXTRUDER_ID);
    auto multi_ams_sizer = new wxBoxSizer(wxVERTICAL);
    multi_ams_sizer->Add(ams_items_sizer, 0);
    multi_ams_sizer->AddSpacer(FromDIP(10));
    m_multi_ams_panel->SetSizer(multi_ams_sizer);
 
    m_main_ams_preview_panel->SetSizer(create_ams_items_sizer(obj, m_main_ams_preview_panel, m_main_ams_preview_list, main_ams_info, MAIN_EXTRUDER_ID));
    m_deputy_ams_preview_panel->SetSizer(create_ams_items_sizer(obj, m_deputy_ams_preview_panel, m_deputy_ams_preview_list, deputy_ams_info, DEPUTY_EXTRUDER_ID));
 
    Layout();
}

References Slic3r::GUI::AMSinfo::ams_id, Slic3r::GUI::AMSinfo::ams_type, create_ams_items_sizer(), DEPUTY_EXTRUDER_ID, Slic3r::GUI::empty_tray_config(), Slic3r::GUI::EXT_AMS, filament_ams_list, Slic3r::MachineObject::GetFilaSwitch(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::MachineObject::HasAms(), Slic3r::DevAmsTray::id, Slic3r::MachineObject::is_multi_extruders(), Slic3r::MachineObject::is_support_ams_humidity, Slic3r::DevFilaSwitch::IsInstalled(), m_ams_id_to_extruder_id_map, m_ams_preview_list, m_deputy_ams_preview_list, m_deputy_ams_preview_panel, m_main_ams_preview_list, m_main_ams_preview_panel, m_multi_ams_panel, MAIN_EXTRUDER_ID, Slic3r::GUI::AMSinfo::nozzle_id, on_switch_ams(), Slic3r::GUI::AMSinfo::parse_ams_info(), Slic3r::GUI::AMSinfo::parse_ext_info(), update_filament_combobox(), update_multi_extruder_filament_combobox(), VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, and Slic3r::MachineObject::vt_slot.

Referenced by create_selection_panel(), init_with_machine(), and update_combobox_filaments().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void Slic3r::GUI::CalibrationPresetPage::update ( MachineObject * obj )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizardPage.

{
    curr_obj = obj;
    
    //update printer status
    update_show_status();
 
    update_sync_button_status();
}

References curr_obj, update_show_status(), and update_sync_button_status().

Here is the call graph for this function:

update_combobox_filaments()

void Slic3r::GUI::CalibrationPresetPage::update_combobox_filaments ( MachineObject * obj )

protected

{
    if (!obj) return;
 
    if (!obj->is_info_ready())
        return;
 
    //step 1: update combobox filament list
    float nozzle_value = get_nozzle_value();
    obj->cali_selected_nozzle_dia = nozzle_value;
    if (nozzle_value < 1e-3) {
        return;
    }
 
    Preset* printer_preset = get_printer_preset(obj, nozzle_value);
    if (!printer_preset)
        return;
 
    auto opt_extruder_type = printer_preset->config.option<ConfigOptionEnumsGeneric>("extruder_type");
    if (opt_extruder_type) {
        assert(opt_extruder_type->values.size() <= 2);
        for (size_t i = 0; i < opt_extruder_type->values.size(); ++i) {
            m_extrder_types[i] = (ExtruderType)(opt_extruder_type->values[i]);
        }
    }
 
    // sync ams filaments list info
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (preset_bundle && printer_preset) {
        preset_bundle->set_calibrate_printer(printer_preset->name);
    }
 
    //step 2: sync ams info from object by default
    sync_ams_info(obj);
 
    //step 3: select the default compatible filament to calibration
    select_default_compatible_filament();
}

References Slic3r::MachineObject::cali_selected_nozzle_dia, Slic3r::Preset::config, get_nozzle_value(), get_printer_preset(), Slic3r::MachineObject::is_info_ready(), m_extrder_types, Slic3r::Preset::name, Slic3r::ConfigBase::option(), select_default_compatible_filament(), Slic3r::PresetBundle::set_calibrate_printer(), and sync_ams_info().

Referenced by on_device_connected(), and on_select_nozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

update_filament_combobox()

void Slic3r::GUI::CalibrationPresetPage::update_filament_combobox ( std::string ams_id = "" )

protected

{
    for (auto& fcb : m_filament_comboBox_list) {
        fcb->update_from_preset();
        fcb->set_select_mode(m_cali_filament_mode);
    }
 
    for (auto i = 0; i < m_ams_preview_list.size(); i++) {
        AMSPreview *item = m_ams_preview_list[i];
        if (item->get_ams_id() == ams_id) {
            item->OnSelected();
        } else {
            item->UnSelected();
        }
    }
 
    DynamicPrintConfig empty_config;
    empty_config.set_key_value("filament_id", new ConfigOptionStrings{ "" });
    empty_config.set_key_value("tag_uid", new ConfigOptionStrings{ "" });
    empty_config.set_key_value("filament_type", new ConfigOptionStrings{ "" });
    empty_config.set_key_value("tray_name", new ConfigOptionStrings{ "" });
    empty_config.set_key_value("filament_colour", new ConfigOptionStrings{ "" });
    empty_config.set_key_value("filament_exist", new ConfigOptionBools{ false });
 
    if (filament_ams_list.empty())
        return;
 
    int ams_id_int = 0;
    try {
        if (!ams_id.empty())
            ams_id_int = std::stoi(ams_id.c_str());
 
    } catch (...) {}
 
    int item_size = 4;
    if (ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
        item_size = 1;
    }
 
    if (ams_id_int >= 128 && ams_id_int < 153) { // N3S
        item_size = 1;
    }
 
    for (int i = 0; i < 4; i++) {
        if (i < item_size)
            m_filament_comboBox_list[i]->ShowPanel();
        else
            m_filament_comboBox_list[i]->HidePanel();
 
        int tray_index = ams_id_int * 4 + i;
        if (ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
            tray_index = stoi(ams_id);
        }
 
        auto it = std::find_if(filament_ams_list.begin(), filament_ams_list.end(), [tray_index](auto& entry) {
            return entry.first == tray_index;
            });
 
        if (it != filament_ams_list.end()) {
            m_filament_comboBox_list[i]->load_tray_from_ams(tray_index, it->second);
        }
        else {
            m_filament_comboBox_list[i]->load_tray_from_ams(tray_index, empty_config);
        }
    }
    Layout();
}

References filament_ams_list, Slic3r::GUI::AMSPreview::get_ams_id(), m_ams_preview_list, Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode, m_filament_comboBox_list, Slic3r::GUI::AMSPreview::OnSelected(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::AMSPreview::UnSelected(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by create_ams_items_sizer(), on_switch_ams(), and sync_ams_info().

Here is the call graph for this function:

Here is the caller graph for this function:

update_flow_ratio_type()

void Slic3r::GUI::CalibrationPresetPage::update_flow_ratio_type ( FlowRatioCalibrationType type )

inline

{ curr_obj->flow_ratio_calibration_type = type; }

References curr_obj.

update_multi_extruder_filament_combobox()

void Slic3r::GUI::CalibrationPresetPage::update_multi_extruder_filament_combobox ( const std::string & ams_id, int nozzle_id )

protected

{
    if (nozzle_id == 0) {
        for (auto &fcb : m_main_filament_comboBox_list) {
            fcb->update_from_preset();
            fcb->set_select_mode(m_cali_filament_mode);
        }
        for (auto i = 0; i < m_main_ams_preview_list.size(); i++) {
            AMSPreview *item = m_main_ams_preview_list[i];
            if (item->get_ams_id() == ams_id) {
                item->OnSelected();
            } else {
                item->UnSelected();
            }
        }
    }
    else {
        for (auto &fcb : m_deputy_filament_comboBox_list) {
            fcb->update_from_preset();
            fcb->set_select_mode(m_cali_filament_mode);
        }
        for (auto i = 0; i < m_deputy_ams_preview_list.size(); i++) {
            AMSPreview *item = m_deputy_ams_preview_list[i];
            if (item->get_ams_id() == ams_id) {
                item->OnSelected();
            } else {
                item->UnSelected();
            }
        }
    }
 
    DynamicPrintConfig empty_config = empty_tray_config();
 
    if (filament_ams_list.empty()) return;
 
    int ams_id_int = 0;
    try {
        if (!ams_id.empty())
            ams_id_int = std::stoi(ams_id.c_str());
 
    } catch (...) {}
 
    int item_size = 4;
    if (ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
        item_size = 1;
    }
 
    if (ams_id_int >= 128 && ams_id_int < 153) {  // N3S
        item_size = 1;
    }
 
    for (int i = 0; i < 4; i++) {
        if (i < item_size) {
            if (nozzle_id == 0)
                m_main_filament_comboBox_list[i]->ShowPanel();
            else
                m_deputy_filament_comboBox_list[i]->ShowPanel();
        }
        else {
            if (nozzle_id == 0)
                m_main_filament_comboBox_list[i]->HidePanel();
            else
                m_deputy_filament_comboBox_list[i]->HidePanel();
        }
 
        int tray_index = ams_id_int * 4 + i;
        if (ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
            tray_index = stoi(ams_id);
        }
 
        auto it = std::find_if(filament_ams_list.begin(), filament_ams_list.end(), [tray_index](auto &entry) {
            return entry.first == tray_index;
        });
 
        if (nozzle_id == 0) {
            if (m_main_filament_comboBox_list.empty())
                continue;
            if (it != filament_ams_list.end()) {
                m_main_filament_comboBox_list[i]->load_tray_from_ams(tray_index, it->second);
            } else {
                m_main_filament_comboBox_list[i]->load_tray_from_ams(tray_index, empty_config);
            }
        }
        else{
            if (m_deputy_filament_comboBox_list.empty())
                continue;
            if (it != filament_ams_list.end()) {
                m_deputy_filament_comboBox_list[i]->load_tray_from_ams(tray_index, it->second);
            } else {
                m_deputy_filament_comboBox_list[i]->load_tray_from_ams(tray_index, empty_config);
            }
        }
    }
    Layout();
}

References Slic3r::GUI::empty_tray_config(), filament_ams_list, Slic3r::GUI::AMSPreview::get_ams_id(), Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode, m_deputy_ams_preview_list, m_deputy_filament_comboBox_list, m_main_ams_preview_list, m_main_filament_comboBox_list, Slic3r::GUI::AMSPreview::OnSelected(), Slic3r::GUI::AMSPreview::UnSelected(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by create_ams_items_sizer(), and sync_ams_info().

Here is the call graph for this function:

Here is the caller graph for this function:

update_plate_type_collection()

void Slic3r::GUI::CalibrationPresetPage::update_plate_type_collection ( CalibrationMethod method )

protected

{
    m_comboBox_bed_type->Clear();
    const ConfigOptionDef* bed_type_def = print_config_def.get("curr_bed_type");
    if (bed_type_def && bed_type_def->enum_keys_map) {
        for (int i = 0; i < bed_type_def->enum_labels.size(); i++) {
            m_comboBox_bed_type->AppendString(_L(bed_type_def->enum_labels[i]));
        }
        m_comboBox_bed_type->SetSelection(0);
    }
}

References _L, Slic3r::ConfigOptionDef::enum_keys_map, Slic3r::ConfigOptionDef::enum_labels, m_comboBox_bed_type, and Slic3r::print_config_def.

update_priner_status_msg()

void Slic3r::GUI::CalibrationPresetPage::update_priner_status_msg	(	wxString	msg,
		bool	is_warning )

{
    auto colour = is_warning ? wxColour(0xFF, 0x6F, 0x00) : wxColour(0x6B, 0x6B, 0x6B);
    m_statictext_printer_msg->SetForegroundColour(colour);
 
    if (msg.empty()) {
        if (!m_statictext_printer_msg->GetLabel().empty()) {
            m_statictext_printer_msg->SetLabel(wxEmptyString);
            m_statictext_printer_msg->Hide();
            Layout();
            Fit();
        }
    }
    else {
        msg = format_text(msg);
 
        auto str_new = msg.ToStdString();
        stripWhiteSpace(str_new);
 
        auto str_old = m_statictext_printer_msg->GetLabel().ToStdString();
        stripWhiteSpace(str_old);
 
        if (str_new != str_old) {
            if (m_statictext_printer_msg->GetLabel() != msg) {
                m_statictext_printer_msg->SetLabel(msg);
                m_statictext_printer_msg->SetMinSize(wxSize(FromDIP(600), -1));
                m_statictext_printer_msg->SetMaxSize(wxSize(FromDIP(600), -1));
                m_statictext_printer_msg->Wrap(FromDIP(600));
                m_statictext_printer_msg->Show();
                Layout();
                Fit();
            }
        }
    }
}

References format_text(), Slic3r::GUI::CalibrationWizardPage::m_statictext_printer_msg, and stripWhiteSpace().

Referenced by update_print_status_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_error_info()

void Slic3r::GUI::CalibrationPresetPage::update_print_error_info ( int code, const std::string & msg, const std::string & extra )

inline

{ m_sending_panel->update_print_error_info(code, msg, extra); }

References m_sending_panel.

Referenced by Slic3r::GUI::CalibrationPanel::update_print_error_info().

Here is the caller graph for this function:

update_print_status_msg()

void Slic3r::GUI::CalibrationPresetPage::update_print_status_msg	(	wxString	msg,
		bool	is_warning )

{
    update_priner_status_msg(msg, is_warning);
}

References update_priner_status_msg().

Referenced by on_cali_cancel_job(), on_cali_finished_job(), and show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

update_show_status()

void Slic3r::GUI::CalibrationPresetPage::update_show_status ( )

protected

{
    NetworkAgent* agent = Slic3r::GUI::wxGetApp().getAgent();
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!agent) {return;}
    if (!dev) return;
 
    MachineObject* obj_ = dev->get_selected_machine();
    if (!obj_) {
        if (agent->is_user_login(wxGetApp().get_printer_cloud_provider())) {
            show_status(CaliPresetPageStatus::CaliPresetStatusInvalidPrinter);
        }
        else {
            show_status(CaliPresetPageStatus::CaliPresetStatusNoUserLogin);
        }
        return;
    }
 
    if (!obj_->is_lan_mode_printer()) {
        if (!agent->is_server_connected(wxGetApp().get_printer_cloud_provider())) {
            show_status(CaliPresetPageStatus::CaliPresetStatusConnectingServer);
            return;
        }
    }
 
    if (wxGetApp().app_config) {
        if (obj_->upgrade_force_upgrade) {
            show_status(CaliPresetPageStatus::CaliPresetStatusNeedForceUpgrading);
            return;
        }
 
        if (obj_->upgrade_consistency_request) {
            show_status(CaliPresetStatusNeedConsistencyUpgrading);
            return;
        }
    }
 
    bool has_optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type);
    if (PresetBundle *preset_bundle = wxGetApp().preset_bundle) {
        has_optional_printer_model = has_optional_printer_model ||
            DevPrinterConfigUtil::is_optional_printer_model_id(
                preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle));
    }
 
    if (obj_->is_connecting() || !obj_->is_connected()) {
        show_status(CaliPresetPageStatus::CaliPresetStatusInConnecting);
        return;
    }
    else if (obj_->is_in_upgrading()) {
        show_status(CaliPresetPageStatus::CaliPresetStatusInUpgrading);
        return;
    }
    else if (obj_->is_system_printing()) {
        show_status(CaliPresetPageStatus::CaliPresetStatusInSystemPrinting);
        return;
    }
    else if (obj_->is_in_printing()) {
        show_status(CaliPresetPageStatus::CaliPresetStatusInPrinting);
        return;
    }
 
    //if (obj_->is_multi_extruders()) {
    //    float diameter = obj_->m_extder_data.extders[0].current_nozzle_diameter;
    //    bool  is_same_diameter = std::all_of(obj_->m_extder_data.extders.begin(), obj_->m_extder_data.extders.end(),
    //       [diameter](const Extder& extruder) {
    //            return std::fabs(extruder.current_nozzle_diameter - diameter) < EPSILON;
    //       });
    //    if (!is_same_diameter) {
    //        show_status(CaliPresetPageStatus::CaliPresetStatusDifferentNozzleDiameters);
    //        return;
    //    }
    //}
 
    // check sdcard when if lan mode printer
    if (obj_->is_lan_mode_printer()) {
        if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD) {
            show_status(CaliPresetPageStatus::CaliPresetStatusLanModeNoSdcard);
            return;
        } else if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL ||
                   obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::HAS_SDCARD_READONLY) {
            show_status(CaliPresetPageStatus::CaliPresetStatusLanModeSDcardNotAvailable);
            return;
        }
    }
    else if (!obj_->GetConfig()->SupportPrintWithoutSD() && (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD))
    {
        show_status(CaliPresetPageStatus::CaliPresetStatusNoSdcard);
        return;
    }
 
    if (m_has_filament_incompatible) {
        show_status(CaliPresetPageStatus::CaliPresetStatusFilamentIncompatible);
        return;
    }
 
    show_status(has_optional_printer_model ?
        CaliPresetPageStatus::CaliPresetStatusOptionalPrinterModel :
        CaliPresetPageStatus::CaliPresetStatusNormal);
}

References Slic3r::GUI::CaliPresetStatusConnectingServer, Slic3r::GUI::CaliPresetStatusFilamentIncompatible, Slic3r::GUI::CaliPresetStatusInConnecting, Slic3r::GUI::CaliPresetStatusInPrinting, Slic3r::GUI::CaliPresetStatusInSystemPrinting, Slic3r::GUI::CaliPresetStatusInUpgrading, Slic3r::GUI::CaliPresetStatusInvalidPrinter, Slic3r::GUI::CaliPresetStatusLanModeNoSdcard, Slic3r::GUI::CaliPresetStatusLanModeSDcardNotAvailable, Slic3r::GUI::CaliPresetStatusNeedConsistencyUpgrading, Slic3r::GUI::CaliPresetStatusNeedForceUpgrading, Slic3r::GUI::CaliPresetStatusNormal, Slic3r::GUI::CaliPresetStatusNoSdcard, Slic3r::GUI::CaliPresetStatusNoUserLogin, Slic3r::GUI::CaliPresetStatusOptionalPrinterModel, Slic3r::DevStorage::get_sdcard_state(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetConfig(), Slic3r::MachineObject::GetStorage(), Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_READONLY, Slic3r::MachineObject::is_connected(), Slic3r::MachineObject::is_connecting(), Slic3r::MachineObject::is_in_printing(), Slic3r::MachineObject::is_in_upgrading(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::DevPrinterConfigUtil::is_optional_printer_model_id(), Slic3r::NetworkAgent::is_server_connected(), Slic3r::MachineObject::is_system_printing(), Slic3r::NetworkAgent::is_user_login(), m_has_filament_incompatible, Slic3r::DevStorage::NO_SDCARD, Slic3r::MachineObject::printer_type, show_status(), Slic3r::DevConfig::SupportPrintWithoutSD(), Slic3r::MachineObject::upgrade_consistency_request, and Slic3r::MachineObject::upgrade_force_upgrade.

Referenced by check_filament_compatible(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_sync_button_status()

void Slic3r::GUI::CalibrationPresetPage::update_sync_button_status ( )

protected

{
    auto set_status = [this](bool synced) {
        StateColor synced_colour(std::pair<wxColour, int>(wxColour("#CECECE"), StateColor::Normal));
        StateColor not_synced_colour(std::pair<wxColour, int>(wxColour("#009688"), StateColor::Normal));
        if (synced) {
            m_btn_sync->SetBorderColor(synced_colour);
            m_btn_sync->SetIcon("ams_nozzle_sync");
            m_sync_button_text->SetLabel(_L("AMS and nozzle information are synced"));
        } else {
            m_btn_sync->SetBorderColor(not_synced_colour);
            m_btn_sync->SetIcon("printer_sync");
            m_sync_button_text->SetLabel(_L("Sync AMS and nozzle information"));
        }
    };
 
    set_status(is_nozzle_info_synced());
}

References _L, is_nozzle_info_synced(), m_btn_sync, m_sync_button_text, and StateColor::Normal.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

curr_obj

MachineObject* Slic3r::GUI::CalibrationPresetPage::curr_obj { nullptr }

protected

{ nullptr };

Referenced by create_selection_panel(), get_current_object(), get_extruder_id_by_tray_id(), get_extruder_type(), get_nozzle_diameter(), get_nozzle_volume_type(), get_print_preset(), get_selected_filament_combobox(), init_selection_values(), is_filament_in_blacklist(), is_nozzle_info_synced(), on_select_nozzle(), select_default_compatible_filament(), update(), and update_flow_ratio_type().

filament_ams_list

std::map<int, DynamicPrintConfig> Slic3r::GUI::CalibrationPresetPage::filament_ams_list

protected

Referenced by get_filament_ams_list(), sync_ams_info(), update_filament_combobox(), and update_multi_extruder_filament_combobox().

m_action_panel

CaliPageActionPanel* Slic3r::GUI::CalibrationWizardPage::m_action_panel { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::CalibrationCaliPage::create_page(), Slic3r::GUI::CalibrationFlowCoarseSavePage::create_page(), Slic3r::GUI::CalibrationFlowFineSavePage::create_page(), Slic3r::GUI::CalibrationFlowRateStartPage::create_page(), Slic3r::GUI::CalibrationFlowX1SavePage::create_page(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::create_page(), Slic3r::GUI::CalibrationMaxVolumetricSpeedStartPage::create_page(), Slic3r::GUI::CalibrationPASavePage::create_page(), Slic3r::GUI::CalibrationPAStartPage::create_page(), Slic3r::GUI::CalibrationPresetPage::create_page(), Slic3r::GUI::CalibrationPresetPage::Enable_Send_Button(), msw_rescale(), Slic3r::GUI::CalibrationFlowCoarseSavePage::on_cali_cancel_job(), Slic3r::GUI::CalibrationPresetPage::on_cali_cancel_job(), Slic3r::GUI::CalibrationFlowCoarseSavePage::on_cali_finished_job(), Slic3r::GUI::CalibrationPresetPage::on_cali_finished_job(), Slic3r::GUI::CalibrationFlowCoarseSavePage::on_cali_start_job(), Slic3r::GUI::CalibrationPresetPage::on_cali_start_job(), Slic3r::GUI::CalibrationFlowRateStartPage::on_device_connected(), Slic3r::GUI::CalibrationPAStartPage::on_device_connected(), Slic3r::GUI::CalibrationFlowRateStartPage::on_reset_page(), Slic3r::GUI::CalibrationPAStartPage::on_reset_page(), and Slic3r::GUI::CalibrationCaliPage::update().

m_ams_id_to_extruder_id_map

std::unordered_map<int, int> Slic3r::GUI::CalibrationPresetPage::m_ams_id_to_extruder_id_map

protected

Referenced by get_extruder_id_by_tray_id(), and sync_ams_info().

m_ams_preview_list

std::vector<AMSPreview*> Slic3r::GUI::CalibrationPresetPage::m_ams_preview_list

protected

Referenced by msw_rescale(), on_switch_ams(), select_default_compatible_filament(), sync_ams_info(), and update_filament_combobox().

m_ams_sync_button

ScalableButton* Slic3r::GUI::CalibrationPresetPage::m_ams_sync_button

protected

Referenced by create_selection_panel(), msw_rescale(), on_choose_ams(), on_choose_ext_spool(), and on_sys_color_changed().

m_btn_sync

Button* Slic3r::GUI::CalibrationPresetPage::m_btn_sync {nullptr}

protected

{nullptr};

Referenced by create_selection_panel(), and update_sync_button_status().

m_cali_filament_mode

CalibrationFilamentMode Slic3r::GUI::CalibrationWizardPage::m_cali_filament_mode

protectedinherited

Referenced by Slic3r::GUI::CalibrationPresetPage::CalibrationPresetPage(), Slic3r::GUI::CalibrationPresetPage::get_selected_filament_combobox(), Slic3r::GUI::CalibrationPresetPage::select_default_compatible_filament(), set_cali_filament_mode(), Slic3r::GUI::CalibrationPresetPage::update_filament_combobox(), and Slic3r::GUI::CalibrationPresetPage::update_multi_extruder_filament_combobox().

m_cali_method

CalibrationMethod Slic3r::GUI::CalibrationWizardPage::m_cali_method { CalibrationMethod::CALI_METHOD_MANUAL }

protectedinherited

{ CalibrationMethod::CALI_METHOD_MANUAL };

Referenced by Slic3r::GUI::CalibrationPresetPage::is_filament_in_blacklist(), Slic3r::GUI::CalibrationPresetPage::need_check_sdcard(), Slic3r::GUI::CalibrationPASavePage::on_device_connected(), Slic3r::GUI::CalibrationCaliPage::set_cali_img(), Slic3r::GUI::CalibrationCaliPage::set_cali_method(), set_cali_method(), Slic3r::GUI::CalibrationCaliPage::set_pa_cali_image(), Slic3r::GUI::CalibrationPASavePage::Show(), Slic3r::GUI::CalibrationPASavePage::sync_cali_result(), and Slic3r::GUI::CalibrationCaliPage::update().

m_cali_mode

CalibMode Slic3r::GUI::CalibrationWizardPage::m_cali_mode

protectedinherited

Referenced by Slic3r::GUI::CalibrationCaliPage::CalibrationCaliPage(), Slic3r::GUI::CalibrationFlowCoarseSavePage::CalibrationFlowCoarseSavePage(), Slic3r::GUI::CalibrationFlowFineSavePage::CalibrationFlowFineSavePage(), Slic3r::GUI::CalibrationFlowX1SavePage::CalibrationFlowX1SavePage(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::CalibrationMaxVolumetricSpeedSavePage(), Slic3r::GUI::CalibrationPASavePage::CalibrationPASavePage(), Slic3r::GUI::CalibrationPresetPage::CalibrationPresetPage(), Slic3r::GUI::CalibrationCaliPage::create_page(), Slic3r::GUI::CalibrationFlowCoarseSavePage::create_page(), Slic3r::GUI::CalibrationFlowFineSavePage::create_page(), Slic3r::GUI::CalibrationFlowX1SavePage::create_page(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::create_page(), Slic3r::GUI::CalibrationPASavePage::create_page(), Slic3r::GUI::CalibrationPresetPage::create_page(), Slic3r::GUI::CalibrationPresetPage::is_filament_in_blacklist(), Slic3r::GUI::CalibrationPresetPage::need_check_sdcard(), Slic3r::GUI::CalibrationPresetPage::on_recommend_input_value(), Slic3r::GUI::CalibrationCaliPage::set_cali_img(), Slic3r::GUI::CalibrationCaliPage::set_cali_method(), Slic3r::GUI::CalibrationPresetPage::set_cali_method(), Slic3r::GUI::CalibrationCaliPage::set_pa_cali_image(), and Slic3r::GUI::CalibrationCaliPage::update().

m_cali_stage_panel

CaliPresetCaliStagePanel* Slic3r::GUI::CalibrationPresetPage::m_cali_stage_panel { nullptr }

protected

{ nullptr };

Referenced by create_page(), get_cali_stage(), init_with_machine(), msw_rescale(), on_recommend_input_value(), and set_cali_method().

m_comboBox_bed_type

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_comboBox_bed_type

protected

Referenced by check_filament_compatible(), create_selection_panel(), get_preset_info(), init_selection_values(), is_filaments_compatiable(), and update_plate_type_collection().

m_comboBox_nozzle_dia

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_comboBox_nozzle_dia

protected

Referenced by create_selection_panel(), get_nozzle_diameter(), get_nozzle_value(), get_preset_info(), init_selection_values(), and init_with_machine().

m_comboBox_nozzle_volume

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_comboBox_nozzle_volume

protected

Referenced by create_selection_panel(), get_nozzle_volume_type(), init_selection_values(), and init_with_machine().

m_comboBox_process

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_comboBox_process

protected

m_custom_range_panel

CaliPresetCustomRangePanel* Slic3r::GUI::CalibrationPresetPage::m_custom_range_panel { nullptr }

protected

{ nullptr };

Referenced by Slic3r::GUI::MaxVolumetricSpeedPresetPage::MaxVolumetricSpeedPresetPage(), create_page(), get_custom_range_values(), msw_rescale(), on_recommend_input_value(), and set_cali_method().

m_deputy_ams_items_sizer

wxBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_deputy_ams_items_sizer {nullptr}

protected

{nullptr};

Referenced by create_multi_extruder_filament_list_panel().

m_deputy_ams_preview_list

std::vector<AMSPreview *> Slic3r::GUI::CalibrationPresetPage::m_deputy_ams_preview_list

protected

Referenced by msw_rescale(), sync_ams_info(), and update_multi_extruder_filament_combobox().

m_deputy_ams_preview_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_deputy_ams_preview_panel {nullptr}

protected

{nullptr};

Referenced by create_multi_extruder_filament_list_panel(), and sync_ams_info().

m_deputy_filament_comboBox_list

FilamentComboBoxList Slic3r::GUI::CalibrationPresetPage::m_deputy_filament_comboBox_list

protected

Referenced by create_multi_extruder_filament_list_panel(), get_extruder_id_by_tray_id(), get_selected_filament_combobox(), and update_multi_extruder_filament_combobox().

m_deputy_sizer

wxStaticBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_deputy_sizer

protected

Referenced by create_multi_extruder_filament_list_panel(), and init_with_machine().

m_displayed_bed_types

std::vector<BedType> Slic3r::GUI::CalibrationPresetPage::m_displayed_bed_types

protected

Referenced by get_preset_info(), init_selection_values(), and is_filaments_compatiable().

m_extrder_types

std::vector<ExtruderType> Slic3r::GUI::CalibrationPresetPage::m_extrder_types

protected

Referenced by CalibrationPresetPage(), get_extruder_type(), and update_combobox_filaments().

m_extruder_nozzle_types

std::vector<NozzleVolumeType> Slic3r::GUI::CalibrationPresetPage::m_extruder_nozzle_types

protected

Referenced by CalibrationPresetPage().

m_filament_comboBox_list

FilamentComboBoxList Slic3r::GUI::CalibrationPresetPage::m_filament_comboBox_list

protected

Referenced by create_filament_list_panel(), get_selected_filament_combobox(), msw_rescale(), select_default_compatible_filament(), set_cali_filament_mode(), and update_filament_combobox().

m_filament_from_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_filament_from_panel { nullptr }

protected

{ nullptr };

Referenced by create_selection_panel().

m_filament_list_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_filament_list_panel { nullptr }

protected

{ nullptr };

Referenced by create_filament_list_panel(), create_page(), init_with_machine(), on_choose_ams(), and on_choose_ext_spool().

m_filament_list_tips

Label* Slic3r::GUI::CalibrationPresetPage::m_filament_list_tips { nullptr }

protected

{ nullptr };

Referenced by create_filament_list_panel(), create_multi_extruder_filament_list_panel(), and set_cali_filament_mode().

m_has_filament_incompatible

bool Slic3r::GUI::CalibrationPresetPage::m_has_filament_incompatible { false }

protected

{ false };

Referenced by check_filament_compatible(), and update_show_status().

m_left_comboBox_nozzle_dia

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_left_comboBox_nozzle_dia

protected

Referenced by create_selection_panel(), get_nozzle_diameter(), init_selection_values(), and init_with_machine().

m_left_comboBox_nozzle_volume

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_left_comboBox_nozzle_volume

protected

Referenced by create_selection_panel(), get_nozzle_volume_type(), init_selection_values(), and init_with_machine().

m_left_nozzle_volume_type_sizer

wxStaticBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_left_nozzle_volume_type_sizer

protected

Referenced by create_selection_panel().

m_main_ams_items_sizer

wxBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_main_ams_items_sizer {nullptr}

protected

{nullptr};

Referenced by create_multi_extruder_filament_list_panel().

m_main_ams_preview_list

std::vector<AMSPreview *> Slic3r::GUI::CalibrationPresetPage::m_main_ams_preview_list

protected

Referenced by msw_rescale(), sync_ams_info(), and update_multi_extruder_filament_combobox().

m_main_ams_preview_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_main_ams_preview_panel {nullptr}

protected

{nullptr};

Referenced by create_multi_extruder_filament_list_panel(), and sync_ams_info().

m_main_extruder_on_left

bool Slic3r::GUI::CalibrationPresetPage::m_main_extruder_on_left {true}

protected

{true};

Referenced by create_multi_extruder_filament_list_panel(), and init_with_machine().

m_main_filament_comboBox_list

FilamentComboBoxList Slic3r::GUI::CalibrationPresetPage::m_main_filament_comboBox_list

protected

Referenced by create_multi_extruder_filament_list_panel(), get_selected_filament_combobox(), and update_multi_extruder_filament_combobox().

m_main_sizer

wxStaticBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_main_sizer

protected

Referenced by create_multi_extruder_filament_list_panel(), and init_with_machine().

m_multi_ams_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_multi_ams_panel { nullptr }

protected

{ nullptr };

Referenced by create_filament_list_panel(), and sync_ams_info().

m_multi_extruder_ams_panel_sizer

wxBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_multi_extruder_ams_panel_sizer

protected

Referenced by create_multi_extruder_filament_list_panel().

m_multi_exturder_ams_sizer

wxBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_multi_exturder_ams_sizer

protected

Referenced by create_multi_extruder_filament_list_panel(), and init_with_machine().

m_multi_exutrder_filament_list_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_multi_exutrder_filament_list_panel {nullptr}

protected

{nullptr};

Referenced by create_multi_extruder_filament_list_panel(), create_page(), and init_with_machine().

m_multi_nozzle_info_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_multi_nozzle_info_panel {nullptr}

protected

{nullptr};

Referenced by create_selection_panel(), and init_with_machine().

m_next_page

CalibrationWizardPage* Slic3r::GUI::CalibrationWizardPage::m_next_page {nullptr}

privateinherited

{nullptr};

Referenced by get_next_page(), and set_next_page().

m_nozzle_diameter_tips

Label* Slic3r::GUI::CalibrationPresetPage::m_nozzle_diameter_tips {nullptr}

protected

{nullptr};

Referenced by create_selection_panel().

m_pa_cali_method_combox

CaliComboBox* Slic3r::GUI::CalibrationPresetPage::m_pa_cali_method_combox {nullptr}

protected

{nullptr};

Referenced by create_page(), get_pa_cali_method(), and set_cali_method().

m_page_caption

CaliPageCaption* Slic3r::GUI::CalibrationWizardPage::m_page_caption { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::CalibrationCaliPage::create_page(), Slic3r::GUI::CalibrationFlowCoarseSavePage::create_page(), Slic3r::GUI::CalibrationFlowFineSavePage::create_page(), Slic3r::GUI::CalibrationFlowRateStartPage::create_page(), Slic3r::GUI::CalibrationFlowX1SavePage::create_page(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::create_page(), Slic3r::GUI::CalibrationMaxVolumetricSpeedStartPage::create_page(), Slic3r::GUI::CalibrationPASavePage::create_page(), Slic3r::GUI::CalibrationPAStartPage::create_page(), Slic3r::GUI::CalibrationPresetPage::create_page(), msw_rescale(), and on_sys_color_changed().

m_page_status

CaliPresetPageStatus Slic3r::GUI::CalibrationPresetPage::m_page_status { CaliPresetPageStatus::CaliPresetStatusInit }

protected

{ CaliPresetPageStatus::CaliPresetStatusInit };

Referenced by get_page_status(), get_status(), and show_status().

m_page_type

CaliPageType Slic3r::GUI::CalibrationWizardPage::m_page_type

protectedinherited

Referenced by Slic3r::GUI::CalibrationCaliPage::CalibrationCaliPage(), Slic3r::GUI::CalibrationFlowCoarseSavePage::CalibrationFlowCoarseSavePage(), Slic3r::GUI::CalibrationFlowFineSavePage::CalibrationFlowFineSavePage(), Slic3r::GUI::CalibrationFlowX1SavePage::CalibrationFlowX1SavePage(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::CalibrationMaxVolumetricSpeedSavePage(), Slic3r::GUI::CalibrationPASavePage::CalibrationPASavePage(), Slic3r::GUI::CalibrationPAStartPage::CalibrationPAStartPage(), Slic3r::GUI::CalibrationPresetPage::CalibrationPresetPage(), get_page_type(), Slic3r::GUI::CalibrationCaliPage::set_cali_img(), and Slic3r::GUI::CalibrationCaliPage::set_cali_method().

m_parent

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

protectedinherited

{ nullptr };

Referenced by CalibrationWizardPage().

m_prev_page

CalibrationWizardPage* Slic3r::GUI::CalibrationWizardPage::m_prev_page {nullptr}

privateinherited

{nullptr};

Referenced by get_prev_page(), and set_prev_page().

m_right_comboBox_nozzle_dia

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_right_comboBox_nozzle_dia

protected

Referenced by create_selection_panel(), get_nozzle_diameter(), init_selection_values(), and init_with_machine().

m_right_comboBox_nozzle_volume

ComboBox* Slic3r::GUI::CalibrationPresetPage::m_right_comboBox_nozzle_volume

protected

Referenced by create_selection_panel(), get_nozzle_volume_type(), init_selection_values(), and init_with_machine().

m_right_nozzle_volume_type_sizer

wxStaticBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_right_nozzle_volume_type_sizer

protected

Referenced by create_selection_panel().

m_selection_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_selection_panel { nullptr }

protected

{ nullptr };

Referenced by create_page().

m_sending_panel

CaliPageSendingPanel* Slic3r::GUI::CalibrationPresetPage::m_sending_panel { nullptr }

protected

{ nullptr };

Referenced by create_page(), get_sending_progress_bar(), on_cali_cancel_job(), on_cali_finished_job(), on_cali_start_job(), and update_print_error_info().

m_show_custom_range

bool Slic3r::GUI::CalibrationPresetPage::m_show_custom_range { false }

protected

{ false };

Referenced by CalibrationPresetPage().

m_single_nozzle_info_panel

wxPanel* Slic3r::GUI::CalibrationPresetPage::m_single_nozzle_info_panel {nullptr}

protected

{nullptr};

Referenced by create_selection_panel(), and init_with_machine().

m_statictext_printer_msg

Label* Slic3r::GUI::CalibrationWizardPage::m_statictext_printer_msg { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::CalibrationPresetPage::create_page(), Slic3r::GUI::CalibrationPresetPage::format_text(), and Slic3r::GUI::CalibrationPresetPage::update_priner_status_msg().

m_step_panel

CaliPageStepGuide* Slic3r::GUI::CalibrationPresetPage::m_step_panel { nullptr }

protected

{ nullptr };

Referenced by create_page(), and set_cali_method().

m_stop_update_page_status

bool Slic3r::GUI::CalibrationPresetPage::m_stop_update_page_status { false }

protected

{ false };

Referenced by on_cali_cancel_job(), on_cali_finished_job(), on_cali_start_job(), and show_status().

m_sync_button_text

Label* Slic3r::GUI::CalibrationPresetPage::m_sync_button_text

protected

Referenced by create_selection_panel(), and update_sync_button_status().

m_tips_panel

CaliPresetTipsPanel* Slic3r::GUI::CalibrationPresetPage::m_tips_panel { nullptr }

protected

{ nullptr };

Referenced by check_filament_compatible(), and create_page().

m_top_sizer

wxBoxSizer* Slic3r::GUI::CalibrationPresetPage::m_top_sizer

protected

Referenced by CalibrationPresetPage(), and create_page().

m_warning_panel

CaliPresetWarningPanel* Slic3r::GUI::CalibrationPresetPage::m_warning_panel { nullptr }

protected

{ nullptr };

Referenced by check_filament_compatible(), and create_page().

---

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

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