3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-08 23:46:24 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

NEW: rearch calibration

Browse source 
Change-Id: I20ee304eba1a63e08d0a36abdf06ebe6a6e4451f
Signed-off-by: Stone Li <stone.li@bambulab.com>
This commit is contained in:
Stone Li 2023-07-03 21:48:19 +08:00 • committed by Lane.Wei
parent ced9e43be6
commit 2368d929fe
44 changed files with 7710 additions and 5851 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
resources/images/cali_page_after_flow.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
resources/images/cali_page_after_pa.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3.1 KiB

BIN
resources/images/cali_page_before_flow.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2.8 KiB

BIN
resources/images/cali_page_before_pa.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3.2 KiB

4
resources/images/cali_page_caption_help.svg Normal file
View file

@ -0,0 +1,4 @@
<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
<rect width="48" height="48" rx="24" fill="#D9D9D9"/>
<path d="M18.96 19.68C19.2933 18.7067 19.86 17.9533 20.66 17.42C21.4733 16.8733 22.4067 16.6 23.46 16.6C24.2467 16.6 24.94 16.7533 25.54 17.06C26.14 17.3533 26.6067 17.7667 26.94 18.3C27.2733 18.82 27.44 19.4067 27.44 20.06C27.44 20.7267 27.28 21.2867 26.96 21.74C26.6533 22.18 26.1867 22.6733 25.56 23.22C25.12 23.6333 24.7667 23.9867 24.5 24.28C24.2333 24.5733 24.0067 24.9267 23.82 25.34C23.6467 25.74 23.56 26.2067 23.56 26.74C23.56 27.1133 23.6067 27.4933 23.7 27.88H22.32C22.1467 27.28 22.06 26.7267 22.06 26.22C22.06 25.6733 22.1467 25.1933 22.32 24.78C22.5067 24.3533 22.7267 24 22.98 23.72C23.2333 23.4267 23.5733 23.08 24 22.68C24.52 22.2133 24.9067 21.8067 25.16 21.46C25.4133 21.1 25.54 20.68 25.54 20.2C25.54 19.6 25.3333 19.12 24.92 18.76C24.5067 18.4 23.9667 18.22 23.3 18.22C21.94 18.22 20.9533 18.9733 20.34 20.48L18.96 19.68ZM23.18 32.22C22.8733 32.22 22.6067 32.1067 22.38 31.88C22.1667 31.6533 22.06 31.3867 22.06 31.08C22.06 30.76 22.1667 30.4867 22.38 30.26C22.6067 30.0333 22.8733 29.92 23.18 29.92C23.5 29.92 23.7667 30.0333 23.98 30.26C24.2067 30.4867 24.32 30.76 24.32 31.08C24.32 31.3867 24.2067 31.6533 23.98 31.88C23.7667 32.1067 23.5 32.22 23.18 32.22Z" fill="black"/>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 1.3 KiB

4
resources/images/cali_page_caption_help_hover.svg Normal file
View file

@ -0,0 +1,4 @@
<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
<rect width="48" height="48" rx="24" fill="#D9D9D9"/>
<path d="M18.96 19.68C19.2933 18.7067 19.86 17.9533 20.66 17.42C21.4733 16.8733 22.4067 16.6 23.46 16.6C24.2467 16.6 24.94 16.7533 25.54 17.06C26.14 17.3533 26.6067 17.7667 26.94 18.3C27.2733 18.82 27.44 19.4067 27.44 20.06C27.44 20.7267 27.28 21.2867 26.96 21.74C26.6533 22.18 26.1867 22.6733 25.56 23.22C25.12 23.6333 24.7667 23.9867 24.5 24.28C24.2333 24.5733 24.0067 24.9267 23.82 25.34C23.6467 25.74 23.56 26.2067 23.56 26.74C23.56 27.1133 23.6067 27.4933 23.7 27.88H22.32C22.1467 27.28 22.06 26.7267 22.06 26.22C22.06 25.6733 22.1467 25.1933 22.32 24.78C22.5067 24.3533 22.7267 24 22.98 23.72C23.2333 23.4267 23.5733 23.08 24 22.68C24.52 22.2133 24.9067 21.8067 25.16 21.46C25.4133 21.1 25.54 20.68 25.54 20.2C25.54 19.6 25.3333 19.12 24.92 18.76C24.5067 18.4 23.9667 18.22 23.3 18.22C21.94 18.22 20.9533 18.9733 20.34 20.48L18.96 19.68ZM23.18 32.22C22.8733 32.22 22.6067 32.1067 22.38 31.88C22.1667 31.6533 22.06 31.3867 22.06 31.08C22.06 30.76 22.1667 30.4867 22.38 30.26C22.6067 30.0333 22.8733 29.92 23.18 29.92C23.5 29.92 23.7667 30.0333 23.98 30.26C24.2067 30.4867 24.32 30.76 24.32 31.08C24.32 31.3867 24.2067 31.6533 23.98 31.88C23.7667 32.1067 23.5 32.22 23.18 32.22Z" fill="black"/>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 1.3 KiB

3
resources/images/cali_page_caption_prev.svg Normal file
View file

@ -0,0 +1,3 @@
<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M4.58579 18.5858C3.80474 19.3668 3.80474 20.6332 4.58579 21.4142L17.3137 34.1421C18.0948 34.9232 19.3611 34.9232 20.1421 34.1421C20.9232 33.3611 20.9232 32.0948 20.1421 31.3137L8.82843 20L20.1421 8.68629C20.9232 7.90524 20.9232 6.63891 20.1421 5.85786C19.3611 5.07682 18.0948 5.07682 17.3137 5.85786L4.58579 18.5858ZM34.5 18H6V22H34.5V18Z" fill="black"/>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 467 B

3
resources/images/cali_page_caption_prev_hover.svg Normal file
View file

@ -0,0 +1,3 @@
<svg width="40" height="40" viewBox="0 0 40 40" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M4.58579 18.5858C3.80474 19.3668 3.80474 20.6332 4.58579 21.4142L17.3137 34.1421C18.0948 34.9232 19.3611 34.9232 20.1421 34.1421C20.9232 33.3611 20.9232 32.0948 20.1421 31.3137L8.82843 20L20.1421 8.68629C20.9232 7.90524 20.9232 6.63891 20.1421 5.85786C19.3611 5.07682 18.0948 5.07682 17.3137 5.85786L4.58579 18.5858ZM34.5 18H6V22H34.5V18Z" fill="black"/>
</svg>
Side by side

After

Width:  |  Height:  |  Size: 467 B

5
src/libslic3r/Calib.hpp
View file

@ -32,11 +32,8 @@ struct PrinterCaliInfo
std::string dev_id;
CalibMode mode;
CalibState state;
//std::string filament_preset;
//std::vector<int> tray_ids;
/* tray index -> filament preset name */
std::map<int, std::string> filament_presets;
//float nozzle_dia;
//int bed_type;
};
struct Calib_Params

12
src/slic3r/CMakeLists.txt
View file

@ -392,14 +392,22 @@ set(SLIC3R_GUI_SOURCES
GUI/ReleaseNote.cpp
GUI/SingleChoiceDialog.hpp
GUI/SingleChoiceDialog.cpp
GUI/CaliHistoryDialog.hpp
GUI/CaliHistoryDialog.cpp
GUI/CalibrationPanel.hpp
GUI/CalibrationPanel.cpp
GUI/CalibrationWizard.hpp
GUI/CalibrationWizard.cpp
GUI/EditCalibrationHistoryDialog.cpp
GUI/EditCalibrationHistoryDialog.hpp
GUI/CalibrationWizardPage.cpp
GUI/CalibrationWizardPage.hpp
GUI/CalibrationWizardStartPage.cpp
GUI/CalibrationWizardStartPage.hpp
GUI/CalibrationWizardPresetPage.cpp
GUI/CalibrationWizardPresetPage.hpp
GUI/CalibrationWizardCaliPage.cpp
GUI/CalibrationWizardCaliPage.hpp
GUI/CalibrationWizardSavePage.cpp
GUI/CalibrationWizardSavePage.hpp
GUI/calib_dlg.cpp
GUI/calib_dlg.hpp
GUI/Calibration.hpp

421
src/slic3r/GUI/CaliHistoryDialog.cpp Normal file
View file

@ -0,0 +1,421 @@
#include "CaliHistoryDialog.hpp"
#include "I18N.hpp"
#include "libslic3r/Utils.hpp"
#include "GUI.hpp"
#include "GUI_App.hpp"
#include "format.hpp"
#include "MsgDialog.hpp"
#include "slic3r/Utils/CalibUtils.hpp"
namespace Slic3r {
namespace GUI {
#define HISTORY_WINDOW_SIZE wxSize(FromDIP(600), FromDIP(450))
#define EDIT_HISTORY_DIALOG_INPUT_SIZE wxSize(FromDIP(160), FromDIP(24))
#define HISTORY_WINDOW_ITEMS_COUNT 4
HistoryWindow::HistoryWindow(wxWindow* parent, const std::vector<PACalibResult>& calib_results_history)
: DPIDialog(parent, wxID_ANY, _L("Pressure Advance Calibration Result"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE)
, m_calib_results_history(calib_results_history)
{
this->SetBackgroundColour(*wxWHITE);
auto main_sizer = new wxBoxSizer(wxVERTICAL);
auto scroll_window = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHSCROLL | wxVSCROLL);
scroll_window->SetScrollRate(5, 5);
scroll_window->SetBackgroundColour(*wxWHITE);
auto scroll_sizer = new wxBoxSizer(wxVERTICAL);
scroll_window->SetSizer(scroll_sizer);
wxPanel* comboBox_panel = new wxPanel(scroll_window);
comboBox_panel->SetBackgroundColour(wxColour(238, 238, 238));
auto comboBox_sizer = new wxBoxSizer(wxVERTICAL);
comboBox_panel->SetSizer(comboBox_sizer);
comboBox_sizer->AddSpacer(10);
auto nozzle_dia_title = new wxStaticText(comboBox_panel, wxID_ANY, _L("Nozzle Diameter"));
nozzle_dia_title->SetFont(Label::Head_14);
comboBox_sizer->Add(nozzle_dia_title, 0, wxLEFT | wxRIGHT, FromDIP(15));
comboBox_sizer->AddSpacer(10);
m_comboBox_nozzle_dia = new ComboBox(comboBox_panel, wxID_ANY, "", wxDefaultPosition, wxSize(FromDIP(500), FromDIP(24)), 0, nullptr, wxCB_READONLY);
comboBox_sizer->Add(m_comboBox_nozzle_dia, 0, wxLEFT | wxRIGHT, FromDIP(15));
comboBox_sizer->AddSpacer(10);
scroll_sizer->Add(comboBox_panel);
scroll_sizer->AddSpacer(FromDIP(15));
wxPanel* tips_panel = new wxPanel(scroll_window, wxID_ANY);
auto tips_sizer = new wxBoxSizer(wxVERTICAL);
tips_panel->SetSizer(tips_sizer);
m_tips = new wxStaticText(tips_panel, wxID_ANY, "");
m_tips->SetForegroundColour({ 145, 145, 145 });
tips_sizer->Add(m_tips, 0, wxEXPAND);
scroll_sizer->Add(tips_panel, 0, wxEXPAND);
scroll_sizer->AddSpacer(FromDIP(15));
m_history_data_panel = new wxPanel(scroll_window);
scroll_sizer->Add(m_history_data_panel, 1, wxEXPAND);
main_sizer->Add(scroll_window, 1, wxEXPAND | wxALL, FromDIP(10));
SetSizer(main_sizer);
main_sizer->Fit(this);
SetMinSize(HISTORY_WINDOW_SIZE);
SetSize(HISTORY_WINDOW_SIZE);
CenterOnParent();
wxGetApp().UpdateDlgDarkUI(this);
m_comboBox_nozzle_dia->Bind(wxEVT_COMBOBOX, &HistoryWindow::on_select_nozzle, this);
m_refresh_timer = new wxTimer();
m_refresh_timer->SetOwner(this);
m_refresh_timer->Start(200);
Bind(wxEVT_TIMER, &HistoryWindow::on_timer, this);
}
HistoryWindow::~HistoryWindow()
{
m_refresh_timer->Stop();
}
void HistoryWindow::sync_history_result(MachineObject* obj)
{
BOOST_LOG_TRIVIAL(info) << "sync_history_result";
m_calib_results_history.clear();
if (obj)
m_calib_results_history = obj->pa_calib_tab;
if (m_calib_results_history.empty()) {
// for test
/*
std::vector<PACalibResult> temp_test;
PACalibResult test{ 0, 0, 0.0f, "test", "test", "test_name", 0.1f, 0.5f };
temp_test.push_back(test);
test.tray_id = 1;
temp_test.push_back(test);
test.tray_id = 2;
temp_test.push_back(test);
test.tray_id = 3;
temp_test.push_back(test);
m_calib_results_history = temp_test;
*/
}
sync_history_data();
if (m_calib_results_history.empty()) {
m_tips->SetLabel(_L("No History Result"));
}
else {
m_tips->SetLabel("Success to get history result");
}
m_tips->Refresh();
}
void HistoryWindow::on_device_connected(MachineObject* obj)
{
if (!obj) {
return;
}
curr_obj = obj;
// init nozzle value
static std::array<float, 4> nozzle_diameter_list = { 0.2f, 0.4f, 0.6f, 0.8f };
int selection = 1;
for (int i = 0; i < nozzle_diameter_list.size(); i++) {
m_comboBox_nozzle_dia->AppendString(wxString::Format("%1.1f mm", nozzle_diameter_list[i]));
if (abs(curr_obj->nozzle_diameter - nozzle_diameter_list[i]) < 1e-3) {
selection = i;
}
}
m_comboBox_nozzle_dia->SetSelection(selection);
// trigger on_select nozzle
wxCommandEvent evt(wxEVT_COMBOBOX);
evt.SetEventObject(m_comboBox_nozzle_dia);
wxPostEvent(m_comboBox_nozzle_dia, evt);
}
void HistoryWindow::on_timer(wxTimerEvent& event)
{
update(curr_obj);
}
void HistoryWindow::update(MachineObject* obj)
{
if (!obj) return;
if (obj->cali_version != history_version) {
if (obj->has_get_pa_calib_tab) {
history_version = obj->cali_version;
reqeust_history_result(obj);
}
}
// sync when history is not empty
if (obj->has_get_pa_calib_tab && m_calib_results_history.empty()) {
sync_history_result(curr_obj);
}
}
void HistoryWindow::on_select_nozzle(wxCommandEvent& evt)
{
reqeust_history_result(curr_obj);
}
void HistoryWindow::reqeust_history_result(MachineObject* obj)
{
if (curr_obj) {
curr_obj->reset_pa_cali_history_result();
sync_history_result(curr_obj);
float nozzle_value = get_nozzle_value();
if (nozzle_value > 0) {
CalibUtils::emit_get_PA_calib_infos(nozzle_value);
m_tips->SetLabel("Refreshing the historical pressure advance records");
BOOST_LOG_TRIVIAL(info) << "request calib history";
}
}
}
void HistoryWindow::sync_history_data() {
m_history_data_panel->DestroyChildren();
wxGridBagSizer* gbSizer;
gbSizer = new wxGridBagSizer(FromDIP(0), FromDIP(80));
gbSizer->SetFlexibleDirection(wxBOTH);
gbSizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
m_history_data_panel->SetSizer(gbSizer, true);
auto title_material = new wxStaticText(m_history_data_panel, wxID_ANY, _L("Material"));
title_material->SetFont(Label::Head_14);
gbSizer->Add(title_material, { 0, 0 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
auto title_k = new wxStaticText(m_history_data_panel, wxID_ANY, _L("K"));
title_k->SetFont(Label::Head_14);
gbSizer->Add(title_k, { 0, 1 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
// Hide
//auto title_n = new wxStaticText(m_history_data_panel, wxID_ANY, _L("N"));
//title_n->SetFont(Label::Head_14);
//gbSizer->Add(title_n, { 0, 2 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
auto title_action = new wxStaticText(m_history_data_panel, wxID_ANY, _L("Action"));
title_action->SetFont(Label::Head_14);
gbSizer->Add(title_action, { 0, 2 }, { 1, 1 });
int i = 1;
for (auto& result : m_calib_results_history) {
wxString material_name = "";
material_name = result.name;
auto material_name_value = new wxStaticText(m_history_data_panel, wxID_ANY, material_name);
auto k_str = wxString::Format("%.3f", result.k_value);
auto n_str = wxString::Format("%.3f", result.n_coef);
auto k_value = new wxStaticText(m_history_data_panel, wxID_ANY, k_str);
auto n_value = new wxStaticText(m_history_data_panel, wxID_ANY, n_str);
n_value->Hide();
auto delete_button = new Button(m_history_data_panel, _L("Delete"));
delete_button->SetBackgroundColour(*wxWHITE);
delete_button->SetMinSize(wxSize(-1, FromDIP(24)));
delete_button->SetCornerRadius(FromDIP(12));
delete_button->Bind(wxEVT_BUTTON, [this, gbSizer, i, &result](auto& e) {
for (int j = 0; j < HISTORY_WINDOW_ITEMS_COUNT; j++) {
auto item = gbSizer->FindItemAtPosition({ i, j });
item->GetWindow()->Hide();
}
gbSizer->SetEmptyCellSize({ 0,0 });
m_history_data_panel->Layout();
m_history_data_panel->Fit();
CalibUtils::delete_PA_calib_result({ result.tray_id, result.cali_idx, result.nozzle_diameter, result.filament_id });
});
auto edit_button = new Button(m_history_data_panel, _L("Edit"));
StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(27, 136, 68), StateColor::Pressed),
std::pair<wxColour, int>(wxColour(61, 203, 115), StateColor::Hovered),
std::pair<wxColour, int>(wxColour(0, 174, 66), StateColor::Normal));
edit_button->SetBackgroundColour(*wxWHITE);
edit_button->SetBackgroundColor(btn_bg_green);
edit_button->SetBorderColor(wxColour(0, 174, 66));
edit_button->SetTextColor(wxColour("#FFFFFE"));
edit_button->SetMinSize(wxSize(-1, FromDIP(24)));
edit_button->SetCornerRadius(FromDIP(12));
edit_button->Bind(wxEVT_BUTTON, [this, &result, k_value, material_name_value](auto& e) {
PACalibResult result_buffer = result;
result_buffer.k_value = stof(k_value->GetLabel().ToStdString());
result_buffer.name = material_name_value->GetLabel().ToStdString();
EditCalibrationHistoryDialog dlg(this, result_buffer);
if (dlg.ShowModal() == wxID_OK) {
auto new_result = dlg.get_result();
wxString new_k_str = wxString::Format("%.3f", new_result.k_value);
k_value->SetLabel(new_k_str);
material_name_value->SetLabel(new_result.name);
new_result.tray_id = -1;
CalibUtils::set_PA_calib_result({ new_result });
// TODO Re-request history and refresh page
//wxCommandEvent evt(wxEVT_COMBOBOX);
//evt.SetEventObject(m_comboBox_nozzle_dia);
//wxPostEvent(m_comboBox_nozzle_dia, evt);
}
});
gbSizer->Add(material_name_value, { i, 0 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
gbSizer->Add(k_value, { i, 1 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
//gbSizer->Add(n_value, { i, 2 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
gbSizer->Add(delete_button, { i, 2 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
gbSizer->Add(edit_button, { i, 3 }, { 1, 1 }, wxBOTTOM, FromDIP(15));
i++;
}
Layout();
}
float HistoryWindow::get_nozzle_value()
{
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;
}
EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(wxWindow* parent, const PACalibResult& result)
: DPIDialog(parent, wxID_ANY, _L("Edit Pressure Advance"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE)
, m_new_result(result)
{
this->SetBackgroundColour(*wxWHITE);
auto main_sizer = new wxBoxSizer(wxVERTICAL);
auto top_panel = new wxPanel(this);
auto panel_sizer = new wxBoxSizer(wxVERTICAL);
top_panel->SetSizer(panel_sizer);
auto flex_sizer = new wxFlexGridSizer(0, 2, FromDIP(15), FromDIP(30));
flex_sizer->SetFlexibleDirection(wxBOTH);
flex_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
wxStaticText* material_name_title = new wxStaticText(top_panel, wxID_ANY, _L("Material"));
TextInput* material_name_value = new TextInput(top_panel, m_new_result.name, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
material_name_value->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [this, material_name_value](auto& e) {
if (!material_name_value->GetTextCtrl()->GetValue().IsEmpty())
m_new_result.name = material_name_value->GetTextCtrl()->GetValue().ToStdString();
});
material_name_value->GetTextCtrl()->Bind(wxEVT_KILL_FOCUS, [this, material_name_value](auto& e) {
if (!material_name_value->GetTextCtrl()->GetValue().IsEmpty())
m_new_result.name = material_name_value->GetTextCtrl()->GetValue().ToStdString();
e.Skip();
});
flex_sizer->Add(material_name_title);
flex_sizer->Add(material_name_value);
wxStaticText* k_title = new wxStaticText(top_panel, wxID_ANY, _L("K Factor"));
auto k_str = wxString::Format("%.3f", m_new_result.k_value);
TextInput* k_value = new TextInput(top_panel, k_str, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
k_value->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [this, k_value](auto& e) {
float k = 0.0f;
if (!CalibUtils::validate_input_k_value(k_value->GetTextCtrl()->GetValue(), &k)) {
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (K in 0~0.5)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
}
wxString k_str = wxString::Format("%.3f", k);
k_value->GetTextCtrl()->SetValue(k_str);
m_new_result.k_value = k;
});
k_value->GetTextCtrl()->Bind(wxEVT_KILL_FOCUS, [this, k_value](auto& e) {
float k = 0.0f;
if (!CalibUtils::validate_input_k_value(k_value->GetTextCtrl()->GetValue(), &k)) {
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (K in 0~0.5)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
}
wxString k_str = wxString::Format("%.3f", k);
k_value->GetTextCtrl()->SetValue(k_str);
m_new_result.k_value = k;
e.Skip();
});
flex_sizer->Add(k_title);
flex_sizer->Add(k_value);
// Hide:
//wxStaticText* n_title = new wxStaticText(top_panel, wxID_ANY, _L("N Factor"));
//TextInput* n_value = new TextInput(top_panel, n, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
//flex_sizer->Add(n_title);
//flex_sizer->Add(n_value);
panel_sizer->Add(flex_sizer);
panel_sizer->AddSpacer(FromDIP(25));
auto btn_sizer = new wxBoxSizer(wxHORIZONTAL);
Button* save_btn = new Button(top_panel, _L("Save"));
StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(27, 136, 68), StateColor::Pressed),
std::pair<wxColour, int>(wxColour(61, 203, 115), StateColor::Hovered),
std::pair<wxColour, int>(wxColour(0, 174, 66), StateColor::Normal));
save_btn->SetBackgroundColour(*wxWHITE);
save_btn->SetBackgroundColor(btn_bg_green);
save_btn->SetBorderColor(wxColour(0, 174, 66));
save_btn->SetTextColor(wxColour("#FFFFFE"));
save_btn->SetMinSize(wxSize(-1, FromDIP(24)));
save_btn->SetCornerRadius(FromDIP(12));
Button* cancel_btn = new Button(top_panel, _L("Cancel"));
cancel_btn->SetBackgroundColour(*wxWHITE);
cancel_btn->SetMinSize(wxSize(-1, FromDIP(24)));
cancel_btn->SetCornerRadius(FromDIP(12));
save_btn->Bind(wxEVT_BUTTON, &EditCalibrationHistoryDialog::on_save, this);
cancel_btn->Bind(wxEVT_BUTTON, &EditCalibrationHistoryDialog::on_cancel, this);
btn_sizer->AddStretchSpacer();
btn_sizer->Add(save_btn);
btn_sizer->AddSpacer(FromDIP(20));
btn_sizer->Add(cancel_btn);
panel_sizer->Add(btn_sizer, 0, wxEXPAND, 0);
main_sizer->Add(top_panel, 1, wxEXPAND | wxALL, FromDIP(20));
SetSizer(main_sizer);
Layout();
Fit();
CenterOnParent();
wxGetApp().UpdateDlgDarkUI(this);
}
EditCalibrationHistoryDialog::~EditCalibrationHistoryDialog() {
}
PACalibResult EditCalibrationHistoryDialog::get_result() {
return m_new_result;
}
void EditCalibrationHistoryDialog::on_save(wxCommandEvent& event) {
EndModal(wxID_OK);
}
void EditCalibrationHistoryDialog::on_cancel(wxCommandEvent& event) {
EndModal(wxID_CANCEL);
}
void EditCalibrationHistoryDialog::on_dpi_changed(const wxRect& suggested_rect)
{
}
} // namespace GUI
} // namespace Slic3r

57
src/slic3r/GUI/CaliHistoryDialog.hpp Normal file
View file

@ -0,0 +1,57 @@
#ifndef slic3r_GUI_CaliHistory_hpp_
#define slic3r_GUI_CaliHistory_hpp_
#include "GUI_Utils.hpp"
#include "wxExtensions.hpp"
#include "Widgets/ComboBox.hpp"
#include "DeviceManager.hpp"
namespace Slic3r {
namespace GUI {
class HistoryWindow : public DPIDialog {
public:
HistoryWindow(wxWindow* parent, const std::vector<PACalibResult>& calib_results_history);
~HistoryWindow();
void on_dpi_changed(const wxRect& suggested_rect) {}
void on_select_nozzle(wxCommandEvent& evt);
void reqeust_history_result(MachineObject* obj);
void sync_history_result(MachineObject* obj);
void on_device_connected(MachineObject* obj);
void on_timer(wxTimerEvent& event);
void update(MachineObject* obj);
protected:
void sync_history_data();
float get_nozzle_value();
wxPanel* m_history_data_panel;
ComboBox* m_comboBox_nozzle_dia;
wxStaticText* m_tips;
wxTimer* m_refresh_timer { nullptr };
std::vector<PACalibResult> m_calib_results_history;
MachineObject* curr_obj { nullptr };
int history_version = -1;
};
class EditCalibrationHistoryDialog : public DPIDialog
{
public:
EditCalibrationHistoryDialog(wxWindow* parent, const PACalibResult& result);
~EditCalibrationHistoryDialog();
void on_dpi_changed(const wxRect& suggested_rect) override;
PACalibResult get_result();
protected:
virtual void on_save(wxCommandEvent& event);
virtual void on_cancel(wxCommandEvent& event);
protected:
PACalibResult m_new_result;
};
} // namespace GUI
} // namespace Slic3r
#endif

163
src/slic3r/GUI/CalibrationPanel.cpp
View file

@ -459,20 +459,19 @@ CalibrationPanel::CalibrationPanel(wxWindow* parent, wxWindowID id, const wxPoin
void CalibrationPanel::init_tabpanel() {
m_side_tools = new SideTools(this, wxID_ANY);
m_side_tools->Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(CalibrationPanel::on_printer_clicked), NULL, this);
m_side_tools->get_panel()->Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(CalibrationPanel::on_printer_clicked), NULL, this);
wxBoxSizer* sizer_side_tools = new wxBoxSizer(wxVERTICAL);
sizer_side_tools->Add(m_side_tools, 1, wxEXPAND, 0);
m_tabpanel = new Tabbook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, sizer_side_tools, wxNB_LEFT | wxTAB_TRAVERSAL | wxNB_NOPAGETHEME);
m_side_tools->set_table_panel(m_tabpanel);
m_tabpanel->SetBackgroundColour(*wxWHITE);
m_cali_panels[0] = new PressureAdvanceWizard(m_tabpanel);
m_cali_panels[1] = new FlowRateWizard(m_tabpanel);
m_cali_panels[2] = new MaxVolumetricSpeedWizard(m_tabpanel);
//m_cali_panels[3] = new TemperatureWizard(m_tabpanel);
//m_cali_panels[4] = new RetractionWizard(m_tabpanel);
for (int i = 0; i < (int)CALI_MODE_COUNT; i++) {
bool selected = false;
@ -487,11 +486,7 @@ void CalibrationPanel::init_tabpanel() {
for (int i = 0; i < (int)CALI_MODE_COUNT; i++)
m_tabpanel->SetPageImage(i, "");
m_tabpanel->Bind(wxEVT_BOOKCTRL_PAGE_CHANGED, [this](wxBookCtrlEvent&) {
wxCommandEvent e (EVT_CALIBRATION_TAB_CHANGED);
e.SetEventObject(m_tabpanel->GetCurrentPage());
wxPostEvent(m_tabpanel->GetCurrentPage(), e);
}, m_tabpanel->GetId());
m_initialized = true;
}
void CalibrationPanel::init_timer()
@ -507,60 +502,137 @@ void CalibrationPanel::on_timer(wxTimerEvent& event) {
}
void CalibrationPanel::update_print_error_info(int code, std::string msg, std::string extra) {
for (int i = 0; i < m_tabpanel->GetPageCount(); i++) {
if(m_tabpanel->GetPage(i))
static_cast<CalibrationWizard*>(m_tabpanel->GetPage(i))->update_print_error_info(code, msg, extra);
// update current wizard only
int curr_selected = m_tabpanel->GetSelection();
if (curr_selected >= 0 && curr_selected < CALI_MODE_COUNT) {
if (m_cali_panels[curr_selected]) {
auto page = m_cali_panels[curr_selected]->get_curr_step()->page;
if(page && page->get_page_type() == CaliPageType::CALI_PAGE_PRESET){
auto preset_page = static_cast<CalibrationPresetPage*>(page);
if (preset_page->get_page_status() == CaliPresetPageStatus::CaliPresetStatusSending)
preset_page->update_print_error_info(code, msg, extra);
}
}
}
}
void CalibrationPanel::update_all() {
for (int i = 0; i < (int)CALI_MODE_COUNT; i++) {
m_cali_panels[i]->update_printer();
if (m_cali_panels[i]->IsShown())
m_cali_panels[i]->update_print_progress();
}
NetworkAgent* m_agent = wxGetApp().getAgent();
Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev)
return;
MachineObject* obj = dev->get_selected_machine();
if (!dev) return;
obj = dev->get_selected_machine();
if (!obj) {
m_side_tools->set_none_printer_mode();
// update current wizard only
int curr_selected = m_tabpanel->GetSelection();
if (curr_selected >= 0 && curr_selected < CALI_MODE_COUNT) {
if (m_cali_panels[curr_selected])
m_cali_panels[curr_selected]->update(obj);
}
// check valid machine
if (obj && dev->get_my_machine(obj->dev_id) == nullptr) {
dev->set_selected_machine("");
if (m_agent)
m_agent->set_user_selected_machine("");
show_status((int)MONITOR_NO_PRINTER);
return;
}
/* Update Device Info */
m_side_tools->set_current_printer_name(obj->dev_name);
// update wifi signal image
int wifi_signal_val = 0;
if (!obj->is_connected() || obj->is_connecting()) {
m_side_tools->set_current_printer_signal(WifiSignal::NONE);
}
else {
if (!obj->wifi_signal.empty() && boost::ends_with(obj->wifi_signal, "dBm")) {
if (wxGetApp().is_user_login()) {
dev->check_pushing();
try {
wifi_signal_val = std::stoi(obj->wifi_signal.substr(0, obj->wifi_signal.size() - 3));
m_agent->refresh_connection();
}
catch (...) {
;
}
if (wifi_signal_val > -45) {
m_side_tools->set_current_printer_signal(WifiSignal::STRONG);
}
else if (wifi_signal_val <= -45 && wifi_signal_val >= -60) {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::WEAK);
if (obj) {
wxGetApp().reset_to_active();
if (obj->connection_type() != last_conn_type) {
last_conn_type = obj->connection_type();
}
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
m_side_tools->update_status(obj);
if (!obj) {
show_status((int)MONITOR_NO_PRINTER);
return;
}
if (obj->is_connecting()) {
show_status(MONITOR_CONNECTING);
return;
}
else if (!obj->is_connected()) {
int server_status = 0;
// only disconnected server in cloud mode
if (obj->connection_type() != "lan") {
if (m_agent) {
server_status = m_agent->is_server_connected() ? 0 : (int)MONITOR_DISCONNECTED_SERVER;
}
}
show_status((int)MONITOR_DISCONNECTED + server_status);
return;
}
show_status(MONITOR_NORMAL);
}
void CalibrationPanel::show_status(int status)
{
if (!m_initialized) return;
if (last_status == status)return;
if (last_status & (int)MonitorStatus::MONITOR_CONNECTING != 0) {
NetworkAgent* agent = wxGetApp().getAgent();
json j;
j["dev_id"] = obj ? obj->dev_id : "obj_nullptr";
if (status & (int)MonitorStatus::MONITOR_DISCONNECTED != 0) {
j["result"] = "failed";
if (agent) {
agent->track_event("connect_dev", j.dump());
}
}
else if (status & (int)MonitorStatus::MONITOR_NORMAL != 0) {
j["result"] = "success";
if (agent) {
agent->track_event("connect_dev", j.dump());
}
}
}
last_status = status;
BOOST_LOG_TRIVIAL(info) << "monitor: show_status = " << status;
Freeze();
// update panels
if (m_side_tools) { m_side_tools->show_status(status); };
if ((status & (int)MonitorStatus::MONITOR_NO_PRINTER) != 0) {
set_default();
m_tabpanel->Layout();
}
else if (((status & (int)MonitorStatus::MONITOR_NORMAL) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0))
{
if (((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0))
{
set_default();
}
m_tabpanel->Layout();
}
Layout();
Thaw();
}
bool CalibrationPanel::Show(bool show) {
@ -596,8 +668,15 @@ void CalibrationPanel::on_printer_clicked(wxMouseEvent& event)
}
}
void CalibrationPanel::set_default()
{
obj = nullptr;
last_conn_type = "undefined";
wxGetApp().sidebar().load_ams_list({}, {});
}
CalibrationPanel::~CalibrationPanel() {
m_side_tools->Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler(CalibrationPanel::on_printer_clicked), NULL, this);
m_side_tools->get_panel()->Disconnect(wxEVT_LEFT_DOWN, wxMouseEventHandler(CalibrationPanel::on_printer_clicked), NULL, this);
if (m_refresh_timer)
m_refresh_timer->Stop();
delete m_refresh_timer;

10
src/slic3r/GUI/CalibrationPanel.hpp
View file

@ -107,20 +107,24 @@ public:
Tabbook* get_tabpanel() { return m_tabpanel; };
void update_print_error_info(int code, std::string msg, std::string extra);
void update_all();
void show_status(int status);
bool Show(bool show);
void on_printer_clicked(wxMouseEvent& event);
void set_default();
protected:
void init_tabpanel();
void init_timer();
void on_timer(wxTimerEvent& event);
private:
int last_status;
bool m_initialized { false };
std::string last_conn_type = "undedefined";
MachineObject* obj{ nullptr };
SideTools* m_side_tools{ nullptr };
Tabbook* m_tabpanel{ nullptr };
SelectMObjectPopup m_mobjectlist_popup;
CalibrationWizard* m_cali_panels[CALI_MODE_COUNT];
wxTimer* m_refresh_timer = nullptr;
};
}} // namespace Slic3r::GUI

4733
src/slic3r/GUI/CalibrationWizard.cpp
View file

File diff suppressed because it is too large Load diff

470
src/slic3r/GUI/CalibrationWizard.hpp
View file

@ -1,444 +1,164 @@
#ifndef slic3r_GUI_CalibrationWizard_hpp_
#define slic3r_GUI_CalibrationWizard_hpp_
#include "../slic3r/Utils/CalibUtils.hpp"
#include "DeviceManager.hpp"
#include "CalibrationWizardPage.hpp"
#include "Widgets/ComboBox.hpp"
#include "Widgets/TextInput.hpp"
#include "Widgets/AMSControl.hpp"
#include "Widgets/ProgressBar.hpp"
#include "SavePresetDialog.hpp"
#include "PresetComboBoxes.hpp"
#include "EditCalibrationHistoryDialog.hpp"
#include "../slic3r/Utils/CalibUtils.hpp"
#include "CalibrationWizardStartPage.hpp"
#include "CalibrationWizardPresetPage.hpp"
#include "CalibrationWizardCaliPage.hpp"
#include "CalibrationWizardSavePage.hpp"
namespace Slic3r { namespace GUI {
wxDECLARE_EVENT(EVT_CALIBRATION_TRAY_SELECTION_CHANGED, SimpleEvent);
wxDECLARE_EVENT(EVT_CALIBRATION_NOTIFY_CHANGE_PAGES, SimpleEvent);
wxDECLARE_EVENT(EVT_CALIBRATION_TAB_CHANGED, wxCommandEvent);
enum FilamentSelectMode {
FSMCheckBoxMode,
FSMRadioMode
};
wxString get_calibration_wiki_page(CalibMode cali_mode);
class FilamentComboBox : public wxPanel
class CalibrationWizardPageStep
{
public:
FilamentComboBox(wxWindow* parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize);
~FilamentComboBox() {};
CalibrationWizardPageStep(CalibrationWizardPage* data) {
page = data;
}
void set_select_mode(FilamentSelectMode mode);
FilamentSelectMode get_select_mode() { return m_mode; }
void load_tray_from_ams(int id, DynamicPrintConfig& tray);
void update_from_preset();
int get_tray_id() { return m_tray_id; }
bool is_bbl_filament() { return m_is_bbl_filamnet; }
std::string get_tray_name() { return m_tray_name; }
CalibrateFilamentComboBox* GetComboBox() { return m_comboBox; }
CheckBox* GetCheckBox() { return m_checkBox; }
void SetCheckBox(CheckBox* cb) { m_checkBox = cb; }
wxRadioButton* GetRadioBox() { return m_radioBox; }
void SetRadioBox(wxRadioButton* btn) { m_radioBox = btn; }
virtual bool Show(bool show = true);
virtual bool Enable(bool enable);
virtual void SetValue(bool value, bool send_event = true);
protected:
int m_tray_id;
std::string m_tray_name;
bool m_is_bbl_filamnet{ false };
CheckBox* m_checkBox{nullptr};
//RadioBox* m_radioBox;
wxRadioButton* m_radioBox{ nullptr };
CalibrateFilamentComboBox* m_comboBox{ nullptr };
FilamentSelectMode m_mode{ FSMRadioMode };
CalibrationWizardPageStep* prev { nullptr };
CalibrationWizardPageStep* next { nullptr };
CalibrationWizardPage* page { nullptr };
void chain(CalibrationWizardPageStep* step) {
if (!step) return;
this->next = step;
step->prev = this;
}
};
typedef std::vector<FilamentComboBox*> FilamentComboBoxList;
class CalibrationWizard : public wxPanel {
public:
CalibrationWizard(wxWindow* parent, CalibMode mode, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~CalibrationWizard() {};
CalibrationWizardPage* get_curr_page() { return m_curr_page; }
CalibrationWizardPage* get_frist_page() { return m_first_page; }
void show_page(CalibrationWizardPage* page);
void update_print_error_info(int code, std::string msg, std::string extra);
void show_send_progress_bar(bool show);
void update_printer();
void update_print_progress();
CalibrationWizard(wxWindow* parent, CalibMode mode,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
~CalibrationWizard();
void on_cali_job_finished(wxCommandEvent& event);
virtual void on_cali_job_finished() {}
CalibrationWizardPageStep* get_curr_step() { return m_curr_step; }
void show_step(CalibrationWizardPageStep* step);
virtual void update(MachineObject* obj);
virtual void on_device_connected(MachineObject* obj);
virtual void set_cali_style(CalibrationStyle style) {
m_cali_style = style;
}
virtual void set_cali_method(CalibrationMethod method);
CalibMode get_calibration_mode() { return m_mode; }
protected:
virtual CalibrationWizardPage* create_start_page() { return nullptr; }
virtual CalibrationWizardPage* create_presets_page(bool need_custom_range);
virtual CalibrationWizardPage* create_print_page();
virtual CalibrationWizardPage* create_save_page();
virtual void create_save_panel_content(wxBoxSizer* sizer) {}
virtual void create_pages() = 0;
virtual bool start_calibration(std::vector<int> tray_ids) = 0;
virtual bool save_calibration_result() = 0;
virtual bool recommend_input_value();
virtual void set_save_name() {};
virtual void request_calib_result() {};
virtual void jump_to_page(PageType page_type);
virtual void change_ams_select_mode() {};
virtual void init_bitmaps();
virtual void check_sync_printer_status() {};
private:
ScalableBitmap m_bitmap_pause;
ScalableBitmap m_bitmap_pause_hover;
ScalableBitmap m_bitmap_resume;
ScalableBitmap m_bitmap_resume_hover;
ScalableBitmap m_bitmap_pause_disable;
ScalableBitmap m_bitmap_resume_disable;
ScalableBitmap m_bitmap_abort;
ScalableBitmap m_bitmap_abort_hover;
ScalableBitmap m_bitmap_abort_disable;
bool save_preset(const std::string &old_preset_name, const std::string &new_preset_name, const std::map<std::string, ConfigOption *> &key_values, std::string& message);
protected:
wxString m_wiki_url;
std::map<std::string, PrinterCaliInfo> m_printer_calib_infos;
bool is_between_start_and_runing = false;
CalibMode m_mode;
MachineObject* curr_obj{ nullptr };
void on_cali_go_home();
protected:
/* wx widgets*/
wxScrolledWindow* m_scrolledWindow;
wxBoxSizer* m_all_pages_sizer;
CalibrationWizardPage* m_curr_page{ nullptr };
CalibrationWizardPage* m_first_page{ nullptr };
CalibMode m_mode;
CalibrationStyle m_cali_style;
CalibrationMethod m_cali_method { CalibrationMethod::CALI_METHOD_MANUAL };
MachineObject* curr_obj { nullptr };
MachineObject* last_obj { nullptr };
// preset panel
wxPanel* m_presets_panel;
wxPanel* m_select_ams_mode_panel;
//RadioBox* m_ams_radiobox;
//RadioBox* m_ext_spool_radiobox;
wxRadioButton* m_ams_radiobox;
wxRadioButton* m_ext_spool_radiobox;
bool m_filament_from_ext_spool{ false };
wxPanel* m_muilti_ams_panel;
std::vector<AMSItem*> m_ams_item_list;
wxPanel* m_filament_list_panel;
ScalableButton* m_ams_sync_button;
FilamentComboBoxList m_filament_comboBox_list;
wxPanel* m_virtual_panel;
FilamentComboBox* m_virtual_tray_comboBox;
ComboBox* m_comboBox_nozzle_dia;
ComboBox* m_comboBox_bed_type;
ComboBox* m_comboBox_process;
Preset* m_printer_preset{nullptr};
//Preset* m_filament_preset{ nullptr };
std::map<int, Preset*> m_filament_presets;
Preset* m_print_preset{ nullptr };
wxStaticText* m_from_text;
wxStaticText* m_to_text;
wxStaticText* m_step_text;
TextInput* m_from_value;
TextInput* m_to_value;
TextInput* m_step;
TextInput* m_nozzle_temp;
TextInput* m_bed_temp;
TextInput* m_max_volumetric_speed;
wxStaticText* m_filaments_incompatible_tips;
wxStaticText* m_bed_type_incompatible_tips;
wxPanel* m_send_progress_panel;
// send bar
std::shared_ptr<BBLStatusBarSend> m_send_progress_bar;
wxScrolledWindow* m_sw_print_failed_info{ nullptr };
int m_print_error_code;
std::string m_print_error_msg;
std::string m_print_error_extra;
Label* m_st_txt_error_code{ nullptr };
Label* m_st_txt_error_desc{ nullptr };
Label* m_st_txt_extra_info{ nullptr };
CalibrationWizardPageStep* m_curr_step { nullptr };
// print panel
wxPanel* m_print_panel;
wxStaticBitmap* m_print_picture;
wxStaticText* m_staticText_profile_value;
wxStaticText* m_printing_stage_value;
wxStaticText* m_staticText_progress_percent;
wxStaticText* m_staticText_progress_left_time;
wxStaticText* m_staticText_layers;
ScalableButton* m_button_pause_resume;
ScalableButton* m_button_abort;
ProgressBar* m_print_gauge_progress; // for print
PageButton* m_btn_recali;
PageButton* m_btn_next;
CalibrationWizardPageStep* start_step { nullptr };
CalibrationWizardPageStep* preset_step { nullptr };
CalibrationWizardPageStep* cali_step { nullptr };
CalibrationWizardPageStep* save_step { nullptr };
// save panel
wxPanel* m_save_panel;
CalibrationWizardPageStep* cali_coarse_step { nullptr };
CalibrationWizardPageStep* coarse_save_step { nullptr };
CalibrationWizardPageStep* cali_fine_step { nullptr };
CalibrationWizardPageStep* fine_save_step { nullptr };
void init_printer_calib_info_from_appconfig();
void save_to_printer_calib_info(PageType page_type);
/* save steps of calibration pages */
std::vector<CalibrationWizardPageStep*> m_page_steps;
// preset
void init_presets_selections();
void init_nozzle_selections();
void init_bed_type_selections();
void init_process_selections();
void check_has_ams(MachineObject * obj);
int get_bed_temp(DynamicPrintConfig* config);
FilamentSelectMode get_ams_select_mode() { if (!m_filament_comboBox_list.empty()) return m_filament_comboBox_list[0]->get_select_mode(); return FilamentSelectMode::FSMRadioMode; }
void set_ams_select_mode(FilamentSelectMode mode);
std::vector<int> get_selected_tray();
void set_selected_tray(const std::vector<int>& tray_ids);
FilamentComboBoxList get_selected_filament_comboBox();
void show_send_failed_info(bool show, int code = 0, wxString description = wxEmptyString, wxString extra = wxEmptyString);
void reset_preset_page();
// print
void reset_printing_values();
// save
bool save_presets(Preset* preset, const std::string& config_key, ConfigOption* config_value, const std::string& name, std::string& message);
// event handlers
void on_select_nozzle(wxCommandEvent& evt);
void on_select_tray(SimpleEvent& evt);
void on_select_bed_type(wxCommandEvent& evt);
void on_click_btn_prev(IntEvent& event);
void on_click_btn_next(IntEvent& event);
void on_subtask_abort(wxCommandEvent& event);
void on_subtask_pause_resume(wxCommandEvent& event);
void on_choose_ams(wxCommandEvent& event);
void on_choose_ext_spool(wxCommandEvent& event);
void on_update_ams_filament(bool dialog = true);
void on_switch_ams(std::string ams_id);
SecondaryCheckDialog *go_home_dialog = nullptr;
};
class HistoryWindow : public DPIDialog {
public:
HistoryWindow(wxWindow* parent);
~HistoryWindow() {};
void on_dpi_changed(const wxRect& suggested_rect) {}
void create();
wxPanel* m_history_data_panel;
};
class PressureAdvanceWizard : public CalibrationWizard{
class PressureAdvanceWizard : public CalibrationWizard {
public:
PressureAdvanceWizard(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~PressureAdvanceWizard() {};
protected:
virtual CalibrationWizardPage* create_start_page() override;
void create_history_window();
virtual void create_pages() override;
virtual void create_save_panel_content(wxBoxSizer* sizer) override;
virtual bool start_calibration(std::vector<int> tray_ids) override;
virtual bool save_calibration_result() override;
virtual bool recommend_input_value() override;
virtual void request_calib_result() override;
virtual void change_ams_select_mode() override;
virtual void init_bitmaps() override;
virtual void check_sync_printer_status() override;
void create_pages();
void sync_history_window_data();
void sync_save_page_data();
void switch_pages(SimpleEvent& evt);
private:
// history page
HistoryWindow* m_history_page{ nullptr };
void on_cali_start();
// start page
CalibrationWizardPage* m_page0{ nullptr };
void on_cali_save();
// preset page
CalibrationWizardPage* m_page1{ nullptr };
void on_cali_action(wxCommandEvent& evt);
// print page
CalibrationWizardPage* m_page2{ nullptr };
void update(MachineObject* obj) override;
// save page
CalibrationWizardPage* m_page3{ nullptr };
wxStaticBitmap* m_record_picture;
wxPanel* m_low_end_save_panel;
TextInput* m_k_val;
TextInput* m_n_val;
void on_device_connected(MachineObject* obj) override;
wxPanel* m_high_end_save_panel;
std::vector<PACalibResult> m_calib_results;
std::vector<PACalibResult> m_calib_results_history;
wxPanel* m_grid_panel;
bool is_first_time_get_result = true;
bool has_get_result = false;
int m_cali_version = -1;
};
class FlowRateWizard : public CalibrationWizard {
public:
FlowRateWizard(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~FlowRateWizard() {};
void reset_reuse_panels();
void set_cali_method(CalibrationMethod method) override;
void on_cali_job_finished() override;
protected:
virtual CalibrationWizardPage* create_start_page() override;
void create_low_end_pages();
void create_high_end_pages();
virtual void create_pages() override;
virtual void create_save_panel_content(wxBoxSizer* sizer) override;
virtual bool start_calibration(std::vector<int> tray_ids) override;
virtual bool save_calibration_result() override;
virtual bool recommend_input_value() override;
virtual void set_save_name() override;
virtual void request_calib_result() override;
virtual void change_ams_select_mode() override;
virtual void init_bitmaps() override;
void create_pages();
void sync_save_page_data();
void switch_pages(SimpleEvent& evt);
private:
// start page
CalibrationWizardPage* m_page0{ nullptr };
void on_cali_action(wxCommandEvent& evt);
// preset page
CalibrationWizardPage* m_page1{ nullptr };
wxPanel* m_choose_step_panel;
wxRadioButton* m_complete_radioBox;
wxRadioButton* m_fine_radioBox;
void on_cali_start(CaliPresetStage stage = CaliPresetStage::CALI_MANULA_STAGE_NONE, float cali_value = 0.0f);
// print page
CalibrationWizardPage* m_page2{ nullptr };
void on_cali_save();
// page 3
CalibrationWizardPage* m_low_end_page3{ nullptr };
wxStaticBitmap* m_low_record_picture1;
ComboBox* m_optimal_block_coarse;
wxStaticText* m_coarse_calc_result_text;
float m_coarse_calc_result;
CheckBox* m_checkBox_skip_calibration;
TextInput* m_save_name_input1;
void update(MachineObject* obj) override;
CalibrationWizardPage* m_high_end_page3{ nullptr };
std::vector<FlowRatioCalibResult> m_calib_results;
wxPanel* m_grid_panel;
std::map<int, std::string> m_high_end_save_names;
// page 4
CalibrationWizardPage* m_low_end_page4{ nullptr };
wxStaticBitmap* m_low_print_picture2;
// save page
CalibrationWizardPage* m_low_end_page5{ nullptr };
wxStaticBitmap* m_low_record_picture2;
ComboBox* m_optimal_block_fine;
wxStaticText* m_fine_calc_result_text;
float m_fine_calc_result;
TextInput* m_save_name_input2;
std::string m_save_name;
bool is_first_time_get_result = true;
bool has_get_result = false;
void reset_print_panel_to_page(CalibrationWizardPage* page, wxBoxSizer* sizer);
void reset_send_progress_to_page(CalibrationWizardPage* page, wxBoxSizer* sizer);
void on_fine_tune(wxCommandEvent&);
void on_device_connected(MachineObject* obj) override;
};
class MaxVolumetricSpeedWizard : public CalibrationWizard {
public:
MaxVolumetricSpeedWizard(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~MaxVolumetricSpeedWizard() {};
void on_cali_job_finished() override;
protected:
virtual CalibrationWizardPage* create_start_page() override;
virtual void create_pages() override;
virtual void create_save_panel_content(wxBoxSizer* sizer) override;
virtual bool start_calibration(std::vector<int> tray_ids) override;
virtual bool save_calibration_result() override;
virtual bool recommend_input_value() override;
virtual void set_save_name() override;
virtual void init_bitmaps() override;
private:
// start page
CalibrationWizardPage* m_page0;
void create_pages();
// preset page
CalibrationWizardPage* m_page1;
void on_cali_action(wxCommandEvent& evt);
// print page
CalibrationWizardPage* m_page2;
void on_cali_start();
// save page
CalibrationWizardPage* m_page3;
wxStaticBitmap* m_record_picture;
TextInput* m_optimal_max_speed;
wxStaticText* m_calc_result_text;
float m_calc_result;
TextInput* m_save_name_input;
std::string m_save_name;
void on_cali_save();
void on_device_connected(MachineObject *obj) override;
};
class TemperatureWizard : public CalibrationWizard {
public:
TemperatureWizard(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~TemperatureWizard() {};
protected:
virtual CalibrationWizardPage* create_start_page() override;
virtual void create_pages() override;
virtual void create_save_panel_content(wxBoxSizer* sizer) override;
virtual bool start_calibration(std::vector<int> tray_ids) override;
virtual bool save_calibration_result() override;
virtual bool recommend_input_value() override;
virtual void set_save_name() override;
virtual void init_bitmaps() override;
private:
// start page
CalibrationWizardPage* m_page0;
// preset page
CalibrationWizardPage* m_page1;
// print page
CalibrationWizardPage* m_page2;
// save page
CalibrationWizardPage* m_page3;
wxStaticBitmap* m_record_picture;
TextInput* m_optimal_temp;
TextInput* m_save_name_input;
std::string m_save_name;
};
class RetractionWizard : public CalibrationWizard {
public:
RetractionWizard(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~RetractionWizard() {};
protected:
virtual CalibrationWizardPage* create_start_page() override;
virtual void create_pages() override;
virtual void create_save_panel_content(wxBoxSizer* sizer) override;
virtual bool start_calibration(std::vector<int> tray_ids) override;
virtual bool save_calibration_result() override;
virtual bool recommend_input_value() override;
virtual void set_save_name() override;
virtual void init_bitmaps() override;
private:
// start page
CalibrationWizardPage* m_page0;
// preset page
CalibrationWizardPage* m_page1;
// print page
CalibrationWizardPage* m_page2;
// save page
CalibrationWizardPage* m_page3;
wxStaticBitmap* m_record_picture;
TextInput* m_optimal_retraction;
TextInput* m_save_name_input;
std::string m_save_name;
};
// save printer_type in command event
wxDECLARE_EVENT(EVT_DEVICE_CHANGED, wxCommandEvent);
wxDECLARE_EVENT(EVT_CALIBRATION_JOB_FINISHED, wxCommandEvent);
}} // namespace Slic3r::GUI

404
src/slic3r/GUI/CalibrationWizardCaliPage.cpp Normal file
View file

@ -0,0 +1,404 @@
#include "CalibrationWizardCaliPage.hpp"
#include "I18N.hpp"
#include "Widgets/Label.hpp"
namespace Slic3r { namespace GUI {
static const wxString NA_STR = _L("N/A");
CalibrationCaliPage::CalibrationCaliPage(wxWindow* parent, CalibMode cali_mode, CaliPageType cali_type,
wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: CalibrationWizardPage(parent, id, pos, size, style)
{
m_cali_mode = cali_mode;
m_page_type = cali_type;
m_top_sizer = new wxBoxSizer(wxVERTICAL);
create_page(this);
this->SetSizer(m_top_sizer);
m_top_sizer->Fit(this);
}
CalibrationCaliPage::~CalibrationCaliPage()
{
m_printing_panel->get_pause_resume_button()->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(CalibrationCaliPage::on_subtask_pause_resume), NULL, this);
m_printing_panel->get_abort_button()->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(CalibrationCaliPage::on_subtask_abort), NULL, this);
}
void CalibrationCaliPage::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);
wxArrayString steps;
steps.Add(_L("Preset"));
steps.Add(_L("Calibration"));
steps.Add(_L("Record"));
m_step_panel = new CaliPageStepGuide(parent, steps);
m_step_panel->set_steps(1);
m_top_sizer->Add(m_step_panel, 0, wxEXPAND, 0);
m_printing_picture = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap);
m_top_sizer->Add(m_printing_picture, 0, wxALIGN_CENTER, 0);
m_top_sizer->AddSpacer(FromDIP(20));
set_cali_img();
m_printing_panel = new PrintingTaskPanel(parent, PrintingTaskType::CALIBRATION);
m_printing_panel->SetDoubleBuffered(true);
m_printing_panel->SetSize({ CALIBRATION_PROGRESSBAR_LENGTH, -1 });
m_printing_panel->SetMinSize({ CALIBRATION_PROGRESSBAR_LENGTH, -1 });
m_printing_panel->enable_pause_resume_button(false, "resume_disable");
m_printing_panel->enable_abort_button(false);
m_top_sizer->Add(m_printing_panel, 0, wxALIGN_CENTER, 0);
m_action_panel = new CaliPageActionPanel(parent, m_cali_mode, CaliPageType::CALI_PAGE_CALI);
m_top_sizer->Add(m_action_panel, 0, wxEXPAND, 0);
m_printing_panel->get_pause_resume_button()->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(CalibrationCaliPage::on_subtask_pause_resume), NULL, this);
m_printing_panel->get_abort_button()->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(CalibrationCaliPage::on_subtask_abort), NULL, this);
Layout();
}
void CalibrationCaliPage::on_subtask_pause_resume(wxCommandEvent& event)
{
DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev) return;
MachineObject* obj = dev->get_selected_machine();
if (!obj) return;
if (obj->can_resume())
obj->command_task_resume();
else
obj->command_task_pause();
}
void CalibrationCaliPage::on_subtask_abort(wxCommandEvent& event)
{
DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev) return;
MachineObject* obj = dev->get_selected_machine();
if (!obj) return;
if (abort_dlg == nullptr) {
abort_dlg = new SecondaryCheckDialog(this->GetParent(), wxID_ANY, _L("Cancel print"));
abort_dlg->Bind(EVT_SECONDARY_CHECK_CONFIRM, [this, obj](wxCommandEvent& e) {
if (obj) obj->command_task_abort();
});
}
abort_dlg->update_text(_L("Are you sure you want to cancel this print?"));
abort_dlg->on_show();
}
void CalibrationCaliPage::set_cali_img()
{
if (m_cali_mode == CalibMode::Calib_PA_Line) {
m_printing_picture->SetBitmap(create_scaled_bitmap("extrusion_calibration_tips_en", nullptr, 400));
}
else if (m_cali_mode == CalibMode::Calib_Flow_Rate) {
if (m_page_type == CaliPageType::CALI_PAGE_CALI)
m_printing_picture->SetBitmap(create_scaled_bitmap("flow_rate_calibration", nullptr, 400));
if (m_page_type == CaliPageType::CALI_PAGE_FINE_CALI)
m_printing_picture->SetBitmap(create_scaled_bitmap("flow_rate_calibration_fine", nullptr, 400));
else
m_printing_picture->SetBitmap(create_scaled_bitmap("flow_rate_calibration", nullptr, 400));
}
else if (m_cali_mode == CalibMode::Calib_Vol_speed_Tower) {
m_printing_picture->SetBitmap(create_scaled_bitmap("max_volumetric_speed_calibration", nullptr, 400));
}
}
void CalibrationCaliPage::update(MachineObject* obj)
{
static int get_result_count = 0;
// enable calibration when finished
bool enable_cali = false;
if (obj) {
if (m_cali_mode == CalibMode::Calib_PA_Line) {
if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO) {
if (obj->get_pa_calib_result) {
enable_cali = true;
} else {
if (get_obj_calibration_mode(obj) == m_cali_mode && obj->is_printing_finished()) {
// use selected diameter, add a counter to timeout, add a warning tips when get result failed
CalibUtils::emit_get_PA_calib_results(get_selected_calibration_nozzle_dia(obj));
BOOST_LOG_TRIVIAL(trace) << "CalibUtils::emit_get_PA_calib_results, auto count = " << get_result_count++;
} else {
;
}
}
} else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
if (get_obj_calibration_mode(obj) == m_cali_mode && obj->is_printing_finished()) {
enable_cali = true;
} else {
enable_cali = false;
}
} else {
assert(false);
}
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_CALI_NEXT, enable_cali);
} else if (m_cali_mode == CalibMode::Calib_Flow_Rate) {
if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO) {
if (obj->get_flow_calib_result) {
enable_cali = true;
} else {
if (get_obj_calibration_mode(obj) == m_cali_mode && obj->is_printing_finished()) {
// use selected diameter, add a counter to timeout, add a warning tips when get result failed
CalibUtils::emit_get_flow_ratio_calib_results(get_selected_calibration_nozzle_dia(obj));
} else {
;
}
}
} else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
if (get_obj_calibration_mode(obj) == m_cali_mode && obj->is_printing_finished()) {
// use selected diameter, add a counter to timeout, add a warning tips when get result failed
CalibUtils::emit_get_flow_ratio_calib_results(get_selected_calibration_nozzle_dia(obj));
enable_cali = true;
}
else {
enable_cali = false;
}
} else {
assert(false);
}
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_NEXT, enable_cali);
}
else if (m_cali_mode == CalibMode::Calib_Vol_speed_Tower) {
if (get_obj_calibration_mode(obj) == m_cali_mode && obj->is_printing_finished()) {
enable_cali = true;
} else {
;
}
}
else {
assert(false);
}
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_NEXT, enable_cali);
}
// only display calibration printing status
if (get_obj_calibration_mode(obj) == m_cali_mode) {
update_subtask(obj);
} else {
update_subtask(nullptr);
}
}
void CalibrationCaliPage::update_subtask(MachineObject* obj)
{
if (!obj) return;
if (obj->is_support_layer_num) {
m_printing_panel->update_layers_num(true);
}
else {
m_printing_panel->update_layers_num(false);
}
if (obj->is_system_printing()
|| obj->is_in_calibration()) {
reset_printing_values();
}
else if (obj->is_in_printing() || obj->print_status == "FINISH") {
if (obj->is_in_prepare() || obj->print_status == "SLICING") {
m_printing_panel->get_market_scoring_button()->Hide();
m_printing_panel->enable_abort_button(false);
m_printing_panel->enable_pause_resume_button(false, "pause_disable");
wxString prepare_text;
bool show_percent = true;
if (obj->is_in_prepare()) {
prepare_text = wxString::Format(_L("Downloading..."));
}
else if (obj->print_status == "SLICING") {
if (obj->queue_number <= 0) {
prepare_text = wxString::Format(_L("Cloud Slicing..."));
}
else {
prepare_text = wxString::Format(_L("In Cloud Slicing Queue, there are %s tasks ahead."), std::to_string(obj->queue_number));
show_percent = false;
}
}
else
prepare_text = wxString::Format(_L("Downloading..."));
if (obj->gcode_file_prepare_percent >= 0 && obj->gcode_file_prepare_percent <= 100 && show_percent)
prepare_text += wxString::Format("(%d%%)", obj->gcode_file_prepare_percent);
m_printing_panel->update_stage_value(prepare_text, 0);
m_printing_panel->update_progress_percent(NA_STR, wxEmptyString);
m_printing_panel->update_left_time(NA_STR);
m_printing_panel->update_layers_num(true, wxString::Format(_L("Layer: %s"), NA_STR));
m_printing_panel->update_subtask_name(wxString::Format("%s", GUI::from_u8(obj->subtask_name)));
if (obj->get_modeltask() && obj->get_modeltask()->design_id > 0) {
m_printing_panel->show_profile_info(true, wxString::FromUTF8(obj->get_modeltask()->profile_name));
}
else {
m_printing_panel->show_profile_info(false);
}
update_basic_print_data(false, obj->slice_info->weight, obj->slice_info->prediction);
}
else {
if (obj->can_resume()) {
m_printing_panel->enable_pause_resume_button(true, "resume");
}
else {
m_printing_panel->enable_pause_resume_button(true, "pause");
}
if (obj->print_status == "FINISH") {
m_printing_panel->enable_abort_button(false);
m_printing_panel->enable_pause_resume_button(false, "resume_disable");
bool is_market_task = obj->get_modeltask() && obj->get_modeltask()->design_id > 0;
if (is_market_task) {
m_printing_panel->get_market_scoring_button()->Show();
BOOST_LOG_TRIVIAL(info) << "SHOW_SCORE_BTU: design_id [" << obj->get_modeltask()->design_id << "] print_finish [" << m_print_finish << "]";
if (!m_print_finish && IsShownOnScreen()) {
m_print_finish = true;
}
}
else {
m_printing_panel->get_market_scoring_button()->Hide();
}
}
else {
m_printing_panel->enable_abort_button(true);
m_printing_panel->get_market_scoring_button()->Hide();
if (m_print_finish) {
m_print_finish = false;
}
}
// update printing stage
m_printing_panel->update_left_time(obj->mc_left_time);
if (obj->subtask_) {
m_printing_panel->update_stage_value(obj->get_curr_stage(), obj->subtask_->task_progress);
m_printing_panel->update_progress_percent(wxString::Format("%d", obj->subtask_->task_progress), "%");
m_printing_panel->update_layers_num(true, wxString::Format(_L("Layer: %d/%d"), obj->curr_layer, obj->total_layers));
}
else {
m_printing_panel->update_stage_value(obj->get_curr_stage(), 0);
m_printing_panel->update_progress_percent(NA_STR, wxEmptyString);
m_printing_panel->update_layers_num(true, wxString::Format(_L("Layer: %s"), NA_STR));
}
}
m_printing_panel->update_subtask_name(wxString::Format("%s", GUI::from_u8(obj->subtask_name)));
if (obj->get_modeltask() && obj->get_modeltask()->design_id > 0) {
m_printing_panel->show_profile_info(wxString::FromUTF8(obj->get_modeltask()->profile_name));
}
else {
m_printing_panel->show_profile_info(false);
}
}
else {
reset_printing_values();
}
this->Layout();
}
void CalibrationCaliPage::update_basic_print_data(bool def, float weight, int prediction)
{
if (def) {
wxString str_prediction = wxString::Format("%s", get_bbl_time_dhms(prediction));
wxString str_weight = wxString::Format("%.2fg", weight);
m_printing_panel->show_priting_use_info(true, str_prediction, str_weight);
}
else {
m_printing_panel->show_priting_use_info(false, "0m", "0g");
}
}
void CalibrationCaliPage::reset_printing_values()
{
m_printing_panel->enable_pause_resume_button(false, "pause_disable");
m_printing_panel->enable_abort_button(false);
m_printing_panel->reset_printing_value();
m_printing_panel->update_subtask_name(NA_STR);
m_printing_panel->show_profile_info(false);
m_printing_panel->update_stage_value(wxEmptyString, 0);
m_printing_panel->update_progress_percent(NA_STR, wxEmptyString);
m_printing_panel->get_market_scoring_button()->Hide();
m_printing_panel->update_left_time(NA_STR);
m_printing_panel->update_layers_num(true, wxString::Format(_L("Layer: %s"), NA_STR));
update_basic_print_data(false);
this->Layout();
}
void CalibrationCaliPage::on_device_connected(MachineObject* obj)
{
;
}
void CalibrationCaliPage::set_cali_method(CalibrationMethod method)
{
m_cali_method = method;
wxArrayString auto_steps;
auto_steps.Add(_L("Preset"));
auto_steps.Add(_L("Calibration"));
auto_steps.Add(_L("Record"));
wxArrayString manual_steps;
manual_steps.Add(_L("Preset"));
manual_steps.Add(_L("Calibration1"));
manual_steps.Add(_L("Calibration2"));
manual_steps.Add(_L("Record"));
if (method == CalibrationMethod::CALI_METHOD_AUTO) {
m_step_panel->set_steps_string(auto_steps);
m_step_panel->set_steps(1);
}
else if (method == CalibrationMethod::CALI_METHOD_MANUAL) {
if (m_cali_mode == CalibMode::Calib_PA_Line) {
m_step_panel->set_steps_string(auto_steps);
m_step_panel->set_steps(1);
} else {
m_step_panel->set_steps_string(manual_steps);
if (m_page_type == CaliPageType::CALI_PAGE_CALI)
m_step_panel->set_steps(1);
else if (m_page_type == CaliPageType::CALI_PAGE_FINE_CALI) {
m_step_panel->set_steps(2);
}
else {
m_step_panel->set_steps(1);
}
}
}
else {
assert(false);
}
}
float CalibrationCaliPage::get_selected_calibration_nozzle_dia(MachineObject* obj)
{
// return selected if this is set
if (obj->cali_selected_nozzle_dia > 1e-3 && obj->cali_selected_nozzle_dia < 10.0f)
return obj->cali_selected_nozzle_dia;
// return default nozzle if nozzle diameter is set
if (obj->nozzle_diameter > 1e-3 && obj->nozzle_diameter < 10.0f)
return obj->nozzle_diameter;
// return 0.4 by default
return 0.4;
}
}}

46
src/slic3r/GUI/CalibrationWizardCaliPage.hpp Normal file
View file

@ -0,0 +1,46 @@
#ifndef slic3r_GUI_CalibrationWizardCaliPage_hpp_
#define slic3r_GUI_CalibrationWizardCaliPage_hpp_
#include "CalibrationWizardPage.hpp"
#include "StatusPanel.hpp"
namespace Slic3r { namespace GUI {
class CalibrationCaliPage : public CalibrationWizardPage
{
public:
CalibrationCaliPage(wxWindow* parent,
CalibMode cali_mode,
CaliPageType cali_type = CaliPageType::CALI_PAGE_CALI,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
~CalibrationCaliPage();
void create_page(wxWindow* parent);
void on_subtask_pause_resume(wxCommandEvent& event);
void on_subtask_abort(wxCommandEvent& event);
void set_cali_img();
void update(MachineObject* obj) override;
void update_subtask(MachineObject* obj);
void update_basic_print_data(bool def, float weight = 0.0, int prediction = 0);
void reset_printing_values();
void on_device_connected(MachineObject* obj) override;
void set_cali_method(CalibrationMethod method) override;
protected:
float get_selected_calibration_nozzle_dia(MachineObject* obj);
bool m_print_finish {false};
wxBoxSizer* m_top_sizer;
CaliPageStepGuide* m_step_panel { nullptr };
PrintingTaskPanel* m_printing_panel { nullptr };
wxStaticBitmap* m_printing_picture;
SecondaryCheckDialog* abort_dlg { nullptr };
};
}} // namespace Slic3r::GUI
#endif

611
src/slic3r/GUI/CalibrationWizardPage.cpp
View file

@ -1,14 +1,124 @@
#include "CalibrationWizardPage.hpp"
#include "I18N.hpp"
#include "Widgets/Label.hpp"
#include "MsgDialog.hpp"
namespace Slic3r { namespace GUI {
wxDEFINE_EVENT(EVT_CALIBRATIONPAGE_PREV, IntEvent);
wxDEFINE_EVENT(EVT_CALIBRATIONPAGE_NEXT, IntEvent);
wxDEFINE_EVENT(EVT_CALI_ACTION, wxCommandEvent);
wxDEFINE_EVENT(EVT_CALI_TRAY_CHANGED, wxCommandEvent);
PageButton::PageButton(wxWindow* parent, wxString text, ButtonType type)
: m_type(type),
CalibrationStyle get_cali_style(MachineObject* obj)
{
if (!obj) return CalibrationStyle::CALI_STYLE_DEFAULT;
if (obj->printer_type == "BL-P001" || obj->printer_type == "BL-P002")
return CalibrationStyle::CALI_STYLE_X1;
else if (obj->printer_type == "C11" || obj->printer_type == "C12")
return CalibrationStyle::CALI_STYLE_P1P;
return CalibrationStyle::CALI_STYLE_DEFAULT;
}
wxString get_cali_mode_caption_string(CalibMode mode)
{
if (mode == CalibMode::Calib_PA_Line)
return _L("Pressure Advance Calibration");
if (mode == CalibMode::Calib_Flow_Rate)
return _L("Flow Rate Calibration");
if (mode == CalibMode::Calib_Vol_speed_Tower)
return _L("Max Volumetric Speed");
return "no cali_mode_caption";
}
wxString get_calibration_wiki_page(CalibMode cali_mode)
{
switch (cali_mode) {
case CalibMode::Calib_PA_Line:
return wxString("https://wiki.bambulab.com/en/software/bambu-studio/calibration_pa");
case CalibMode::Calib_Flow_Rate:
return wxString("https://wiki.bambulab.com/en/software/bambu-studio/calibration_flow_rate");
case CalibMode::Calib_Vol_speed_Tower:
return wxString("https://wiki.bambulab.com/en/software/bambu-studio/calibration_volumetric");
case CalibMode::Calib_Temp_Tower:
return wxString("https://wiki.bambulab.com/en/software/bambu-studio/calibration_temperature");
case CalibMode::Calib_Retraction_tower:
return wxString("https://wiki.bambulab.com/en/software/bambu-studio/calibration_retraction");
default:
return "";
}
}
CalibrationFilamentMode get_cali_filament_mode(MachineObject* obj, CalibMode mode)
{
// default
if (!obj) return CalibrationFilamentMode::CALI_MODEL_SINGLE;
if (mode == CalibMode::Calib_PA_Line) {
if (obj->printer_type == "BL-P001" || obj->printer_type == "BL-P002")
return CalibrationFilamentMode::CALI_MODEL_MULITI;
else if (obj->printer_type == "C11" || obj->printer_type == "C12")
return CalibrationFilamentMode::CALI_MODEL_SINGLE;
}
else if (mode == CalibMode::Calib_Flow_Rate) {
if (obj->printer_type == "BL-P001" || obj->printer_type == "BL-P002")
return CalibrationFilamentMode::CALI_MODEL_SINGLE;
else if (obj->printer_type == "C11" || obj->printer_type == "C12")
return CalibrationFilamentMode::CALI_MODEL_SINGLE;
}
return CalibrationFilamentMode::CALI_MODEL_SINGLE;
}
CalibMode get_obj_calibration_mode(const MachineObject* obj)
{
CalibrationMethod method;
int cali_stage;
return get_obj_calibration_mode(obj, method, cali_stage);
}
CalibMode get_obj_calibration_mode(const MachineObject* obj, int& cali_stage)
{
CalibrationMethod method;
return get_obj_calibration_mode(obj, method, cali_stage);
}
CalibMode get_obj_calibration_mode(const MachineObject* obj, CalibrationMethod& method, int& cali_stage)
{
method = CalibrationMethod::CALI_METHOD_MANUAL;
if (!obj) return CalibMode::Calib_None;
if (boost::contains(obj->m_gcode_file, "auto_filament_cali")) {
method = CalibrationMethod::CALI_METHOD_AUTO;
return CalibMode::Calib_PA_Line;
}
if (boost::contains(obj->m_gcode_file, "user_cali_manual_pa")) {
method = CalibrationMethod::CALI_METHOD_MANUAL;
return CalibMode::Calib_PA_Line;
}
if (boost::contains(obj->m_gcode_file, "extrusion_cali")) {
method == CalibrationMethod::CALI_METHOD_MANUAL;
return CalibMode::Calib_PA_Line;
}
if (boost::contains(obj->m_gcode_file, "abs_flowcalib_cali")) {
method = CalibrationMethod::CALI_METHOD_AUTO;
return CalibMode::Calib_Flow_Rate;
}
CalibMode cali_mode = CalibUtils::get_calib_mode_by_name(obj->subtask_name, cali_stage);
if (cali_mode != CalibMode::Calib_None) {
method = CalibrationMethod::CALI_METHOD_MANUAL;
}
return cali_mode;
}
CaliPageButton::CaliPageButton(wxWindow* parent, CaliPageActionType type, wxString text)
: m_action_type(type),
Button(parent, text)
{
StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(206, 206, 206), StateColor::Disabled),
@ -33,18 +143,77 @@ PageButton::PageButton(wxWindow* parent, wxString text, ButtonType type)
StateColor btn_text_white(std::pair<wxColour, int>(wxColour(255, 255, 254), StateColor::Disabled),
std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
switch (m_type)
switch (m_action_type)
{
case Slic3r::GUI::Back:
case Slic3r::GUI::Recalibrate:
case CaliPageActionType::CALI_ACTION_MANAGE_RESULT:
this->SetLabel(_L("Manage Result"));
break;
case CaliPageActionType::CALI_ACTION_MANUAL_CALI:
this->SetLabel(_L("Maual Calibration"));
this->SetToolTip(_L("Result can be read by human eyes."));
break;
case CaliPageActionType::CALI_ACTION_AUTO_CALI:
this->SetLabel(_L("Auto-Calibration"));
this->SetToolTip(_L("We would use Lidar to read the calibration result"));
break;
case CaliPageActionType::CALI_ACTION_START:
this->SetLabel(_L("Start Calibration"));
break;
case CaliPageActionType::CALI_ACTION_PREV:
this->SetLabel(_L("Prev"));
break;
case CaliPageActionType::CALI_ACTION_RECALI:
this->SetLabel(_L("Recalibration"));
break;
case CaliPageActionType::CALI_ACTION_NEXT:
this->SetLabel(_L("Next"));
break;
case CaliPageActionType::CALI_ACTION_CALI_NEXT:
this->SetLabel(_L("Next"));
break;
case CaliPageActionType::CALI_ACTION_CALI:
this->SetLabel(_L("Calibrate"));
break;
case CaliPageActionType::CALI_ACTION_FLOW_CALI_STAGE_2:
this->SetLabel(_L("Calibrate"));
break;
case CaliPageActionType::CALI_ACTION_PA_SAVE:
this->SetLabel(_L("Finish"));
break;
case CaliPageActionType::CALI_ACTION_FLOW_SAVE:
this->SetLabel(_L("Finish"));
break;
case CaliPageActionType::CALI_ACTION_FLOW_COARSE_SAVE:
this->SetLabel(_L("Finish"));
break;
case CaliPageActionType::CALI_ACTION_FLOW_FINE_SAVE:
this->SetLabel(_L("Finish"));
break;
case CaliPageActionType::CALI_ACTION_COMMON_SAVE:
this->SetLabel(_L("Finish"));
break;
default:
this->SetLabel("Unknown");
break;
}
switch (m_action_type)
{
case CaliPageActionType::CALI_ACTION_PREV:
case CaliPageActionType::CALI_ACTION_RECALI:
SetBackgroundColor(btn_bg_white);
SetBorderColor(btn_bd_white);
SetTextColor(btn_text_white);
break;
case Slic3r::GUI::Start:
case Slic3r::GUI::Next:
case Slic3r::GUI::Calibrate:
case Slic3r::GUI::Save:
case CaliPageActionType::CALI_ACTION_START:
case CaliPageActionType::CALI_ACTION_NEXT:
case CaliPageActionType::CALI_ACTION_CALI:
case CaliPageActionType::CALI_ACTION_FLOW_CALI_STAGE_2:
case CaliPageActionType::CALI_ACTION_PA_SAVE:
case CaliPageActionType::CALI_ACTION_FLOW_SAVE:
case CaliPageActionType::CALI_ACTION_FLOW_COARSE_SAVE:
case CaliPageActionType::CALI_ACTION_FLOW_FINE_SAVE:
case CaliPageActionType::CALI_ACTION_COMMON_SAVE:
SetBackgroundColor(btn_bg_green);
SetBorderColor(btn_bd_green);
SetTextColor(btn_text_green);
@ -59,102 +228,358 @@ PageButton::PageButton(wxWindow* parent, wxString text, ButtonType type)
SetCornerRadius(FromDIP(12));
}
CalibrationWizardPage::CalibrationWizardPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: wxPanel(parent, id, pos, size, style)
FilamentComboBox::FilamentComboBox(wxWindow* parent, const wxPoint& pos, const wxSize& size)
: wxPanel(parent, wxID_ANY, pos, size, wxTAB_TRAVERSAL)
{
SetBackgroundColour(*wxWHITE);
wxBoxSizer* main_sizer = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* page_sizer;
page_sizer = new wxBoxSizer(wxVERTICAL);
m_comboBox = new CalibrateFilamentComboBox(this);
m_comboBox->SetSize(CALIBRATION_FILAMENT_COMBOX_SIZE);
m_comboBox->SetMinSize(CALIBRATION_FILAMENT_COMBOX_SIZE);
main_sizer->Add(m_comboBox->clr_picker, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(8));
main_sizer->Add(m_comboBox, 0, wxALIGN_CENTER);
wxBoxSizer* title_sizer;
title_sizer = new wxBoxSizer(wxHORIZONTAL);
m_title = new wxStaticText(this, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, 0);
m_title->Wrap(-1);
m_title->SetFont(Label::Head_16);
title_sizer->Add(m_title, 0, wxALL | wxEXPAND, 0);
title_sizer->AddStretchSpacer();
page_sizer->Add(title_sizer, 0, wxEXPAND, 0);
page_sizer->AddSpacer(FromDIP(20));
m_top_sizer = new wxBoxSizer(wxHORIZONTAL);
m_top_sizer->AddStretchSpacer();
m_preset_text = new wxStaticText(this, wxID_ANY, _L("Preset"), wxDefaultPosition, wxDefaultSize, 0);
m_preset_text->SetFont(::Label::Head_14);
m_top_sizer->Add(m_preset_text, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(15));
auto line1 = new wxPanel(this, wxID_ANY, wxDefaultPosition, {FromDIP(200), 1});
line1->SetBackgroundColour(*wxBLACK);
m_top_sizer->Add(line1, 1, wxALIGN_CENTER, 0);
m_calibration_text = new wxStaticText(this, wxID_ANY, _L("Calibration"), wxDefaultPosition, wxDefaultSize, 0);
m_calibration_text->SetFont(::Label::Head_14);
m_top_sizer->Add(m_calibration_text, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(15));
auto line2 = new wxPanel(this, wxID_ANY, wxDefaultPosition, { FromDIP(200), 1});
line2->SetBackgroundColour(*wxBLACK);
m_top_sizer->Add(line2, 1, wxALIGN_CENTER, 0);
m_record_text = new wxStaticText(this, wxID_ANY, _L("Record"), wxDefaultPosition, wxDefaultSize, 0);
m_record_text->SetFont(::Label::Head_14);
m_top_sizer->Add(m_record_text, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(15));
m_top_sizer->AddStretchSpacer();
page_sizer->Add(m_top_sizer, 0, wxEXPAND, 0);
page_sizer->AddSpacer(FromDIP(40));
m_content_sizer = new wxBoxSizer(wxVERTICAL);
page_sizer->Add(m_content_sizer, 0, wxALIGN_CENTER, 0);
page_sizer->AddSpacer(FromDIP(40));
m_btn_sizer = new wxBoxSizer(wxHORIZONTAL);
m_btn_sizer->AddStretchSpacer();
m_btn_prev = new PageButton(this, "Back", Back);
m_btn_sizer->Add(m_btn_prev, 0);
m_btn_sizer->AddSpacer(FromDIP(10));
m_btn_next = new PageButton(this, "Next", Next);
m_btn_sizer->Add(m_btn_next, 0);
m_btn_sizer->AddStretchSpacer();
page_sizer->Add(m_btn_sizer, 0, wxEXPAND, 0);
this->SetSizer(page_sizer);
this->SetSizer(main_sizer);
this->Layout();
page_sizer->Fit(this);
m_btn_prev->Bind(wxEVT_BUTTON, &CalibrationWizardPage::on_click_prev, this);
m_btn_next->Bind(wxEVT_BUTTON, &CalibrationWizardPage::on_click_next, this);
main_sizer->Fit(this);
}
void CalibrationWizardPage::set_highlight_step_text(PageType page_type) {
if (page_type == PageType::Start) {
m_top_sizer->Clear(true);
void FilamentComboBox::set_select_mode(CalibrationFilamentMode mode)
{
m_mode = mode;
if (m_checkBox)
m_checkBox->Show(m_mode == CalibrationFilamentMode::CALI_MODEL_MULITI);
if (m_radioBox)
m_radioBox->Show(m_mode == CalibrationFilamentMode::CALI_MODEL_SINGLE);
Layout();
}
void FilamentComboBox::load_tray_from_ams(int id, DynamicPrintConfig& tray)
{
m_comboBox->load_tray(tray);
m_tray_id = id;
m_tray_name = m_comboBox->get_tray_name();
m_is_bbl_filamnet = MachineObject::is_bbl_filament(m_comboBox->get_tag_uid());
Enable(m_comboBox->is_tray_exist());
if (m_comboBox->is_tray_exist()) {
if (!m_comboBox->is_compatible_with_printer()) {
SetValue(false);
}
}
}
void FilamentComboBox::update_from_preset() { m_comboBox->update(); }
bool FilamentComboBox::Show(bool show)
{
return wxPanel::Show(show);
}
bool FilamentComboBox::Enable(bool enable) {
if (!enable)
SetValue(false);
if (m_radioBox)
m_radioBox->Enable(enable);
if (m_checkBox)
m_checkBox->Enable(enable);
return wxPanel::Enable(enable);
}
void FilamentComboBox::SetValue(bool value, bool send_event) {
if (m_radioBox) {
if (value == m_radioBox->GetValue()) {
if (m_checkBox) {
if (value == m_checkBox->GetValue())
return;
}
m_preset_text->SetForegroundColour(wxColour(181, 181, 181));
m_calibration_text->SetForegroundColour(wxColour(181, 181, 181));
m_record_text->SetForegroundColour(wxColour(181, 181, 181));
if(page_type == PageType::Preset)
m_preset_text->SetForegroundColour(*wxBLACK);
if (page_type == PageType::Calibration || page_type == PageType::CoarseSave || page_type == PageType::FineCalibration)
m_calibration_text->SetForegroundColour(*wxBLACK);
if (page_type == PageType::Save)
m_record_text->SetForegroundColour(*wxBLACK);
else {
return;
}
}
}
if (m_radioBox)
m_radioBox->SetValue(value);
if (m_checkBox)
m_checkBox->SetValue(value);
}
void CalibrationWizardPage::on_click_prev(wxCommandEvent&)
CaliPageCaption::CaliPageCaption(wxWindow* parent, CalibMode cali_mode,
wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: wxPanel(parent, id, pos, size, style)
{
IntEvent e(EVT_CALIBRATIONPAGE_PREV, static_cast<int>(m_btn_prev->GetButtonType()), m_parent);
m_parent->GetEventHandler()->ProcessEvent(e);
init_bitmaps();
auto top_sizer = new wxBoxSizer(wxVERTICAL);
auto caption_sizer = new wxBoxSizer(wxHORIZONTAL);
m_prev_btn = new ScalableButton(this, wxID_ANY, "cali_page_caption_prev",
wxEmptyString, wxDefaultSize, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, true, 30);
m_prev_btn->SetBackgroundColour(*wxWHITE);
caption_sizer->Add(m_prev_btn, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(10));
wxString title = get_cali_mode_caption_string(cali_mode);
wxStaticText* title_text = new wxStaticText(this, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, 0);
title_text->Wrap(-1);
title_text->SetFont(Label::Head_16);
caption_sizer->Add(title_text, 0, wxALIGN_CENTER | wxRIGHT, FromDIP(10));
m_help_btn = new ScalableButton(this, wxID_ANY, "cali_page_caption_help",
wxEmptyString, wxDefaultSize, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, true, 30);
m_help_btn->SetBackgroundColour(*wxWHITE);
caption_sizer->Add(m_help_btn, 0, wxALIGN_CENTER);
top_sizer->Add(caption_sizer, 1, wxEXPAND);
top_sizer->AddSpacer(FromDIP(35));
this->SetSizer(top_sizer);
top_sizer->Fit(this);
// hover effect
m_prev_btn->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {
m_prev_btn->SetBitmap(m_prev_bmp_hover.bmp());
});
m_prev_btn->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {
m_prev_btn->SetBitmap(m_prev_bmp_normal.bmp());
});
// hover effect
m_help_btn->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {
m_help_btn->SetBitmap(m_help_bmp_hover.bmp());
});
m_help_btn->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {
m_help_btn->SetBitmap(m_help_bmp_normal.bmp());
});
// send event
m_prev_btn->Bind(wxEVT_BUTTON, [this](auto& e) {
wxCommandEvent event(EVT_CALI_ACTION);
event.SetEventObject(m_parent);
event.SetInt((int)(CaliPageActionType::CALI_ACTION_GO_HOME));
wxPostEvent(m_parent, event);
});
}
void CalibrationWizardPage::on_click_next(wxCommandEvent&)
{
IntEvent e(EVT_CALIBRATIONPAGE_NEXT, static_cast<int>(m_btn_next->GetButtonType()), m_parent);
m_parent->GetEventHandler()->ProcessEvent(e);
void CaliPageCaption::init_bitmaps() {
m_prev_bmp_normal = ScalableBitmap(this, "cali_page_caption_prev", 30);
m_prev_bmp_hover = ScalableBitmap(this, "cali_page_caption_prev_hover", 30);
m_help_bmp_normal = ScalableBitmap(this, "cali_page_caption_help", 30);
m_help_bmp_hover = ScalableBitmap(this, "cali_page_caption_help_hover", 30);
}
void CaliPageCaption::show_prev_btn(bool show)
{
m_prev_btn->Show(show);
}
void CaliPageCaption::show_help_icon(bool show)
{
m_help_btn->Show(show);
}
CaliPageStepGuide::CaliPageStepGuide(wxWindow* parent, wxArrayString steps,
wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: wxPanel(parent, id, pos, size, style),
m_steps(steps)
{
auto top_sizer = new wxBoxSizer(wxVERTICAL);
m_step_sizer = new wxBoxSizer(wxHORIZONTAL);
m_step_sizer->AddSpacer(FromDIP(90));
for (int i = 0; i < m_steps.size(); i++) {
wxStaticText* step_text = new wxStaticText(this, wxID_ANY, m_steps[i]);
step_text->SetForegroundColour(wxColour(181, 181, 181));
m_text_steps.push_back(step_text);
m_step_sizer->Add(step_text, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(15));
if (i != m_steps.size() - 1) {
auto line = new wxPanel(this, wxID_ANY, wxDefaultPosition, { FromDIP(200), 1 });
line->SetBackgroundColour(*wxBLACK);
m_step_sizer->Add(line, 1, wxALIGN_CENTER);
}
}
m_step_sizer->AddSpacer(FromDIP(90));
top_sizer->Add(m_step_sizer, 0, wxEXPAND);
top_sizer->AddSpacer(FromDIP(30));
this->SetSizer(top_sizer);
top_sizer->Fit(this);
}
void CaliPageStepGuide::set_steps(int index)
{
for (wxStaticText* text_step : m_text_steps) {
text_step->SetForegroundColour(wxColour(181, 181, 181));
}
m_text_steps[index]->SetForegroundColour(*wxBLACK);
}
void CaliPageStepGuide::set_steps_string(wxArrayString steps)
{
m_steps.Clear();
m_text_steps.clear();
m_step_sizer->Clear(true);
m_steps = steps;
m_step_sizer->AddSpacer(FromDIP(90));
for (int i = 0; i < m_steps.size(); i++) {
wxStaticText* step_text = new wxStaticText(this, wxID_ANY, m_steps[i]);
step_text->SetForegroundColour(wxColour(181, 181, 181));
m_text_steps.push_back(step_text);
m_step_sizer->Add(step_text, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(15));
if (i != m_steps.size() - 1) {
auto line = new wxPanel(this, wxID_ANY, wxDefaultPosition, { FromDIP(200), 1 });
line->SetBackgroundColour(*wxBLACK);
m_step_sizer->Add(line, 1, wxALIGN_CENTER);
}
}
m_step_sizer->AddSpacer(FromDIP(90));
Layout();
}
CaliPageActionPanel::CaliPageActionPanel(wxWindow* parent,
CalibMode cali_mode,
CaliPageType page_type,
wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: wxPanel(parent, id, pos, size, style)
{
m_parent = parent;
wxWindow* btn_parent = this;
if (cali_mode == CalibMode::Calib_PA_Line) {
if (page_type == CaliPageType::CALI_PAGE_START) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_MANAGE_RESULT));
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_MANUAL_CALI));
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_AUTO_CALI));
}
else if (page_type == CaliPageType::CALI_PAGE_PRESET) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_CALI));
}
else if (page_type == CaliPageType::CALI_PAGE_CALI) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_CALI_NEXT));
}
else if (page_type == CaliPageType::CALI_PAGE_PA_SAVE) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_PA_SAVE));
}
}
else if (cali_mode == CalibMode::Calib_Flow_Rate) {
if (page_type == CaliPageType::CALI_PAGE_START) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_MANUAL_CALI));
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_AUTO_CALI));
}
else if (page_type == CaliPageType::CALI_PAGE_PRESET) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_CALI));
}
else if (page_type == CaliPageType::CALI_PAGE_CALI) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_NEXT));
}
else if (page_type == CaliPageType::CALI_PAGE_COARSE_SAVE) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_FLOW_COARSE_SAVE));
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_FLOW_CALI_STAGE_2));
}
else if (page_type == CaliPageType::CALI_PAGE_FINE_SAVE) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_FLOW_FINE_SAVE));
}
else if (page_type == CaliPageType::CALI_PAGE_FLOW_SAVE) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_FLOW_SAVE));
}
}
else {
if (page_type == CaliPageType::CALI_PAGE_START) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_START));
}
else if (page_type == CaliPageType::CALI_PAGE_PRESET) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_CALI));
}
else if (page_type == CaliPageType::CALI_PAGE_CALI) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_NEXT));
}
else if (page_type == CaliPageType::CALI_PAGE_COMMON_SAVE) {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_COMMON_SAVE));
}
else {
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_PREV));
m_action_btns.push_back(new CaliPageButton(btn_parent, CaliPageActionType::CALI_ACTION_NEXT));
}
}
auto top_sizer = new wxBoxSizer(wxHORIZONTAL);
top_sizer->Add(0, 0, 1, wxEXPAND, 5);
for (int i = 0; i < m_action_btns.size(); i++) {
top_sizer->Add(m_action_btns[i], 0, wxALL, 5);
m_action_btns[i]->Bind(wxEVT_BUTTON,
[this, i](wxCommandEvent& evt) {
wxCommandEvent event(EVT_CALI_ACTION);
event.SetEventObject(m_parent);
event.SetInt((int)m_action_btns[i]->get_action_type());
wxPostEvent(m_parent, event);
});
}
top_sizer->Add(0, 0, 1, wxEXPAND, 5);
this->SetSizer(top_sizer);
top_sizer->Fit(this);
}
void CaliPageActionPanel::bind_button(CaliPageActionType action_type, bool is_block)
{
for (int i = 0; i < m_action_btns.size(); i++) {
if (m_action_btns[i]->get_action_type() == action_type) {
if (is_block) {
m_action_btns[i]->Bind(wxEVT_BUTTON,
[this](wxCommandEvent& evt) {
MessageDialog msg(nullptr, _L("The current firmware version of the printer does not support calibration.\nPlease upgrade the printer firmware."), _L("Calibration not supported"), wxOK | wxICON_WARNING);
msg.ShowModal();
});
}
else {
m_action_btns[i]->Bind(wxEVT_BUTTON,
[this, i](wxCommandEvent& evt) {
wxCommandEvent event(EVT_CALI_ACTION);
event.SetEventObject(m_parent);
event.SetInt((int)m_action_btns[i]->get_action_type());
wxPostEvent(m_parent, event);
});
}
}
}
}
void CaliPageActionPanel::show_button(CaliPageActionType action_type, bool show)
{
for (int i = 0; i < m_action_btns.size(); i++) {
if (m_action_btns[i]->get_action_type() == action_type) {
m_action_btns[i]->Show(show);
}
}
}
void CaliPageActionPanel::enable_button(CaliPageActionType action_type, bool enable)
{
for (int i = 0; i < m_action_btns.size(); i++) {
if (m_action_btns[i]->get_action_type() == action_type) {
m_action_btns[i]->Enable(enable);
}
}
}
CalibrationWizardPage::CalibrationWizardPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: wxPanel(parent, id, pos, size, style)
, m_parent(parent)
{
SetBackgroundColour(*wxWHITE);
}
}}

272
src/slic3r/GUI/CalibrationWizardPage.hpp
View file

@ -1,45 +1,206 @@
#ifndef slic3r_GUI_CalibrationWizardPage_hpp_
#define slic3r_GUI_CalibrationWizardPage_hpp_
#include "wx/event.h"
#include "Widgets/Button.hpp"
#include "Event.hpp"
#include "Widgets/ComboBox.hpp"
#include "Widgets/TextInput.hpp"
#include "Widgets/AMSControl.hpp"
#include "Widgets/ProgressBar.hpp"
#include "wxExtensions.hpp"
#include "PresetComboBoxes.hpp"
#include "../slic3r/Utils/CalibUtils.hpp"
#include "../../libslic3r/Calib.hpp"
namespace Slic3r { namespace GUI {
wxDECLARE_EVENT(EVT_CALIBRATIONPAGE_PREV, IntEvent);
wxDECLARE_EVENT(EVT_CALIBRATIONPAGE_NEXT, IntEvent);
#define PRESET_GAP FromDIP(25)
#define CALIBRATION_COMBOX_SIZE wxSize(FromDIP(500), FromDIP(24))
#define CALIBRATION_FILAMENT_COMBOX_SIZE wxSize(FromDIP(250), FromDIP(24))
#define CALIBRATION_OPTIMAL_INPUT_SIZE wxSize(FromDIP(300), FromDIP(24))
#define CALIBRATION_FROM_TO_INPUT_SIZE wxSize(FromDIP(160), FromDIP(24))
#define CALIBRATION_FGSIZER_HGAP FromDIP(50)
#define CALIBRATION_TEXT_MAX_LENGTH FromDIP(90) + CALIBRATION_FGSIZER_HGAP + 2 * CALIBRATION_FILAMENT_COMBOX_SIZE.x
#define CALIBRATION_PROGRESSBAR_LENGTH FromDIP(690)
class CalibrationWizard;
enum ButtonType
enum class CalibrationStyle : int
{
Start,
Restart,
Back,
Next,
Calibrate,
Recalibrate,
Save,
CALI_STYLE_DEFAULT = 0,
CALI_STYLE_X1,
CALI_STYLE_P1P,
};
class PageButton : public Button
CalibrationStyle get_cali_style(MachineObject* obj);
wxString get_cali_mode_caption_string(CalibMode mode);
enum CalibrationFilamentMode {
/* calibration single filament at once */
CALI_MODEL_SINGLE = 0,
/* calibration multi filament at once */
CALI_MODEL_MULITI,
};
enum CalibrationMethod {
CALI_METHOD_MANUAL = 0,
CALI_METHOD_AUTO,
CALI_METHOD_NONE,
};
wxString get_calibration_wiki_page(CalibMode cali_mode);
CalibrationFilamentMode get_cali_filament_mode(MachineObject* obj, CalibMode mode);
CalibMode get_obj_calibration_mode(const MachineObject* obj);
CalibMode get_obj_calibration_mode(const MachineObject* obj, int& cali_stage);
CalibMode get_obj_calibration_mode(const MachineObject* obj, CalibrationMethod& method, int& cali_stage);
enum class CaliPageType {
CALI_PAGE_START = 0,
CALI_PAGE_PRESET,
CALI_PAGE_CALI,
CALI_PAGE_COARSE_SAVE,
CALI_PAGE_FINE_CALI,
CALI_PAGE_FINE_SAVE,
CALI_PAGE_PA_SAVE,
CALI_PAGE_FLOW_SAVE,
CALI_PAGE_COMMON_SAVE,
};
class FilamentComboBox : public wxPanel
{
public:
PageButton(wxWindow* parent, wxString text, ButtonType type);
void SetButtonType(ButtonType rhs_type) { m_type = rhs_type; }
ButtonType GetButtonType() { return m_type; }
~PageButton() {};
private:
ButtonType m_type;
FilamentComboBox(wxWindow* parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize);
~FilamentComboBox() {};
void set_select_mode(CalibrationFilamentMode mode);
CalibrationFilamentMode get_select_mode() { return m_mode; }
void load_tray_from_ams(int id, DynamicPrintConfig& tray);
void update_from_preset();
int get_tray_id() { return m_tray_id; }
bool is_bbl_filament() { return m_is_bbl_filamnet; }
std::string get_tray_name() { return m_tray_name; }
CalibrateFilamentComboBox* GetComboBox() { return m_comboBox; }
CheckBox* GetCheckBox() { return m_checkBox; }
void SetCheckBox(CheckBox* cb) { m_checkBox = cb; }
wxRadioButton* GetRadioBox() { return m_radioBox; }
void SetRadioBox(wxRadioButton* btn) { m_radioBox = btn; }
virtual bool Show(bool show = true);
virtual bool Enable(bool enable);
virtual void SetValue(bool value, bool send_event = true);
protected:
int m_tray_id { -1 };
std::string m_tray_name;
bool m_is_bbl_filamnet{ false };
CheckBox* m_checkBox{ nullptr };
wxRadioButton* m_radioBox{ nullptr };
CalibrateFilamentComboBox* m_comboBox{ nullptr };
CalibrationFilamentMode m_mode { CalibrationFilamentMode::CALI_MODEL_SINGLE };
};
enum class PageType {
Start,
Preset,
Calibration,
CoarseSave,
FineCalibration,
Save,
Finish,
typedef std::vector<FilamentComboBox*> FilamentComboBoxList;
class CaliPageCaption : public wxPanel
{
public:
CaliPageCaption(wxWindow* parent,
CalibMode cali_mode,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void show_prev_btn(bool show = true);
void show_help_icon(bool show = true);
protected:
ScalableButton* m_prev_btn;
ScalableButton* m_help_btn;
private:
void init_bitmaps();
ScalableBitmap m_prev_bmp_normal;
ScalableBitmap m_prev_bmp_hover;
ScalableBitmap m_help_bmp_normal;
ScalableBitmap m_help_bmp_hover;
};
class CaliPageStepGuide : public wxPanel
{
public:
CaliPageStepGuide(wxWindow* parent,
wxArrayString steps,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void set_steps(int index);
void set_steps_string(wxArrayString steps);
protected:
wxArrayString m_steps;
wxBoxSizer* m_step_sizer;
std::vector<wxStaticText*> m_text_steps;
};
enum class CaliPageActionType : int
{
CALI_ACTION_MANAGE_RESULT = 0,
CALI_ACTION_MANUAL_CALI,
CALI_ACTION_AUTO_CALI,
CALI_ACTION_START,
CALI_ACTION_CALI,
CALI_ACTION_FLOW_CALI_STAGE_2,
CALI_ACTION_RECALI,
CALI_ACTION_PREV,
CALI_ACTION_NEXT,
CALI_ACTION_CALI_NEXT,
CALI_ACTION_PA_SAVE,
CALI_ACTION_FLOW_SAVE,
CALI_ACTION_FLOW_COARSE_SAVE,
CALI_ACTION_FLOW_FINE_SAVE,
CALI_ACTION_COMMON_SAVE,
CALI_ACTION_GO_HOME,
CALI_ACTION_COUNT
};
class CaliPageButton : public Button
{
public:
CaliPageButton(wxWindow* parent, CaliPageActionType type, wxString text = wxEmptyString);
CaliPageActionType get_action_type() { return m_action_type; }
private:
CaliPageActionType m_action_type;
};
class CaliPageActionPanel : public wxPanel
{
public:
CaliPageActionPanel(wxWindow* parent,
CalibMode cali_mode,
CaliPageType page_type,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void bind_button(CaliPageActionType action_type, bool is_block);
void show_button(CaliPageActionType action_type, bool show = true);
void enable_button(CaliPageActionType action_type, bool enable = true);
protected:
std::vector<CaliPageButton*> m_action_btns;
};
class CalibrationWizardPage : public wxPanel
@ -48,6 +209,8 @@ public:
CalibrationWizardPage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
~CalibrationWizardPage() {};
CaliPageType get_page_type() { return m_page_type; }
CalibrationWizardPage* get_prev_page() { return m_prev_page; }
CalibrationWizardPage* get_next_page() { return m_next_page; }
void set_prev_page(CalibrationWizardPage* prev) { m_prev_page = prev; }
@ -59,36 +222,43 @@ public:
return next;
}
wxBoxSizer* get_top_hsizer() { return m_top_sizer; }
wxBoxSizer* get_content_vsizer() { return m_content_sizer; }
wxBoxSizer* get_btn_hsizer() { return m_btn_sizer; }
PageButton* get_prev_btn() { return m_btn_prev; }
PageButton* get_next_btn() { return m_btn_next; }
PageType get_page_type() { return m_page_type; }
virtual void update(MachineObject* obj) { curr_obj = obj; }
/* device changed and connected */
virtual void on_device_connected(MachineObject* obj) {}
void set_page_type(PageType type) { m_page_type = type; }
void set_page_title(wxString title) { m_title->SetLabel(title); }
void set_highlight_step_text(PageType page_type);
virtual void on_reset_page() {}
virtual void set_cali_filament_mode(CalibrationFilamentMode mode) {
m_cali_filament_mode = mode;
}
virtual void set_cali_method(CalibrationMethod method) {
m_cali_method = method;
if (method == CalibrationMethod::CALI_METHOD_MANUAL) {
set_cali_filament_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
}
}
protected:
CalibMode m_cali_mode;
CaliPageType m_page_type;
CalibrationFilamentMode m_cali_filament_mode;
CalibrationMethod m_cali_method{ CalibrationMethod::CALI_METHOD_MANUAL };
MachineObject* curr_obj { nullptr };
wxWindow* m_parent { nullptr };
CaliPageCaption* m_page_caption { nullptr };
CaliPageActionPanel* m_action_panel { nullptr };
private:
wxStaticText* m_title;
wxBoxSizer* m_top_sizer;
wxStaticText* m_preset_text;
wxStaticText* m_calibration_text;
wxStaticText* m_record_text;
wxBoxSizer* m_content_sizer;
wxBoxSizer* m_btn_sizer;
PageButton* m_btn_prev;
PageButton* m_btn_next;
PageType m_page_type;
CalibrationWizardPage* m_prev_page{nullptr};
CalibrationWizardPage* m_next_page{nullptr};
void on_click_prev(wxCommandEvent&);
void on_click_next(wxCommandEvent&);
CalibrationWizardPage* m_prev_page {nullptr};
CalibrationWizardPage* m_next_page {nullptr};
};
wxDECLARE_EVENT(EVT_CALI_ACTION, wxCommandEvent);
wxDECLARE_EVENT(EVT_CALI_TRAY_CHANGED, wxCommandEvent);
}} // namespace Slic3r::GUI
#endif

1408
src/slic3r/GUI/CalibrationWizardPresetPage.cpp Normal file
View file

File diff suppressed because it is too large Load diff

259
src/slic3r/GUI/CalibrationWizardPresetPage.hpp Normal file
View file

@ -0,0 +1,259 @@
#ifndef slic3r_GUI_CalibrationWizardPresetPage_hpp_
#define slic3r_GUI_CalibrationWizardPresetPage_hpp_
#include "CalibrationWizardPage.hpp"
namespace Slic3r { namespace GUI {
enum CaliPresetStage {
CALI_MANULA_STAGE_NONE = 0,
CALI_MANUAL_STAGE_1,
CALI_MANUAL_STAGE_2,
};
class CaliPresetCaliStagePanel : public wxPanel
{
public:
CaliPresetCaliStagePanel(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_cali_stage(CaliPresetStage stage, float value);
void get_cali_stage(CaliPresetStage& stage, float& value);
void set_flow_ratio_value(wxString flow_ratio);
protected:
CaliPresetStage m_stage;
wxBoxSizer* m_top_sizer;
wxRadioButton* m_complete_radioBox;
wxRadioButton* m_fine_radioBox;
TextInput * flow_ratio_input;
float m_flow_ratio_value;
};
class CaliPresetWarningPanel : public wxPanel
{
public:
CaliPresetWarningPanel(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_warning(wxString text);
protected:
wxBoxSizer* m_top_sizer;
wxStaticText* m_warning_text;
};
class CaliPresetTipsPanel : public wxPanel
{
public:
CaliPresetTipsPanel(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_params(int nozzle_temp, int bed_temp, float max_volumetric);
void get_params(int& nozzle_temp, int& bed_temp, float& max_volumetric);
protected:
wxBoxSizer* m_top_sizer;
TextInput* m_nozzle_temp;
TextInput* m_bed_temp;
TextInput* m_max_volumetric_speed;
};
class CaliPresetCustomRangePanel : public wxPanel
{
public:
CaliPresetCustomRangePanel(wxWindow* parent,
int input_value_nums = 3,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void create_panel(wxWindow* parent);
void set_unit(wxString unit);
void set_titles(wxArrayString titles);
void set_values(wxArrayString values);
wxArrayString get_values();
protected:
wxBoxSizer* m_top_sizer;
int m_input_value_nums;
std::vector<wxStaticText*> m_title_texts;
std::vector<TextInput*> m_value_inputs;
};
enum CaliPresetPageStatus
{
CaliPresetStatusInit = 0,
CaliPresetStatusNormal,
CaliPresetStatusSending,
};
class CalibrationPresetPage : public CalibrationWizardPage
{
public:
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(MachineObject* obj) override;
void on_device_connected(MachineObject* obj) override;
void update_print_error_info(int code, const std::string& msg, const std::string& extra);
void show_send_failed_info(bool show, int code = 0, wxString description = wxEmptyString, wxString extra = wxEmptyString);
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 init_with_machine(MachineObject* obj);
void sync_ams_info(MachineObject* obj);
void select_default_compatible_filament();
std::vector<FilamentComboBox*> get_selected_filament_combobox();
// key is tray_id
std::map<int, Preset*> get_selected_filaments();
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() {
return m_send_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();
CaliPresetPageStatus get_page_status() { return m_page_status; }
protected:
void create_selection_panel(wxWindow* parent);
void create_filament_list_panel(wxWindow* parent);
void create_ext_spool_panel(wxWindow* parent);
void create_sending_panel(wxWindow* parent);
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::vector<Preset*>& prests);
bool is_filaments_compatiable(const std::vector<Preset*>& prests,
int& bed_temp,
std::string& incompatiable_filament_name,
std::string& error_tips);
void update_combobox_filaments(MachineObject* obj);
float get_nozzle_value();
void show_status(CaliPresetPageStatus status);
CaliPageStepGuide* m_step_panel { nullptr };
CaliPresetCaliStagePanel* m_cali_stage_panel { nullptr };
wxPanel* m_selection_panel { nullptr };
wxPanel* m_filament_from_panel { nullptr };
wxPanel* m_multi_ams_panel { nullptr };
wxPanel* m_filament_list_panel { nullptr };
wxPanel* m_ext_spool_panel { nullptr };
CaliPresetWarningPanel* m_warning_panel { nullptr };
CaliPresetCustomRangePanel* m_custom_range_panel { nullptr };
CaliPresetTipsPanel* m_tips_panel { nullptr };
wxPanel* m_sending_panel { nullptr };
wxBoxSizer* m_top_sizer;
// m_selection_panel widgets
ComboBox* m_comboBox_nozzle_dia;
ComboBox* m_comboBox_bed_type;
ComboBox* m_comboBox_process;
wxRadioButton* m_ams_radiobox;
wxRadioButton* m_ext_spool_radiobox;
ScalableButton* m_ams_sync_button;
FilamentComboBoxList m_filament_comboBox_list;
FilamentComboBox* m_virtual_tray_comboBox;
// m_sending panel widgets
std::shared_ptr<BBLStatusBarSend> m_send_progress_bar;
wxScrolledWindow* m_sw_print_failed_info { nullptr };
Label* m_st_txt_error_code { nullptr };
Label* m_st_txt_error_desc { nullptr };
Label* m_st_txt_extra_info { nullptr };
int m_print_error_code;
std::string m_print_error_msg;
std::string m_print_error_extra;
std::vector<AMSItem*> m_ams_item_list;
// for update filament combobox, key : tray_id
std::map<int, DynamicPrintConfig> filament_ams_list;
CaliPresetPageStatus m_page_status { CaliPresetPageStatus::CaliPresetStatusInit };
bool m_show_custom_range { false };
MachineObject* curr_obj { nullptr };
};
class MaxVolumetricSpeedPresetPage : public CalibrationPresetPage
{
public:
MaxVolumetricSpeedPresetPage(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);
};
}} // namespace Slic3r::GUI
#endif

1252
src/slic3r/GUI/CalibrationWizardSavePage.cpp Normal file
View file

File diff suppressed because it is too large Load diff

284
src/slic3r/GUI/CalibrationWizardSavePage.hpp Normal file
View file

@ -0,0 +1,284 @@
#ifndef slic3r_GUI_CalibrationWizardSavePage_hpp_
#define slic3r_GUI_CalibrationWizardSavePage_hpp_
#include "CalibrationWizardPage.hpp"
#include "Widgets/TextInput.hpp"
namespace Slic3r { namespace GUI {
enum CaliSaveStyle {
CALI_SAVE_P1P_STYLE = 0,
CALI_SAVE_X1_STYLE,
};
class CalibrationCommonSavePage : public CalibrationWizardPage
{
public:
CalibrationCommonSavePage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
protected:
wxBoxSizer* m_top_sizer;
};
class PAColumnDataPanel : wxPanel {
public:
PAColumnDataPanel(
wxWindow* parent,
bool is_failed,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
bool is_failed() { return m_is_failed; }
int get_col_idx() { return m_col_idx; }
wxString get_k_str();
wxString get_n_str();
wxString get_name();
void set_data(wxString k_str, wxString n_str, wxString name);
private:
wxBoxSizer* m_top_sizer;
TextInput* m_k_value_input;
TextInput* m_n_value_input;
ComboBox* m_comboBox_tray_name;
int m_col_idx;
bool m_is_failed;
};
class CaliSavePresetValuePanel : public wxPanel
{
protected:
wxBoxSizer* m_top_sizer;
wxStaticBitmap* m_record_picture;
wxStaticText* m_value_title;
wxStaticText* m_save_name_title;
::TextInput* m_input_value;
::TextInput* m_input_name;
public:
CaliSavePresetValuePanel(
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_img(const std::string& bmp_name_in);
void set_value_title(const wxString& title);
void set_save_name_title(const wxString& title);
void get_value(double& value);
void get_save_name(std::string& name);
void set_save_name(const std::string& name);
};
class CaliPASaveAutoPanel : public wxPanel
{
public:
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) { m_obj = obj; }
void sync_cali_result(const std::vector<PACalibResult>& cali_result);
void save_to_result_from_widgets(wxWindow* window, bool* out_is_valid);
bool get_result(std::vector<PACalibResult>& out_result);
protected:
wxBoxSizer* m_top_sizer;
wxPanel* m_grid_panel{ nullptr };
std::vector<PACalibResult> m_calib_results;
MachineObject* m_obj;
};
class CaliPASaveManualPanel : public wxPanel
{
public:
CaliPASaveManualPanel(
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_save_img();
void set_machine_obj(MachineObject* obj) { m_obj = obj; }
void set_default_name(const wxString& name);
bool get_result(PACalibResult& out_result);
virtual bool Show(bool show = true) override;
protected:
wxBoxSizer* m_top_sizer;
wxStaticBitmap* m_record_picture;
::TextInput* m_save_name_input;
::TextInput* m_k_val;
::TextInput* m_n_val;
MachineObject* m_obj;
};
class CaliPASaveP1PPanel : public wxPanel
{
public:
CaliPASaveP1PPanel(
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_save_img();
bool get_result(float* out_k, float* out_n);
protected:
wxBoxSizer* m_top_sizer;
wxStaticBitmap* m_record_picture;
::TextInput* m_k_val;
::TextInput* m_n_val;
};
class CalibrationPASavePage : public CalibrationCommonSavePage
{
public:
CalibrationPASavePage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
void set_cali_method(CalibrationMethod method) override;
// sync widget value from obj cali result
void sync_cali_result(MachineObject* obj);
bool get_auto_result(std::vector<PACalibResult>& result) { return m_auto_panel->get_result(result); }
bool get_manual_result(PACalibResult& result) { return m_manual_panel->get_result(result); }
bool get_p1p_result(float* k, float* n) { return m_p1p_panel->get_result(k, n); }
void show_panels(CalibrationMethod method, const std::string& printer_type);
void on_device_connected(MachineObject* obj);
void update(MachineObject* obj) override;
protected:
CaliPageStepGuide* m_step_panel { nullptr };
CaliPASaveAutoPanel* m_auto_panel { nullptr };
CaliPASaveManualPanel* m_manual_panel { nullptr };
CaliPASaveP1PPanel* m_p1p_panel{ nullptr };
CaliSaveStyle m_save_style;
std::vector<PACalibResult> m_calib_results_history;
};
class CalibrationFlowX1SavePage : public CalibrationCommonSavePage
{
public:
CalibrationFlowX1SavePage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
// sync widget value from cali flow rate result
void sync_cali_result(const std::vector<FlowRatioCalibResult>& cali_result);
void save_to_result_from_widgets(wxWindow* window, bool* out_is_valid);
bool get_result(std::vector<std::pair<wxString, float>>& out_results);
protected:
CaliPageStepGuide* m_step_panel{ nullptr };
wxPanel* m_grid_panel{ nullptr };
std::map<int, std::pair<wxString, float>> m_save_results; // map<tray_id, <name, flow ratio>>
};
class CalibrationFlowCoarseSavePage : public CalibrationCommonSavePage
{
public:
CalibrationFlowCoarseSavePage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
void set_save_img();
void set_default_name(const wxString& name);
bool is_skip_fine_calibration();
void set_curr_flow_ratio(float value);
bool get_result(float* out_value, wxString* out_name);
virtual bool Show(bool show = true) override;
protected:
CaliPageStepGuide* m_step_panel{ nullptr };
wxStaticBitmap* m_record_picture;
ComboBox* m_optimal_block_coarse;
TextInput* m_save_name_input;
bool m_skip_fine_calibration = false;
float m_curr_flow_ratio;
float m_coarse_flow_ratio;
};
class CalibrationFlowFineSavePage : public CalibrationCommonSavePage
{
public:
CalibrationFlowFineSavePage(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
void set_save_img();
void set_default_name(const wxString& name);
void set_curr_flow_ratio(float value);
bool get_result(float* out_value, wxString* out_name);
virtual bool Show(bool show = true) override;
protected:
CaliPageStepGuide* m_step_panel{ nullptr };
wxStaticBitmap* m_record_picture;
ComboBox* m_optimal_block_fine;
TextInput* m_save_name_input;
float m_curr_flow_ratio;
float m_fine_flow_ratio;
};
class CalibrationMaxVolumetricSpeedSavePage : public CalibrationCommonSavePage
{
public:
CalibrationMaxVolumetricSpeedSavePage(wxWindow *parent, wxWindowID id = wxID_ANY,
const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
void create_page(wxWindow *parent);
void set_save_img();
bool get_save_result(double &value, std::string &name);
void set_prest_name(const std::string &name) { m_save_preset_panel->set_save_name(name); };
virtual bool Show(bool show = true) override;
protected:
CaliPageStepGuide *m_step_panel{nullptr};
CaliSavePresetValuePanel *m_save_preset_panel;
};
}} // namespace Slic3r::GUI
#endif

304
src/slic3r/GUI/CalibrationWizardStartPage.cpp Normal file
View file

@ -0,0 +1,304 @@
#include "CalibrationWizardStartPage.hpp"
#include "I18N.hpp"
#include "Widgets/Label.hpp"
namespace Slic3r { namespace GUI {
CalibrationStartPage::CalibrationStartPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
:CalibrationWizardPage(parent, id, pos, size, style)
{
m_top_sizer = new wxBoxSizer(wxVERTICAL);
}
void CalibrationStartPage::create_wiki(wxWindow* parent)
{
m_wiki_text = new wxStaticText(parent, wxID_ANY, _L("Wiki"));
m_wiki_text->SetFont(Label::Head_14);
m_wiki_text->SetForegroundColour({ 0, 88, 220 });
m_wiki_text->Bind(wxEVT_ENTER_WINDOW, [this](wxMouseEvent& e) {
e.Skip();
SetCursor(wxCURSOR_HAND);
});
m_wiki_text->Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& e) {
e.Skip();
SetCursor(wxCURSOR_ARROW);
});
m_wiki_text->Bind(wxEVT_LEFT_UP, [this](wxMouseEvent& e) {
if (!m_wiki_url.empty())
wxLaunchDefaultBrowser(m_wiki_url);
});
}
void CalibrationStartPage::create_when(wxWindow* parent, wxString title, wxString content)
{
m_when_title = new wxStaticText(this, wxID_ANY, title);
m_when_title->SetFont(Label::Head_14);
m_when_title->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
m_when_content = new wxStaticText(this, wxID_ANY, content);
m_when_content->SetFont(Label::Body_14);
m_when_content->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
}
void CalibrationStartPage::create_bitmap(wxWindow* parent, const wxBitmap& before_img, const wxBitmap& after_img)
{
m_images_sizer = new wxBoxSizer(wxHORIZONTAL);
m_before_bmp = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0);
m_before_bmp->SetBitmap(before_img);
m_images_sizer->Add(m_before_bmp, 0, wxALL, 0);
m_images_sizer->AddSpacer(FromDIP(20));
m_after_bmp = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0);
m_after_bmp->SetBitmap(after_img);
m_images_sizer->Add(m_after_bmp, 0, wxALL, 0);
}
void CalibrationStartPage::create_bitmap(wxWindow* parent, std::string before_img, std::string after_img)
{
wxBitmap before_bmp = create_scaled_bitmap(before_img, nullptr, 400);
wxBitmap after_bmp = create_scaled_bitmap(after_img, nullptr, 400);
create_bitmap(parent, before_bmp, after_bmp);
}
CalibrationPAStartPage::CalibrationPAStartPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: CalibrationStartPage(parent, id, pos, size, style)
{
m_cali_mode = CalibMode::Calib_PA_Line;
m_page_type = CaliPageType::CALI_PAGE_START;
m_wiki_url = get_calibration_wiki_page(m_cali_mode);
create_page(this);
this->SetSizer(m_top_sizer);
m_top_sizer->Fit(this);
}
void CalibrationPAStartPage::create_page(wxWindow* parent)
{
m_page_caption = new CaliPageCaption(parent, CalibMode::Calib_PA_Line);
m_page_caption->show_prev_btn(false);
m_top_sizer->Add(m_page_caption, 0, wxEXPAND, 0);
create_when(parent,
_L("When you need Pressure Advance Calibration"),
_L("uneven extrusion"));
m_top_sizer->Add(m_when_title);
m_top_sizer->Add(m_when_content);
m_top_sizer->AddSpacer(PRESET_GAP);
create_bitmap(parent, "cali_page_before_pa", "cali_page_after_pa");
m_top_sizer->Add(m_images_sizer, 0, wxALL, 0);
m_top_sizer->AddSpacer(PRESET_GAP);
auto about_title = new wxStaticText(parent, wxID_ANY, _L("About this calibration"));
about_title->SetFont(Label::Head_14);
about_title->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
m_top_sizer->Add(about_title);
auto about_text = new wxStaticText(parent, wxID_ANY, _L("After calibration, the linear compensation factor(K) will be recorded and applied to printing. This factor would be different if device, degree of usage, material, and material family type are different"));
about_text->SetFont(Label::Body_14);
about_text->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
m_top_sizer->Add(about_text);
m_top_sizer->AddSpacer(PRESET_GAP);
create_wiki(parent);
m_top_sizer->Add(m_wiki_text, 0);
m_action_panel = new CaliPageActionPanel(parent, CalibMode::Calib_PA_Line, CaliPageType::CALI_PAGE_START);
m_top_sizer->Add(m_action_panel, 0, wxEXPAND, 0);
}
void CalibrationPAStartPage::on_reset_page()
{
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, false);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
void CalibrationPAStartPage::on_device_connected(MachineObject* obj)
{
//enable all button
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, true);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
if (obj->printer_type == "BL-P001" || obj->printer_type == "BL-P002") {
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, true);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
if (obj->cali_version <= -1) {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, true);
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
}
else {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
}
else if (obj->printer_type == "C11" || obj->printer_type == "C12") {
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, false);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
if (obj->cali_version <= -1) {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
}
else {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
}
}
CalibrationFlowRateStartPage::CalibrationFlowRateStartPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: CalibrationStartPage(parent, id, pos, size, style)
{
m_cali_mode = CalibMode::Calib_Flow_Rate;
m_wiki_url = get_calibration_wiki_page(m_cali_mode);
create_page(this);
this->SetSizer(m_top_sizer);
m_top_sizer->Fit(this);
}
void CalibrationFlowRateStartPage::create_page(wxWindow* parent)
{
m_page_caption = new CaliPageCaption(parent, CalibMode::Calib_Flow_Rate);
m_page_caption->show_prev_btn(false);
m_top_sizer->Add(m_page_caption, 0, wxEXPAND, 0);
create_when(parent,
_L("When you need Flow Rate Calibration"),
_L("Over-extrusion or under extrusion"));
m_top_sizer->Add(m_when_title);
m_top_sizer->Add(m_when_content);
m_top_sizer->AddSpacer(PRESET_GAP);
auto recommend_title = new wxStaticText(parent, wxID_ANY, _L("Flow Rate calibration is recommended when you print with:"));
recommend_title->SetFont(Label::Head_14);
recommend_title->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
m_top_sizer->Add(recommend_title);
auto recommend_text1 = new wxStaticText(parent, wxID_ANY, _L("material with significant thermal shrinkage/expansion, such as..."));
recommend_text1->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
recommend_text1->SetFont(Label::Body_14);
m_top_sizer->Add(recommend_text1);
auto recommend_text2 = new wxStaticText(parent, wxID_ANY, _L("materials with inaccurate filament diameter"));
recommend_text2->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
recommend_text2->SetFont(Label::Body_14);
m_top_sizer->Add(recommend_text2);
m_top_sizer->AddSpacer(PRESET_GAP);
create_bitmap(parent, "cali_page_before_flow", "cali_page_after_flow");
m_top_sizer->Add(m_images_sizer, 0, wxALL, 0);
m_top_sizer->AddSpacer(PRESET_GAP);
create_wiki(parent);
m_top_sizer->Add(m_wiki_text, 0);
m_action_panel = new CaliPageActionPanel(parent, CalibMode::Calib_Flow_Rate, CaliPageType::CALI_PAGE_START);
m_top_sizer->Add(m_action_panel, 0, wxEXPAND, 0);
}
void CalibrationFlowRateStartPage::on_reset_page()
{
//disable all button
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, false);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
void CalibrationFlowRateStartPage::on_device_connected(MachineObject* obj)
{
//enable all button
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, true);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
m_action_panel->enable_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
if (obj->printer_type == "BL-P001" || obj->printer_type == "BL-P002") {
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
if (obj->cali_version <= -1) {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, true);
}
else {
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
}
else if (obj->printer_type == "C11" || obj->printer_type == "C12") {
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANAGE_RESULT, false);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_AUTO_CALI, false);
m_action_panel->show_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, true);
m_action_panel->bind_button(CaliPageActionType::CALI_ACTION_MANUAL_CALI, false);
}
}
CalibrationMaxVolumetricSpeedStartPage::CalibrationMaxVolumetricSpeedStartPage(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: CalibrationStartPage(parent, id, pos, size, style)
{
m_cali_mode = CalibMode::Calib_Vol_speed_Tower;
m_wiki_url = get_calibration_wiki_page(m_cali_mode);
create_page(this);
this->SetSizer(m_top_sizer);
m_top_sizer->Fit(this);
}
void CalibrationMaxVolumetricSpeedStartPage::create_page(wxWindow* parent)
{
m_page_caption = new CaliPageCaption(parent, m_cali_mode);
m_page_caption->show_prev_btn(false);
m_top_sizer->Add(m_page_caption, 0, wxEXPAND, 0);
create_when(parent, _L("When you need Max Volumetric Speed Calibration"), _L("Over-extrusion or under extrusion"));
m_top_sizer->Add(m_when_title);
m_top_sizer->Add(m_when_content);
m_top_sizer->AddSpacer(PRESET_GAP);
auto recommend_title = new wxStaticText(parent, wxID_ANY, _L("Max Volumetric Speed calibration is recommended when you print with:"));
recommend_title->SetFont(Label::Head_14);
recommend_title->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
m_top_sizer->Add(recommend_title);
auto recommend_text1 = new wxStaticText(parent, wxID_ANY, _L("material with significant thermal shrinkage/expansion, such as..."));
recommend_text1->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
recommend_text1->SetFont(Label::Body_14);
m_top_sizer->Add(recommend_text1);
auto recommend_text2 = new wxStaticText(parent, wxID_ANY, _L("materials with inaccurate filament diameter"));
recommend_text2->Wrap(CALIBRATION_TEXT_MAX_LENGTH);
recommend_text2->SetFont(Label::Body_14);
m_top_sizer->Add(recommend_text2);
m_top_sizer->AddSpacer(PRESET_GAP);
create_bitmap(parent, "cali_page_before_flow", "cali_page_after_flow");
m_top_sizer->Add(m_images_sizer, 0, wxALL, 0);
m_top_sizer->AddSpacer(PRESET_GAP);
create_wiki(parent);
m_top_sizer->Add(m_wiki_text, 0);
m_action_panel = new CaliPageActionPanel(parent, m_cali_mode, CaliPageType::CALI_PAGE_START);
m_top_sizer->Add(m_action_panel, 0, wxEXPAND, 0);
}
}}

80
src/slic3r/GUI/CalibrationWizardStartPage.hpp Normal file
View file

@ -0,0 +1,80 @@
#ifndef slic3r_GUI_CalibrationWizardStartPage_hpp_
#define slic3r_GUI_CalibrationWizardStartPage_hpp_
#include "CalibrationWizardPage.hpp"
namespace Slic3r { namespace GUI {
class CalibrationStartPage : public CalibrationWizardPage
{
public:
CalibrationStartPage(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
protected:
CalibMode m_cali_mode;
wxString m_wiki_url;
wxBoxSizer* m_top_sizer;
wxBoxSizer* m_images_sizer;
wxStaticText* m_wiki_text;
wxStaticText* m_when_title;
wxStaticText* m_when_content;
wxStaticBitmap* m_before_bmp;
wxStaticBitmap* m_after_bmp;
void create_wiki(wxWindow* parent);
void create_when(wxWindow* parent, wxString title, wxString content);
void create_bitmap(wxWindow* parent, const wxBitmap& before_img, const wxBitmap& after_img);
void create_bitmap(wxWindow* parent, std::string before_img, std::string after_img);
};
class CalibrationPAStartPage : public CalibrationStartPage
{
public:
CalibrationPAStartPage(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
void on_reset_page();
void on_device_connected(MachineObject* obj);
};
class CalibrationFlowRateStartPage : public CalibrationStartPage
{
public:
CalibrationFlowRateStartPage(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
void on_reset_page();
void on_device_connected(MachineObject* obj);
};
class CalibrationMaxVolumetricSpeedStartPage : public CalibrationStartPage
{
public:
CalibrationMaxVolumetricSpeedStartPage(wxWindow* parent,
wxWindowID id = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL);
void create_page(wxWindow* parent);
};
}} // namespace Slic3r::GUI
#endif

88
src/slic3r/GUI/DeviceManager.cpp
View file

@ -1186,6 +1186,14 @@ bool MachineObject::is_system_printing()
return false;
}
bool MachineObject::check_pa_result_validation(PACalibResult& result)
{
if (result.k_value < 0 || result.k_value > 10)
return false;
return true;
}
bool MachineObject::is_axis_at_home(std::string axis)
{
if (home_flag < 0)
@ -1248,6 +1256,8 @@ bool MachineObject::is_in_calibration()
return false;
}
bool MachineObject::is_calibration_done()
{
return calibration_done;
@ -1984,6 +1994,9 @@ int MachineObject::command_set_pa_calibration(const std::vector<PACalibResult>&
for (int i = 0; i < pa_calib_values.size(); ++i) {
if (pa_calib_values[i].tray_id >= 0)
j["print"]["filaments"][i]["tray_id"] = pa_calib_values[i].tray_id;
if (pa_calib_values[i].cali_idx >= 0)
j["print"]["filaments"][i]["cali_idx"] = pa_calib_values[i].cali_idx;
j["print"]["filaments"][i]["tray_id"] = pa_calib_values[i].tray_id;
j["print"]["filaments"][i]["filament_id"] = pa_calib_values[i].filament_id;
j["print"]["filaments"][i]["setting_id"] = pa_calib_values[i].setting_id;
j["print"]["filaments"][i]["name"] = pa_calib_values[i].name;
@ -2016,6 +2029,8 @@ int MachineObject::command_delete_pa_calibration(const PACalibIndexInfo& pa_cali
int MachineObject::command_get_pa_calibration_tab(float nozzle_diameter, const std::string &filament_id)
{
reset_pa_cali_history_result();
if ((printer_type == "BL-P001" || printer_type == "BL-P002")) {
json j;
j["print"]["command"] = "extrusion_cali_get";
@ -3852,13 +3867,31 @@ int MachineObject::parse_json(std::string payload)
extrusion_cali_set_hold_start = std::chrono::system_clock::now();
}
else if (jj["command"].get<std::string>() == "extrusion_cali_get") {
reset_pa_cali_history_result();
has_get_pa_calib_tab = true;
if (jj.contains("nozzle_diameter")) {
if (jj["nozzle_diameter"].is_number_float()) {
pa_calib_tab_nozzle_dia = jj["nozzle_diameter"].get<float>();
}
else if (jj["nozzle_diameter"].is_string()) {
pa_calib_tab_nozzle_dia = stof(jj["nozzle_diameter"].get<std::string>().c_str());
}
else {
assert(false);
}
}
else {
assert(false);
}
if (jj.contains("filaments") && jj["filaments"].is_array()) {
try {
#ifdef CALI_DEBUG
std::string str = jj.dump();
BOOST_LOG_TRIVIAL(info) << "extrusion_cali_get: " << str;
#endif
if (jj["filaments"].is_array()) {
try {
pa_calib_tab.clear();
for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
PACalibResult pa_calib_result;
pa_calib_result.filament_id = (*it)["filament_id"].get<std::string>();
@ -3882,23 +3915,31 @@ int MachineObject::parse_json(std::string payload)
else if ((*it)["n_coef"].is_string())
pa_calib_result.n_coef = stof((*it)["n_coef"].get<std::string>().c_str());
if (check_pa_result_validation(pa_calib_result))
pa_calib_tab.push_back(pa_calib_result);
else {
BOOST_LOG_TRIVIAL(info) << "pa result is invalid";
}
has_get_pa_calib_tab = true;
}
}
catch (...) {
}
}
// notify cali history to update
}
else if (jj["command"].get<std::string>() == "extrusion_cali_get_result") {
reset_pa_cali_result();
get_pa_calib_result = true;
if (jj.contains("filaments") && jj["filaments"].is_array()) {
try {
#ifdef CALI_DEBUG
std::string str = jj.dump();
BOOST_LOG_TRIVIAL(info) << "extrusion_cali_get_result: " << str;
#endif
if (jj["filaments"].is_array()) {
try {
pa_calib_results.clear();
for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
PACalibResult pa_calib_result;
pa_calib_result.tray_id = (*it)["tray_id"].get<int>();
@ -3921,23 +3962,35 @@ int MachineObject::parse_json(std::string payload)
else if ((*it)["n_coef"].is_string())
pa_calib_result.n_coef = stof((*it)["n_coef"].get<std::string>().c_str());
if ((*it).contains("confidence"))
if (it->contains("confidence")) {
pa_calib_result.confidence = (*it)["confidence"].get<int>();
pa_calib_results.push_back(pa_calib_result);
} else {
pa_calib_result.confidence = 0;
}
if (check_pa_result_validation(pa_calib_result))
pa_calib_results.push_back(pa_calib_result);
else {
BOOST_LOG_TRIVIAL(info) << "pa result is invalid";
}
}
has_get_pa_calib_result = true;
} catch (...) {}
}
if (pa_calib_results.empty()) {
BOOST_LOG_TRIVIAL(info) << "no pa calib result";
}
}
else if (jj["command"].get<std::string>() == "flowrate_get_result") {
this->reset_flow_rate_cali_result();
get_flow_calib_result = true;
if (jj.contains("filaments") && jj["filaments"].is_array()) {
try {
#ifdef CALI_DEBUG
std::string str = jj.dump();
BOOST_LOG_TRIVIAL(info) << "flowrate_get_result: " << str;
#endif
if (jj["filaments"].is_array()) {
try {
flow_ratio_results.clear();
for (auto it = jj["filaments"].begin(); it != jj["filaments"].end(); it++) {
FlowRatioCalibResult flow_ratio_calib_result;
flow_ratio_calib_result.tray_id = (*it)["tray_id"].get<int>();
@ -3945,10 +3998,15 @@ int MachineObject::parse_json(std::string payload)
flow_ratio_calib_result.setting_id = (*it)["setting_id"].get<std::string>();
flow_ratio_calib_result.nozzle_diameter = stof(jj["nozzle_diameter"].get<std::string>().c_str());
flow_ratio_calib_result.flow_ratio = stof((*it)["flow_ratio"].get<std::string>().c_str());
if (it->contains("confidence")) {
flow_ratio_calib_result.confidence = (*it)["confidence"].get<int>();
} else {
flow_ratio_calib_result.confidence = 0;
}
flow_ratio_results.push_back(flow_ratio_calib_result);
}
has_get_flow_ratio_result = true;
} catch (...) {}
}
}

50
src/slic3r/GUI/DeviceManager.hpp
View file

@ -327,9 +327,25 @@ public:
std::vector<X1CCalibInfo> calib_datas;
};
class CaliPresetInfo
{
public:
int tray_id;
float nozzle_diameter;
std::string filament_id;
std::string setting_id;
std::string name;
};
class PACalibResult
{
public:
enum CalibResult {
CALI_RESULT_SUCCESS = 0,
CALI_RESULT_PROBLEM = 1,
CALI_RESULT_FAILED = 2,
};
int tray_id;
int cali_idx;
float nozzle_diameter;
@ -338,7 +354,7 @@ public:
std::string name;
float k_value;
float n_coef;
int confidence = -1;
int confidence = -1; // 0: success 1: uncertain 2: failed
};
struct PACalibIndexInfo
@ -357,6 +373,7 @@ public:
std::string filament_id;
std::string setting_id;
float flow_ratio;
int confidence; // 0: success 1: uncertain 2: failed
};
#define UpgradeNoError 0
@ -661,12 +678,37 @@ public:
bool is_support_layer_num { false };
int cali_version = -1;
bool has_get_pa_calib_tab = false;
bool has_get_pa_calib_result = false;
bool has_get_flow_ratio_result = false;
float cali_selected_nozzle_dia { 0.0 };
// 1: record when start calibration in preset page
// 2: reset when start calibration in start page
// 3: save tray_id, filament_id, setting_id, and name, nozzle_dia
std::vector<CaliPresetInfo> selected_cali_preset;
bool has_get_pa_calib_tab{ false };
std::vector<PACalibResult> pa_calib_tab;
float pa_calib_tab_nozzle_dia;
bool get_pa_calib_result { false };
std::vector<PACalibResult> pa_calib_results;
bool get_flow_calib_result { false };
std::vector<FlowRatioCalibResult> flow_ratio_results;
void reset_pa_cali_history_result()
{
pa_calib_tab_nozzle_dia = 0.4f;
has_get_pa_calib_tab = false;
pa_calib_tab.clear();
}
void reset_pa_cali_result() {
get_pa_calib_result = false;
pa_calib_results.clear();
}
void reset_flow_rate_cali_result() {
get_flow_calib_result = false;
flow_ratio_results.clear();
}
bool check_pa_result_validation(PACalibResult& result);
std::vector<int> stage_list_info;
int stage_curr = 0;

198
src/slic3r/GUI/EditCalibrationHistoryDialog.cpp
View file

@ -1,198 +0,0 @@
#include "EditCalibrationHistoryDialog.hpp"
#include "MsgDialog.hpp"
#include "GUI_App.hpp"
namespace Slic3r { namespace GUI {
#define EDIT_HISTORY_DIALOG_INPUT_SIZE wxSize(FromDIP(160), FromDIP(24))
static bool validate_input_k_value(wxString k_text, float* output_value)
{
float default_k = 0.0f;
if (k_text.IsEmpty()) {
*output_value = default_k;
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (K in 0~0.5)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
return false;
}
double k_value = 0.0;
try {
k_text.ToDouble(&k_value);
}
catch (...) {
;
}
if (k_value < 0 || k_value > 0.5) {
*output_value = default_k;
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (K in 0~0.5)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
return false;
}
*output_value = k_value;
return true;
};
static bool validate_input_n_value(wxString n_text, float* output_value) {
float default_n = 1.0f;
if (n_text.IsEmpty()) {
*output_value = default_n;
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (N in 0.6~2.0)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
return false;
}
double n_value = 0.0;
try {
n_text.ToDouble(&n_value);
}
catch (...) {
;
}
if (n_value < 0.6 || n_value > 2.0) {
*output_value = default_n;
MessageDialog msg_dlg(nullptr, _L("Please input a valid value (N in 0.6~2.0)"), wxEmptyString, wxICON_WARNING | wxOK);
msg_dlg.ShowModal();
return false;
}
*output_value = n_value;
return true;
}
EditCalibrationHistoryDialog::EditCalibrationHistoryDialog(wxWindow* parent, wxString k, wxString n, wxString material_name, wxString nozzle_dia)
: DPIDialog(parent, wxID_ANY, _L("Edit Pressure Advance"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE)
{
create(k, n, material_name, nozzle_dia);
wxGetApp().UpdateDlgDarkUI(this);
}
EditCalibrationHistoryDialog::~EditCalibrationHistoryDialog() {
}
void EditCalibrationHistoryDialog::create(const wxString& k, const wxString& n, const wxString& material_name, const wxString& nozzle_dia)
{
this->SetBackgroundColour(*wxWHITE);
auto main_sizer = new wxBoxSizer(wxVERTICAL);
auto top_panel = new wxPanel(this);
auto panel_sizer = new wxBoxSizer(wxVERTICAL);
top_panel->SetSizer(panel_sizer);
auto flex_sizer = new wxFlexGridSizer(0, 2, FromDIP(15), FromDIP(30));
flex_sizer->SetFlexibleDirection(wxBOTH);
flex_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
wxStaticText* nozzle_title = new wxStaticText(top_panel, wxID_ANY, _L("Nozzle Diameter"));
wxStaticText* nozzle_value = new wxStaticText(top_panel, wxID_ANY, nozzle_dia);
flex_sizer->Add(nozzle_title);
flex_sizer->Add(nozzle_value);
wxStaticText* material_name_title = new wxStaticText(top_panel, wxID_ANY, _L("Material"));
TextInput* material_name_value = new TextInput(top_panel, material_name, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
m_material_name = material_name.ToStdString();
material_name_value->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [this, material_name_value](auto& e) {
if (!material_name_value->GetTextCtrl()->GetValue().IsEmpty())
m_material_name = material_name_value->GetTextCtrl()->GetValue().ToStdString();
});
material_name_value->GetTextCtrl()->Bind(wxEVT_KILL_FOCUS, [this, material_name_value](auto& e) {
if (!material_name_value->GetTextCtrl()->GetValue().IsEmpty())
m_material_name = material_name_value->GetTextCtrl()->GetValue().ToStdString();
e.Skip();
});
flex_sizer->Add(material_name_title);
flex_sizer->Add(material_name_value);
wxStaticText* k_title = new wxStaticText(top_panel, wxID_ANY, _L("K Factor"));
TextInput* k_value = new TextInput(top_panel, k, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
double double_k = 0.0;
k_value->GetTextCtrl()->GetValue().ToDouble(&double_k);
m_k_value = double_k;
k_value->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [this, k_value](auto& e) {
float k = 0.0f;
validate_input_k_value(k_value->GetTextCtrl()->GetValue(), &k);
wxString k_str = wxString::Format("%.3f", k);
k_value->GetTextCtrl()->SetValue(k_str);
m_k_value = k;
});
k_value->GetTextCtrl()->Bind(wxEVT_KILL_FOCUS, [this, k_value](auto& e) {
float k = 0.0f;
validate_input_k_value(k_value->GetTextCtrl()->GetValue(), &k);
wxString k_str = wxString::Format("%.3f", k);
k_value->GetTextCtrl()->SetValue(k_str);
m_k_value = k;
e.Skip();
});
flex_sizer->Add(k_title);
flex_sizer->Add(k_value);
// Hide:
//wxStaticText* n_title = new wxStaticText(top_panel, wxID_ANY, _L("N Factor"));
//TextInput* n_value = new TextInput(top_panel, n, "", "", wxDefaultPosition, EDIT_HISTORY_DIALOG_INPUT_SIZE, wxTE_PROCESS_ENTER);
//flex_sizer->Add(n_title);
//flex_sizer->Add(n_value);
panel_sizer->Add(flex_sizer);
panel_sizer->AddSpacer(FromDIP(25));
auto btn_sizer = new wxBoxSizer(wxHORIZONTAL);
Button* save_btn = new Button(top_panel, _L("Save"));
StateColor btn_bg_green(std::pair<wxColour, int>(wxColour(27, 136, 68), StateColor::Pressed),
std::pair<wxColour, int>(wxColour(61, 203, 115), StateColor::Hovered),
std::pair<wxColour, int>(wxColour(0, 174, 66), StateColor::Normal));
save_btn->SetBackgroundColour(*wxWHITE);
save_btn->SetBackgroundColor(btn_bg_green);
save_btn->SetBorderColor(wxColour(0, 174, 66));
save_btn->SetTextColor(wxColour("#FFFFFE"));
save_btn->SetMinSize(wxSize(-1, FromDIP(24)));
save_btn->SetCornerRadius(FromDIP(12));
Button* cancel_btn = new Button(top_panel, _L("Cancel"));
cancel_btn->SetBackgroundColour(*wxWHITE);
cancel_btn->SetMinSize(wxSize(-1, FromDIP(24)));
cancel_btn->SetCornerRadius(FromDIP(12));
save_btn->Bind(wxEVT_BUTTON, &EditCalibrationHistoryDialog::on_save, this);
cancel_btn->Bind(wxEVT_BUTTON, &EditCalibrationHistoryDialog::on_cancel, this);
btn_sizer->AddStretchSpacer();
btn_sizer->Add(save_btn);
btn_sizer->AddSpacer(FromDIP(20));
btn_sizer->Add(cancel_btn);
panel_sizer->Add(btn_sizer, 0, wxEXPAND, 0);
main_sizer->Add(top_panel, 1, wxEXPAND | wxALL, FromDIP(20));
SetSizer(main_sizer);
Layout();
Fit();
CenterOnParent();
}
float EditCalibrationHistoryDialog::get_k_value(){
return m_k_value;
}
float EditCalibrationHistoryDialog::get_n_value(){
return m_n_value;
}
wxString EditCalibrationHistoryDialog::get_material_name_value() {
return m_material_name;
}
void EditCalibrationHistoryDialog::on_save(wxCommandEvent& event) {
EndModal(wxID_OK);
}
void EditCalibrationHistoryDialog::on_cancel(wxCommandEvent& event) {
EndModal(wxID_CANCEL);
}
void EditCalibrationHistoryDialog::on_dpi_changed(const wxRect& suggested_rect)
{
}
}} // namespace Slic3r::GUI

31
src/slic3r/GUI/EditCalibrationHistoryDialog.hpp
View file

@ -1,31 +0,0 @@
#ifndef slic3r_EditCalibrationHistoryDialog_hpp_
#define slic3r_EditCalibrationHistoryDialog_hpp_
#include "GUI_Utils.hpp"
namespace Slic3r { namespace GUI {
class EditCalibrationHistoryDialog : public DPIDialog
{
public:
EditCalibrationHistoryDialog(wxWindow* parent, wxString k, wxString n, wxString material_name, wxString nozzle_dia);
~EditCalibrationHistoryDialog();
void on_dpi_changed(const wxRect& suggested_rect) override;
float get_k_value();
float get_n_value();
wxString get_material_name_value();
protected:
void create(const wxString& k, const wxString& n, const wxString& material_name, const wxString& nozzle_dia);
virtual void on_save(wxCommandEvent& event);
virtual void on_cancel(wxCommandEvent& event);
protected:
float m_k_value;
float m_n_value;
std::string m_material_name;
};
}} // namespace Slic3r::GUI
#endif

1
src/slic3r/GUI/HMSPanel.cpp
View file

@ -1,5 +1,6 @@
#include "HMS.hpp"
#include "HMSPanel.hpp"
#include <slic3r/GUI/Widgets/SideTools.hpp>
#include <slic3r/GUI/Widgets/Label.hpp>
#include <slic3r/GUI/I18N.hpp>
#include "GUI.hpp"

5
src/slic3r/GUI/MainFrame.hpp
View file

@ -219,12 +219,11 @@ public:
{
tpHome = 0,
tp3DEditor = 1,
//tpSettings = 1,
tpPreview = 2,
tpMonitor = 3,
tpProject = 4,
tpCalibration = 5,
toAuxiliary = 6,
tpAuxiliary = 5,
tpCalibration = 6,
toDebugTool = 7,
};

285
src/slic3r/GUI/Monitor.cpp
View file

@ -160,162 +160,9 @@ MonitorPanel::~MonitorPanel()
{
m_side_tools = new SideTools(this, wxID_ANY);
wxBoxSizer* sizer_side_tools = new wxBoxSizer(wxVERTICAL);
/* auto warning_panel = new wxPanel(this, wxID_ANY);
warning_panel->SetBackgroundColour(wxColour(255, 111, 0));
warning_panel->SetSize(wxSize(FromDIP(220), FromDIP(25)));
warning_panel->SetMinSize(wxSize(FromDIP(220), FromDIP(25)));
warning_panel->SetMaxSize(wxSize(FromDIP(220), FromDIP(25)));
sizer_side_tools->Add(warning_panel, 0, wxEXPAND, 0);
wxBoxSizer *sizer_boxh = new wxBoxSizer(wxVERTICAL);
wxBoxSizer *sizer_boxv = new wxBoxSizer(wxHORIZONTAL);*/
m_connection_info = new Button(this, wxEmptyString);
m_connection_info->SetBackgroundColor(wxColour(255, 111, 0));
m_connection_info->SetBorderColor(wxColour(255, 111, 0));
m_connection_info->SetTextColor(*wxWHITE);
m_connection_info->SetFont(::Label::Body_13);
m_connection_info->SetCornerRadius(0);
m_connection_info->SetSize(wxSize(FromDIP(-1), FromDIP(25)));
m_connection_info->SetMinSize(wxSize(FromDIP(-1), FromDIP(25)));
m_connection_info->SetMaxSize(wxSize(FromDIP(-1), FromDIP(25)));
wxBoxSizer* connection_sizer_V = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* connection_sizer_H = new wxBoxSizer(wxHORIZONTAL);
m_hyperlink = new wxHyperlinkCtrl(m_connection_info, wxID_ANY, _L("Failed to connect to the server"), wxT("https://wiki.bambulab.com/en/software/bambu-studio/failed-to-connect-printer"), wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE);
m_hyperlink->SetBackgroundColour(wxColour(255, 111, 0));
m_more_err_open = ScalableBitmap(this, "monitir_err_open", 16);
m_more_err_close = ScalableBitmap(this, "monitir_err_close", 16);
m_more_button = new ScalableButton(m_connection_info, wxID_ANY, "monitir_err_open");
m_more_button->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_HAND); });
m_more_button->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_ARROW); });
m_more_button->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
if (!m_more_err_state) {
m_more_button->SetBitmap(m_more_err_close.bmp());
Freeze();
m_side_error_panel->Show();
m_more_err_state = true;
m_tabpanel->Refresh();
m_tabpanel->Layout();
Thaw();
}
else {
m_more_button->SetBitmap(m_more_err_open.bmp());
Freeze();
m_side_error_panel->Hide();
m_more_err_state = false;
m_tabpanel->Refresh();
m_tabpanel->Layout();
Thaw();
}
});
connection_sizer_H->Add(m_hyperlink, 0, wxALIGN_CENTER | wxALL, 5);
connection_sizer_H->Add(m_more_button, 0, wxALIGN_CENTER | wxALL, 3);
connection_sizer_V->Add(connection_sizer_H, 0, wxALIGN_CENTER, 0);
m_connection_info->SetSizer(connection_sizer_V);
m_connection_info->Layout();
connection_sizer_V->Fit(m_connection_info);
m_side_error_panel = new wxWindow(this,wxID_ANY);
m_side_error_panel->SetBackgroundColour(wxColour(255,232,214));
m_side_error_panel->SetMinSize(wxSize(-1, -1));
m_side_error_panel->SetMaxSize(wxSize(-1, -1));
m_side_error_panel->Hide();
m_more_button->Hide();
m_connection_info->Hide();
wxBoxSizer* sizer_print_failed_info = new wxBoxSizer(wxVERTICAL);
m_side_error_panel->SetSizer(sizer_print_failed_info);
wxBoxSizer* sizer_error_code = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* sizer_error_desc = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* sizer_extra_info = new wxBoxSizer(wxHORIZONTAL);
m_link_network_state = new Label(m_side_error_panel, _L("Check cloud service status"), wxALIGN_CENTER_HORIZONTAL|wxST_ELLIPSIZE_END);
m_link_network_state->SetMinSize(wxSize(FromDIP(220), -1));
m_link_network_state->SetMaxSize(wxSize(FromDIP(220), -1));
m_link_network_state->SetForegroundColour(0x00AE42);
m_link_network_state->SetFont(::Label::Body_12);
m_link_network_state->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {wxGetApp().link_to_network_check(); });
m_link_network_state->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {m_link_network_state->SetCursor(wxCURSOR_HAND); });
m_link_network_state->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {m_link_network_state->SetCursor(wxCURSOR_ARROW); });
auto st_title_error_code = new wxStaticText(m_side_error_panel, wxID_ANY, _L("code"),wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_error_code_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_error_code = new Label(m_side_error_panel, wxEmptyString);
st_title_error_code->SetForegroundColour(0x909090);
st_title_error_code_doc->SetForegroundColour(0x909090);
m_st_txt_error_code->SetForegroundColour(0x909090);
st_title_error_code->SetFont(::Label::Body_12);
st_title_error_code_doc->SetFont(::Label::Body_12);
m_st_txt_error_code->SetFont(::Label::Body_12);
st_title_error_code->SetMinSize(wxSize(FromDIP(32), -1));
st_title_error_code->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_error_code->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_error_code->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_error_code->Add(st_title_error_code, 0, wxALL, 0);
sizer_error_code->Add(st_title_error_code_doc, 0, wxALL, 0);
sizer_error_code->Add(m_st_txt_error_code, 0, wxALL, 0);
auto st_title_error_desc = new wxStaticText(m_side_error_panel, wxID_ANY, wxT("desc"),wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_error_desc_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_error_desc = new Label(m_side_error_panel, wxEmptyString);
st_title_error_desc->SetForegroundColour(0x909090);
st_title_error_desc_doc->SetForegroundColour(0x909090);
m_st_txt_error_desc->SetForegroundColour(0x909090);
st_title_error_desc->SetFont(::Label::Body_12);
st_title_error_desc_doc->SetFont(::Label::Body_12);
m_st_txt_error_desc->SetFont(::Label::Body_12);
st_title_error_desc->SetMinSize(wxSize(FromDIP(32), -1));
st_title_error_desc->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_error_desc->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_error_desc->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_error_desc->Add(st_title_error_desc, 0, wxALL, 0);
sizer_error_desc->Add(st_title_error_desc_doc, 0, wxALL, 0);
sizer_error_desc->Add(m_st_txt_error_desc, 0, wxALL, 0);
auto st_title_extra_info = new wxStaticText(m_side_error_panel, wxID_ANY, wxT("info"),wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_extra_info_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_extra_info = new Label(m_side_error_panel, wxEmptyString);
st_title_extra_info->SetForegroundColour(0x909090);
st_title_extra_info_doc->SetForegroundColour(0x909090);
m_st_txt_extra_info->SetForegroundColour(0x909090);
st_title_extra_info->SetFont(::Label::Body_12);
st_title_extra_info_doc->SetFont(::Label::Body_12);
m_st_txt_extra_info->SetFont(::Label::Body_12);
st_title_extra_info->SetMinSize(wxSize(FromDIP(32), -1));
st_title_extra_info->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_extra_info->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_extra_info->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_extra_info->Add(st_title_extra_info, 0, wxALL, 0);
sizer_extra_info->Add(st_title_extra_info_doc, 0, wxALL, 0);
sizer_extra_info->Add(m_st_txt_extra_info, 0, wxALL, 0);
sizer_print_failed_info->Add(m_link_network_state, 0, wxALIGN_CENTER, 3);
sizer_print_failed_info->Add(sizer_error_code, 0, wxLEFT, 5);
sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
sizer_print_failed_info->Add(sizer_error_desc, 0, wxLEFT, 5);
sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
sizer_print_failed_info->Add(sizer_extra_info, 0, wxLEFT, 5);
m_st_txt_error_desc->SetLabel("");
m_st_txt_error_desc->Wrap(FromDIP(170));
sizer_side_tools->Add(m_connection_info, 0, wxEXPAND, 0);
sizer_side_tools->Add(m_side_error_panel, 0, wxEXPAND, 0);
sizer_side_tools->Add(m_side_tools, 1, wxEXPAND, 0);
m_tabpanel = new Tabbook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, sizer_side_tools, wxNB_LEFT | wxTAB_TRAVERSAL | wxNB_NOPAGETHEME);
m_side_tools->set_table_panel(m_tabpanel);
m_tabpanel->SetBackgroundColour(wxColour("#FEFFFF"));
m_tabpanel->Bind(wxEVT_BOOKCTRL_PAGE_CHANGED, [this](wxBookCtrlEvent& e) {
auto page = m_tabpanel->GetCurrentPage();
@ -344,24 +191,6 @@ MonitorPanel::~MonitorPanel()
show_status((int)MonitorStatus::MONITOR_NO_PRINTER);
}
void MonitorPanel::update_connect_err_info(int code, wxString desc, wxString info)
{
m_st_txt_error_code->SetLabelText(wxString::Format("%d", code));
m_st_txt_error_desc->SetLabelText(desc);
m_st_txt_extra_info->SetLabelText(info);
m_st_txt_error_code->Wrap(FromDIP(175));
m_st_txt_error_desc->Wrap(FromDIP(175));
m_st_txt_extra_info->Wrap(FromDIP(175));
if (code == BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED) {
m_link_network_state->Hide();
}
else if(code == BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED){
m_link_network_state->Show();
}
}
void MonitorPanel::set_default()
{
obj = nullptr;
@ -403,7 +232,6 @@ void MonitorPanel::msw_rescale()
/* side_tool rescale */
m_side_tools->msw_rescale();
m_tabpanel->Rescale();
//m_status_add_machine_panel->msw_rescale();
m_status_info_panel->msw_rescale();
@ -411,11 +239,6 @@ void MonitorPanel::msw_rescale()
m_upgrade_panel->msw_rescale();
m_hms_panel->msw_rescale();
m_connection_info->SetCornerRadius(0);
m_connection_info->SetSize(wxSize(FromDIP(220), FromDIP(25)));
m_connection_info->SetMinSize(wxSize(FromDIP(220), FromDIP(25)));
m_connection_info->SetMaxSize(wxSize(FromDIP(220), FromDIP(25)));
Layout();
Refresh();
}
@ -489,41 +312,6 @@ void MonitorPanel::on_size(wxSizeEvent &event)
Refresh();
}
void MonitorPanel::update_status(MachineObject* obj)
{
if (!obj) return;
/* Update Device Info */
m_side_tools->set_current_printer_name(obj->dev_name);
// update wifi signal image
int wifi_signal_val = 0;
if (!obj->is_connected() || obj->is_connecting()) {
m_side_tools->set_current_printer_signal(WifiSignal::NONE);
} else {
if (!obj->wifi_signal.empty() && boost::ends_with(obj->wifi_signal, "dBm")) {
try {
wifi_signal_val = std::stoi(obj->wifi_signal.substr(0, obj->wifi_signal.size() - 3));
}
catch (...) {
;
}
if (wifi_signal_val > -45) {
m_side_tools->set_current_printer_signal(WifiSignal::STRONG);
}
else if (wifi_signal_val <= -45 && wifi_signal_val >= -60) {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::WEAK);
}
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
}
}
}
void MonitorPanel::update_all()
{
NetworkAgent* m_agent = wxGetApp().getAgent();
@ -561,13 +349,10 @@ void MonitorPanel::update_all()
}
m_status_info_panel->obj = obj;
m_upgrade_panel->update(obj);
m_status_info_panel->m_media_play_ctrl->SetMachineObject(obj);
m_upgrade_panel->update(obj);
m_media_file_panel->SetMachineObject(obj);
update_status(obj);
m_side_tools->update_status(obj);
if (!obj) {
show_status((int)MONITOR_NO_PRINTER);
@ -659,10 +444,7 @@ void MonitorPanel::update_side_panel()
void MonitorPanel::show_status(int status)
{
if (!m_initialized) return;
if (last_status == status)
return;
if (last_status == status)return;
if (last_status & (int)MonitorStatus::MONITOR_CONNECTING != 0) {
NetworkAgent* agent = wxGetApp().getAgent();
json j;
@ -684,49 +466,14 @@ void MonitorPanel::show_status(int status)
BOOST_LOG_TRIVIAL(info) << "monitor: show_status = " << status;
if (((status & (int) MonitorStatus::MONITOR_DISCONNECTED) != 0) || ((status & (int) MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)) {
if ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER)) {
m_hyperlink->SetLabel(_L("Failed to connect to the server"));
update_connect_err_info(BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED,
_L("Failed to connect to cloud service"),
_L("Please click on the hyperlink above to view the cloud service status"));
}
else {
m_hyperlink->SetLabel(_L("Failed to connect to the printer"));
update_connect_err_info(BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED,
_L("Connection to printer failed"),
_L("Please check the network connection of the printer and Studio."));
}
m_hyperlink->Show();
m_connection_info->SetLabel(wxEmptyString);
m_connection_info->SetBackgroundColor(0xFF6F00);
m_connection_info->SetBorderColor(0xFF6F00);
m_connection_info->Show();
m_more_button->Show();
#if !BBL_RELEASE_TO_PUBLIC
m_upgrade_panel->update(nullptr);
#endif
} else if ((status & (int) MonitorStatus::MONITOR_NORMAL) != 0) {
m_connection_info->Hide();
m_more_button->Hide();
m_side_error_panel->Hide();
} else if ((status & (int) MonitorStatus::MONITOR_CONNECTING) != 0) {
m_hyperlink->Hide();
m_connection_info->SetLabel(_L("Connecting..."));
m_connection_info->SetBackgroundColor(0x00AE42);
m_connection_info->SetBorderColor(0x00AE42);
m_connection_info->Show();
m_more_button->Hide();
m_side_error_panel->Hide();
}
Freeze();
Freeze();
// update panels
if (m_side_tools) { m_side_tools->show_status(status); };
m_status_info_panel->show_status(status);
m_hms_panel->show_status(status);
m_upgrade_panel->show_status(status);
@ -734,31 +481,23 @@ void MonitorPanel::show_status(int status)
if ((status & (int)MonitorStatus::MONITOR_NO_PRINTER) != 0) {
set_default();
m_side_tools->set_none_printer_mode();
m_connection_info->Hide();
m_side_error_panel->Hide();
m_more_button->Hide();
m_tabpanel->Refresh();
m_tabpanel->Layout();
#if !BBL_RELEASE_TO_PUBLIC
m_upgrade_panel->update(nullptr);
#endif
} else if (((status & (int)MonitorStatus::MONITOR_NORMAL) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int) MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0)
) {
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0) )
{
if (((status & (int) MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int) MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0)) {
m_side_tools->set_current_printer_signal(WifiSignal::NONE);
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0))
{
set_default();
}
m_tabpanel->Refresh();
m_tabpanel->Layout();
}
Layout();
Thaw();
Thaw();
}
} // GUI

19
src/slic3r/GUI/Monitor.hpp
View file

@ -83,9 +83,6 @@ private:
MediaFilePanel* m_media_file_panel;
UpgradePanel* m_upgrade_panel;
HMSPanel* m_hms_panel;
Button * m_connection_info{nullptr};
wxWindow * m_side_error_panel{nullptr};
wxHyperlinkCtrl* m_hyperlink{nullptr};
/* side tools */
SideTools* m_side_tools{nullptr};
@ -94,12 +91,6 @@ private:
wxStaticText* m_staticText_printer_name;
wxStaticBitmap* m_bitmap_wifi_signal;
wxBoxSizer * m_side_tools_sizer;
Label* m_link_network_state;
Label* m_st_txt_error_code;
Label* m_st_txt_error_desc;
Label* m_st_txt_extra_info;
SelectMachinePopup m_select_machine;
/* images */
@ -110,15 +101,10 @@ private:
wxBitmap m_printer_img;
wxBitmap m_arrow_img;
ScalableButton* m_more_button;
bool m_more_err_state{false};
ScalableBitmap m_more_err_open;
ScalableBitmap m_more_err_close;
int last_wifi_signal = -1;
wxTimer* m_refresh_timer = nullptr;
int last_status;
bool m_initialized { false };
wxTimer* m_refresh_timer = nullptr;
public:
MonitorPanel(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL);
@ -136,7 +122,6 @@ public:
void init_bitmap();
void init_timer();
void init_tabpanel();
void update_connect_err_info(int code, wxString desc, wxString info);
Tabbook* get_tabpanel() { return m_tabpanel; };
void set_default();
wxWindow* create_side_tools();
@ -152,7 +137,6 @@ public:
void on_size(wxSizeEvent &event);
/* update apis */
void update_status(MachineObject* obj);
//void update_ams(MachineObject* obj);
void update_all();
@ -165,6 +149,7 @@ public:
std::string last_conn_type = "undedefined";
};
} // GUI
} // Slic3r

48
src/slic3r/GUI/Plater.cpp
View file

@ -1406,18 +1406,10 @@ void Sidebar::on_bed_type_change(BedType bed_type)
m_bed_type_list->SetSelection(sel_idx);
}
void Sidebar::load_ams_list(std::string const &device, MachineObject* obj)
std::map<int, DynamicPrintConfig> Sidebar::build_filament_ams_list(MachineObject* obj)
{
std::map<int, DynamicPrintConfig> filament_ams_list;
if (!obj) {
p->ams_list_device = device;
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " clear list";
wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
for (auto c : p->combos_filament)
c->update();
return;
}
if (!obj) return filament_ams_list;
auto vt_tray = obj->vt_tray;
bool is_support_virtual_tray = obj->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY);
@ -1426,8 +1418,8 @@ void Sidebar::load_ams_list(std::string const &device, MachineObject* obj)
vt_tray_config.set_key_value("filament_id", new ConfigOptionStrings{ vt_tray.setting_id });
vt_tray_config.set_key_value("tag_uid", new ConfigOptionStrings{ vt_tray.tag_uid });
vt_tray_config.set_key_value("filament_type", new ConfigOptionStrings{ vt_tray.type });
vt_tray_config.set_key_value("tray_name", new ConfigOptionStrings{std::string("Ext")});
vt_tray_config.set_key_value("filament_colour", new ConfigOptionStrings{into_u8(wxColour("#" + vt_tray.color).GetAsString(wxC2S_HTML_SYNTAX))});
vt_tray_config.set_key_value("tray_name", new ConfigOptionStrings{ std::string("Ext") });
vt_tray_config.set_key_value("filament_colour", new ConfigOptionStrings{ into_u8(wxColour("#" + vt_tray.color).GetAsString(wxC2S_HTML_SYNTAX)) });
vt_tray_config.set_key_value("filament_exist", new ConfigOptionBools{ true });
filament_ams_list.emplace(VIRTUAL_TRAY_ID, std::move(vt_tray_config));
@ -1441,16 +1433,32 @@ void Sidebar::load_ams_list(std::string const &device, MachineObject* obj)
<< boost::format(": ams %1% tray %2% id %3% color %4%") % ams.first % tray.first % tray.second->setting_id % tray.second->color;
char t = tray.first.front() - '0' + '1';
DynamicPrintConfig tray_config;
tray_config.set_key_value("filament_id", new ConfigOptionStrings{tray.second->setting_id});
tray_config.set_key_value("filament_id", new ConfigOptionStrings{ tray.second->setting_id });
tray_config.set_key_value("tag_uid", new ConfigOptionStrings{ tray.second->tag_uid });
tray_config.set_key_value("filament_type", new ConfigOptionStrings{tray.second->type});
tray_config.set_key_value("tray_name", new ConfigOptionStrings{std::string(1, n) + std::string(1, t)});
tray_config.set_key_value("filament_colour", new ConfigOptionStrings{into_u8(wxColour("#" + tray.second->color).GetAsString(wxC2S_HTML_SYNTAX))});
tray_config.set_key_value("filament_exist", new ConfigOptionBools{tray.second->is_exists});
tray_config.set_key_value("filament_type", new ConfigOptionStrings{ tray.second->type });
tray_config.set_key_value("tray_name", new ConfigOptionStrings{ std::string(1, n) + std::string(1, t) });
tray_config.set_key_value("filament_colour", new ConfigOptionStrings{ into_u8(wxColour("#" + tray.second->color).GetAsString(wxC2S_HTML_SYNTAX)) });
tray_config.set_key_value("filament_exist", new ConfigOptionBools{ tray.second->is_exists });
filament_ams_list.emplace(((n - 'A') * 4 + t - '1'), std::move(tray_config));
}
}
return filament_ams_list;
}
void Sidebar::load_ams_list(std::string const &device, MachineObject* obj)
{
std::map<int, DynamicPrintConfig> filament_ams_list = build_filament_ams_list(obj);
if (!obj) {
p->ams_list_device = device;
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " clear list";
wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
for (auto c : p->combos_filament)
c->update();
return;
}
p->ams_list_device = device;
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% items") % filament_ams_list.size();
wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
@ -10789,9 +10797,11 @@ void Plater::send_calibration_job_finished(wxCommandEvent & evt)
auto calibration_panel = p->main_frame->m_calibration;
if (calibration_panel) {
auto curr_wizard = static_cast<CalibrationWizard*>(calibration_panel->get_tabpanel()->GetPage(evt.GetInt()));
curr_wizard->show_send_progress_bar(false);
curr_wizard->show_page(curr_wizard->get_curr_page()->get_next_page());
wxCommandEvent event(EVT_CALIBRATION_JOB_FINISHED);
event.SetEventObject(curr_wizard);
wxPostEvent(curr_wizard, event);
}
evt.Skip();
}
void Plater::print_job_finished(wxCommandEvent &evt)

1
src/slic3r/GUI/Plater.hpp
View file

@ -127,6 +127,7 @@ public:
// BBS
void on_bed_type_change(BedType bed_type);
void load_ams_list(std::string const & device, MachineObject* obj);
std::map<int, DynamicPrintConfig> build_filament_ams_list(MachineObject* obj);
void sync_ams_list();
ObjectList* obj_list();

14
src/slic3r/GUI/PresetComboBoxes.cpp
View file

@ -1522,16 +1522,12 @@ void GUI::CalibrateFilamentComboBox::OnSelect(wxCommandEvent &evt)
}
m_is_compatible = true;
static_cast<FilamentComboBox*>(m_parent)->Enable(true);
std::string selected_name = evt.GetString().ToUTF8().data();
selected_name = Preset::remove_suffix_modified(selected_name);
m_selected_preset = m_collection->find_preset(selected_name);
std::string preset_name = m_collection->get_preset_name_by_alias(selected_name);
std::string preset_name = m_collection->get_preset_name_by_alias(evt.GetString().ToUTF8().data());
m_selected_preset = m_collection->find_preset(preset_name);
SimpleEvent e(EVT_CALIBRATION_TRAY_SELECTION_CHANGED);
auto cali_tab = wxGetApp().mainframe->m_calibration->get_tabpanel();
auto calibration_wizard = static_cast<CalibrationWizard*>(cali_tab->GetPage(cali_tab->GetSelection()));
e.SetEventObject(calibration_wizard);
wxPostEvent(calibration_wizard, e);
wxCommandEvent e(EVT_CALI_TRAY_CHANGED);
e.SetEventObject(m_parent);
wxPostEvent(m_parent, e);
}
} // namespace Slic3r

1203
src/slic3r/GUI/StatusPanel.cpp
View file

File diff suppressed because it is too large Load diff

85
src/slic3r/GUI/StatusPanel.hpp
View file

@ -40,15 +40,6 @@ class StepIndicator;
namespace Slic3r {
namespace GUI {
enum MonitorStatus {
MONITOR_UNKNOWN = 0,
MONITOR_NORMAL = 1 << 1,
MONITOR_NO_PRINTER = 1 << 2,
MONITOR_DISCONNECTED = 1 << 3,
MONITOR_DISCONNECTED_SERVER = 1 << 4,
MONITOR_CONNECTING = 1 << 5,
};
enum CameraRecordingStatus {
RECORDING_NONE,
RECORDING_OFF_NORMAL,
@ -65,6 +56,79 @@ enum CameraTimelapseStatus {
TIMELAPSE_ON_HOVER,
};
enum PrintingTaskType {
PRINGINT,
CALIBRATION,
};
class PrintingTaskPanel : public wxPanel
{
public:
PrintingTaskPanel(wxWindow* parent, PrintingTaskType type);
~PrintingTaskPanel();
void create_panel(wxWindow* parent);
private:
MachineObject* m_obj;
ScalableBitmap m_thumbnail_placeholder;
ScalableBitmap m_bitmap_use_time;
ScalableBitmap m_bitmap_use_weight;
wxPanel * m_panel_printing_title;
wxPanel* m_staticline;
wxPanel* m_panel_error_txt;
wxBoxSizer* m_printing_sizer;
wxStaticText * m_staticText_printing;
wxStaticText* m_staticText_subtask_value;
wxStaticText* m_staticText_consumption_of_time;
wxStaticText* m_staticText_consumption_of_weight;
wxStaticText* m_printing_stage_value;
wxStaticText* m_staticText_profile_value;
wxStaticText* m_staticText_progress_percent;
wxStaticText* m_staticText_progress_percent_icon;
wxStaticText* m_staticText_progress_left;
wxStaticText* m_staticText_layers;
wxStaticBitmap* m_bitmap_thumbnail;
wxStaticBitmap* m_bitmap_static_use_time;
wxStaticBitmap* m_bitmap_static_use_weight;
ScalableButton* m_button_pause_resume;
ScalableButton* m_button_abort;
Button* m_button_market_scoring;
Button* m_button_clean;
ProgressBar* m_gauge_progress;
ErrorMsgStaticText* m_error_text;
PrintingTaskType m_type;
public:
void init_bitmaps();
void init_scaled_buttons();
void error_info_reset();
void show_error_msg(wxString msg);
void reset_printing_value();
void msw_rescale();
public:
void enable_pause_resume_button(bool enable, std::string type);
void enable_abort_button(bool enable);
void update_subtask_name(wxString name);
void update_stage_value(wxString stage, int val);
void update_progress_percent(wxString percent, wxString icon);
void update_left_time(wxString time);
void update_left_time(int mc_left_time);
void update_layers_num(bool show, wxString num = wxEmptyString);
void show_priting_use_info(bool show, wxString time = wxEmptyString, wxString weight = wxEmptyString);
void show_profile_info(bool show, wxString profile = wxEmptyString);
public:
ScalableButton* get_abort_button() {return m_button_abort;};
ScalableButton* get_pause_resume_button() {return m_button_pause_resume;};
Button* get_market_scoring_button() {return m_button_market_scoring;};
Button* get_clean_button() {return m_button_clean;};
wxStaticBitmap* get_bitmap_thumbnail() {return m_bitmap_thumbnail;};
};
class StatusBasePanel : public wxScrolledWindow
{
protected:
@ -208,7 +272,7 @@ protected:
StepIndicator* m_calibration_flow;
wxPanel * m_machine_ctrl_panel;
wxPanel * m_project_task_panel;
PrintingTaskPanel * m_project_task_panel;
// Virtual event handlers, override them in your derived class
virtual void on_subtask_pause_resume(wxCommandEvent &event) { event.Skip(); }
@ -239,7 +303,6 @@ public:
void init_bitmaps();
wxBoxSizer *create_monitoring_page();
wxBoxSizer *create_project_task_page(wxWindow *parent);
wxBoxSizer *create_machine_control_page(wxWindow *parent);
wxBoxSizer *create_temp_axis_group(wxWindow *parent);

1
src/slic3r/GUI/UpgradePanel.cpp
View file

@ -1,4 +1,5 @@
#include "UpgradePanel.hpp"
#include <slic3r/GUI/Widgets/SideTools.hpp>
#include <slic3r/GUI/Widgets/Label.hpp>
#include <slic3r/GUI/I18N.hpp>
#include "GUI.hpp"

361
src/slic3r/GUI/Widgets/SideTools.cpp
View file

@ -1,18 +1,23 @@
#include "SideTools.hpp"
#include "bambu_networking.hpp"
#include <wx/dcmemory.h>
#include <wx/dcgraph.h>
#include "Label.hpp"
#include "StateColor.hpp"
#include "../GUI_App.hpp"
#include "../wxExtensions.hpp"
#include "../I18N.hpp"
#include "../GUI.hpp"
namespace Slic3r { namespace GUI {
SideTools::SideTools(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
SideToolsPanel::SideToolsPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
wxPanel::Create(parent, id, pos, wxSize(0, FromDIP(50)));
Bind(wxEVT_PAINT, &SideTools::OnPaint, this);
wxPanel::Create(parent, id, pos, size);
SetMinSize(wxSize(-1, FromDIP(50)));
SetMaxSize(wxSize(-1, FromDIP(50)));
Bind(wxEVT_PAINT, &SideToolsPanel::OnPaint, this);
SetBackgroundColour(wxColour("#FEFFFF"));
m_printing_img = ScalableBitmap(this, "printer", 16);
@ -30,33 +35,33 @@ namespace Slic3r { namespace GUI {
m_intetval_timer = new wxTimer();
m_intetval_timer->SetOwner(this);
this->Bind(wxEVT_TIMER, &SideTools::stop_interval, this);
this->Bind(wxEVT_ENTER_WINDOW, &SideTools::on_mouse_enter, this);
this->Bind(wxEVT_LEAVE_WINDOW, &SideTools::on_mouse_leave, this);
this->Bind(wxEVT_LEFT_DOWN, &SideTools::on_mouse_left_down, this);
this->Bind(wxEVT_LEFT_UP, &SideTools::on_mouse_left_up, this);
this->Bind(wxEVT_TIMER, &SideToolsPanel::stop_interval, this);
this->Bind(wxEVT_ENTER_WINDOW, &SideToolsPanel::on_mouse_enter, this);
this->Bind(wxEVT_LEAVE_WINDOW, &SideToolsPanel::on_mouse_leave, this);
this->Bind(wxEVT_LEFT_DOWN, &SideToolsPanel::on_mouse_left_down, this);
this->Bind(wxEVT_LEFT_UP, &SideToolsPanel::on_mouse_left_up, this);
}
SideTools::~SideTools() { delete m_intetval_timer; }
SideToolsPanel::~SideToolsPanel() { delete m_intetval_timer; }
void SideTools::set_none_printer_mode()
void SideToolsPanel::set_none_printer_mode()
{
m_none_printer = true;
Refresh();
}
void SideTools::on_timer(wxTimerEvent &event)
void SideToolsPanel::on_timer(wxTimerEvent &event)
{
}
void SideTools::set_current_printer_name(std::string dev_name)
void SideToolsPanel::set_current_printer_name(std::string dev_name)
{
m_none_printer = false;
m_dev_name = from_u8(dev_name);
Refresh();
}
void SideTools::set_current_printer_signal(WifiSignal sign)
void SideToolsPanel::set_current_printer_signal(WifiSignal sign)
{
if (last_printer_signal == sign) return;
@ -66,36 +71,36 @@ void SideTools::set_current_printer_signal(WifiSignal sign)
Refresh();
}
void SideTools::start_interval()
void SideToolsPanel::start_interval()
{
m_intetval_timer->Start(SIDE_TOOL_CLICK_INTERVAL);
m_is_in_interval = true;
}
void SideTools::stop_interval(wxTimerEvent& event)
void SideToolsPanel::stop_interval(wxTimerEvent& event)
{
m_is_in_interval = false;
m_intetval_timer->Stop();
}
bool SideTools::is_in_interval()
bool SideToolsPanel::is_in_interval()
{
return m_is_in_interval;
}
void SideTools::msw_rescale()
void SideToolsPanel::msw_rescale()
{
Refresh();
}
void SideTools::OnPaint(wxPaintEvent &event)
void SideToolsPanel::OnPaint(wxPaintEvent &event)
{
wxPaintDC dc(this);
doRender(dc);
}
void SideTools::render(wxDC &dc)
void SideToolsPanel::render(wxDC &dc)
{
#ifdef __WXMSW__
wxSize size = GetSize();
@ -116,7 +121,7 @@ void SideTools::render(wxDC &dc)
#endif
}
void SideTools::doRender(wxDC &dc)
void SideToolsPanel::doRender(wxDC &dc)
{
auto left = FromDIP(15);
wxSize size = GetSize();
@ -208,27 +213,335 @@ void SideTools::doRender(wxDC &dc)
}
}
void SideTools::on_mouse_left_down(wxMouseEvent &evt)
void SideToolsPanel::on_mouse_left_down(wxMouseEvent &evt)
{
m_click = true;
Refresh();
}
void SideTools::on_mouse_left_up(wxMouseEvent &evt)
void SideToolsPanel::on_mouse_left_up(wxMouseEvent &evt)
{
m_click = false;
Refresh();
}
void SideTools::on_mouse_enter(wxMouseEvent &evt)
void SideToolsPanel::on_mouse_enter(wxMouseEvent &evt)
{
m_hover = true;
Refresh();
}
void SideTools::on_mouse_leave(wxMouseEvent &evt)
void SideToolsPanel::on_mouse_leave(wxMouseEvent &evt)
{
m_hover = false;
Refresh();
}
SideTools::SideTools(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
wxPanel::Create(parent, id, pos, size);
SetBackgroundColour(wxColour("#FEFFFF"));
m_side_tools = new SideToolsPanel(this, wxID_ANY);
m_connection_info = new Button(this, wxEmptyString);
m_connection_info->SetBackgroundColor(wxColour(255, 111, 0));
m_connection_info->SetBorderColor(wxColour(255, 111, 0));
m_connection_info->SetTextColor(*wxWHITE);
m_connection_info->SetFont(::Label::Body_13);
m_connection_info->SetCornerRadius(0);
m_connection_info->SetSize(wxSize(FromDIP(-1), FromDIP(25)));
m_connection_info->SetMinSize(wxSize(FromDIP(-1), FromDIP(25)));
m_connection_info->SetMaxSize(wxSize(FromDIP(-1), FromDIP(25)));
wxBoxSizer* connection_sizer_V = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* connection_sizer_H = new wxBoxSizer(wxHORIZONTAL);
m_hyperlink = new wxHyperlinkCtrl(m_connection_info, wxID_ANY, _L("Failed to connect to the server"), wxT("https://wiki.bambulab.com/en/software/bambu-studio/failed-to-connect-printer"), wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE);
m_hyperlink->SetBackgroundColour(wxColour(255, 111, 0));
m_more_err_open = ScalableBitmap(this, "monitir_err_open", 16);
m_more_err_close = ScalableBitmap(this, "monitir_err_close", 16);
m_more_button = new ScalableButton(m_connection_info, wxID_ANY, "monitir_err_open");
m_more_button->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_HAND); });
m_more_button->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_ARROW); });
m_more_button->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
if (!m_more_err_state) {
m_more_button->SetBitmap(m_more_err_close.bmp());
Freeze();
m_side_error_panel->Show();
m_more_err_state = true;
m_tabpanel->Refresh();
m_tabpanel->Layout();
Thaw();
}
else {
m_more_button->SetBitmap(m_more_err_open.bmp());
Freeze();
m_side_error_panel->Hide();
m_more_err_state = false;
m_tabpanel->Refresh();
m_tabpanel->Layout();
Thaw();
}
});
connection_sizer_H->Add(m_hyperlink, 0, wxALIGN_CENTER | wxALL, 5);
connection_sizer_H->Add(m_more_button, 0, wxALIGN_CENTER | wxALL, 3);
connection_sizer_V->Add(connection_sizer_H, 0, wxALIGN_CENTER, 0);
m_connection_info->SetSizer(connection_sizer_V);
m_connection_info->Layout();
connection_sizer_V->Fit(m_connection_info);
m_side_error_panel = new wxWindow(this, wxID_ANY);
m_side_error_panel->SetBackgroundColour(wxColour(255, 232, 214));
m_side_error_panel->SetMinSize(wxSize(-1, -1));
m_side_error_panel->SetMaxSize(wxSize(-1, -1));
m_side_error_panel->Hide();
m_more_button->Hide();
m_connection_info->Hide();
wxBoxSizer* sizer_print_failed_info = new wxBoxSizer(wxVERTICAL);
m_side_error_panel->SetSizer(sizer_print_failed_info);
wxBoxSizer* sizer_error_code = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* sizer_error_desc = new wxBoxSizer(wxHORIZONTAL);
wxBoxSizer* sizer_extra_info = new wxBoxSizer(wxHORIZONTAL);
m_link_network_state = new Label(m_side_error_panel, _L("Check cloud service status"), wxALIGN_CENTER_HORIZONTAL | wxST_ELLIPSIZE_END);
m_link_network_state->SetMinSize(wxSize(FromDIP(220), -1));
m_link_network_state->SetMaxSize(wxSize(FromDIP(220), -1));
m_link_network_state->SetForegroundColour(0x00AE42);
m_link_network_state->SetFont(::Label::Body_12);
m_link_network_state->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {wxGetApp().link_to_network_check(); });
m_link_network_state->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {m_link_network_state->SetCursor(wxCURSOR_HAND); });
m_link_network_state->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {m_link_network_state->SetCursor(wxCURSOR_ARROW); });
auto st_title_error_code = new wxStaticText(m_side_error_panel, wxID_ANY, _L("code"), wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_error_code_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_error_code = new Label(m_side_error_panel, wxEmptyString);
st_title_error_code->SetForegroundColour(0x909090);
st_title_error_code_doc->SetForegroundColour(0x909090);
m_st_txt_error_code->SetForegroundColour(0x909090);
st_title_error_code->SetFont(::Label::Body_12);
st_title_error_code_doc->SetFont(::Label::Body_12);
m_st_txt_error_code->SetFont(::Label::Body_12);
st_title_error_code->SetMinSize(wxSize(FromDIP(32), -1));
st_title_error_code->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_error_code->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_error_code->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_error_code->Add(st_title_error_code, 0, wxALL, 0);
sizer_error_code->Add(st_title_error_code_doc, 0, wxALL, 0);
sizer_error_code->Add(m_st_txt_error_code, 0, wxALL, 0);
auto st_title_error_desc = new wxStaticText(m_side_error_panel, wxID_ANY, wxT("desc"), wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_error_desc_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_error_desc = new Label(m_side_error_panel, wxEmptyString);
st_title_error_desc->SetForegroundColour(0x909090);
st_title_error_desc_doc->SetForegroundColour(0x909090);
m_st_txt_error_desc->SetForegroundColour(0x909090);
st_title_error_desc->SetFont(::Label::Body_12);
st_title_error_desc_doc->SetFont(::Label::Body_12);
m_st_txt_error_desc->SetFont(::Label::Body_12);
st_title_error_desc->SetMinSize(wxSize(FromDIP(32), -1));
st_title_error_desc->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_error_desc->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_error_desc->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_error_desc->Add(st_title_error_desc, 0, wxALL, 0);
sizer_error_desc->Add(st_title_error_desc_doc, 0, wxALL, 0);
sizer_error_desc->Add(m_st_txt_error_desc, 0, wxALL, 0);
auto st_title_extra_info = new wxStaticText(m_side_error_panel, wxID_ANY, wxT("info"), wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
auto st_title_extra_info_doc = new wxStaticText(m_side_error_panel, wxID_ANY, ": ");
m_st_txt_extra_info = new Label(m_side_error_panel, wxEmptyString);
st_title_extra_info->SetForegroundColour(0x909090);
st_title_extra_info_doc->SetForegroundColour(0x909090);
m_st_txt_extra_info->SetForegroundColour(0x909090);
st_title_extra_info->SetFont(::Label::Body_12);
st_title_extra_info_doc->SetFont(::Label::Body_12);
m_st_txt_extra_info->SetFont(::Label::Body_12);
st_title_extra_info->SetMinSize(wxSize(FromDIP(32), -1));
st_title_extra_info->SetMaxSize(wxSize(FromDIP(32), -1));
m_st_txt_extra_info->SetMinSize(wxSize(FromDIP(175), -1));
m_st_txt_extra_info->SetMaxSize(wxSize(FromDIP(175), -1));
sizer_extra_info->Add(st_title_extra_info, 0, wxALL, 0);
sizer_extra_info->Add(st_title_extra_info_doc, 0, wxALL, 0);
sizer_extra_info->Add(m_st_txt_extra_info, 0, wxALL, 0);
sizer_print_failed_info->Add(m_link_network_state, 0, wxALIGN_CENTER, 3);
sizer_print_failed_info->Add(sizer_error_code, 0, wxLEFT, 5);
sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
sizer_print_failed_info->Add(sizer_error_desc, 0, wxLEFT, 5);
sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
sizer_print_failed_info->Add(sizer_extra_info, 0, wxLEFT, 5);
m_st_txt_error_desc->SetLabel("");
m_st_txt_error_desc->Wrap(FromDIP(170));
wxBoxSizer* m_main_sizer = new wxBoxSizer(wxVERTICAL);
m_main_sizer->Add(m_connection_info, 0, wxEXPAND, 0);
m_main_sizer->Add(m_side_error_panel, 0, wxEXPAND, 0);
m_main_sizer->Add(m_side_tools, 1, wxEXPAND, 0);
SetSizer(m_main_sizer);
Layout();
Fit();
}
void SideTools::msw_rescale()
{
m_side_tools->msw_rescale();
m_connection_info->SetCornerRadius(0);
m_connection_info->SetSize(wxSize(FromDIP(220), FromDIP(25)));
m_connection_info->SetMinSize(wxSize(FromDIP(220), FromDIP(25)));
m_connection_info->SetMaxSize(wxSize(FromDIP(220), FromDIP(25)));
}
bool SideTools::is_in_interval()
{
return m_side_tools->is_in_interval();
}
void SideTools::set_current_printer_name(std::string dev_name)
{
m_side_tools->set_current_printer_name(dev_name);
}
void SideTools::set_current_printer_signal(WifiSignal sign)
{
m_side_tools->set_current_printer_signal(sign);
}
void SideTools::set_none_printer_mode()
{
m_side_tools->set_none_printer_mode();
}
void SideTools::start_interval()
{
m_side_tools->start_interval();
}
void SideTools::update_connect_err_info(int code, wxString desc, wxString info)
{
m_st_txt_error_code->SetLabelText(wxString::Format("%d", code));
m_st_txt_error_desc->SetLabelText(desc);
m_st_txt_extra_info->SetLabelText(info);
m_st_txt_error_code->Wrap(FromDIP(175));
m_st_txt_error_desc->Wrap(FromDIP(175));
m_st_txt_extra_info->Wrap(FromDIP(175));
if (code == BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED) {
m_link_network_state->Hide();
}
else if (code == BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED) {
m_link_network_state->Show();
}
}
void SideTools::update_status(MachineObject* obj)
{
if (!obj) return;
/* Update Device Info */
m_side_tools->set_current_printer_name(obj->dev_name);
// update wifi signal image
int wifi_signal_val = 0;
if (!obj->is_connected() || obj->is_connecting()) {
m_side_tools->set_current_printer_signal(WifiSignal::NONE);
}
else {
if (!obj->wifi_signal.empty() && boost::ends_with(obj->wifi_signal, "dBm")) {
try {
wifi_signal_val = std::stoi(obj->wifi_signal.substr(0, obj->wifi_signal.size() - 3));
}
catch (...) {
;
}
if (wifi_signal_val > -45) {
m_side_tools->set_current_printer_signal(WifiSignal::STRONG);
}
else if (wifi_signal_val <= -45 && wifi_signal_val >= -60) {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::WEAK);
}
}
else {
m_side_tools->set_current_printer_signal(WifiSignal::MIDDLE);
}
}
}
void SideTools::show_status(int status)
{
if (((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0) || ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)) {
if ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER)) {
m_hyperlink->SetLabel(_L("Failed to connect to the server"));
update_connect_err_info(BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED,
_L("Failed to connect to cloud service"),
_L("Please click on the hyperlink above to view the cloud service status"));
}
else {
m_hyperlink->SetLabel(_L("Failed to connect to the printer"));
update_connect_err_info(BAMBU_NETWORK_ERR_CONNECTION_TO_PRINTER_FAILED,
_L("Connection to printer failed"),
_L("Please check the network connection of the printer and Studio."));
}
m_hyperlink->Show();
m_connection_info->SetLabel(wxEmptyString);
m_connection_info->SetBackgroundColor(0xFF6F00);
m_connection_info->SetBorderColor(0xFF6F00);
m_connection_info->Show();
m_more_button->Show();
}
else if ((status & (int)MonitorStatus::MONITOR_NORMAL) != 0) {
m_connection_info->Hide();
m_more_button->Hide();
m_side_error_panel->Hide();
}
else if ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0) {
m_hyperlink->Hide();
m_connection_info->SetLabel(_L("Connecting..."));
m_connection_info->SetBackgroundColor(0x00AE42);
m_connection_info->SetBorderColor(0x00AE42);
m_connection_info->Show();
m_more_button->Hide();
m_side_error_panel->Hide();
}
if ((status & (int)MonitorStatus::MONITOR_NO_PRINTER) != 0) {
m_side_tools->set_none_printer_mode();
m_connection_info->Hide();
m_side_error_panel->Hide();
m_more_button->Hide();
}
else if (((status & (int)MonitorStatus::MONITOR_NORMAL) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0)
) {
if (((status & (int)MonitorStatus::MONITOR_DISCONNECTED) != 0)
|| ((status & (int)MonitorStatus::MONITOR_DISCONNECTED_SERVER) != 0)
|| ((status & (int)MonitorStatus::MONITOR_CONNECTING) != 0)) {
m_side_tools->set_current_printer_signal(WifiSignal::NONE);
}
}
Layout();
Fit();
}
SideTools::~SideTools()
{
}
}}

57
src/slic3r/GUI/Widgets/SideTools.hpp
View file

@ -4,6 +4,11 @@
#include <wx/dcgraph.h>
#include <wx/gdicmn.h>
#include <wx/dcclient.h>
#include <wx/hyperlink.h>
#include "Button.hpp"
#include "Label.hpp"
#include "../GUI/Tabbook.hpp"
#include "../DeviceManager.hpp"
#include "../wxExtensions.hpp"
#define SIDE_TOOLS_GREY900 wxColour(38, 46, 48)
@ -19,11 +24,20 @@ enum WifiSignal {
STRONG,
};
enum MonitorStatus {
MONITOR_UNKNOWN = 0,
MONITOR_NORMAL = 1 << 1,
MONITOR_NO_PRINTER = 1 << 2,
MONITOR_DISCONNECTED = 1 << 3,
MONITOR_DISCONNECTED_SERVER = 1 << 4,
MONITOR_CONNECTING = 1 << 5,
};
#define SIDE_TOOL_CLICK_INTERVAL 20
namespace Slic3r { namespace GUI {
class SideTools : public wxPanel
class SideToolsPanel : public wxPanel
{
private:
WifiSignal m_wifi_type{WifiSignal::NONE};
@ -52,8 +66,8 @@ protected:
bool m_is_in_interval {false};
public:
SideTools(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
~SideTools();
SideToolsPanel(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
~SideToolsPanel();
void set_none_printer_mode();
void on_timer(wxTimerEvent &event);
@ -73,6 +87,43 @@ protected:
void on_mouse_left_down(wxMouseEvent &evt);
void on_mouse_left_up(wxMouseEvent &evt);
};
class SideTools : public wxPanel
{
public:
SideTools(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize);
~SideTools();
private:
SideToolsPanel* m_side_tools{ nullptr };
Tabbook* m_tabpanel{ nullptr };
Label* m_link_network_state{ nullptr };
Label* m_st_txt_error_code{ nullptr };
Label* m_st_txt_error_desc{ nullptr };
Label* m_st_txt_extra_info{ nullptr };
wxWindow* m_side_error_panel{ nullptr };
Button* m_connection_info{ nullptr };
wxHyperlinkCtrl* m_hyperlink{ nullptr };
ScalableButton* m_more_button{ nullptr };
ScalableBitmap m_more_err_open;
ScalableBitmap m_more_err_close;
bool m_more_err_state{ false };
public:
void set_table_panel(Tabbook* tb) {m_tabpanel = tb;};
void msw_rescale();
bool is_in_interval();
void set_current_printer_name(std::string dev_name);
void set_current_printer_signal(WifiSignal sign);
void set_none_printer_mode();
void start_interval();
void update_status(MachineObject* obj);
void update_connect_err_info(int code, wxString desc, wxString info);
void show_status(int status);
public:
SideToolsPanel* get_panel() {return m_side_tools;};
};
}} // namespace Slic3r::GUI
#endif // !slic3r_GUI_SIDETOOLS_hpp_

136
src/slic3r/Utils/CalibUtils.cpp
View file

@ -24,14 +24,102 @@ static std::string MachineBedTypeString[5] = {
"pte"
};
static std::map<CalibMode, std::string> calib_mode_to_name = {
{CalibMode::Calib_Flow_Rate, "flow_rate_calib_mode"},
{CalibMode::Calib_Temp_Tower, "temp_tower_calib_mode"},
{CalibMode::Calib_Vol_speed_Tower, "vol_speed_tower_calib_mode"},
{CalibMode::Calib_VFA_Tower, "vfa_tower_calib_mode"},
{CalibMode::Calib_Retraction_tower, "retration_tower_calib_mode"}
std::string get_calib_mode_name(CalibMode cali_mode, int stage)
{
switch(cali_mode) {
case CalibMode::Calib_Flow_Rate:
if (stage == 1)
return "flow_rate_coarse_calib_mode";
else if (stage == 2)
return "flow_rate_fine_calib_mode";
else
return "flow_rate_coarse_calib_mode";
case CalibMode::Calib_Temp_Tower:
return "temp_tower_calib_mode";
case CalibMode::Calib_Vol_speed_Tower:
return "vol_speed_tower_calib_mode";
case CalibMode::Calib_VFA_Tower:
return "vfa_tower_calib_mode";
case CalibMode::Calib_Retraction_tower:
return "retration_tower_calib_mode";
default:
assert(false);
return "";
}
}
CalibMode CalibUtils::get_calib_mode_by_name(const std::string name, int& cali_stage)
{
if (name == "flow_rate_coarse_calib_mode") {
cali_stage = 1;
return CalibMode::Calib_Flow_Rate;
}
else if (name == "flow_rate_fine_calib_mode") {
cali_stage = 2;
return CalibMode::Calib_Flow_Rate;
}
else if (name == "temp_tower_calib_mode")
return CalibMode::Calib_Temp_Tower;
else if (name == "vol_speed_tower_calib_mode")
return CalibMode::Calib_Vol_speed_Tower;
else if (name == "vfa_tower_calib_mode")
return CalibMode::Calib_VFA_Tower;
else if (name == "retration_tower_calib_mode")
return CalibMode::Calib_Retraction_tower;
return CalibMode::Calib_None;
}
bool CalibUtils::validate_input_k_value(wxString k_text, float* output_value)
{
float default_k = 0.0f;
if (k_text.IsEmpty()) {
*output_value = default_k;
return false;
}
double k_value = 0.0;
try {
k_text.ToDouble(&k_value);
}
catch (...) {
;
}
if (k_value < 0 || k_value > 0.5) {
*output_value = default_k;
return false;
}
*output_value = k_value;
return true;
};
bool CalibUtils::validate_input_flow_ratio(wxString flow_ratio, float* output_value) {
float default_flow_ratio = 1.0f;
if (flow_ratio.IsEmpty()) {
*output_value = default_flow_ratio;
return false;
}
double flow_ratio_value = 0.0;
try {
flow_ratio.ToDouble(&flow_ratio_value);
}
catch (...) {
;
}
if (flow_ratio_value <= 0.0 || flow_ratio_value >= 2.0) {
*output_value = default_flow_ratio;
return false;
}
*output_value = flow_ratio_value;
return true;
}
static void cut_model(Model &model, std::array<Vec3d, 4> plane_points, ModelObjectCutAttributes attributes)
{
size_t obj_idx = 0;
@ -82,17 +170,7 @@ std::array<Vec3d, 4> get_cut_plane_points(const BoundingBoxf3 &bbox, const doubl
return plane_pts;
}
CalibMode CalibUtils::get_calib_mode_by_name(const std::string &name)
{
for (auto iter = calib_mode_to_name.begin(); iter != calib_mode_to_name.end(); ++iter) {
if (iter->second == name) {
return iter->first;
}
}
return CalibMode::Calib_None;
}
void CalibUtils::calib_PA(const X1CCalibInfos &calib_infos, std::string &error_message, int mode)
void CalibUtils::calib_PA(const X1CCalibInfos& calib_infos, int mode, std::string& error_message)
{
DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev)
@ -572,7 +650,7 @@ void CalibUtils::calib_VFA(const CalibInfo& calib_info, std::string& error_messa
cut_model(model, plane_pts, ModelObjectCutAttribute::KeepLower);
}
else {
error_message = "The start, end or step is not valid value.";
error_message = L("The start, end or step is not valid value.");
return;
}
@ -681,7 +759,7 @@ void CalibUtils::process_and_store_3mf(Model* model, const DynamicPrintConfig& f
BuildVolume build_volume(bedfs, print_height);
unsigned int count = model->update_print_volume_state(build_volume);
if (count == 0) {
error_message = "Unable to calibrate: maybe because the set calibration value range is too large, or the step is too small";
error_message = L("Unable to calibrate: maybe because the set calibration value range is too large, or the step is too small");
return;
}
@ -729,7 +807,7 @@ void CalibUtils::process_and_store_3mf(Model* model, const DynamicPrintConfig& f
success = Slic3r::store_bbs_3mf(store_params);
}
void CalibUtils::send_to_print(const CalibInfo& calib_info, std::string &error_message)
void CalibUtils::send_to_print(const CalibInfo &calib_info, std::string &error_message, int flow_ratio_mode)
{
std::string dev_id = calib_info.dev_id;
std::string select_ams = calib_info.select_ams;
@ -738,35 +816,35 @@ void CalibUtils::send_to_print(const CalibInfo& calib_info, std::string &error_m
DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
if (!dev) {
error_message = "Need select printer";
error_message = L("Need select printer");
return;
}
MachineObject* obj_ = dev->get_selected_machine();
if (obj_ == nullptr) {
error_message = "Need select printer";
error_message = L("Need select printer");
return;
}
if (obj_->is_in_printing()) {
error_message = "Cannot send the print job when the printer is updating firmware";
error_message = L("Cannot send the print job when the printer is updating firmware");
return;
}
else if (obj_->is_system_printing()) {
error_message = "The printer is executing instructions. Please restart printing after it ends";
error_message = L("The printer is executing instructions. Please restart printing after it ends");
return;
}
else if (obj_->is_in_printing()) {
error_message = "The printer is busy on other print job";
error_message = L("The printer is busy on other print job");
return;
}
else if (!obj_->is_function_supported(PrinterFunction::FUNC_PRINT_WITHOUT_SD) && (obj_->get_sdcard_state() == MachineObject::SdcardState::NO_SDCARD)) {
error_message = "An SD card needs to be inserted before printing.";
error_message = L("An SD card needs to be inserted before printing.");
return;
}
if (obj_->is_lan_mode_printer()) {
if (obj_->get_sdcard_state() == MachineObject::SdcardState::NO_SDCARD) {
error_message = "An SD card needs to be inserted before printing via LAN.";
error_message = L("An SD card needs to be inserted before printing via LAN.");
return;
}
}
@ -809,7 +887,9 @@ void CalibUtils::send_to_print(const CalibInfo& calib_info, std::string &error_m
print_job->task_ams_mapping = select_ams;
print_job->task_ams_mapping_info = "";
print_job->task_use_ams = select_ams == "[254]" ? false : true;
print_job->m_project_name = calib_mode_to_name[calib_info.params.mode];
CalibMode cali_mode = calib_info.params.mode;
print_job->m_project_name = get_calib_mode_name(cali_mode, flow_ratio_mode);
print_job->has_sdcard = obj_->has_sdcard();
print_job->set_print_config(MachineBedTypeString[bed_type], true, false, false, false, true);

9
src/slic3r/Utils/CalibUtils.hpp
View file

@ -28,9 +28,9 @@ public:
CalibUtils(){};
static std::shared_ptr<PrintJob> print_job;
static CalibMode get_calib_mode_by_name(const std::string &name);
static CalibMode get_calib_mode_by_name(const std::string name, int &cali_stage);
static void calib_PA(const X1CCalibInfos &calib_infos, std::string &error_message, int mode = 0); // 0: automatic mode; 1: manual mode. default: automatic mode
static void calib_PA(const X1CCalibInfos& calib_infos, int mode, std::string& error_message);
static void emit_get_PA_calib_results(float nozzle_diameter);
static bool get_PA_calib_results(std::vector<PACalibResult> &pa_calib_results);
@ -59,9 +59,12 @@ public:
//help function
static int get_selected_calib_idx(const std::vector<PACalibResult> &pa_calib_values, int cali_idx);
static bool validate_input_k_value(wxString k_text, float* output_value);
static bool validate_input_flow_ratio(wxString flow_ratio, float* output_value);
private:
static void process_and_store_3mf(Model* model, const DynamicPrintConfig& full_config, const Calib_Params& params, std::string& error_message);
static void send_to_print(const CalibInfo& calib_info, std::string &error_message);
static void send_to_print(const CalibInfo &calib_info, std::string& error_message, int flow_ratio_mode = 0); // 0: none 1: coarse 2: fine
};
}