Slic3r::GUI::CaliPASaveAutoPanel Class Reference

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

Inheritance diagram for Slic3r::GUI::CaliPASaveAutoPanel:

Collaboration diagram for Slic3r::GUI::CaliPASaveAutoPanel:

Public Member Functions
	CaliPASaveAutoPanel (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
void	create_panel (wxWindow *parent)
void	set_machine_obj (MachineObject *obj)
std::vector< std::pair< int, std::string > >	default_naming (std::vector< std::pair< int, std::string > > preset_names)
void	sync_cali_result (const std::vector< PACalibResult > &cali_result, const std::vector< PACalibResult > &history_result)
void	save_to_result_from_widgets (wxWindow *window, bool *out_is_valid, wxString *out_msg)
bool	get_result (std::vector< PACalibResult > &out_result)
bool	is_all_failed ()

Protected Member Functions
void	sync_cali_result_for_multi_extruder (const std::vector< PACalibResult > &cali_result, const std::vector< PACalibResult > &history_result)

Protected Attributes
wxBoxSizer *	m_top_sizer
wxPanel *	m_complete_text_panel
wxPanel *	m_part_failed_panel
wxPanel *	m_grid_panel { nullptr }
wxPanel *	m_multi_extruder_grid_panel { nullptr }
std::vector< PACalibResult >	m_calib_results
std::vector< PACalibResult >	m_history_results
bool	m_is_all_failed { true }
MachineObject *	m_obj { nullptr }

Detailed Description

Constructor & Destructor Documentation

CaliPASaveAutoPanel()

Slic3r::GUI::CaliPASaveAutoPanel::CaliPASaveAutoPanel	(	wxWindow *	parent,
		wxWindowID	id = wxID_ANY,
		const wxPoint &	pos = wxDefaultPosition,
		const wxSize &	size = wxDefaultSize,
		long	style = wxTAB_TRAVERSAL )

    : wxPanel(parent, id, pos, size, style)
{
    SetBackgroundColour(*wxWHITE);
 
    m_top_sizer = new wxBoxSizer(wxVERTICAL);
 
    create_panel(this);
 
    this->SetSizer(m_top_sizer);
    m_top_sizer->Fit(this);
}

References create_panel(), m_top_sizer, and style.

Here is the call graph for this function:

Member Function Documentation

create_panel()

void Slic3r::GUI::CaliPASaveAutoPanel::create_panel

(

wxWindow *

parent

)

{
    m_complete_text_panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_complete_text_panel->SetBackgroundColour(*wxWHITE);
    m_complete_text_panel->Hide();
    wxBoxSizer* complete_text_sizer = new wxBoxSizer(wxVERTICAL);
    auto complete_text = new Label(m_complete_text_panel, _L("We found the best Flow Dynamics Calibration Factor"));
    complete_text->SetFont(Label::Head_14);
    complete_text_sizer->Add(complete_text, 0, wxEXPAND);
    m_complete_text_panel->SetSizer(complete_text_sizer);
 
    m_part_failed_panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_part_failed_panel->SetBackgroundColour(wxColour(238, 238, 238));
    wxBoxSizer* part_failed_sizer = new wxBoxSizer(wxVERTICAL);
    m_part_failed_panel->SetSizer(part_failed_sizer);
    part_failed_sizer->AddSpacer(FromDIP(10));
    auto part_failed_text = new Label(m_part_failed_panel, _L("Part of the calibration failed! You may clean the plate and retry. The failed test result would be dropped."));
    part_failed_text->SetFont(Label::Body_14);
    part_failed_sizer->Add(part_failed_text, 0, wxLEFT | wxRIGHT, FromDIP(20));
    part_failed_sizer->AddSpacer(FromDIP(10));
 
    m_top_sizer->Add(m_part_failed_panel, 0, wxEXPAND, 0);
 
    m_top_sizer->AddSpacer(FromDIP(20));
 
    m_top_sizer->Add(m_complete_text_panel, 0, wxEXPAND, 0);
 
    m_top_sizer->AddSpacer(FromDIP(20));
 
    m_grid_panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_grid_panel->SetBackgroundColour(*wxWHITE);
    m_top_sizer->Add(m_grid_panel, 0, wxALIGN_CENTER);
 
    m_multi_extruder_grid_panel = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_multi_extruder_grid_panel->SetBackgroundColour(*wxWHITE);
    m_top_sizer->Add(m_multi_extruder_grid_panel, 0, wxALIGN_CENTER);
 
    m_top_sizer->AddSpacer(FromDIP(10));
 
    auto naming_hints = new Label(parent, _L("*We recommend you to add brand, materia, type, and even humidity level in the Name"));
    naming_hints->SetFont(Label::Body_14);
    naming_hints->SetForegroundColour(wxColour(157, 157, 157));
    m_top_sizer->Add(naming_hints, 0, wxEXPAND, 0);
 
    m_top_sizer->AddSpacer(FromDIP(20));
}

References _L, Label::Body_14, Label::Head_14, m_complete_text_panel, m_grid_panel, m_multi_extruder_grid_panel, m_part_failed_panel, and m_top_sizer.

Referenced by CaliPASaveAutoPanel().

Here is the caller graph for this function:

default_naming()

std::vector< std::pair< int, std::string > > Slic3r::GUI::CaliPASaveAutoPanel::default_naming

(

std::vector< std::pair< int, std::string > >

preset_names

)

{
    std::unordered_set<std::string> set;
    int i = 1;
    for (auto& item : preset_names) {
        if (!set.insert(item.second).second) {
            item.second = get_default_name(item.second, CalibMode::Calib_PA_Line).ToUTF8().data();
            item.second += "_" + std::to_string(i);
            i++;
        }
        else {
            item.second = get_default_name(item.second, CalibMode::Calib_PA_Line).ToUTF8().data();
        }
    }
    return preset_names;
}

References Slic3r::Calib_PA_Line, and Slic3r::GUI::get_default_name().

Referenced by sync_cali_result().

Here is the call graph for this function:

Here is the caller graph for this function:

get_result()

bool Slic3r::GUI::CaliPASaveAutoPanel::get_result

(

std::vector< PACalibResult > &

out_result

)

                                                                         {
    bool is_valid = true;
    wxString err_msg;
    // Check if the input value is valid and save to m_calib_results
    if (m_obj && m_obj->is_multi_extruders())
        save_to_result_from_widgets(m_multi_extruder_grid_panel, &is_valid, &err_msg);
    else
        save_to_result_from_widgets(m_grid_panel, &is_valid, &err_msg);
    if (is_valid) {
        out_result = m_calib_results;
        return true;
    }
    else {
        MessageDialog msg_dlg(nullptr, err_msg, wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return false;
    }
}

References m_calib_results, m_grid_panel, m_multi_extruder_grid_panel, m_obj, save_to_result_from_widgets(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Here is the call graph for this function:

is_all_failed()

bool Slic3r::GUI::CaliPASaveAutoPanel::is_all_failed ( )

inline

{ return m_is_all_failed; }

References m_is_all_failed.

save_to_result_from_widgets()

void Slic3r::GUI::CaliPASaveAutoPanel::save_to_result_from_widgets	(	wxWindow *	window,
		bool *	out_is_valid,
		wxString *	out_msg )

                                                                                                             {
    if (!window)
        return;
 
    //operate
    // The grid can hold two rows with the same tray_id under different extruders
    // (rack / dual-address configs), so results must be keyed by (tray_id, extruder_id).
    auto find_result = [this](int tray_id, int extruder_id) -> PACalibResult* {
        auto it = std::find_if(m_calib_results.begin(), m_calib_results.end(), [tray_id, extruder_id](const PACalibResult& r) {
            return r.tray_id == tray_id && r.extruder_id == extruder_id;
        });
        return it != m_calib_results.end() ? &(*it) : nullptr;
    };
    auto input = dynamic_cast<GridTextInput*>(window);
    if (input && input->IsShown()) {
        int tray_id     = input->get_col_idx();
        int extruder_id = input->get_extruder_id();
        if (input->get_type() == GridTextInputType::K) {
            float k = 0.0f;
            if (!CalibUtils::validate_input_k_value(input->GetTextCtrl()->GetValue(), &k)) {
                *out_msg = wxString::Format(_L("Please input a valid value (K in %.1f~%.1f)"), MIN_PA_K_VALUE, MAX_PA_K_VALUE);
                *out_is_valid = false;
            }
            else if (auto* result = find_result(tray_id, extruder_id))
                result->k_value = k;
        }
        else if (input->get_type() == GridTextInputType::N) {
        }
    }
 
    auto comboBox = dynamic_cast<GridComboBox*>(window);
    if (comboBox && comboBox->IsShown()) {
        int tray_id     = comboBox->get_col_idx();
        int extruder_id = comboBox->get_extruder_id();
        wxString name = comboBox->GetTextCtrl()->GetValue().ToStdString();
        if (name.IsEmpty()) {
            *out_msg = _L("Please enter the name you want to save to printer.");
            *out_is_valid = false;
        }
        else if (name.Length() > 40) {
            *out_msg = _L("The name cannot exceed 40 characters.");
            *out_is_valid = false;
        }
        if (auto* result = find_result(tray_id, extruder_id))
            result->name = into_u8(name);
    }
 
    auto childern = window->GetChildren();
    for (auto child : childern) {
        save_to_result_from_widgets(child, out_is_valid, out_msg);
    }
};

References _L, Slic3r::GUI::into_u8(), Slic3r::GUI::K, m_calib_results, Slic3r::GUI::MAX_PA_K_VALUE, Slic3r::GUI::MIN_PA_K_VALUE, Slic3r::GUI::N, save_to_result_from_widgets(), and Slic3r::GUI::CalibUtils::validate_input_k_value().

Referenced by get_result(), and save_to_result_from_widgets().

Here is the call graph for this function:

Here is the caller graph for this function:

set_machine_obj()

void Slic3r::GUI::CaliPASaveAutoPanel::set_machine_obj ( MachineObject * obj )

inline

{ m_obj = obj; }

References m_obj.

sync_cali_result()

void Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result	(	const std::vector< PACalibResult > &	cali_result,
		const std::vector< PACalibResult > &	history_result )

{
    if (m_obj && m_obj->is_multi_extruders()) {
        m_grid_panel->Hide();
        m_multi_extruder_grid_panel->Show();
        sync_cali_result_for_multi_extruder(cali_result, history_result);
        return;
    }
 
    m_grid_panel->Show();
    m_multi_extruder_grid_panel->Hide();
 
    m_history_results = history_result;
    m_calib_results.clear();
    for (auto& item : cali_result) {
        if (item.confidence == 0)
            m_calib_results.push_back(item);
    }
    m_grid_panel->DestroyChildren();
    auto grid_sizer = new wxBoxSizer(wxHORIZONTAL);
    const int COLUMN_GAP = FromDIP(20);
    const int ROW_GAP = FromDIP(30);
    wxBoxSizer* left_title_sizer = new wxBoxSizer(wxVERTICAL);
    left_title_sizer->AddSpacer(FromDIP(52));
    auto k_title = new Label(m_grid_panel, _L("Factor K"));
    k_title->SetFont(Label::Head_14);
    left_title_sizer->Add(k_title, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
    auto n_title = new Label(m_grid_panel, _L("Factor N"));
    n_title->SetFont(Label::Head_14);
    // hide n value
    n_title->Hide();
    left_title_sizer->Add(n_title, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
    auto brand_title = new Label(m_grid_panel, _L("Name"));
    brand_title->SetFont(Label::Head_14);
    left_title_sizer->Add(brand_title, 0, wxALIGN_CENTER);
    grid_sizer->Add(left_title_sizer);
    grid_sizer->AddSpacer(COLUMN_GAP);
 
    m_is_all_failed = true;
    bool part_failed = false;
    if (cali_result.empty())
        part_failed = true;
 
    std::vector<std::pair<int, std::string>> preset_names;
    for (auto& info : m_obj->selected_cali_preset) {
        preset_names.push_back({ info.tray_id, info.name });
    }
    preset_names = default_naming(preset_names);
 
    std::vector<PACalibResult> sorted_cali_result = cali_result;
    std::sort(sorted_cali_result.begin(), sorted_cali_result.end(), [](const PACalibResult &left, const PACalibResult& right) {
        return left.tray_id < right.tray_id;
    });
 
    for (auto &item : sorted_cali_result) {
        bool result_failed = false;
        if (item.confidence != 0) {
            result_failed = true;
            part_failed = true;
        }
        else {
            m_is_all_failed = false;
        }
 
        wxBoxSizer* column_data_sizer = new wxBoxSizer(wxVERTICAL);
        auto tray_title = new Label(m_grid_panel, "");
        tray_title->SetFont(Label::Head_14);
        wxString tray_name = get_tray_name_by_tray_id(item.tray_id);
        tray_title->SetLabel(tray_name);
 
        auto k_value = new GridTextInput(m_grid_panel, "", "", CALIBRATION_SAVE_INPUT_SIZE, item.tray_id, GridTextInputType::K, item.extruder_id);
        auto n_value = new GridTextInput(m_grid_panel, "", "", CALIBRATION_SAVE_INPUT_SIZE, item.tray_id, GridTextInputType::N, item.extruder_id);
        k_value->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
        n_value->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
        auto k_value_failed = new Label(m_grid_panel, _L("Failed"));
        auto n_value_failed = new Label(m_grid_panel, _L("Failed"));
 
        auto comboBox_tray_name = new GridComboBox(m_grid_panel, CALIBRATION_SAVE_INPUT_SIZE, item.tray_id, item.extruder_id);
        auto tray_name_failed = new Label(m_grid_panel, " - ");
        wxArrayString selections;
        static std::vector<PACalibResult> filtered_results;
        filtered_results.clear();
        for (auto history : history_result) {
            if (history.filament_id == item.filament_id) {
                filtered_results.push_back(history);
                selections.push_back(from_u8(history.name));
            }
        }
        comboBox_tray_name->Set(selections);
 
        column_data_sizer->Add(tray_title, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(k_value, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(n_value, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(k_value_failed, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(n_value_failed, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(comboBox_tray_name, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
        column_data_sizer->Add(tray_name_failed, 0, wxALIGN_CENTER | wxBOTTOM, ROW_GAP);
 
        auto set_edit_mode = [this, k_value, n_value, k_value_failed, n_value_failed, comboBox_tray_name, tray_name_failed](std::string str) {
            if (str == "normal") {
                comboBox_tray_name->Show();
                tray_name_failed->Show(false);
                k_value->Show();
                n_value->Show();
                k_value_failed->Show(false);
                n_value_failed->Show(false);
            }
            if (str == "failed") {
                comboBox_tray_name->Show(false);
                tray_name_failed->Show();
                k_value->Show(false);
                n_value->Show(false);
                k_value_failed->Show();
                n_value_failed->Show();
            }
 
            // hide n value
            n_value->Hide();
            n_value_failed->Hide();
 
            m_grid_panel->Layout();
            m_grid_panel->Update();
        };
 
        if (!result_failed) {
            set_edit_mode("normal");
 
            auto k_str = wxString::Format("%.3f", item.k_value);
            auto n_str = wxString::Format("%.3f", item.n_coef);
            k_value->GetTextCtrl()->SetValue(k_str);
            n_value->GetTextCtrl()->SetValue(n_str);
 
            for (auto& name : preset_names) {
                int tray_id = item.tray_id;
                /* upgrade single extruder printer tray_id from 254 to 255 */
                if (!m_obj->is_multi_extruders() && tray_id == VIRTUAL_TRAY_DEPUTY_ID) {
                    tray_id = VIRTUAL_TRAY_MAIN_ID;
                }
 
                if (tray_id == name.first) {
                    comboBox_tray_name->SetValue(from_u8(name.second));
                }
            }
 
            comboBox_tray_name->Bind(wxEVT_COMBOBOX, [comboBox_tray_name](auto& e) {
                int selection = comboBox_tray_name->GetSelection();
                auto history = filtered_results[selection];
                });
        }
        else {
            set_edit_mode("failed");
        }
 
        grid_sizer->Add(column_data_sizer);
        grid_sizer->AddSpacer(COLUMN_GAP);
    }
 
    m_grid_panel->SetSizer(grid_sizer, true);
    m_grid_panel->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
        SetFocusIgnoringChildren();
        });
 
    if (part_failed) {
        m_part_failed_panel->Show();
        m_complete_text_panel->Show();
        if (m_is_all_failed) {
            m_complete_text_panel->Hide();
        }
    }
    else {
        m_complete_text_panel->Show();
        m_part_failed_panel->Hide();
    }
 
    wxGetApp().UpdateDarkUIWin(this);
 
    Layout();
}

References _L, CALIBRATION_SAVE_INPUT_SIZE, default_naming(), Slic3r::GUI::from_u8(), Slic3r::GUI::get_tray_name_by_tray_id(), Label::Head_14, Slic3r::GUI::K, m_calib_results, m_complete_text_panel, m_grid_panel, m_history_results, m_is_all_failed, m_multi_extruder_grid_panel, m_obj, m_part_failed_panel, Slic3r::GUI::N, sync_cali_result_for_multi_extruder(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Here is the call graph for this function:

sync_cali_result_for_multi_extruder()

void Slic3r::GUI::CaliPASaveAutoPanel::sync_cali_result_for_multi_extruder ( const std::vector< PACalibResult > & cali_result, const std::vector< PACalibResult > & history_result )

protected

{
    if (!m_obj)
        return;
 
    std::map<int, DynamicPrintConfig> old_full_filament_ams_list = wxGetApp().sidebar().build_filament_ams_list(m_obj);
    std::map<int, DynamicPrintConfig> full_filament_ams_list;
    for (auto ams_item : old_full_filament_ams_list) {
        int key = ams_item.first & 0x0FFFF;
        full_filament_ams_list[key] = std::move(ams_item.second);
    }
 
    m_is_all_failed  = true;
    bool part_failed = false;
    if (cali_result.empty())
        part_failed = true;
 
    m_history_results = history_result;
    m_calib_results.clear();
    for (auto &item : cali_result) {
        if (item.confidence == 0) {
            PACalibResult result = item;
            result.tray_id = 4 * item.ams_id + item.slot_id;
            if (item.ams_id == VIRTUAL_TRAY_MAIN_ID || item.ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
                result.tray_id = item.ams_id;
            }
            m_calib_results.push_back(result);
        }
    }
    m_multi_extruder_grid_panel->DestroyChildren();
    auto        grid_sizer       = new wxBoxSizer(wxHORIZONTAL);
    const int   COLUMN_GAP       = FromDIP(10);
    const int   ROW_GAP          = FromDIP(10);
 
    m_multi_extruder_grid_panel->SetSizer(grid_sizer, true);
    m_multi_extruder_grid_panel->Bind(wxEVT_LEFT_DOWN, [this](auto &e) { SetFocusIgnoringChildren(); });
 
    const std::string& cwsp_pt = m_obj->printer_type;
    wxStaticBoxSizer *left_sizer  = new wxStaticBoxSizer(wxVERTICAL, m_multi_extruder_grid_panel, _L(DevPrinterConfigUtil::get_toolhead_display_name(cwsp_pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::SentenceCase)));
    wxStaticBoxSizer *right_sizer = new wxStaticBoxSizer(wxVERTICAL, m_multi_extruder_grid_panel, _L(DevPrinterConfigUtil::get_toolhead_display_name(cwsp_pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::SentenceCase)));
    grid_sizer->Add(left_sizer);
    grid_sizer->AddSpacer(COLUMN_GAP);
    grid_sizer->Add(right_sizer);
 
    wxFlexGridSizer *left_grid_sizer  = new wxFlexGridSizer(3, COLUMN_GAP, ROW_GAP);
 
    // The main extruder can carry a nozzle rack (H2C); non-rack printers keep the 3-column layout.
    auto ns       = m_obj->GetNozzleSystem();
    auto rack     = ns ? ns->GetNozzleRack() : nullptr;
    bool has_rack = rack && rack->IsSupported();
 
    wxFlexGridSizer *right_grid_sizer = new wxFlexGridSizer(has_rack ? 4 : 3, COLUMN_GAP, ROW_GAP);
    left_sizer->Add(left_grid_sizer);
    right_sizer->Add(right_grid_sizer);
 
    // main extruder
    {
        left_grid_sizer->Add(new wxStaticText(m_multi_extruder_grid_panel, wxID_ANY, ""), 1, wxEXPAND); // fill empty space
 
        auto brand_title = new Label(m_multi_extruder_grid_panel, _L("Name"), 0, CALIBRATION_SAVE_INPUT_SIZE);
        brand_title->SetFont(Label::Head_14);
        left_grid_sizer->Add(brand_title, 1, wxALIGN_CENTER);
 
        auto k_title = new Label(m_multi_extruder_grid_panel, _L("Factor K"), 0, CALIBRATION_SAVE_NUMBER_INPUT_SIZE);
        k_title->SetFont(Label::Head_14);
        left_grid_sizer->Add(k_title, 1, wxALIGN_CENTER);
    }
 
    // deputy extruder
    {
        right_grid_sizer->Add(new wxStaticText(m_multi_extruder_grid_panel, wxID_ANY, ""), 1, wxEXPAND); // fill empty space
 
        auto brand_title = new Label(m_multi_extruder_grid_panel, _L("Name"), 0, CALIBRATION_SAVE_INPUT_SIZE);
        brand_title->SetFont(Label::Head_14);
        right_grid_sizer->Add(brand_title, 1, wxALIGN_CENTER);
 
        auto k_title = new Label(m_multi_extruder_grid_panel, _L("Factor K"), 0, CALIBRATION_SAVE_NUMBER_INPUT_SIZE);
        k_title->SetFont(Label::Head_14);
        right_grid_sizer->Add(k_title, 1, wxALIGN_CENTER);
 
        if (has_rack) {
            auto nozzle_title = new Label(m_multi_extruder_grid_panel, _L("Nozzle ID"), 0, CALIBRATION_SAVE_NUMBER_INPUT_SIZE);
            nozzle_title->SetFont(Label::Head_14);
            right_grid_sizer->Add(nozzle_title, 1, wxALIGN_CENTER);
        }
    }
 
    // key: (extruder_id, tray_id)
    std::vector<std::pair<std::pair<int, int>, std::string>> preset_names;
    int i = 1;
    std::unordered_set<std::string> set;
    for (auto &info : m_obj->selected_cali_preset) {
        std::string default_name;
        // Derive extruder_id from the tray so the extruder/tray key stays consistent
        // with the calibration result's extruder_id.
        int extruder_id = 0;
        if (info.tray_id == VIRTUAL_TRAY_MAIN_ID) {
            extruder_id = 0;
        } else if (info.tray_id == VIRTUAL_TRAY_DEPUTY_ID) {
            extruder_id = 1;
        } else {
            int ams_id  = info.tray_id / 4;
            extruder_id = m_obj->get_extruder_id_by_ams_id(std::to_string(ams_id));
        }
        {
            if (extruder_id == MAIN_EXTRUDER_ID) {
                default_name += DevPrinterConfigUtil::get_toolhead_display_name(cwsp_pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase);
                if (has_rack) {
                    default_name += "_";
                    if (info.nozzle_pos_id == 0) {
                        default_name += "R";
                    } else if (info.nozzle_pos_id >= 0x10) {
                        default_name += std::to_string((info.nozzle_pos_id & 0x0f) + 1);
                    } else {
                        default_name += "N/A";
                    }
                }
            } else if (extruder_id == DEPUTY_EXTRUDER_ID) {
                default_name += DevPrinterConfigUtil::get_toolhead_display_name(cwsp_pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::TitleCase);
            }
        }
 
        // nozzle_volume_type
        {
            default_name += "_";
            if (info.nozzle_volume_type == NozzleVolumeType::nvtStandard) {
                default_name += L("Standard");
            }
            else if (info.nozzle_volume_type == NozzleVolumeType::nvtHighFlow) {
                default_name += L("High Flow");
            }
        }
 
        // filament_id
        {
            default_name += "_";
            default_name += get_default_name(info.name, CalibMode::Calib_PA_Line).ToUTF8().data();
            if (!set.insert(default_name).second) {
                default_name += "_" + std::to_string(i);
                i++;
            }
        }
 
        preset_names.push_back({{extruder_id, info.tray_id}, default_name});
    }
 
    bool left_first_add_item = true;
    bool right_first_add_item = true;
    std::vector<PACalibResult> sorted_cali_result   = cali_result;
    if (m_obj && m_obj->is_support_new_auto_cali_method) {
        for (auto &res : sorted_cali_result) {
            if (res.ams_id == VIRTUAL_TRAY_MAIN_ID || res.ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
                res.tray_id = res.ams_id;
            } else {
                res.tray_id = res.ams_id * 4 + res.slot_id;
            }
        }
    }
 
    std::sort(sorted_cali_result.begin(), sorted_cali_result.end(), [](const PACalibResult &left, const PACalibResult &right) {
        return left.tray_id < right.tray_id;
    });
    for (auto &item : sorted_cali_result) {
        bool result_failed = false;
        if (item.confidence != 0) {
            result_failed = true;
            part_failed   = true;
        } else {
            m_is_all_failed = false;
        }
 
        wxString tray_name = get_tray_name_by_tray_id(item.tray_id);
        wxButton *tray_title = new wxButton(m_multi_extruder_grid_panel, wxID_ANY, {}, wxDefaultPosition, wxSize(FromDIP(20), FromDIP(20)), wxBU_EXACTFIT | wxBU_AUTODRAW | wxBORDER_NONE);
        tray_title->SetBackgroundColour(*wxWHITE);
        tray_title->SetBitmap(*get_extruder_color_icon(full_filament_ams_list[item.tray_id].opt_string("filament_colour", 0u), tray_name.ToStdString(), FromDIP(20), FromDIP(20)));
        tray_title->SetToolTip("");
 
        auto k_value = new GridTextInput(m_multi_extruder_grid_panel, "", "", CALIBRATION_SAVE_NUMBER_INPUT_SIZE, item.tray_id, GridTextInputType::K, item.extruder_id);
        auto n_value = new GridTextInput(m_multi_extruder_grid_panel, "", "", CALIBRATION_SAVE_NUMBER_INPUT_SIZE, item.tray_id, GridTextInputType::N, item.extruder_id);
        k_value->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
        n_value->GetTextCtrl()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
        auto k_value_failed = new Label(m_multi_extruder_grid_panel, _L("Failed"));
        auto n_value_failed = new Label(m_multi_extruder_grid_panel, _L("Failed"));
 
        auto nozzle_id_value = new Label(m_multi_extruder_grid_panel, wxEmptyString);
        nozzle_id_value->SetMinSize(wxSize(FromDIP(180), FromDIP(24)));
        nozzle_id_value->Wrap(-1);
        auto nozzle_id_failed = new Label(m_multi_extruder_grid_panel, _L("Failed"));
 
        auto                              comboBox_tray_name = new GridComboBox(m_multi_extruder_grid_panel, CALIBRATION_SAVE_INPUT_SIZE, item.tray_id, item.extruder_id);
        auto                              tray_name_failed   = new Label(m_multi_extruder_grid_panel, " - ");
        wxArrayString                     selections;
        static std::vector<PACalibResult> filtered_results;
        filtered_results.clear();
        for (auto history : history_result) {
            if (history.filament_id == item.filament_id
                && history.extruder_id == item.extruder_id
                && history.nozzle_volume_type == item.nozzle_volume_type
                && history.nozzle_diameter == item.nozzle_diameter) {
                filtered_results.push_back(history);
                selections.push_back(from_u8(history.name));
            }
        }
        comboBox_tray_name->Set(selections);
 
        auto set_edit_mode = [this, k_value, n_value, k_value_failed, n_value_failed, nozzle_id_value, nozzle_id_failed, comboBox_tray_name, tray_name_failed](std::string str, bool display_nozzle) {
            if (str == "normal") {
                comboBox_tray_name->Show();
                tray_name_failed->Show(false);
                k_value->Show();
                n_value->Show();
                nozzle_id_value->Show(display_nozzle);
                k_value_failed->Show(false);
                n_value_failed->Show(false);
                nozzle_id_failed->Show(false);
            }
            if (str == "failed") {
                comboBox_tray_name->Show(false);
                tray_name_failed->Show();
                k_value->Show(false);
                n_value->Show(false);
                nozzle_id_value->Show(false);
                k_value_failed->Show();
                n_value_failed->Show();
                nozzle_id_failed->Show(display_nozzle);
            }
 
            // hide n value
            n_value->Hide();
            n_value_failed->Hide();
 
            m_multi_extruder_grid_panel->Layout();
            m_multi_extruder_grid_panel->Update();
        };
 
        if (!result_failed) {
            set_edit_mode("normal", has_rack && item.extruder_id == MAIN_EXTRUDER_ID);
 
            auto k_str = wxString::Format("%.3f", item.k_value);
            auto n_str = wxString::Format("%.3f", item.n_coef);
            k_value->GetTextCtrl()->SetValue(k_str);
            n_value->GetTextCtrl()->SetValue(n_str);
 
            if (has_rack && item.extruder_id == MAIN_EXTRUDER_ID) {
                wxString nozzle_id_str;
                if (item.nozzle_pos_id == 0) {
                    nozzle_id_str += "R | ";
                } else if (item.nozzle_pos_id >= 0x10) {
                    nozzle_id_str += wxString::Format("%d | ", (item.nozzle_pos_id & 0x0f) + 1);
                } else {
                    nozzle_id_str += "N/A | ";
                    BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << "Nozzle position id is -1 or invalid.";
                }
                nozzle_id_str += wxString::Format("%.1f mm ", item.nozzle_diameter);
                switch (item.nozzle_volume_type) {
                case NozzleVolumeType::nvtStandard:    nozzle_id_str += _L("Standard Flow"); break;
                case NozzleVolumeType::nvtHighFlow:    nozzle_id_str += _L("High Flow"); break;
                case NozzleVolumeType::nvtTPUHighFlow: nozzle_id_str += _L("TPU High Flow"); break;
                case NozzleVolumeType::nvtE3DHighFlow: nozzle_id_str += _L("E3D High Flow"); break;
                default: break;
                }
                nozzle_id_value->SetLabel(nozzle_id_str);
            }
 
            for (auto &name : preset_names) {
                int extruder_id = name.first.first;
                int tray_id     = name.first.second;
                if (item.tray_id == tray_id && item.extruder_id == extruder_id) {
                    comboBox_tray_name->SetValue(from_u8(name.second));
                }
            }
 
            comboBox_tray_name->Bind(wxEVT_COMBOBOX, [comboBox_tray_name](auto &e) {
                int  selection = comboBox_tray_name->GetSelection();
                auto history   = filtered_results[selection];
            });
        } else {
            set_edit_mode("failed", has_rack && item.extruder_id == MAIN_EXTRUDER_ID);
        }
 
        if ((m_obj->is_main_extruder_on_left() && item.extruder_id == 0)
            || (!m_obj->is_main_extruder_on_left() && item.extruder_id == 1)) {
            if (left_first_add_item) {
                wxString title_name = left_sizer->GetStaticBox()->GetLabel();
                title_name += " - ";
                title_name += get_nozzle_volume_type_name(item.nozzle_volume_type);
                left_sizer->GetStaticBox()->SetLabel(title_name);
                left_first_add_item = false;
            }
 
            left_grid_sizer->Add(tray_title, 1, wxEXPAND);
 
            if (comboBox_tray_name->IsShown()) {
                left_grid_sizer->Add(comboBox_tray_name, 1, wxEXPAND);
            } else {
                left_grid_sizer->Add(tray_name_failed, 1, wxEXPAND);
            }
 
            if (k_value->IsShown()) {
                left_grid_sizer->Add(k_value, 1, wxEXPAND);
            } else {
                left_grid_sizer->Add(k_value_failed, 1, wxEXPAND);
            }
        }
        else {
            if (right_first_add_item) {
                wxString title_name = right_sizer->GetStaticBox()->GetLabel();
                title_name += " - ";
                title_name += get_nozzle_volume_type_name(item.nozzle_volume_type);
                right_sizer->GetStaticBox()->SetLabel(title_name);
                right_first_add_item = false;
            }
            right_grid_sizer->Add(tray_title, 1, wxEXPAND);
 
            if (comboBox_tray_name->IsShown()) {
                right_grid_sizer->Add(comboBox_tray_name, 1, wxEXPAND);
            } else {
                right_grid_sizer->Add(tray_name_failed, 1, wxEXPAND);
            }
 
            if (k_value->IsShown()) {
                right_grid_sizer->Add(k_value, 1, wxEXPAND);
            } else {
                right_grid_sizer->Add(k_value_failed, 1, wxEXPAND);
            }
 
            if (has_rack) {
                if (nozzle_id_value->IsShown()) {
                    right_grid_sizer->Add(nozzle_id_value, 1, wxEXPAND);
                } else {
                    right_grid_sizer->Add(nozzle_id_failed, 1, wxEXPAND);
                }
            }
        }
    }
 
    if (left_first_add_item)
        left_sizer->Show(false);
    if (right_first_add_item)
        right_sizer->Show(false);
 
    if (part_failed) {
        m_part_failed_panel->Show();
        m_complete_text_panel->Show();
        if (m_is_all_failed) {
            m_complete_text_panel->Hide();
        }
    } else {
        m_complete_text_panel->Show();
        m_part_failed_panel->Hide();
    }
 
    wxGetApp().UpdateDarkUIWin(this);
 
    Layout();
}

References _L, Slic3r::Calib_PA_Line, CALIBRATION_SAVE_INPUT_SIZE, CALIBRATION_SAVE_NUMBER_INPUT_SIZE, DEPUTY_EXTRUDER_ID, Slic3r::Extruder, Slic3r::GUI::from_u8(), Slic3r::GUI::get_default_name(), get_extruder_color_icon(), Slic3r::GUI::get_nozzle_volume_type_name(), Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), Slic3r::GUI::get_tray_name_by_tray_id(), Label::Head_14, Slic3r::GUI::K, L, m_calib_results, m_complete_text_panel, m_history_results, m_is_all_failed, m_multi_extruder_grid_panel, m_obj, m_part_failed_panel, MAIN_EXTRUDER_ID, Slic3r::GUI::N, Slic3r::Nozzle, Slic3r::nvtE3DHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtStandard, Slic3r::nvtTPUHighFlow, Slic3r::SentenceCase, Slic3r::TitleCase, Slic3r::PACalibResult::tray_id, VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, wxButton, and wxStaticText.

Referenced by sync_cali_result().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_calib_results

std::vector<PACalibResult> Slic3r::GUI::CaliPASaveAutoPanel::m_calib_results

protected

Referenced by get_result(), save_to_result_from_widgets(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_complete_text_panel

wxPanel* Slic3r::GUI::CaliPASaveAutoPanel::m_complete_text_panel

protected

Referenced by create_panel(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_grid_panel

wxPanel* Slic3r::GUI::CaliPASaveAutoPanel::m_grid_panel { nullptr }

protected

{ nullptr };

Referenced by create_panel(), get_result(), and sync_cali_result().

m_history_results

std::vector<PACalibResult> Slic3r::GUI::CaliPASaveAutoPanel::m_history_results

protected

Referenced by sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_is_all_failed

bool Slic3r::GUI::CaliPASaveAutoPanel::m_is_all_failed { true }

protected

{ true };

Referenced by is_all_failed(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_multi_extruder_grid_panel

wxPanel* Slic3r::GUI::CaliPASaveAutoPanel::m_multi_extruder_grid_panel { nullptr }

protected

{ nullptr };

Referenced by create_panel(), get_result(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_obj

MachineObject* Slic3r::GUI::CaliPASaveAutoPanel::m_obj { nullptr }

protected

{ nullptr };

Referenced by get_result(), set_machine_obj(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_part_failed_panel

wxPanel* Slic3r::GUI::CaliPASaveAutoPanel::m_part_failed_panel

protected

Referenced by create_panel(), sync_cali_result(), and sync_cali_result_for_multi_extruder().

m_top_sizer

wxBoxSizer* Slic3r::GUI::CaliPASaveAutoPanel::m_top_sizer

protected

Referenced by CaliPASaveAutoPanel(), and create_panel().

---

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

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