mozhe
/
BambuStudio
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

NEW:new fialment load/unload process 

jira:[none]

Change-Id: Ie0076d5c7ec619414121c1f6d37876aaa4e044c1
This commit is contained in:
tao wang 2024-12-04 09:38:34 +08:00 committed by lane.wei
parent 58d6ac32f9
commit 5d9a7eaadc
15 changed files with 826 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
resources/images/filament_load_extruder.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

2
src/slic3r/CMakeLists.txt
View File

@ -62,6 +62,8 @@ set(SLIC3R_GUI_SOURCES
GUI/Widgets/AMSControl.hpp
GUI/Widgets/AMSItem.cpp
GUI/Widgets/AMSItem.hpp
GUI/Widgets/FilamentLoad.cpp
GUI/Widgets/FilamentLoad.hpp
GUI/Widgets/FanControl.cpp
GUI/Widgets/FanControl.hpp
GUI/Widgets/Scrollbar.cpp

40
src/slic3r/GUI/DeviceManager.cpp
View File

@ -2005,6 +2005,19 @@ int MachineObject::command_ams_change_filament(int tray_id, int old_temp, int ne
return this->publish_json(j.dump());
}
int MachineObject::command_ams_change_filament2(int ams_id, int slot_id, int old_temp, int new_temp)
{
json j;
j["print"]["command"] = "ams_change_filament";
j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
j["print"]["target"] = ams_id == VIRTUAL_TRAY_MAIN_ID?VIRTUAL_TRAY_DEPUTY_ID:slot_id;
j["print"]["curr_temp"] = old_temp;
j["print"]["tar_temp"] = new_temp;
j["print"]["ams_id"] = ams_id;
j["print"]["slot_id"] = slot_id;
return this->publish_json(j.dump());
}
int MachineObject::command_ams_user_settings(int ams_id, bool start_read_opt, bool tray_read_opt, bool remain_flag)
{
json j;
@ -3608,14 +3621,14 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
if (jj.contains("nozzle_temper")) {
if (jj["nozzle_temper"].is_number()) {
if (m_extder_data.extders.size() == 1) {
m_extder_data.extders[0].temp = jj["nozzle_temper"].get<float>();
m_extder_data.extders[MAIN_NOZZLE_ID].temp = jj["nozzle_temper"].get<float>();
}
}
}
if (jj.contains("nozzle_target_temper")) {
if (jj["nozzle_target_temper"].is_number()) {
if (m_extder_data.extders.size() == 1) {
m_extder_data.extders[0].target_temp = jj["nozzle_target_temper"].get<float>();
m_extder_data.extders[MAIN_NOZZLE_ID].target_temp = jj["nozzle_target_temper"].get<float>();
}
}
}
@ -3812,8 +3825,8 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
nozzle_diameter = string_to_float(jj["nozzle_diameter"].get<std::string>());
}
if (nozzle_diameter == 0.0f) {m_extder_data.extders[0].current_nozzle_diameter = 0.4f;}
else {m_extder_data.extders[0].current_nozzle_diameter = round(nozzle_diameter * 10) / 10;}
if (nozzle_diameter == 0.0f) {m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter = 0.4f;}
else {m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter = round(nozzle_diameter * 10) / 10;}
}
}
}
@ -3830,7 +3843,7 @@ int MachineObject::parse_json(std::string payload, bool key_field_only)
else {
if (jj["nozzle_type"].is_string()) {
auto nozzle_type = jj["nozzle_type"].get<std::string>();
m_extder_data.extders[0].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_type = NozzleTypeStrToEumn[nozzle_type];
}
}
}
@ -5734,7 +5747,8 @@ void MachineObject::parse_new_info(json print)
} else {
m_extder_data.current_extder_id = get_flag_bits(extruder["state"].get<int>(), 4, 3);
m_extder_data.target_extder_id = get_flag_bits(extruder["state"].get<int>(), 8, 3);
m_extder_data.state = (ExtruderSwitchState) get_flag_bits(extruder["state"].get<int>(), 12, 2);
m_extder_data.switch_extder_state = (ExtruderSwitchState) get_flag_bits(extruder["state"].get<int>(), 12, 2);
m_extder_data.current_loading_extder_id = get_flag_bits(extruder["state"].get<int>(), 15, 3);
}
for (auto it = extruder["info"].begin(); it != extruder["info"].end(); it++) {
@ -5752,16 +5766,16 @@ void MachineObject::parse_new_info(json print)
extder_obj.target_temp = get_flag_bits(njon["temp"].get<int>(), 16, 15);
AmsSlot spre;
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
spre.slot_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 0, 8));
spre.ams_id = std::to_string(get_flag_bits(njon["spre"].get<int>(), 8, 8));
AmsSlot snow;
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
snow.slot_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 0, 8));
snow.ams_id = std::to_string(get_flag_bits(njon["snow"].get<int>(), 8, 8));
AmsSlot star;
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
star.slot_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 0, 8));
star.ams_id = std::to_string(get_flag_bits(njon["star"].get<int>(), 8, 8));
extder_obj.nozzle_id = njon["hnow"].get<int>();
extder_obj.target_nozzle_id = njon["htar"].get<int>();
@ -6048,7 +6062,7 @@ void MachineObject::check_ams_filament_valid()
std::string preset_setting_id;
PresetBundle * preset_bundle = Slic3r::GUI::wxGetApp().preset_bundle;
std::ostringstream stream;
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[0].current_nozzle_diameter;
stream << std::fixed << std::setprecision(1) << m_extder_data.extders[MAIN_NOZZLE_ID].current_nozzle_diameter;
std::string nozzle_diameter_str = stream.str();
bool is_equation = preset_bundle->check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(MachineObject::get_preset_printer_model_name(
this->printer_type),

6
src/slic3r/GUI/DeviceManager.hpp
View File

@ -37,6 +37,8 @@
#define HOLD_COUNT_CAMERA 6
#define GET_VERSION_RETRYS 10
#define RETRY_INTERNAL 2000
#define MAIN_NOZZLE_ID 0
#define DEPUTY_NOZZLE_ID 1
#define VIRTUAL_TRAY_MAIN_ID 255
#define VIRTUAL_TRAY_DEPUTY_ID 254
#define START_SEQ_ID 20000
@ -218,7 +220,8 @@ struct ExtderData
int current_extder_id{0};
int target_extder_id{0};
int total_extder_count {0};
int state;
int current_loading_extder_id {-1};
ExtruderSwitchState switch_extder_state;
std::vector<Extder> extders;
};
@ -1039,6 +1042,7 @@ public:
// ams controls
int command_ams_switch(int tray_index, int old_temp = 210, int new_temp = 210);
int command_ams_change_filament(int tray_id, int old_temp = 210, int new_temp = 210);
int command_ams_change_filament2(int ams_id, int slot_id, int old_temp = 210, int new_temp = 210);
int command_ams_user_settings(int ams_id, bool start_read_opt, bool tray_read_opt, bool remain_flag = false);
int command_ams_switch_filament(bool switch_filament);
int command_ams_air_print_detect(bool air_print_detect);

2
src/slic3r/GUI/Monitor.cpp
View File

@ -305,8 +305,6 @@ void MonitorPanel::select_machine(std::string machine_sn)
if (!dev->set_selected_machine(event.GetString().ToStdString()))
return;
m_status_info_panel->reset_ams_group_show_flag();
set_default();
update_all();

16
src/slic3r/GUI/SelectMachine.cpp
View File

@ -950,9 +950,8 @@ void SelectMachineDialog::update_select_layout(MachineObject *obj)
m_checkbox_list["flow_cali"]->Hide();
m_checkbox_list["nozzle_offset_cali"]->Hide();
if (!obj) {
return;
}
if (!obj) {return;}
AppConfig *config = wxGetApp().app_config;
if (obj->is_enable_np) {
m_checkbox_list["nozzle_offset_cali"]->Show();
@ -968,27 +967,28 @@ void SelectMachineDialog::update_select_layout(MachineObject *obj)
m_checkbox_list["bed_leveling"]->update_options(ops_no_auto);
m_checkbox_list["flow_cali"]->update_options(ops_auto);
AppConfig *config = wxGetApp().app_config;
if (config && config->get("print", "bed_leveling") == "0") {
m_checkbox_list["bed_leveling"]->setValue("off");
} else {
m_checkbox_list["bed_leveling"]->setValue("on");
}
if (config && config->get("print", "flow_cali") == "0") {
m_checkbox_list["flow_cali"]->setValue("off");
} else {
m_checkbox_list["flow_cali"]->setValue("on");
}
update_timelapse_enable_status();
update_flow_cali_check(obj);
}
if (config && config->get("print", "timelapse") == "0") {
m_checkbox_list["timelapse"]->setValue("off");
} else {
m_checkbox_list["timelapse"]->setValue("on");
}
update_timelapse_enable_status();
update_flow_cali_check(obj);
}
if (obj && obj->is_support_auto_flow_calibration) {
m_checkbox_list["flow_cali"]->Show();
}

551
src/slic3r/GUI/StatusPanel.cpp
View File

@ -1307,10 +1307,15 @@ wxBoxSizer *StatusBasePanel::create_machine_control_page(wxWindow *parent)
auto temp_axis_ctrl_sizer = create_temp_axis_group(parent);
auto m_ams_ctrl_sizer = create_ams_group(parent);
auto m_filament_load_sizer = create_filament_group(parent);
bSizer_control->Add(0, 0, 0, wxTOP, FromDIP(8));
bSizer_control->Add(temp_axis_ctrl_sizer, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(8));
bSizer_control->Add(0, 0, 0, wxTOP, FromDIP(6));
bSizer_control->Add(m_ams_ctrl_sizer, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(8));
bSizer_control->Add(m_filament_load_sizer, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(8));
bSizer_control->Add(0, 0, 0, wxTOP, FromDIP(4));
bSizer_control->Add(temp_axis_ctrl_sizer, 0, wxALL | wxEXPAND, FromDIP(4));
bSizer_control->Add(0, 0, 0, wxTOP, FromDIP(10));
bSizer_control->Add(m_ams_ctrl_sizer, 0, wxALL | wxEXPAND, FromDIP(4));
bSizer_right->Add(bSizer_control, 1, wxEXPAND | wxALL, 0);
return bSizer_right;
@ -1587,7 +1592,6 @@ void StatusBasePanel::reset_temp_misc_control()
m_tempCtrl_bed->GetTextCtrl()->SetValue(TEMP_BLANK_STR);
m_tempCtrl_chamber->SetLabel(TEMP_BLANK_STR);
m_tempCtrl_chamber->GetTextCtrl()->SetValue(TEMP_BLANK_STR);
//m_button_unload->Show();
m_tempCtrl_nozzle->Enable(true);
m_tempCtrl_nozzle_deputy->Enable(true);
@ -1805,21 +1809,6 @@ wxBoxSizer *StatusBasePanel::create_extruder_control(wxWindow *parent)
m_bpButton_e_down_10->SetBorderColor(e_ctrl_bd);
m_bpButton_e_down_10->SetMinSize(wxSize(FromDIP(40), FromDIP(40)));
/*m_button_unload = new Button(panel, _L("Unload"));
StateColor abort_bg(std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Disabled), std::pair<wxColour, int>(wxColour(206, 206, 206), StateColor::Pressed),
std::pair<wxColour, int>(wxColour(238, 238, 238), StateColor::Hovered), std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Enabled),
std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Normal));
m_button_unload->SetBackgroundColor(abort_bg);
StateColor abort_bd(std::pair<wxColour, int>(wxColour(144, 144, 144), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
m_button_unload->SetBorderColor(abort_bd);
StateColor abort_text(std::pair<wxColour, int>(wxColour(144, 144, 144), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
m_button_unload->SetTextColor(abort_text);
m_button_unload->SetFont(Label::Body_10);
m_button_unload->SetMinSize(wxSize(-1, FromDIP(24)));
m_button_unload->SetCornerRadius(FromDIP(12));
bSizer_e_ctrl->Add(0, 0, 1, wxEXPAND, 0);
bSizer_e_ctrl->Add(m_button_unload, 0, wxALIGN_CENTER_HORIZONTAL| wxTOP|wxBOTTOM, FromDIP(5));*/
m_extruder_label = new ::Label(panel, _L("Extruder"));
m_extruder_label->SetFont(::Label::Body_13);
m_extruder_label->SetForegroundColour(TEXT_LIGHT_FONT_COL);
@ -1877,15 +1866,75 @@ wxBoxSizer *StatusBasePanel::create_ams_group(wxWindow *parent)
return sizer;
}
wxBoxSizer* StatusBasePanel::create_filament_group(wxWindow* parent)
{
auto sizer = new wxBoxSizer(wxVERTICAL);
auto sizer_box = new wxBoxSizer(wxVERTICAL);
m_filament_load_box = new StaticBox(parent);
StateColor box_colour(std::pair<wxColour, int>(*wxWHITE, StateColor::Normal));
StateColor box_border_colour(std::pair<wxColour, int>(STATUS_PANEL_BG, StateColor::Normal));
m_filament_load_box->SetBackgroundColor(box_colour);
m_filament_load_box->SetBorderColor(box_border_colour);
m_filament_load_box->SetCornerRadius(5);
m_filament_load_box->SetMinSize(wxSize(FromDIP(586), -1));
m_filament_load_box->SetMaxSize(wxSize(FromDIP(586), -1));
m_filament_load_box->SetBackgroundColour(*wxWHITE);
m_filament_step = new FilamentLoad(m_filament_load_box, wxID_ANY);
m_filament_step->SetDoubleBuffered(true);
m_filament_step->set_min_size(wxSize(wxSize(FromDIP(586), FromDIP(215))));
m_filament_step->set_max_size(wxSize(wxSize(FromDIP(586), FromDIP(215))));
m_filament_step->SetBackgroundColour(*wxWHITE);
StateColor btn_bd_white(std::pair<wxColour, int>(wxColour(255, 255, 254), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
StateColor btn_text_white(std::pair<wxColour, int>(wxColour(255, 255, 254), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
StateColor btn_bg_white(std::pair<wxColour, int>(AMS_CONTROL_DISABLE_COLOUR, StateColor::Disabled), std::pair<wxColour, int>(AMS_CONTROL_DISABLE_COLOUR, StateColor::Pressed),
std::pair<wxColour, int>(AMS_CONTROL_DEF_BLOCK_BK_COLOUR, StateColor::Hovered),
std::pair<wxColour, int>(AMS_CONTROL_WHITE_COLOUR, StateColor::Normal));
m_button_retry = new Button(m_filament_load_box, _L("Retry"));
m_button_retry->SetFont(Label::Body_13);
m_button_retry->SetBorderColor(btn_bd_white);
m_button_retry->SetTextColor(btn_text_white);
m_button_retry->SetMinSize(wxSize(FromDIP(80), FromDIP(31)));
m_button_retry->SetBackgroundColor(btn_bg_white);
m_button_retry->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
wxCommandEvent evt(EVT_AMS_RETRY);
evt.SetEventObject(this);
wxPostEvent(m_parent, evt);
});
sizer_box->Add(m_filament_step, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP|wxLEFT|wxRIGHT, FromDIP(10));
sizer_box->Add(0, 0, 0, wxTOP, FromDIP(5));
sizer_box->Add(m_button_retry, 0, wxLEFT, FromDIP(28));
sizer_box->Add(0, 0, 0, wxTOP, FromDIP(10));
m_filament_load_box->SetBackgroundColour(*wxWHITE);
m_filament_load_box->SetSizer(sizer_box);
m_filament_load_box->Layout();
m_filament_load_box->Fit();
sizer->Add(m_filament_load_box, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, FromDIP(10));
return sizer;
}
void StatusBasePanel::show_ams_group(bool show)
{
if (m_show_ams_group != show || m_show_ams_group_reset) {
m_ams_control->Show(true);
m_ams_control_box->Show(true);
if (m_ams_control->IsShown() != show) {
m_ams_control->Show(show);
m_ams_control->show_noams_mode();
if (m_show_ams_group != show) { Fit(); }
}
if (m_ams_control_box->IsShown() != show) {
m_ams_control_box->Show(show);
}
if (m_show_ams_group != show)
{
m_show_ams_group = show;
m_show_ams_group_reset = false;
m_ams_control->Layout();
m_ams_control->Fit();
Layout();
@ -1893,6 +1942,22 @@ void StatusBasePanel::show_ams_group(bool show)
}
}
void StatusBasePanel::show_filament_load_group(bool show)
{
if (m_filament_load_box->IsShown() != show) {
m_filament_load_box->Show(show);
}
if (m_filament_step->IsShown() != show) {
m_filament_step->Show(show);
}
if (m_show_filament_group != show ) {
m_show_filament_group = show;
Layout();
Fit();
}
}
void StatusPanel::update_camera_state(MachineObject* obj)
{
@ -1981,7 +2046,6 @@ StatusPanel::StatusPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, co
, m_fan_control_popup(new FanControlPopup(this))
{
init_scaled_buttons();
//m_buttons.push_back(m_button_unload);
m_buttons.push_back(m_bpButton_z_10);
m_buttons.push_back(m_bpButton_z_1);
m_buttons.push_back(m_bpButton_z_down_1);
@ -2056,7 +2120,6 @@ StatusPanel::StatusPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, co
m_bpButton_e_down_10->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_axis_ctrl_e_down_10), NULL, this);
m_nozzle_btn_panel->Connect(wxCUSTOMEVT_SELECT_NOZZLE_POS, wxCommandEventHandler(StatusPanel::on_nozzle_selected), NULL, this);
//m_button_unload->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_start_unload), NULL, this);
Bind(EVT_AMS_EXTRUSION_CALI, &StatusPanel::on_filament_extrusion_cali, this);
Bind(EVT_AMS_LOAD, &StatusPanel::on_ams_load, this);
Bind(EVT_AMS_UNLOAD, &StatusPanel::on_ams_unload, this);
@ -2124,8 +2187,7 @@ StatusPanel::~StatusPanel()
m_calibration_btn->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_start_calibration), NULL, this);
m_options_btn->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_show_print_options), NULL, this);
m_parts_btn->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_show_parts_options), NULL, this);
//m_button_unload->Disconnect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(StatusPanel::on_start_unload), NULL, this);
//
// remove warning dialogs
if (m_print_error_dlg != nullptr)
delete m_print_error_dlg;
@ -2147,8 +2209,6 @@ StatusPanel::~StatusPanel()
void StatusPanel::init_scaled_buttons()
{
m_project_task_panel->init_scaled_buttons();
//m_button_unload->SetMinSize(wxSize(-1, FromDIP(24)));
//m_button_unload->SetCornerRadius(FromDIP(12));
m_bpButton_z_10->SetMinSize(Z_BUTTON_SIZE);
m_bpButton_z_10->SetCornerRadius(0);
m_bpButton_z_1->SetMinSize(Z_BUTTON_SIZE);
@ -2605,7 +2665,6 @@ void StatusPanel::show_printing_status(bool ctrl_area, bool temp_area)
m_staticText_z_tip->SetForegroundColour(DISCONNECT_TEXT_COL);
m_extruder_label->SetForegroundColour(DISCONNECT_TEXT_COL);
//m_button_unload->Enable(false);
m_switch_speed->SetValue(false);
} else {
m_switch_speed->Enable();
@ -2633,7 +2692,6 @@ void StatusPanel::show_printing_status(bool ctrl_area, bool temp_area)
m_staticText_z_tip->SetForegroundColour(TEXT_LIGHT_FONT_COL);
m_extruder_label->SetForegroundColour(TEXT_LIGHT_FONT_COL);
//m_button_unload->Enable();
m_switch_speed->SetValue(true);
}
@ -2994,16 +3052,16 @@ void StatusPanel::update_ams(MachineObject *obj)
BOOST_LOG_TRIVIAL(trace) << "machine object" << obj->dev_name << " was disconnected, set show_ams_group is false";
}
m_ams_control->SetAmsModel(AMSModel::EXT_AMS, ams_mode);
show_ams_group(false);
show_filament_load_group(false);
m_ams_control->show_auto_refill(false);
}
else {
m_ams_control->SetAmsModel(ams_mode, ams_mode);
m_filament_step->SetAmsModel(ams_mode, ams_mode);
show_ams_group(true);
show_filament_load_group(true);
m_ams_control->show_auto_refill(true);
}
@ -3033,18 +3091,6 @@ void StatusPanel::update_ams(MachineObject *obj)
}
std::string dev_id = obj->dev_id;
ExtderData data = obj->m_extder_data;
//if (obj->ams_exist_bits != last_ams_exist_bits || obj->tray_exist_bits != last_tray_exist_bits || obj->tray_is_bbl_bits != last_tray_is_bbl_bits ||
// obj->tray_read_done_bits != last_read_done_bits || obj->ams_version != last_ams_version) {
// m_ams_control->UpdateAms(ams_info, false);
// // select current ams
// //if (!obj->m_ams_id.empty()) m_ams_control->SwitchAms(obj->m_ams_id);
// last_tray_exist_bits = obj->tray_exist_bits;
// last_ams_exist_bits = obj->ams_exist_bits;
// last_tray_is_bbl_bits = obj->tray_is_bbl_bits;
// last_read_done_bits = obj->tray_read_done_bits;
// last_ams_version = obj->ams_version;
//}
// must select a current can
m_ams_control->UpdateAms(ams_info, ext_info, data, dev_id, false);
@ -3064,119 +3110,208 @@ void StatusPanel::update_ams(MachineObject *obj)
is_vt_tray = true;
// set segment 1, 2
if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID) || obj->m_tray_now == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
if (!obj->is_enable_np) {
if (obj->m_tray_now == std::to_string(255) || obj->m_tray_now == std::to_string(254)) {
m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
}
else {
} else {
if (obj->m_tray_now != "255" && obj->is_filament_at_extruder() && !obj->m_tray_id.empty()) {
m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2);
}
else if (obj->m_tray_now != "255") {
} else if (obj->m_tray_now != "255") {
m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1);
}
else {
} else {
m_ams_control->SetAmsStep(obj->m_ams_id, obj->m_tray_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
}
}
// set segment 3
if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID) || obj->m_tray_now == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
if (obj->m_tray_now == std::to_string(255) || obj->m_tray_now == std::to_string(254)) {
m_ams_control->SetExtruder(obj->is_filament_at_extruder(), true, obj->m_ams_id, obj->vt_slot[0].get_color());
} else {
m_ams_control->SetExtruder(obj->is_filament_at_extruder(), false, obj->m_ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
}
}
else {
if (obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE) {
/*right*/
if (obj->m_extder_data.extders.size() > 0) {
auto ext = obj->m_extder_data.extders[MAIN_NOZZLE_ID];
if (ext.ext_has_filament) {
if (ext.snow.slot_id == std::to_string(MAIN_NOZZLE_ID) || ext.snow.slot_id == std::to_string(MAIN_NOZZLE_ID)) {
m_ams_control->SetAmsStep(ext.star.ams_id, "0", AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3);
} else {
m_ams_control->SetAmsStep(ext.snow.ams_id, ext.snow.slot_id, AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2);
}
m_ams_control->SetExtruder(true, true, ext.snow.ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
} else {
m_ams_control->SetAmsStep(ext.snow.ams_id, ext.snow.slot_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
m_ams_control->SetExtruder(false, true, ext.snow.ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
}
}
/*left*/
if (obj->m_extder_data.extders.size() > 1) {
auto ext = obj->m_extder_data.extders[DEPUTY_NOZZLE_ID];
if (ext.ext_has_filament) {
if (ext.snow.slot_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ext.snow.slot_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
m_ams_control->SetAmsStep(ext.snow.ams_id, "0", AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3);
} else {
m_ams_control->SetAmsStep(ext.snow.ams_id, ext.snow.slot_id, AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2);
}
m_ams_control->SetExtruder(true, true, ext.snow.ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
} else {
m_ams_control->SetAmsStep(ext.snow.ams_id, ext.snow.slot_id, AMSPassRoadType::AMS_ROAD_TYPE_UNLOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
m_ams_control->SetExtruder(false, true, ext.snow.ams_id, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id));
}
}
//m_ams_control->SetAmsStep(std::to_string(VIRTUAL_TRAY_MAIN_ID), "0", AMSPassRoadType::AMS_ROAD_TYPE_LOAD, AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3);
//m_ams_control->SetExtruder(true, true, std::to_string(VIRTUAL_TRAY_MAIN_ID), *wxRED);
}
bool ams_loading_state = false;
auto ams_status_sub = obj->ams_status_sub;
int vt_tray_id = VIRTUAL_TRAY_DEPUTY_ID;
/*if (obj->is_enable_np) {
if (obj->m_extder_data.current_loading_extder_id == MAIN_NOZZLE_ID || obj->m_extder_data.current_loading_extder_id == DEPUTY_NOZZLE_ID) {
ams_loading_state = true;
}
} else if(obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE){
ams_loading_state = true;
}*/
if (ams_loading_state) {
update_filament_step();
if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_MAIN_ID) && (obj->m_tray_now != std::to_string(VIRTUAL_TRAY_MAIN_ID) || obj->m_tray_now != "255")) {
m_filament_step->updateID(std::atoi(obj->m_ams_id.c_str()), std::atoi(obj->m_tray_id.c_str()));
if (obj->m_tray_tar == std::to_string(vt_tray_id) && (obj->m_tray_now != std::to_string(vt_tray_id) || obj->m_tray_now != "255")) {
// wait to heat hotend
if (obj->ams_status_sub == 0x02) {
if (ams_status_sub == 0x02) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_VT_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_VT_LOAD);
}
else if (obj->ams_status_sub == 0x05) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_FEED_FILAMENT, FilamentStepType::STEP_TYPE_VT_LOAD);
else if (ams_status_sub == 0x05) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_VT_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_VT_LOAD);
}
else if (obj->ams_status_sub == 0x06) {
else if (ams_status_sub == 0x06) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CONFIRM_EXTRUDED, FilamentStepType::STEP_TYPE_VT_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CONFIRM_EXTRUDED, FilamentStepType::STEP_TYPE_VT_LOAD);
}
else if (obj->ams_status_sub == 0x07) {
else if (ams_status_sub == 0x07) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_VT_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_VT_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_VT_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_VT_LOAD);
ams_loading_state = false;
}
} else {
// wait to heat hotend
if (obj->ams_status_sub == 0x02) {
if (ams_status_sub == 0x02) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_HEAT_NOZZLE, FilamentStepType::STEP_TYPE_UNLOAD);
}
} else if (obj->ams_status_sub == 0x03) {
} else if (ams_status_sub == 0x03) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
}
} else if (obj->ams_status_sub == 0x04) {
} else if (ams_status_sub == 0x04) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
}
} else if (obj->ams_status_sub == 0x05) {
} else if (ams_status_sub == 0x05) {
if (!obj->is_ams_unload()) {
if(m_is_load_with_temp){
m_ams_control->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CUT_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}else{
m_ams_control->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
}
} else if (obj->ams_status_sub == 0x06) {
} else if (ams_status_sub == 0x06) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PUSH_NEW_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
}
} else if (obj->ams_status_sub == 0x07) {
} else if (ams_status_sub == 0x07) {
if (!obj->is_ams_unload()) {
if (m_is_load_with_temp) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PULL_CURR_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}else{
m_ams_control->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_LOAD);
}
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD);
}
}
else if (obj->ams_status_sub == 0x08) {
else if (ams_status_sub == 0x08) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_LOAD);
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_UNLOAD);
}
}
else if (ams_status_sub == 0x0B) {
if (!obj->is_ams_unload()) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_LOAD);
} else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_UNLOAD);
}
}
else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_UNLOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_UNLOAD);
ams_loading_state = false;
}
}
} else if (obj->ams_status_main == AMS_STATUS_MAIN_ASSIST) {
m_ams_control->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_LOAD);
ams_loading_state = false;
} else {
m_ams_control->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_LOAD);
m_filament_step->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_LOAD);
ams_loading_state = false;
}
show_filament_load_group(ams_loading_state);
for (auto ams_it = obj->amsList.begin(); ams_it != obj->amsList.end(); ams_it++) {
std::string ams_id = ams_it->first;
@ -3195,36 +3330,7 @@ void StatusPanel::update_ams(MachineObject *obj)
} catch (...) {}
}
bool is_curr_tray_selected = false;
if (!curr_ams_id.empty() && !curr_can_id.empty() && (curr_ams_id != std::to_string(VIRTUAL_TRAY_MAIN_ID)) ) {
if (curr_can_id == obj->m_tray_now) {
is_curr_tray_selected = true;
}
else {
std::map<std::string, Ams*>::iterator it = obj->amsList.find(curr_ams_id);
if (it == obj->amsList.end()) {
BOOST_LOG_TRIVIAL(trace) << "ams: find " << curr_ams_id << " failed";
return;
}
auto tray_it = it->second->trayList.find(curr_can_id);
if (tray_it == it->second->trayList.end()) {
BOOST_LOG_TRIVIAL(trace) << "ams: find " << curr_can_id << " failed";
return;
}
if (!tray_it->second->is_exists) {
is_curr_tray_selected = true;
}
}
}else if (curr_ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (curr_ams_id == obj->m_tray_now) {
is_curr_tray_selected = true;
}
}else {
is_curr_tray_selected = true;
}
update_ams_control_state(is_curr_tray_selected);
update_ams_control_state(curr_ams_id, curr_can_id);
}
void StatusPanel::update_ams_insert_material(MachineObject* obj) {
@ -3239,107 +3345,126 @@ void StatusPanel::update_ams_insert_material(MachineObject* obj) {
}
void StatusPanel::update_ams_control_state(bool is_curr_tray_selected)
void StatusPanel::update_ams_control_state(std::string ams_id, std::string slot_id)
{
return;
// set default value to true
bool enable[ACTION_BTN_COUNT];
enable[ACTION_BTN_CALI] = true;
enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = true;
if (obj->is_in_printing()) {
if (obj->is_in_extrusion_cali()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
enable[ACTION_BTN_CALI] = true;
}
else {
enable[ACTION_BTN_CALI] = false;
}
}
else {
enable[ACTION_BTN_CALI] = true;
}
if (obj->is_enable_np) {
if (obj->is_in_printing() && !obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
if (obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
// select current
if (is_curr_tray_selected) {
enable[ACTION_BTN_LOAD] = false;
}
if (!obj->is_filament_at_extruder()) {
enable[ACTION_BTN_UNLOAD] = false;
}
if (obj->ams_exist_bits == 0) {
if (obj->is_in_printing()) {
if (!obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
else{
if (obj->m_tray_now == "255") {
enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false;
}
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true;
}
}
}
}
else {
if (obj->is_in_printing() /*&& obj->can_resume() && obj->m_tray_now != std::to_string(VIRTUAL_TRAY_MAIN_ID) */) {
if (!obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
else {
if (obj->m_tray_now == "255") {
if ( m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID) ) {
enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false;
}
else if (!m_ams_control->GetCurrentCan(m_ams_control->GetCurentAms()).empty()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true;
}
else if (!m_ams_control->GetCurrentCan(m_ams_control->GetCurentAms()).empty()) {
if (!obj->can_resume() || obj->is_in_extrusion_cali()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
else {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
/*switch now*/
bool in_switch_filament = false;
for ( auto ext : obj->m_extder_data.extders) {
if (ext.ams_stat == AmsStatusMain::AMS_STATUS_MAIN_FILAMENT_CHANGE) {
in_switch_filament = true;
}
}
// if (obj->m_tray_now == "255") {
if (in_switch_filament) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
if (ams_id.empty() || slot_id.empty()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
else if (ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) || ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
//todo
} else {
for (auto ext : obj->m_extder_data.extders) {
if (ext.snow.ams_id == ams_id && ext.snow.slot_id == slot_id) {
enable[ACTION_BTN_LOAD] = false;
}
}
/*empty*/
std::map<std::string, Ams *>::iterator it = obj->amsList.find(ams_id);
if (it == obj->amsList.end()) {
enable[ACTION_BTN_LOAD] = false;
} else {
auto tray_it = it->second->trayList.find(slot_id);
if (tray_it == it->second->trayList.end()) { enable[ACTION_BTN_LOAD] = false; }
if (!tray_it->second->is_exists) { enable[ACTION_BTN_LOAD] = false; }
}
}
}
} else {
}
//if (!obj->is_filament_at_extruder()) {
// enable[ACTION_BTN_UNLOAD] = false;
//}
/*if (obj->ams_exist_bits == 0) {
if (obj->is_in_printing()) {
if (!obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
else{
if (obj->m_tray_now == "255") {
enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false;
}
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true;
}
}
}
}
else {
if (obj->is_in_printing()) {
if (!obj->can_resume()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
else {
if (obj->m_tray_now == "255") {
if ( m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID) ) {
enable[ACTION_BTN_LOAD] = true;
enable[ACTION_BTN_UNLOAD] = false;
}
else if (!m_ams_control->GetCurrentCan(m_ams_control->GetCurentAms()).empty()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
else if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
if (m_ams_control->GetCurentAms() == std::to_string(VIRTUAL_TRAY_MAIN_ID)) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = true;
}
else if (!m_ams_control->GetCurrentCan(m_ams_control->GetCurentAms()).empty()) {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
else {
enable[ACTION_BTN_LOAD] = false;
enable[ACTION_BTN_UNLOAD] = false;
}
}
}
}*/
m_ams_control->SetActionState(enable);
}
@ -3837,11 +3962,6 @@ void StatusPanel::on_axis_ctrl_e_down_10(wxCommandEvent &event)
}
}
void StatusPanel::on_start_unload(wxCommandEvent &event)
{
if (obj) obj->command_ams_switch(255);
}
void StatusPanel::on_set_bed_temp()
{
if (!obj) {return;}
@ -3936,7 +4056,8 @@ void StatusPanel::on_ams_load(SimpleEvent &event)
void StatusPanel::update_filament_step()
{
m_ams_control->UpdateStepCtrl(obj->is_filament_at_extruder());
//m_ams_control->UpdateStepCtrl(obj->is_filament_at_extruder());
m_filament_step->UpdateStepCtrl(obj->is_filament_at_extruder());
if (!obj->is_filament_at_extruder()) {
m_is_load_with_temp = true;
}
@ -3970,8 +4091,17 @@ void StatusPanel::on_ams_load_curr()
catch (...) {
;
}
if (obj->is_enable_np) {
try {
if (!curr_ams_id.empty() && !curr_can_id.empty()) {
obj->command_ams_change_filament2(stoi(curr_ams_id), 0, old_temp, new_temp);
}
} catch (...) {}
} else {
obj->command_ams_switch(VIRTUAL_TRAY_MAIN_ID, old_temp, new_temp);
}
}
std::map<std::string, Ams*>::iterator it = obj->amsList.find(curr_ams_id);
if (it == obj->amsList.end()) {
@ -3985,24 +4115,32 @@ void StatusPanel::on_ams_load_curr()
}
AmsTray* curr_tray = obj->get_curr_tray();
AmsTray* targ_tray = obj->get_ams_tray(curr_ams_id, curr_can_id);
if (curr_tray && targ_tray) {
int old_temp = -1;
int new_temp = -1;
if (curr_tray && targ_tray) {
try {
if (!curr_tray->nozzle_temp_max.empty() && !curr_tray->nozzle_temp_min.empty())
old_temp = (atoi(curr_tray->nozzle_temp_min.c_str()) + atoi(curr_tray->nozzle_temp_max.c_str())) / 2;
if (!targ_tray->nozzle_temp_max.empty() && !targ_tray->nozzle_temp_min.empty())
new_temp = (atoi(targ_tray->nozzle_temp_min.c_str()) + atoi(targ_tray->nozzle_temp_max.c_str())) / 2;
}
catch (...) {
} catch (...) {
;
}
int tray_index = atoi(curr_ams_id.c_str()) * 4 + atoi(tray_it->second->id.c_str());
obj->command_ams_switch(tray_index, old_temp, new_temp);
}
else {
int tray_index = atoi(curr_ams_id.c_str()) * 4 + atoi(tray_it->second->id.c_str());
obj->command_ams_switch(tray_index, -1, -1);
if (obj->is_enable_np) {
try {
if (!curr_ams_id.empty() && !curr_can_id.empty()) {
obj->command_ams_change_filament2(stoi(curr_ams_id), stoi(curr_can_id), old_temp, new_temp);
}
}
catch (...){}
} else {
obj->command_ams_switch(tray_index, old_temp, new_temp);
}
}
}
@ -4019,7 +4157,21 @@ void StatusPanel::on_ams_load_vams(wxCommandEvent& event) {
void StatusPanel::on_ams_unload(SimpleEvent &event)
{
if (obj) { obj->command_ams_switch(255); }
if (obj) {
if (obj->is_enable_np) {
try {
std::string curr_ams_id = m_ams_control->GetCurentAms();
std::string curr_can_id = m_ams_control->GetCurrentCan(curr_ams_id);
for (auto ext : obj->m_extder_data.extders) {
if (ext.snow.ams_id == curr_ams_id && ext.snow.slot_id == curr_can_id) { obj->command_ams_change_filament2(stoi(curr_ams_id), 255); }
}
} catch (...) {}
} else {
obj->command_ams_switch(255);
}
}
}
void StatusPanel::on_ams_filament_backup(SimpleEvent& event)
@ -4289,7 +4441,6 @@ void StatusPanel::on_ams_selected(wxCommandEvent &event)
std::string curr_selected_ams_id = std::to_string(event.GetInt());
if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_MAIN_ID)) == 0) {
//update_ams_control_state(curr_ams_id, true);
return;
} else {
std::string curr_can_id = event.GetString().ToStdString();
@ -4701,6 +4852,7 @@ void StatusPanel::set_default()
m_switch_printing_fan_timeout = 0;
m_switch_cham_fan_timeout = 0;
m_show_ams_group = false;
m_show_filament_group = false;
reset_printing_values();
m_bitmap_timelapse_img->Hide();
@ -4715,6 +4867,7 @@ void StatusPanel::set_default()
m_ams_control->Hide();
m_ams_control_box->Hide();
m_ams_control->Reset();
m_filament_step->Hide();
error_info_reset();
#ifndef __WXGTK__
SetFocus();

14
src/slic3r/GUI/StatusPanel.hpp
View File

@ -29,6 +29,7 @@
#include "Widgets/ProgressBar.hpp"
#include "Widgets/ImageSwitchButton.hpp"
#include "Widgets/AMSControl.hpp"
#include "Widgets/FilamentLoad.hpp"
#include "Widgets/FanControl.hpp"
#include "HMS.hpp"
@ -456,7 +457,7 @@ protected:
wxBoxSizer* m_ams_list;
wxStaticText * m_ams_debug;
bool m_show_ams_group{false};
bool m_show_ams_group_reset{true};
bool m_show_filament_group{ false };
AMSControl* m_ams_control;
StaticBox* m_ams_control_box;
wxStaticBitmap *m_ams_extruder_img;
@ -482,6 +483,10 @@ protected:
wxPanel * m_machine_ctrl_panel;
PrintingTaskPanel * m_project_task_panel;
FilamentLoad* m_filament_step;
Button *m_button_retry {nullptr};
StaticBox* m_filament_load_box;
// Virtual event handlers, override them in your derived class
virtual void on_subtask_pause_resume(wxCommandEvent &event) { event.Skip(); }
virtual void on_subtask_abort(wxCommandEvent &event) { event.Skip(); }
@ -527,9 +532,10 @@ public:
int skip_print_error = 0;
wxBoxSizer *create_ams_group(wxWindow *parent);
wxBoxSizer *create_settings_group(wxWindow *parent);
wxBoxSizer* create_filament_group(wxWindow* parent);
void reset_ams_group_show_flag() {m_show_ams_group_reset = true;};
void show_ams_group(bool show = true);
void show_filament_load_group(bool show = true);
MediaPlayCtrl* get_media_play_ctrl() {return m_media_play_ctrl;};
};
@ -622,8 +628,6 @@ protected:
void axis_ctrl_e_hint(bool up_down);
void on_nozzle_selected(wxCommandEvent &event);
void on_start_unload(wxCommandEvent &event);
/* temp control */
void on_bed_temp_kill_focus(wxFocusEvent &event);
void on_bed_temp_set_focus(wxFocusEvent &event);
@ -689,7 +693,7 @@ protected:
void update_ams(MachineObject* obj);
void update_ams_insert_material(MachineObject* obj);
void update_extruder_status(MachineObject* obj);
void update_ams_control_state(bool is_curr_tray_selected);
void update_ams_control_state(std::string ams_id, std::string slot_id);
void update_cali(MachineObject* obj);
void update_calib_bitmap();

22
src/slic3r/GUI/Widgets/AMSControl.cpp
View File

@ -4166,12 +4166,18 @@ void AMSControl::SwitchAms(std::string ams_id)
pos == AMSPanelPos::LEFT_PANEL ? m_simplebook_ams_left->SetSelection(item->m_selection) : m_simplebook_ams_right->SetSelection(item->m_selection);
if (item->m_info.cans.size() == GENERIC_AMS_SLOT_NUM) {
if (item->m_info.ams_type == AMSModel::AMS_LITE) {
pos == AMSPanelPos::LEFT_PANEL ? m_down_road->UpdateLeft(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE)
: m_down_road->UpdateRight(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE);
if (pos == AMSPanelPos::LEFT_PANEL) {
m_down_road->UpdateLeft(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE);
} else {
m_down_road->UpdateRight(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE);
}
}
else {
pos == AMSPanelPos::LEFT_PANEL ? m_down_road->UpdateLeft(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR)
: m_down_road->UpdateRight(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR);
if (pos == AMSPanelPos::LEFT_PANEL) {
m_down_road->UpdateLeft(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR);
} else {
m_down_road->UpdateRight(m_extder_data.total_extder_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR);
}
}
}
else {
@ -4186,11 +4192,9 @@ void AMSControl::SwitchAms(std::string ams_id)
: m_down_road->UpdateRight(m_extder_data.total_extder_count, mode);
if (pos == AMSPanelPos::LEFT_PANEL) {
m_down_road->UpdatePassRoad(item->m_info.current_can_id, AMSPanelPos::LEFT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
}
else{
} else {
m_down_road->UpdatePassRoad(item->m_info.current_can_id, AMSPanelPos::RIGHT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
}
}
}
}
@ -4513,6 +4517,10 @@ void AMSControl::SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadTy
length = 145;
}
if (model == EXT_AMS && ams->m_info.ext_type == AMSModelOriginType::GENERIC_EXT){
length = 82;
}
for (auto i = 0; i < m_ams_info.size(); i++) {
if (m_ams_info[i].ams_id == ams_id) {
m_ams_info[i].current_step = step;

5
src/slic3r/GUI/Widgets/AMSItem.cpp
View File

@ -957,7 +957,7 @@ void AMSLib::on_left_down(wxMouseEvent &evt)
auto top = 0;
auto bottom = 0;
if (m_ams_model == AMSModel::GENERIC_AMS) {
if (m_ams_model == AMSModel::GENERIC_AMS || m_ams_model == AMSModel::N3F_AMS || m_ams_model == AMSModel::EXT_AMS) {
top = (size.y - FromDIP(15) - m_bitmap_editable_light.GetBmpSize().y);
bottom = size.y - FromDIP(15);
}
@ -2265,7 +2265,6 @@ void AMSRoadDownPart::create(wxWindow* parent, wxWindowID id, const wxPoint& pos
// Refresh();
//}
void AMSRoadDownPart::UpdateLeft(int nozzle_num, AMSRoadShowMode mode) {
this->m_left_rode_mode = mode;
m_nozzle_num = nozzle_num;
@ -2277,7 +2276,6 @@ void AMSRoadDownPart::UpdateRight(int nozzle_num, AMSRoadShowMode mode) {
Refresh();
}
void AMSRoadDownPart::OnVamsLoading(bool load, wxColour col /*= AMS_CONTROL_GRAY500*/)
{
/*m_vams_loading = load;
@ -2478,6 +2476,7 @@ void AMSRoadDownPart::UpdatePassRoad(string can_id, AMSPanelPos pos, int len, AM
m_pass_road_right_step = step;
}
}
Refresh();
}
void AMSRoadDownPart::msw_rescale() {

6
src/slic3r/GUI/Widgets/AMSItem.hpp
View File

@ -126,8 +126,8 @@ enum FilamentStep {
STEP_CUT_FILAMENT,
STEP_PULL_CURR_FILAMENT,
STEP_PUSH_NEW_FILAMENT,
STEP_GRAB_NEW_FILAMENT,
STEP_PURGE_OLD_FILAMENT,
STEP_FEED_FILAMENT,
STEP_CONFIRM_EXTRUDED,
STEP_CHECK_POSITION,
STEP_COUNT,
@ -162,10 +162,6 @@ enum FilamentStepType {
#define AMS_HUMIDITY_SIZE wxSize(FromDIP(93), FromDIP(26))
#define AMS_PANEL_SIZE wxSize(FromDIP(264), FromDIP(150))
#define MAIN_NOZZLE_ID 0
#define DEPUTY_NOZZLE_ID 1
#define GENERIC_AMS_SLOT_NUM 4
#define MAX_AMS_NUM_IN_PANEL 2

223
src/slic3r/GUI/Widgets/FilamentLoad.cpp Normal file
View File

@ -0,0 +1,223 @@
#include "FilamentLoad.hpp"
#include "Label.hpp"
#include "../BitmapCache.hpp"
#include "../I18N.hpp"
#include "../GUI_App.hpp"
#include <wx/simplebook.h>
#include <wx/dcgraph.h>
#include <boost/log/trivial.hpp>
#include "CalibUtils.hpp"
namespace Slic3r {
namespace GUI {
FilamentLoad::FilamentLoad(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size)
: wxSimplebook(parent, wxID_ANY, pos, size)
{
SetBackgroundColour(*wxWHITE);
m_filament_load_steps = new FilamentStepIndicator(this, wxID_ANY);
m_filament_unload_steps = new ::FilamentStepIndicator(this, wxID_ANY);
m_filament_vt_load_steps = new ::FilamentStepIndicator(this, wxID_ANY);
this->AddPage(m_filament_load_steps, wxEmptyString, false);
this->AddPage(m_filament_unload_steps, wxEmptyString, false);
this->AddPage(m_filament_vt_load_steps, wxEmptyString, false);
//UpdateStepCtrl(false);
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_IDLE] = _L("Idling...");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE] = _L("Heat the nozzle");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT] = _L("Cut filament");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT] = _L("Pull back current filament");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT] = _L("Push new filament into extruder");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_GRAB_NEW_FILAMENT] = _L("Grab new filament");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT] = _L("Purge old filament");
//FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_FEED_FILAMENT] = _L("Feed Filament");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CONFIRM_EXTRUDED] = _L("Confirm extruded");
FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION] = _L("Check filament location");
}
void FilamentLoad::SetFilamentStep(FilamentStep item_idx, FilamentStepType f_type)
{
if (item_idx == FilamentStep::STEP_IDLE) {
m_filament_load_steps->Idle();
m_filament_unload_steps->Idle();
m_filament_vt_load_steps->Idle();
this->Hide();
return;
}
this->Show();
wxString step_str = wxEmptyString;
if (item_idx < FilamentStep::STEP_COUNT) {
step_str = FILAMENT_CHANGE_STEP_STRING[item_idx];
}
auto step_control = m_filament_load_steps;
if (f_type == FilamentStepType::STEP_TYPE_LOAD) {
step_control = m_filament_load_steps;
if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) {
if (this->GetSelection() != 0) {
this->SetSelection(0);
}
m_filament_load_steps->SelectItem(m_filament_load_steps->GetItemUseText(step_str));
}
else {
m_filament_load_steps->Idle();
this->Hide();
this->Layout();
}
}
else if (f_type == FilamentStepType::STEP_TYPE_UNLOAD) {
step_control = m_filament_unload_steps;
if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) {
if (GetSelection() != 1) {
this->SetSelection(1);
this->Layout();
}
m_filament_unload_steps->SelectItem(m_filament_unload_steps->GetItemUseText(step_str));
}
else {
m_filament_unload_steps->Idle();
this->Hide();
this->Layout();
}
}
else if (f_type == FilamentStepType::STEP_TYPE_VT_LOAD) {
step_control = m_filament_vt_load_steps;
this->SetSelection(2);
this->Layout();
if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) {
if (item_idx == STEP_CONFIRM_EXTRUDED) {
m_filament_vt_load_steps->SelectItem(2);
}
else {
m_filament_vt_load_steps->SelectItem(m_filament_vt_load_steps->GetItemUseText(step_str));
}
}
else {
m_filament_vt_load_steps->Idle();
this->Hide();
this->Layout();
}
}
else {
step_control = m_filament_load_steps;
if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) {
SetSelection(0);
m_filament_load_steps->SelectItem(m_filament_load_steps->GetItemUseText(step_str));
}
else {
m_filament_load_steps->Idle();
this->Hide();
this->Layout();
}
}
wxString slot_info = L"Ams-";
slot_info = slot_info + std::to_string(m_ams_id);
slot_info = slot_info + L'-';
slot_info = slot_info + std::to_string(m_slot_id);
slot_info = slot_info + L" Slot";
step_control->SetSlotInformation(slot_info);
}
void FilamentLoad::UpdateStepCtrl(bool is_extrusion_exist) {
m_filament_load_steps->DeleteAllItems();
m_filament_unload_steps->DeleteAllItems();
m_filament_vt_load_steps->DeleteAllItems();
is_extrusion = true; //Forgot what it means, need to update dynamically
if (m_ams_model == AMSModel::GENERIC_AMS || m_ext_model == AMSModel::GENERIC_AMS) {
if (is_extrusion) {
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]);
}
else {
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]);
}
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_GRAB_NEW_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]);
}
if (m_ams_model == AMSModel::AMS_LITE || m_ext_model == AMSModel::AMS_LITE) {
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]);
m_filament_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]);
m_filament_vt_load_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]);
m_filament_unload_steps->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]);
}
}
void FilamentLoad::show_nofilament_mode(bool show)
{
m_filament_load_steps->DeleteAllItems();
m_filament_unload_steps->DeleteAllItems();
m_filament_vt_load_steps->DeleteAllItems();
m_filament_load_steps->Idle();
m_filament_unload_steps->Idle();
m_filament_vt_load_steps->Idle();
this->Layout();
Refresh();
/*if (!show)
{
m_filament_load_steps->Idle();
m_filament_unload_steps->Idle();
m_filament_vt_load_steps->Idle();
}
else {
this->Show();
this->Layout();
}*/
}
void FilamentLoad::set_min_size(const wxSize& minSize) {
this->SetMinSize(minSize);
m_filament_load_steps->SetMinSize(minSize);
m_filament_unload_steps->SetMinSize(minSize);
m_filament_vt_load_steps->SetMinSize(minSize);
}
void FilamentLoad::set_max_size(const wxSize& minSize) {
this->SetMaxSize(minSize);
m_filament_load_steps->SetMaxSize(minSize);
m_filament_unload_steps->SetMaxSize(minSize);
m_filament_vt_load_steps->SetMaxSize(minSize);
}
void FilamentLoad::set_background_color(const wxColour& colour) {
m_filament_load_steps->SetBackgroundColour(colour);
m_filament_unload_steps->SetBackgroundColour(colour);
m_filament_vt_load_steps->SetBackgroundColour(colour);
}
}} // namespace Slic3r::GUI

60
src/slic3r/GUI/Widgets/FilamentLoad.hpp Normal file
View File

@ -0,0 +1,60 @@
#ifndef slic3r_GUI_FILAMENTLOAD_hpp_
#define slic3r_GUI_FILAMENTLOAD_hpp_
#include "../wxExtensions.hpp"
#include "StaticBox.hpp"
#include "StepCtrl.hpp"
#include "AMSControl.hpp"
#include "../DeviceManager.hpp"
#include "slic3r/GUI/Event.hpp"
#include "slic3r/GUI/AmsMappingPopup.hpp"
#include <wx/simplebook.h>
#include <wx/hyperlink.h>
#include <wx/animate.h>
#include <wx/dynarray.h>
namespace Slic3r { namespace GUI {
class FilamentLoad : public wxSimplebook
{
public:
FilamentLoad(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize);
protected:
::FilamentStepIndicator* m_filament_load_steps = { nullptr };
::FilamentStepIndicator* m_filament_unload_steps = { nullptr };
::FilamentStepIndicator* m_filament_vt_load_steps = { nullptr };
int m_ams_id = { 1 };
int m_slot_id = { 1 };
bool is_extrusion = false;
public:
std::map<FilamentStep, wxString> FILAMENT_CHANGE_STEP_STRING;
AMSModel m_ams_model{ AMSModel::GENERIC_AMS };
AMSModel m_ext_model{ AMSModel::AMS_LITE };
AMSModel m_is_none_ams_mode{ AMSModel::AMS_LITE };
void SetAmsModel(AMSModel mode, AMSModel ext_mode) { m_ams_model = mode; m_ext_model = ext_mode; };
void SetFilamentStep(FilamentStep item_idx, FilamentStepType f_type);
void ShowFilamentTip(bool hasams = true);
void UpdateStepCtrl(bool is_extrusion_exist);
void show_nofilament_mode(bool show);
void updateID(int ams_id, int slot_id) { m_ams_id = ams_id; m_slot_id = slot_id; };
void SetExt(bool ext) { is_extrusion = ext; };
void set_min_size(const wxSize& minSize);
void set_max_size(const wxSize& maxSize);
void set_background_color(const wxColour& colour);
};
}}
#endif // !slic3r_GUI_filamentload_hpp_

131
src/slic3r/GUI/Widgets/StepCtrl.cpp
View File

@ -351,3 +351,134 @@ void StepIndicator::doRender(wxDC &dc)
circleY += itemWidth;
}
}
/* FilamentStepIndicator */
FilamentStepIndicator::FilamentStepIndicator(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
: StepCtrlBase(parent, id, pos, size, style)
, bmp_ok(this, "step_ok", 12)
{
static Slic3r::GUI::BitmapCache cache;
bmp_extruder = *cache.load_png("filament_load_extruder", FromDIP(300), FromDIP(200), false, false);
SetFont(Label::Body_12);
font_tip = Label::Body_12;
clr_bar = 0xE1E1E1;
clr_step = StateColor(
std::make_pair(0xACACAC, (int)StateColor::Disabled),
std::make_pair(0x00AE42, 0));
clr_text = StateColor(
std::make_pair(0xACACAC, (int)StateColor::Disabled),
std::make_pair(0x323A3D, (int)StateColor::Checked),
std::make_pair(0x6B6B6B, 0));
clr_tip = *wxWHITE;
StaticBox::border_width = 0;
radius = 9;
bar_width = 0;
}
void FilamentStepIndicator::Rescale()
{
bmp_ok.msw_rescale();
radius = bmp_ok.GetBmpHeight() / 2;
bar_width = bmp_ok.GetBmpHeight() / 20;
if (bar_width < 2) bar_width = 2;
}
void FilamentStepIndicator::SelectNext() { SelectItem(step + 1); }
void FilamentStepIndicator::doRender(wxDC& dc)
{
if (steps.empty()) return;
StaticBox::doRender(dc);
wxSize size = GetSize();
int states = state_handler.states();
if (!IsEnabled()) {
states = clr_step.Disabled;
}
dc.SetFont(::Label::Head_16);
dc.SetTextForeground(wxColour(0, 174, 66));
int circleX = 20;
int circleY = 20;
wxSize sz = dc.GetTextExtent(L"Loading");
dc.DrawText(L"Loading", circleX, circleY);
dc.SetFont(::Label::Body_13);
dc.DrawText(m_slot_information, circleX + sz.GetWidth() + FromDIP(5), circleY + FromDIP(3));
dc.DrawBitmap(bmp_extruder, FromDIP(250), circleY);
circleY += sz.y;
int textWidth = size.x - radius * 5;
dc.SetFont(GetFont());
wxString firstLine;
if (step == 0) dc.SetFont(GetFont().Bold());
wxSize firstLineSize = Label::split_lines(dc, textWidth, steps.front(), firstLine);
wxString lastLine;
if (step == steps.size() - 1) dc.SetFont(GetFont().Bold());
wxSize lastLineSize = Label::split_lines(dc, textWidth, steps.back(), lastLine);
int firstPadding = std::max(0, firstLineSize.y / 2 - radius);
int lastPadding = std::max(0, lastLineSize.y / 2 - radius);
int itemWidth = radius * 3;
// Draw thin bar stick
dc.SetPen(wxPen(clr_bar.colorForStates(states)));
dc.SetBrush(wxBrush(clr_bar.colorForStates(states)));
//dc.DrawRectangle(rcBar);
circleX += radius;
circleY += radius * 3 + firstPadding;
dc.SetPen(wxPen(clr_step.colorForStates(states)));
dc.SetBrush(wxBrush(clr_step.colorForStates(states)));
for (int i = 0; i < steps.size(); ++i) {
bool disabled = step > i;
bool checked = step == i;
// Draw circle point & texts in it
dc.DrawEllipse(circleX - radius, circleY - radius, radius * 2, radius * 2);
// Draw content ( icon or text ) in circle
if (disabled) {
wxSize sz = bmp_ok.GetBmpSize();
dc.DrawBitmap(bmp_ok.bmp(), circleX - sz.x / 2, circleY - sz.y / 2);
}
else {
dc.SetFont(font_tip);
dc.SetTextForeground(clr_tip.colorForStates(states));
auto tip = tips[i];
if (tip.IsEmpty()) tip.append(1, wchar_t(L'0' + i + 1));
wxSize sz = dc.GetTextExtent(tip);
dc.DrawText(tip, circleX - sz.x / 2, circleY - sz.y / 2 + 1);
}
// Draw step text
dc.SetTextForeground(clr_text.colorForStates(states
| (disabled ? StateColor::Disabled : checked ? StateColor::Checked : 0)));
dc.SetFont(checked ? GetFont().Bold() : GetFont());
wxString text;
wxSize textSize;
if (i == 0) {
text = firstLine;
textSize = firstLineSize;
}
else if (i == steps.size() - 1) {
text = lastLine;
textSize = lastLineSize;
}
else {
textSize = Label::split_lines(dc, textWidth, steps[i], text);
}
dc.DrawText(text, circleX + radius * 1.5, circleY - (textSize.y / 2));
circleY += itemWidth;
}
}
void FilamentStepIndicator::SetSlotInformation(wxString slot) {
this->m_slot_information = slot;
}

24
src/slic3r/GUI/Widgets/StepCtrl.hpp
View File

@ -103,4 +103,28 @@ private:
void doRender(wxDC &dc) override;
};
class FilamentStepIndicator : public StepCtrlBase
{
ScalableBitmap bmp_ok;
wxBitmap bmp_extruder;
wxString m_slot_information = "";
public:
FilamentStepIndicator(wxWindow* parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0);
virtual void Rescale();
void SelectNext();
void SetSlotInformation(wxString slot);
private:
void doRender(wxDC& dc) override;
};
#endif // !slic3r_GUI_StepCtrlBase_hpp_