diff --git a/resources/config.json b/resources/config.json index aa1bbf589..53a7abeeb 100644 --- a/resources/config.json +++ b/resources/config.json @@ -26,7 +26,7 @@ "ftp_folder": "sdcard/", "printer_thumbnail_image": "printer_thumbnail_p1p" }, - { + { "display_name": "Bambu Lab P1S", "func": { "FUNC_CHAMBER_TEMP": false, @@ -47,9 +47,9 @@ "camera_resolution": [ "720p" ], "bed_temperature_limit": 100, "model_id": "C12", - "compatible_machine":["BL-P001", "BL-P002", "C11"], + "compatible_machine": [ "BL-P001", "BL-P002", "C11" ], "printer_type": "C12", - "ftp_folder" : "sdcard/", + "ftp_folder": "sdcard/", "printer_thumbnail_image": "printer_thumbnail_p1p" }, { diff --git a/resources/images/ams_extra_framework_mid.svg b/resources/images/ams_extra_framework_mid.svg new file mode 100644 index 000000000..480ae748b --- /dev/null +++ b/resources/images/ams_extra_framework_mid.svg @@ -0,0 +1,3 @@ + + + diff --git a/resources/images/enable_ams_disable.svg b/resources/images/enable_ams_disable.svg new file mode 100644 index 000000000..69060f2a1 --- /dev/null +++ b/resources/images/enable_ams_disable.svg @@ -0,0 +1,3 @@ + + + diff --git a/resources/images/extra_ams_tray_left.svg b/resources/images/extra_ams_tray_left.svg new file mode 100644 index 000000000..f2aae5c5e --- /dev/null +++ b/resources/images/extra_ams_tray_left.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/extra_ams_tray_left_hover.svg b/resources/images/extra_ams_tray_left_hover.svg new file mode 100644 index 000000000..aff51a25d --- /dev/null +++ b/resources/images/extra_ams_tray_left_hover.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/extra_ams_tray_left_selected.svg b/resources/images/extra_ams_tray_left_selected.svg new file mode 100644 index 000000000..b63329c06 --- /dev/null +++ b/resources/images/extra_ams_tray_left_selected.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/extra_ams_tray_right.svg b/resources/images/extra_ams_tray_right.svg new file mode 100644 index 000000000..993222a8d --- /dev/null +++ b/resources/images/extra_ams_tray_right.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/extra_ams_tray_right_hover.svg b/resources/images/extra_ams_tray_right_hover.svg new file mode 100644 index 000000000..01a634981 --- /dev/null +++ b/resources/images/extra_ams_tray_right_hover.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/extra_ams_tray_right_selected.svg b/resources/images/extra_ams_tray_right_selected.svg new file mode 100644 index 000000000..3fbb312a7 --- /dev/null +++ b/resources/images/extra_ams_tray_right_selected.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/resources/images/printer_thumbnail_n1.svg b/resources/images/printer_thumbnail_n1.svg new file mode 100644 index 000000000..87022438d --- /dev/null +++ b/resources/images/printer_thumbnail_n1.svg @@ -0,0 +1,1295 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/images/printer_thumbnail_n1_dark.svg b/resources/images/printer_thumbnail_n1_dark.svg new file mode 100644 index 000000000..87022438d --- /dev/null +++ b/resources/images/printer_thumbnail_n1_dark.svg @@ -0,0 +1,1295 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/slic3r/GUI/StatusPanel.cpp b/src/slic3r/GUI/StatusPanel.cpp index 531599a51..7067a312c 100644 --- a/src/slic3r/GUI/StatusPanel.cpp +++ b/src/slic3r/GUI/StatusPanel.cpp @@ -1405,11 +1405,11 @@ wxBoxSizer *StatusBasePanel::create_ams_group(wxWindow *parent) return sizer; } -void StatusBasePanel::show_ams_group(bool show, bool support_virtual_tray, bool support_extrustion_cali) +void StatusBasePanel::show_ams_group(bool show) { m_ams_control->Show(true); m_ams_control_box->Show(true); - m_ams_control->show_noams_mode(show, support_virtual_tray, support_extrustion_cali); + m_ams_control->show_noams_mode(); if (m_show_ams_group != show) { Fit(); } @@ -2251,9 +2251,9 @@ void StatusPanel::update_ams(MachineObject *obj) CalibUtils::emit_get_PA_calib_info(obj->nozzle_diameter, ""); } - bool is_support_extrusion_cali = obj->is_function_supported(PrinterFunction::FUNC_EXTRUSION_CALI); - bool is_support_virtual_tray = obj->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY); + bool is_support_virtual_tray = obj->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY); bool is_support_filament_backup = obj->is_function_supported(PrinterFunction::FUNC_FILAMENT_BACKUP); + AMSModel ams_mode = AMSModel::GENERIC_AMS; if (!obj || !obj->is_connected() @@ -2269,11 +2269,18 @@ void StatusPanel::update_ams(MachineObject *obj) BOOST_LOG_TRIVIAL(trace) << "machine object" << obj->dev_name << " was disconnected, set show_ams_group is false"; } - show_ams_group(false, obj->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY), is_support_extrusion_cali); + + if (obj->printer_type == "N1") { ams_mode = AMSModel::EXTRA_AMS; } + m_ams_control->SetAmsModel(AMSModel::NO_AMS, ams_mode); + + show_ams_group(false); m_ams_control->show_auto_refill(false); } else { - show_ams_group(true, obj->is_function_supported(PrinterFunction::FUNC_VIRTUAL_TYAY), is_support_extrusion_cali); + if (obj->printer_type == "N1") { ams_mode = AMSModel::EXTRA_AMS; } + m_ams_control->SetAmsModel(ams_mode, ams_mode); + + show_ams_group(true); if (!obj->m_is_support_show_bak || !is_support_filament_backup || !obj->ams_support_auto_switch_filament_flag) { m_ams_control->show_auto_refill(false); @@ -2307,7 +2314,7 @@ void StatusPanel::update_ams(MachineObject *obj) //} // must select a current can - m_ams_control->UpdateAms(ams_info, false, is_support_extrusion_cali); + m_ams_control->UpdateAms(ams_info, false); last_tray_exist_bits = obj->tray_exist_bits; last_ams_exist_bits = obj->ams_exist_bits; @@ -2341,13 +2348,15 @@ void StatusPanel::update_ams(MachineObject *obj) // set segment 3 if (obj->m_tray_now == std::to_string(VIRTUAL_TRAY_ID)) { - m_ams_control->SetExtruder(obj->is_filament_at_extruder(), true, obj->vt_tray.get_color()); + m_ams_control->SetExtruder(obj->is_filament_at_extruder(), true, obj->m_ams_id, obj->vt_tray.get_color()); } else { - m_ams_control->SetExtruder(obj->is_filament_at_extruder(), false, m_ams_control->GetCanColour(obj->m_ams_id, obj->m_tray_id)); + 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)); } if (obj->ams_status_main == AMS_STATUS_MAIN_FILAMENT_CHANGE) { + update_filament_step(); + if (obj->m_tray_tar == std::to_string(VIRTUAL_TRAY_ID) && (obj->m_tray_now != std::to_string(VIRTUAL_TRAY_ID) || obj->m_tray_now != "255")) { // wait to heat hotend if (obj->ams_status_sub == 0x02) { @@ -2418,6 +2427,14 @@ void StatusPanel::update_ams(MachineObject *obj) else { m_ams_control->SetFilamentStep(FilamentStep::STEP_PURGE_OLD_FILAMENT, FilamentStepType::STEP_TYPE_UNLOAD); } + } + else if (obj->ams_status_sub == 0x08) { + if (!obj->is_ams_unload()) { + m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_LOAD); + } + else { + m_ams_control->SetFilamentStep(FilamentStep::STEP_CHECK_POSITION, FilamentStepType::STEP_TYPE_UNLOAD); + } } else { m_ams_control->SetFilamentStep(FilamentStep::STEP_IDLE, FilamentStepType::STEP_TYPE_UNLOAD); } @@ -2475,10 +2492,10 @@ void StatusPanel::update_ams(MachineObject *obj) is_curr_tray_selected = true; } - update_ams_control_state(is_support_extrusion_cali, is_curr_tray_selected); + update_ams_control_state(is_curr_tray_selected); } -void StatusPanel::update_ams_control_state(bool is_support_virtual_tray, bool is_curr_tray_selected) +void StatusPanel::update_ams_control_state(bool is_curr_tray_selected) { // set default value to true bool enable[ACTION_BTN_COUNT]; @@ -2486,21 +2503,18 @@ void StatusPanel::update_ams_control_state(bool is_support_virtual_tray, bool is enable[ACTION_BTN_LOAD] = true; enable[ACTION_BTN_UNLOAD] = true; - if (!is_support_virtual_tray) { - enable[ACTION_BTN_CALI] = false; - } - else { - 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 { + 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_in_printing() && !obj->can_resume()) { @@ -2996,47 +3010,43 @@ void StatusPanel::on_ams_load(SimpleEvent &event) on_ams_load_curr(); } +void StatusPanel::update_filament_step() +{ + m_ams_control->UpdateStepCtrl(obj->is_filament_at_extruder()); + if (!obj->is_filament_at_extruder()) { + m_is_load_with_temp = true; + } + else { + m_is_load_with_temp = false; + } +} + void StatusPanel::on_ams_load_curr() { if (obj) { std::string curr_ams_id = m_ams_control->GetCurentAms(); std::string curr_can_id = m_ams_control->GetCurrentCan(curr_ams_id); - m_ams_control->UpdateStepCtrl(obj->is_filament_at_extruder()); - if(!obj->is_filament_at_extruder()){ - m_is_load_with_temp = true; - }else{ - m_is_load_with_temp = false; - } - + update_filament_step(); //virtual tray if (curr_ams_id.compare(std::to_string(VIRTUAL_TRAY_ID)) == 0) { - /*if (con_load_dlg == nullptr) { - con_load_dlg = new SecondaryCheckDialog(this->GetParent(), wxID_ANY, _L("Confirm")); - con_load_dlg->Bind(EVT_SECONDARY_CHECK_CONFIRM, [this](wxCommandEvent& e) {*/ - int old_temp = -1; - int new_temp = -1; - AmsTray* curr_tray = &obj->vt_tray; + int old_temp = -1; + int new_temp = -1; + AmsTray* curr_tray = &obj->vt_tray; - if (!curr_tray) return; + if (!curr_tray) return; - 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 (!obj->vt_tray.nozzle_temp_max.empty() && !obj->vt_tray.nozzle_temp_min.empty()) - new_temp = (atoi(obj->vt_tray.nozzle_temp_min.c_str()) + atoi(obj->vt_tray.nozzle_temp_max.c_str())) / 2; - } - catch (...) { - ; - } - obj->command_ams_switch(VIRTUAL_TRAY_ID, old_temp, new_temp); - /*} - ); + 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 (!obj->vt_tray.nozzle_temp_max.empty() && !obj->vt_tray.nozzle_temp_min.empty()) + new_temp = (atoi(obj->vt_tray.nozzle_temp_min.c_str()) + atoi(obj->vt_tray.nozzle_temp_max.c_str())) / 2; } - con_load_dlg->update_text(_L("Please confirm the filament is ready?")); - con_load_dlg->on_show();*/ - return; + catch (...) { + ; + } + obj->command_ams_switch(VIRTUAL_TRAY_ID, old_temp, new_temp); } std::map::iterator it = obj->amsList.find(curr_ams_id); diff --git a/src/slic3r/GUI/StatusPanel.hpp b/src/slic3r/GUI/StatusPanel.hpp index 7ff009885..ad0fdf8f8 100644 --- a/src/slic3r/GUI/StatusPanel.hpp +++ b/src/slic3r/GUI/StatusPanel.hpp @@ -404,7 +404,7 @@ public: wxBoxSizer *create_ams_group(wxWindow *parent); wxBoxSizer *create_settings_group(wxWindow *parent); - void show_ams_group(bool show = true, bool support_virtual_tray = true, bool support_extrustion_cali = true); + void show_ams_group(bool show = true); }; @@ -495,6 +495,7 @@ protected: /* extruder apis */ void on_ams_load(SimpleEvent &event); + void update_filament_step(); void on_ams_load_curr(); void on_ams_unload(SimpleEvent &event); void on_ams_filament_backup(SimpleEvent& event); @@ -544,7 +545,7 @@ protected: void update_misc_ctrl(MachineObject *obj); void update_ams(MachineObject* obj); void update_extruder_status(MachineObject* obj); - void update_ams_control_state(bool is_support_virtual_tray, bool is_curr_tray_selected); + void update_ams_control_state(bool is_curr_tray_selected); void update_cali(MachineObject* obj); void reset_printing_values(); diff --git a/src/slic3r/GUI/Widgets/AMSControl.cpp b/src/slic3r/GUI/Widgets/AMSControl.cpp index 620a25bb6..330ae6e97 100644 --- a/src/slic3r/GUI/Widgets/AMSControl.cpp +++ b/src/slic3r/GUI/Widgets/AMSControl.cpp @@ -10,11 +10,6 @@ namespace Slic3r { namespace GUI { -static const int LOAD_STEP_COUNT = 5; -static const int LOAD_WITH_TEMP_STEP_COUNT = 3; -static const int UNLOAD_STEP_COUNT = 3; -static const int VT_LOAD_STEP_COUNT = 4; - static const wxColour AMS_TRAY_DEFAULT_COL = wxColour(255, 255, 255); wxDEFINE_EVENT(EVT_AMS_EXTRUSION_CALI, wxCommandEvent); @@ -110,18 +105,18 @@ Description:AMSrefresh AMSrefresh::AMSrefresh() { SetFont(Label::Body_10);} -AMSrefresh::AMSrefresh(wxWindow *parent, wxWindowID id, wxString number, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh() +AMSrefresh::AMSrefresh(wxWindow *parent, wxString number, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh() { m_info = info; m_can_id = number.ToStdString(); - create(parent, id, pos, size); + create(parent, wxID_ANY, pos, size); } -AMSrefresh::AMSrefresh(wxWindow *parent, wxWindowID id, int number, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh() +AMSrefresh::AMSrefresh(wxWindow *parent, int number, Caninfo info, const wxPoint &pos, const wxSize &size) : AMSrefresh() { m_info = info; m_can_id = wxString::Format("%d", number).ToStdString(); - create(parent, id, pos, size); + create(parent, wxID_ANY, pos, size); } AMSrefresh::~AMSrefresh() @@ -617,12 +612,12 @@ void AMSVirtualRoad::msw_rescale() /************************************************* Description:AMSLib **************************************************/ -AMSLib::AMSLib(wxWindow *parent, wxWindowID id, Caninfo info, const wxPoint &pos, const wxSize &size) +AMSLib::AMSLib(wxWindow *parent, Caninfo info) { m_border_color = (wxColour(130, 130, 128)); m_road_def_color = AMS_CONTROL_GRAY500; wxWindow::SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); - create(parent, id, pos, size); + create(parent); Bind(wxEVT_PAINT, &AMSLib::paintEvent, this); Bind(wxEVT_ENTER_WINDOW, &AMSLib::on_enter_window, this); @@ -650,6 +645,16 @@ void AMSLib::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const w m_bitmap_readonly_light = ScalableBitmap(this, "ams_readonly_light", 14); m_bitmap_transparent = ScalableBitmap(this, "transparent_ams_lib", 68); + m_bitmap_extra_tray_left = ScalableBitmap(this, "extra_ams_tray_left", 80); + m_bitmap_extra_tray_right = ScalableBitmap(this, "extra_ams_tray_right", 80); + + m_bitmap_extra_tray_left_hover = ScalableBitmap(this, "extra_ams_tray_left_hover", 80); + m_bitmap_extra_tray_right_hover = ScalableBitmap(this, "extra_ams_tray_right_hover", 80); + + m_bitmap_extra_tray_left_selected = ScalableBitmap(this, "extra_ams_tray_left_selected", 80); + m_bitmap_extra_tray_right_selected = ScalableBitmap(this, "extra_ams_tray_right_selected", 80); + + m_sizer_body->Add(0, 0, 1, wxEXPAND, 0); m_sizer_body->Add(m_sizer_edit, 0, wxALIGN_CENTER, 0); m_sizer_body->Add(0, 0, 0, wxBOTTOM, GetSize().y * 0.12); @@ -671,16 +676,25 @@ void AMSLib::on_leave_window(wxMouseEvent &evt) void AMSLib::on_left_down(wxMouseEvent &evt) { - //dc.DrawBitmap(temp_bitmap, (size.x - m_bitmap_editable.GetSize().x) / 2, ( size.y - FromDIP(10) - temp_bitmap.GetSize().y) ); if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE) { auto size = GetSize(); auto pos = evt.GetPosition(); if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) { + auto left = FromDIP(10); - auto top = (size.y - FromDIP(15) - m_bitmap_editable_light.GetBmpSize().y); - auto right = size.x - FromDIP(10);; - auto bottom = size.y - FromDIP(15); + auto right = size.x - FromDIP(10); + auto top = 0; + auto bottom = 0; + + if (m_ams_model == AMSModel::GENERIC_AMS) { + top = (size.y - FromDIP(15) - m_bitmap_editable_light.GetBmpSize().y); + bottom = size.y - FromDIP(15); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) { + top = (size.y - FromDIP(20) - m_bitmap_editable_light.GetBmpSize().y); + bottom = size.y - FromDIP(20); + } if (pos.x >= left && pos.x <= right && pos.y >= top && top <= bottom) { if (m_selected) { @@ -726,12 +740,110 @@ void AMSLib::render(wxDC &dc) #endif // text - auto tmp_lib_colour = m_info.material_colour; + if (m_ams_model == AMSModel::GENERIC_AMS) { + render_generic_text(dc); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) { + render_extra_text(dc); + } +} + +void AMSLib::render_extra_text(wxDC& dc) +{ + auto tmp_lib_colour = m_info.material_colour; auto temp_text_colour = AMS_CONTROL_GRAY800; if (tmp_lib_colour.GetLuminance() < 0.6) { temp_text_colour = AMS_CONTROL_WHITE_COLOUR; - } else { + } + else { + temp_text_colour = AMS_CONTROL_GRAY800; + } + + if (m_info.material_remain < 50) { + temp_text_colour = AMS_CONTROL_GRAY800; + } + + if (tmp_lib_colour.Alpha() == 0) { + temp_text_colour = AMS_CONTROL_GRAY800; + } + + dc.SetFont(::Label::Body_13); + dc.SetTextForeground(temp_text_colour); + + auto libsize = GetSize(); + if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND + || m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND + || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) { + + if (m_info.material_name.empty()) { + auto tsize = dc.GetMultiLineTextExtent("?"); + auto pot = wxPoint(0, 0); + pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(2), (libsize.y - tsize.y) / 2 - FromDIP(5)); + dc.DrawText(L("?"), pot); + } + else { + auto tsize = dc.GetMultiLineTextExtent(m_info.material_name); + std::vector split_char_arr = { " ", "-" }; + bool has_split = false; + std::string has_split_char = " "; + + for (std::string split_char : split_char_arr) { + if (m_info.material_name.find(split_char) != std::string::npos) { + has_split = true; + has_split_char = split_char; + } + } + + + if (has_split) { + dc.SetFont(::Label::Body_10); + auto line_top = m_info.material_name.substr(0, m_info.material_name.find(has_split_char)); + auto line_bottom = m_info.material_name.substr(m_info.material_name.find(has_split_char)); + + auto line_top_tsize = dc.GetMultiLineTextExtent(line_top); + auto line_bottom_tsize = dc.GetMultiLineTextExtent(line_bottom); + + auto pot_top = wxPoint((libsize.x - line_top_tsize.x) / 2 + FromDIP(3), (libsize.y - line_top_tsize.y) / 2 - line_top_tsize.y); + dc.DrawText(line_top, pot_top); + + auto pot_bottom = wxPoint((libsize.x - line_bottom_tsize.x) / 2 + FromDIP(3), (libsize.y - line_bottom_tsize.y) / 2); + dc.DrawText(line_bottom, pot_bottom); + + + } + else { + dc.SetFont(::Label::Body_10); + auto pot = wxPoint(0, 0); + if (m_obj ) { + pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(6), (libsize.y - tsize.y) / 2 - FromDIP(5)); + } + dc.DrawText(m_info.material_name, pot); + } + } + } + + if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) { + auto tsize = dc.GetMultiLineTextExtent(_L("/")); + auto pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(2), (libsize.y - tsize.y) / 2 + FromDIP(3)); + dc.DrawText(_L("/"), pot); + } +} + +void AMSLib::render_generic_text(wxDC &dc) +{ + bool show_k_value = true; + if (m_obj && (m_obj->get_printer_series() == PrinterSeries::SERIES_X1) && (abs(m_info.k - 0) < 1e-3)) { + show_k_value = false; + } + + auto tmp_lib_colour = m_info.material_colour; + auto temp_text_colour = AMS_CONTROL_GRAY800; + + if (tmp_lib_colour.GetLuminance() < 0.6) { + temp_text_colour = AMS_CONTROL_WHITE_COLOUR; + } + else { temp_text_colour = AMS_CONTROL_GRAY800; } @@ -754,15 +866,12 @@ void AMSLib::render(wxDC &dc) if (m_info.material_name.empty() /*&& m_info.material_state != AMSCanType::AMS_CAN_TYPE_VIRTUAL*/) { auto tsize = dc.GetMultiLineTextExtent("?"); auto pot = wxPoint(0, 0); - if (m_obj->is_function_supported(PrinterFunction::FUNC_EXTRUSION_CALI)) { - pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9)); - } else { - pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3)); - } + pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9)); dc.DrawText(L("?"), pot); - } else { + } + else { auto tsize = dc.GetMultiLineTextExtent(m_info.material_name); - std::vector split_char_arr = {" ", "-"}; + std::vector split_char_arr = { " ", "-" }; bool has_split = false; std::string has_split_char = " "; @@ -777,10 +886,10 @@ void AMSLib::render(wxDC &dc) if (has_split) { dc.SetFont(::Label::Body_12); - auto line_top = m_info.material_name.substr(0, m_info.material_name.find(has_split_char)); + auto line_top = m_info.material_name.substr(0, m_info.material_name.find(has_split_char)); auto line_bottom = m_info.material_name.substr(m_info.material_name.find(has_split_char)); - auto line_top_tsize = dc.GetMultiLineTextExtent(line_top); + auto line_top_tsize = dc.GetMultiLineTextExtent(line_top); auto line_bottom_tsize = dc.GetMultiLineTextExtent(line_bottom); if (!m_show_kn) { @@ -797,20 +906,23 @@ void AMSLib::render(wxDC &dc) auto pot_bottom = wxPoint((libsize.x - line_bottom_tsize.x) / 2, (libsize.y - line_bottom_tsize.y) / 2 - FromDIP(8)); dc.DrawText(line_bottom, pot_bottom); } - - } else { + + } + else { auto pot = wxPoint(0, 0); - if (m_obj) { + if (m_obj && show_k_value) { pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 - FromDIP(9)); - } + } else { + pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3)); + } dc.DrawText(m_info.material_name, pot); } } //draw k&n - if (m_obj) { - if (m_show_kn){ + if (m_obj && show_k_value) { + if (m_show_kn) { wxString str_k = wxString::Format("K %1.3f", m_info.k); wxString str_n = wxString::Format("N %1.3f", m_info.n); dc.SetFont(::Label::Body_11); @@ -823,17 +935,111 @@ void AMSLib::render(wxDC &dc) if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) { auto tsize = dc.GetMultiLineTextExtent(_L("Empty")); - auto pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3)); + auto pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3)); dc.DrawText(_L("Empty"), pot); } } void AMSLib::doRender(wxDC &dc) { - wxSize size = GetSize(); - auto tmp_lib_colour = m_info.material_colour; - auto temp_bitmap_third = m_bitmap_editable_light; - auto temp_bitmap_brand = m_bitmap_readonly_light; + if (m_ams_model == AMSModel::GENERIC_AMS) { + render_generic_lib(dc); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) { + render_extra_lib(dc); + } +} + +void AMSLib::render_extra_lib(wxDC& dc) +{ + wxSize size = GetSize(); + + ScalableBitmap tray_bitmap = m_can_index <= 1 ? m_bitmap_extra_tray_left : m_bitmap_extra_tray_right; + ScalableBitmap tray_bitmap_hover = m_can_index <= 1 ? m_bitmap_extra_tray_left_hover : m_bitmap_extra_tray_right_hover; + ScalableBitmap tray_bitmap_selected = m_can_index <= 1 ? m_bitmap_extra_tray_left_selected : m_bitmap_extra_tray_right_selected; + + + auto tmp_lib_colour = m_info.material_colour; + auto temp_bitmap_third = m_bitmap_editable_light; + auto temp_bitmap_brand = m_bitmap_readonly_light; + + //draw road + + + dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxSOLID)); + dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); + + if (m_pass_road) { + dc.SetPen(wxPen(m_info.material_colour, 6, wxSOLID)); + } + + if (m_can_index == 0 || m_can_index == 3) { + dc.DrawLine(size.x / 2, size.y / 2, size.x / 2, size.y); + } + else { + dc.DrawLine(size.x / 2, size.y / 2, size.x / 2, 0); + } + + + //draw def background + dc.SetPen(wxPen(*wxTRANSPARENT_PEN)); + dc.SetBrush(wxBrush(AMS_CONTROL_DEF_LIB_BK_COLOUR)); + dc.DrawRoundedRectangle(FromDIP(10), FromDIP(10), size.x - FromDIP(20), size.y - FromDIP(20), 0); + + if (tmp_lib_colour.GetLuminance() < 0.6) { + temp_bitmap_third = m_bitmap_editable_light; + temp_bitmap_brand = m_bitmap_readonly_light; + } + else { + temp_bitmap_third = m_bitmap_editable; + temp_bitmap_brand = m_bitmap_readonly; + } + + if (m_info.material_remain < 50) { + temp_bitmap_third = m_bitmap_editable; + temp_bitmap_brand = m_bitmap_readonly; + } + + if (tmp_lib_colour.Alpha() == 0) { + temp_bitmap_third = m_bitmap_editable; + temp_bitmap_brand = m_bitmap_readonly; + } + + dc.SetPen(wxPen(*wxTRANSPARENT_PEN)); + dc.SetBrush(wxBrush(tmp_lib_colour)); + dc.DrawRoundedRectangle(FromDIP(10), FromDIP(10), size.x - FromDIP(20), size.y - FromDIP(20), 0); + + + if (!m_disable_mode) { + // edit icon + if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE) + { + if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) + dc.DrawBitmap(temp_bitmap_third.bmp(), (size.x - temp_bitmap_third.GetBmpSize().x) / 2 + FromDIP(2), (size.y - FromDIP(18) - temp_bitmap_third.GetBmpSize().y)); + if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND) + dc.DrawBitmap(temp_bitmap_brand.bmp(), (size.x - temp_bitmap_brand.GetBmpSize().x) / 2 + FromDIP(2), (size.y - FromDIP(18) - temp_bitmap_brand.GetBmpSize().y)); + } + } + + // selected & hover + if (m_selected) { + dc.DrawBitmap(tray_bitmap_selected.bmp(), (size.x - tray_bitmap_selected.GetBmpSize().x) / 2, (size.y - tray_bitmap_selected.GetBmpSize().y) / 2); + } + else if (!m_selected && m_hover) { + dc.DrawBitmap(tray_bitmap_hover.bmp(), (size.x - tray_bitmap_hover.GetBmpSize().x) / 2, (size.y - tray_bitmap_hover.GetBmpSize().y) / 2); + } + else { + dc.DrawBitmap(tray_bitmap.bmp(), (size.x - tray_bitmap.GetBmpSize().x) / 2, (size.y - tray_bitmap.GetBmpSize().y) / 2); + } +} + + +void AMSLib::render_generic_lib(wxDC &dc) +{ + wxSize size = GetSize(); + auto tmp_lib_colour = m_info.material_colour; + auto temp_bitmap_third = m_bitmap_editable_light; + auto temp_bitmap_brand = m_bitmap_readonly_light; //draw def background dc.SetPen(wxPen(*wxTRANSPARENT_PEN)); @@ -843,7 +1049,8 @@ void AMSLib::doRender(wxDC &dc) if (tmp_lib_colour.GetLuminance() < 0.6) { temp_bitmap_third = m_bitmap_editable_light; temp_bitmap_brand = m_bitmap_readonly_light; - } else { + } + else { temp_bitmap_third = m_bitmap_editable; temp_bitmap_brand = m_bitmap_readonly; } @@ -860,24 +1067,19 @@ void AMSLib::doRender(wxDC &dc) // selected if (m_selected) { - // lib dc.SetPen(wxPen(tmp_lib_colour, 2, wxSOLID)); dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); if (m_radius == 0) { dc.DrawRectangle(0, 0, size.x, size.y); - } else { + } + else { dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), m_radius); } dc.SetPen(wxPen(*wxTRANSPARENT_PEN)); dc.SetBrush(wxBrush(tmp_lib_colour)); - /* if (m_radius == 0) { - dc.DrawRectangle(0, 0, size.x, size.y); - } else { - dc.DrawRoundedRectangle(FromDIP(4), FromDIP(4), size.x - FromDIP(8), size.y - FromDIP(8), m_radius); - }*/ } - + if (!m_selected && m_hover) { dc.SetPen(wxPen(AMS_CONTROL_BRAND_COLOUR, 2, wxSOLID)); dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); @@ -890,19 +1092,10 @@ void AMSLib::doRender(wxDC &dc) dc.SetPen(wxPen(*wxTRANSPARENT_PEN)); dc.SetBrush(wxBrush(tmp_lib_colour)); - /* if (m_radius == 0) { - dc.DrawRectangle(0, 0, size.x, size.y); - } else { - dc.DrawRoundedRectangle(FromDIP(4), FromDIP(4), size.x - FromDIP(8), size.y - FromDIP(8), m_radius); - }*/ - } else { + } + else { dc.SetPen(wxPen(tmp_lib_colour, 1, wxSOLID)); dc.SetBrush(wxBrush(tmp_lib_colour)); - /*if (m_radius == 0) { - dc.DrawRectangle(0, 0, size.x, size.y); - } else { - dc.DrawRoundedRectangle(FromDIP(4), FromDIP(4), size.x - FromDIP(8), size.y - FromDIP(8), m_radius); - }*/ } //draw remain @@ -916,7 +1109,7 @@ void AMSLib::doRender(wxDC &dc) //transparent auto alpha = m_info.material_colour.Alpha(); if (alpha == 0) { - dc.DrawBitmap(m_bitmap_transparent.bmp(),FromDIP(4), FromDIP(4)); + dc.DrawBitmap(m_bitmap_transparent.bmp(), FromDIP(4), FromDIP(4)); } //gradient @@ -942,7 +1135,7 @@ void AMSLib::doRender(wxDC &dc) #else dc.DrawRoundedRectangle(FromDIP(4), FromDIP(4) + top, size.x - FromDIP(8), curr_height, m_radius - 1); #endif - } + } } if (top > 2) { @@ -972,7 +1165,7 @@ void AMSLib::doRender(wxDC &dc) #endif } } - + //border dc.SetPen(wxPen(wxColour(130, 130, 128), 1, wxSOLID)); dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); @@ -981,7 +1174,7 @@ void AMSLib::doRender(wxDC &dc) #else dc.DrawRoundedRectangle(FromDIP(3), FromDIP(3), size.x - FromDIP(6), size.y - FromDIP(6), m_radius); #endif - + if (!m_disable_mode) { // edit icon if (m_info.material_state != AMSCanType::AMS_CAN_TYPE_EMPTY && m_info.material_state != AMSCanType::AMS_CAN_TYPE_NONE) @@ -994,6 +1187,14 @@ void AMSLib::doRender(wxDC &dc) } } +void AMSLib::on_pass_road(bool pass) +{ + if (m_pass_road != pass) { + m_pass_road = pass; + Refresh(); + } +} + void AMSLib::Update(Caninfo info, bool refresh) { DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager(); @@ -1329,7 +1530,7 @@ AMSItem::AMSItem(wxWindow *parent, wxWindowID id, AMSinfo amsinfo, const wxSize { m_amsinfo = amsinfo; m_cube_size = cube_size; - create(parent, id, pos, size); + create(parent, id, pos, AMS_ITEM_SIZE); Bind(wxEVT_PAINT, &AMSItem::paintEvent, this); Bind(wxEVT_ENTER_WINDOW, &AMSItem::OnEnterWindow, this); Bind(wxEVT_LEAVE_WINDOW, &AMSItem::OnLeaveWindow, this); @@ -1356,8 +1557,9 @@ void AMSItem::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const { m_ts_bitmap_cube = new ScalableBitmap(this, "ts_bitmap_cube", 14); wxWindow::Create(parent, id, pos, size); + SetMinSize(AMS_ITEM_SIZE); + SetMaxSize(AMS_ITEM_SIZE); SetBackgroundColour(AMS_CONTROL_WHITE_COLOUR); - HideHumidity(); Refresh(); } @@ -1386,28 +1588,6 @@ void AMSItem::UnSelected() Refresh(); } -void AMSItem::ShowHumidity() -{ - m_show_humidity = true; - SetSize(AMS_ITEM_HUMIDITY_SIZE); - SetMinSize(AMS_ITEM_HUMIDITY_SIZE); - Refresh(); -} - -void AMSItem::HideHumidity() -{ - m_show_humidity = false; - SetSize(AMS_ITEM_SIZE); - SetMinSize(AMS_ITEM_SIZE); - Refresh(); -} - -void AMSItem::SetHumidity(int humidity) -{ - m_humidity = humidity; - Refresh(); -} - bool AMSItem::Enable(bool enable) { return wxWindow::Enable(enable); } void AMSItem::paintEvent(wxPaintEvent &evt) @@ -1489,20 +1669,6 @@ void AMSItem::doRender(wxDC &dc) left += m_space; } - m_show_humidity = false; - if (m_show_humidity) { - left = 4 * AMS_ITEM_CUBE_SIZE.x + 6 * m_space; - dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 1)); - dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); - dc.DrawLine(left, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, left, ((size.y - AMS_ITEM_CUBE_SIZE.y) / 2) + AMS_ITEM_CUBE_SIZE.y); - - left += m_space + m_space / 2; - /* dc.SetFont(::Label::Body_13); - dc.SetTextForeground(AMS_CONTROL_GRAY800); - auto tsize = dc.GetTextExtent("00% RH"); - auto text = wxString::Format("%d%% RH", m_humidity);*/ - } - auto border_colour = AMS_CONTROL_BRAND_COLOUR; if (!wxWindow::IsEnabled()) { border_colour = AMS_CONTROL_DISABLE_COLOUR; } @@ -1527,29 +1693,166 @@ Description:AmsCan AmsCans::AmsCans() {} -AmsCans::AmsCans(wxWindow *parent, wxWindowID id, AMSinfo info, const wxPoint &pos, const wxSize &size) : AmsCans() +AmsCans::AmsCans(wxWindow *parent,AMSinfo info, AMSModel model) : AmsCans() { - wxWindow::Create(parent, wxID_ANY, pos, AMS_CANS_WINDOW_SIZE); - create(parent, id, info, pos, size); + m_bitmap_extra_framework = ScalableBitmap(this, "ams_extra_framework_mid", 140); + + SetDoubleBuffered(true); + m_ams_model = model; + m_info = info; + + wxWindow::Create(parent, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE); + create(parent); + Bind(wxEVT_PAINT, &AmsCans::paintEvent, this); } -void AmsCans::create(wxWindow *parent, wxWindowID id, AMSinfo info, const wxPoint &pos, const wxSize &size) +void AmsCans::create(wxWindow *parent) { - sizer_can = new wxBoxSizer(wxHORIZONTAL); - m_info = info; - Freeze(); - for (auto it = m_info.cans.begin(); it != m_info.cans.end(); it++) { - AddCan(*it, m_can_count, m_info.cans.size()); - m_can_count++; + SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); + + if (m_ams_model == AMSModel::GENERIC_AMS) { + sizer_can = new wxBoxSizer(wxHORIZONTAL); + for (auto it = m_info.cans.begin(); it != m_info.cans.end(); it++) { + AddCan(*it, m_can_count, m_info.cans.size(), sizer_can); + m_can_count++; + } + SetSizer(sizer_can); + } + else if(m_ams_model == AMSModel::EXTRA_AMS) { + sizer_can = new wxBoxSizer(wxVERTICAL); + sizer_can_middle = new wxBoxSizer(wxHORIZONTAL); + sizer_can_left = new wxBoxSizer(wxVERTICAL); + sizer_can_right = new wxBoxSizer(wxVERTICAL); + + sizer_can_left->Add(0,0,0,wxTOP,FromDIP(8)); + + for (auto it = m_info.cans.begin(); it != m_info.cans.end(); it++) { + if (m_can_count <= 1) { + AddCan(*it, m_can_count, m_info.cans.size(), sizer_can_left); + if (m_can_count == 0) { + sizer_can_left->Add(0,0,0,wxTOP,FromDIP(20)); + } + } + else { + AddCan(*it, m_can_count, m_info.cans.size(), sizer_can_right); + if (m_can_count == 2) { + sizer_can_right->Prepend(0, 0, 0, wxTOP, FromDIP(20)); + } + } + + m_can_count++; + } + + sizer_can_right->Prepend(0,0,0,wxTOP,FromDIP(8)); + sizer_can_middle->Add(0, 0, 0, wxLEFT, FromDIP(8)); + sizer_can_middle->Add(sizer_can_left, 0, wxALL, 0); + sizer_can_middle->Add( 0, 0, 0, wxLEFT, FromDIP(20) ); + sizer_can_middle->Add(sizer_can_right, 0, wxALL, 0); + sizer_can->Add(sizer_can_middle, 1, wxALIGN_CENTER, 0); + SetSizer(sizer_can); } - SetSizer(sizer_can); Layout(); Fit(); Thaw(); } +void AmsCans::AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* sizer) +{ + + auto amscan = new wxWindow(this, wxID_ANY); + amscan->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); + + wxBoxSizer* m_sizer_ams = new wxBoxSizer(wxVERTICAL); + + + auto m_panel_refresh = new AMSrefresh(amscan, m_can_count, caninfo); + auto m_panel_lib = new AMSLib(amscan, caninfo); + + m_panel_lib->Bind(wxEVT_LEFT_DOWN, [this, canindex](wxMouseEvent& ev) { + m_canlib_selection = canindex; + // m_canlib_id = caninfo.can_id; + + for (auto i = 0; i < m_can_lib_list.GetCount(); i++) { + CanLibs* lib = m_can_lib_list[i]; + if (lib->canLib->m_can_index == m_canlib_selection) { + wxCommandEvent evt(EVT_AMS_UNSELETED_VAMS); + evt.SetString(m_info.ams_id); + wxPostEvent(GetParent()->GetParent(), evt); + lib->canLib->OnSelected(); + } + else { + lib->canLib->UnSelected(); + } + } + ev.Skip(); + }); + + + m_panel_lib->m_ams_model = m_ams_model; + m_panel_lib->m_info.can_id = caninfo.can_id; + m_panel_lib->m_can_index = canindex; + + + auto m_panel_road = new AMSRoad(amscan, wxID_ANY, caninfo, canindex, maxcan, wxDefaultPosition, AMS_CAN_ROAD_SIZE); + + if (m_ams_model == AMSModel::GENERIC_AMS) { + m_sizer_ams->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(14)); + m_sizer_ams->Add(m_panel_refresh, 0, wxALIGN_CENTER_HORIZONTAL, 0); + m_sizer_ams->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(2)); + m_sizer_ams->Add(m_panel_lib, 1, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(3)); + m_sizer_ams->Add(m_panel_road, 0, wxALL, 0); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) + { + m_sizer_ams = new wxBoxSizer(wxHORIZONTAL); + m_panel_road->Hide(); + + if (canindex <= 1) { + m_sizer_ams->Add(m_panel_refresh, 0, wxALIGN_CENTER, 0); + m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_CENTER, 0); + } + else { + m_sizer_ams->Add(m_panel_lib, 0, wxALIGN_CENTER, 0); + m_sizer_ams->Add(m_panel_refresh, 0, wxALIGN_CENTER, 0); + } + } + + + amscan->SetSizer(m_sizer_ams); + amscan->Layout(); + amscan->Fit(); + + if (m_ams_model == AMSModel::GENERIC_AMS) { + sizer->Add(amscan, 0, wxALL, 0); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) + { + if (canindex > 1) { + sizer->Prepend(amscan, 0, wxALL, 0); + } + else { + sizer->Add(amscan, 0, wxALL, 0); + } + } + + Canrefreshs* canrefresh = new Canrefreshs; + canrefresh->canID = caninfo.can_id; + canrefresh->canrefresh = m_panel_refresh; + m_can_refresh_list.Add(canrefresh); + + CanLibs* canlib = new CanLibs; + canlib->canID = caninfo.can_id; + canlib->canLib = m_panel_lib; + m_can_lib_list.Add(canlib); + + CanRoads* canroad = new CanRoads; + canroad->canID = caninfo.can_id; + canroad->canRoad = m_panel_road; + m_can_road_list.Add(canroad); +} + void AmsCans::Update(AMSinfo info) { m_info = info; @@ -1574,77 +1877,22 @@ void AmsCans::Update(AMSinfo info) lib->canLib->Hide(); } } - for (auto i = 0; i < m_can_road_list.GetCount(); i++) { - CanRoads *road = m_can_road_list[i]; - if (i < m_can_count) { - road->canRoad->Update(m_info, info.cans[i], i, m_can_count); - road->canRoad->Show(); - } else { - road->canRoad->Hide(); - } - } - Layout(); -} - -void AmsCans::AddCan(Caninfo caninfo, int canindex, int maxcan) -{ - auto amscan = new wxWindow(this, wxID_ANY); - amscan->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); - wxBoxSizer *m_sizer_ams = new wxBoxSizer(wxVERTICAL); - m_sizer_ams->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(14)); - - auto m_panel_refresh = new AMSrefresh(amscan, wxID_ANY, m_can_count, caninfo); - m_sizer_ams->Add(m_panel_refresh, 0, wxALIGN_CENTER_HORIZONTAL, 0); - m_sizer_ams->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(2)); - - auto m_panel_lib = new AMSLib(amscan, wxID_ANY, caninfo); - m_panel_lib->Bind(wxEVT_LEFT_DOWN, [this, canindex](wxMouseEvent &ev) { - m_canlib_selection = canindex; - // m_canlib_id = caninfo.can_id; - - for (auto i = 0; i < m_can_lib_list.GetCount(); i++) { - CanLibs *lib = m_can_lib_list[i]; - if (lib->canLib->m_can_index == m_canlib_selection) { - wxCommandEvent evt(EVT_AMS_UNSELETED_VAMS); - evt.SetString(m_info.ams_id); - wxPostEvent(GetParent()->GetParent(), evt); - lib->canLib->OnSelected(); - } else { - lib->canLib->UnSelected(); + if (m_ams_model == AMSModel::GENERIC_AMS) { + for (auto i = 0; i < m_can_road_list.GetCount(); i++) { + CanRoads* road = m_can_road_list[i]; + if (i < m_can_count) { + road->canRoad->Update(m_info, info.cans[i], i, m_can_count); + road->canRoad->Show(); + } + else { + road->canRoad->Hide(); } } - ev.Skip(); - }); - - m_panel_lib->m_info.can_id = caninfo.can_id; - m_panel_lib->m_can_index = canindex; - auto m_panel_road = new AMSRoad(amscan, wxID_ANY, caninfo, canindex, maxcan, wxDefaultPosition, AMS_CAN_ROAD_SIZE); - m_sizer_ams->Add(m_panel_lib, 1, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(3)); - m_sizer_ams->Add(m_panel_road, 0, wxALL, 0); - - amscan->SetSizer(m_sizer_ams); - amscan->Layout(); - amscan->Fit(); - sizer_can->Add(amscan, 0, wxALL, 0); - - Canrefreshs *canrefresh = new Canrefreshs; - canrefresh->canID = caninfo.can_id; - canrefresh->canrefresh = m_panel_refresh; - m_can_refresh_list.Add(canrefresh); - - CanLibs *canlib = new CanLibs; - canlib->canID = caninfo.can_id; - canlib->canLib = m_panel_lib; - m_can_lib_list.Add(canlib); - - CanRoads *canroad = new CanRoads; - canroad->canID = caninfo.can_id; - canroad->canRoad = m_panel_road; - m_can_road_list.Add(canroad); + } + Layout(); } - void AmsCans::SetDefSelectCan() { if (m_can_lib_list.GetCount() > 0) { @@ -1688,6 +1936,19 @@ wxColour AmsCans::GetTagColr(wxString canid) return tag_colour; } +void AmsCans::SetAmsStepExtra(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step) +{ + if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) { + SetAmsStep(canid.ToStdString()); + }else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) { + SetAmsStep(canid.ToStdString()); + }else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) { + SetAmsStep(canid.ToStdString()); + }else if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) { + SetAmsStep(""); + } +} + void AmsCans::SetAmsStep(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step) { @@ -1761,6 +2022,14 @@ void AmsCans::SetAmsStep(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP s } } +void AmsCans::SetAmsStep(std::string can_id) +{ + if (m_road_canid != can_id) { + m_road_canid = can_id; + Refresh(); + } +} + void AmsCans::PlayRridLoading(wxString canid) { for (auto i = 0; i < m_can_refresh_list.GetCount(); i++) { @@ -1777,6 +2046,156 @@ std::string AmsCans::GetCurrentCan() return wxString::Format("%d", m_canlib_selection).ToStdString(); } +void AmsCans::paintEvent(wxPaintEvent& evt) +{ + wxPaintDC dc(this); + render(dc); +} + +void AmsCans::render(wxDC& dc) +{ +#ifdef __WXMSW__ + wxSize size = GetSize(); + wxMemoryDC memdc; + wxBitmap bmp(size.x, size.y); + memdc.SelectObject(bmp); + memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 }); + + { + wxGCDC dc2(memdc); + doRender(dc2); + } + + memdc.SelectObject(wxNullBitmap); + dc.DrawBitmap(bmp, 0, 0); +#else + doRender(dc); +#endif +} + +void AmsCans::doRender(wxDC& dc) +{ + wxSize size = GetSize(); + dc.DrawBitmap(m_bitmap_extra_framework.bmp(), (size.x - m_bitmap_extra_framework.GetBmpSize().x) / 2, (size.y - m_bitmap_extra_framework.GetBmpSize().y) / 2); + + //road for extra + if (m_ams_model == AMSModel::EXTRA_AMS) { + + auto end_top = size.x / 2 - FromDIP(99); + auto passroad_width = 6; + + for (auto i = 0; i < m_can_lib_list.GetCount(); i++) { + CanLibs* lib = m_can_lib_list[i]; + + if (m_road_canid.empty()) { + lib->canLib->on_pass_road(false); + } + else { + if (lib->canLib->m_info.can_id == m_road_canid) { + m_road_colour = lib->canLib->m_info.material_colour; + lib->canLib->on_pass_road(true); + } + } + } + + + // A1 + dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxSOLID)); + dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); + + try + { + auto a1_top = size.y / 2 - FromDIP(4); + auto a1_left = m_can_lib_list[0]->canLib->GetScreenPosition().x + m_can_lib_list[0]->canLib->GetSize().x / 2; + auto local_pos1 = GetScreenPosition().x + GetSize().x / 2; + a1_left = size.x / 2 + (a1_left - local_pos1); + dc.DrawLine(a1_left, FromDIP(30), a1_left, a1_top); + dc.DrawLine(a1_left, a1_top, end_top, a1_top); + + + // A2 + auto a2_top = size.y / 2 + FromDIP(8); + auto a2_left = m_can_lib_list[1]->canLib->GetScreenPosition().x + m_can_lib_list[1]->canLib->GetSize().x / 2; + auto local_pos2 = GetScreenPosition().x + GetSize().x / 2; + a2_left = size.x / 2 + (a2_left - local_pos2); + dc.DrawLine(a2_left, FromDIP(160), a2_left, a2_top); + dc.DrawLine(a2_left, a2_top, end_top, a2_top); + + // A3 + auto a3_top = size.y / 2 + FromDIP(4); + auto a3_left = m_can_lib_list[2]->canLib->GetScreenPosition().x + m_can_lib_list[2]->canLib->GetSize().x / 2; + auto local_pos3 = GetScreenPosition().x + GetSize().x / 2; + a3_left = size.x / 2 + (a3_left - local_pos3); + dc.DrawLine(a3_left, FromDIP(160), a3_left, a3_top); + dc.DrawLine(a3_left, a3_top, end_top, a3_top); + + + // A4 + auto a4_top = size.y / 2; + auto a4_left = m_can_lib_list[3]->canLib->GetScreenPosition().x + m_can_lib_list[3]->canLib->GetSize().x / 2; + auto local_pos4 = GetScreenPosition().x + GetSize().x / 2; + a4_left = size.x / 2 + (a4_left - local_pos4); + dc.DrawLine(a4_left, FromDIP(30), a4_left, a4_top); + dc.DrawLine(a4_left, a4_top, end_top, a4_top); + + + if (!m_road_canid.empty()) { + if (m_road_canid == "0") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(a1_left, FromDIP(30), a1_left, a1_top); + dc.DrawLine(a1_left, a1_top, end_top, a1_top); + } + + if (m_road_canid == "1") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(a2_left, FromDIP(160), a2_left, a2_top); + dc.DrawLine(a2_left, a2_top, end_top, a2_top); + } + + if (m_road_canid == "2") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(a3_left, FromDIP(160), a3_left, a3_top); + dc.DrawLine(a3_left, a3_top, end_top, a3_top); + } + + if (m_road_canid == "3") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(a4_left, FromDIP(30), a4_left, a4_top); + dc.DrawLine(a4_left, a4_top, end_top, a4_top); + } + } + + //to Extruder + dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxSOLID)); + dc.SetBrush(wxBrush(*wxTRANSPARENT_BRUSH)); + + dc.DrawLine(end_top, a1_top, end_top, size.y); + + if (!m_road_canid.empty()) { + if (!m_road_canid.empty()) { + if (m_road_canid == "0") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(end_top, a1_top, end_top, size.y); + } + else if (m_road_canid == "1") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(end_top, a2_top, end_top, size.y); + } + else if (m_road_canid == "2") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(end_top, a3_top, end_top, size.y); + } + else if (m_road_canid == "3") { + dc.SetPen(wxPen(m_road_colour, passroad_width, wxSOLID)); + dc.DrawLine(end_top, a4_top, end_top, size.y); + } + } + } + } + catch (...){} + } +} + void AmsCans::StopRridLoading(wxString canid) { for (auto i = 0; i < m_can_refresh_list.GetCount(); i++) { @@ -1806,15 +2225,6 @@ void AmsCans::show_sn_value(bool show) } } -//wxColour AmsCans::GetCanColour(wxString canid) -//{ -// wxColour col = *wxWHITE; -// for (auto i = 0; i < m_can_lib_list.GetCount(); i++) { -// CanLibs *lib = m_can_lib_list[i]; -// if (lib->canLib->m_info.can_id == canid) { col = lib->canLib->m_info.material_colour; } -// } -// return col; -//} /************************************************* Description:AMSControl @@ -1853,8 +2263,8 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons m_panel_top_empty->Layout(); m_sizer_top_empty->Fit(m_panel_top_empty); - m_simplebook_amsitems->AddPage(m_panel_top, wxEmptyString, false); m_simplebook_amsitems->AddPage(m_panel_top_empty, wxEmptyString, false); + m_simplebook_amsitems->AddPage(m_panel_top, wxEmptyString, false); wxBoxSizer *m_sizer_bottom = new wxBoxSizer(wxHORIZONTAL); @@ -1862,18 +2272,18 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons //ams tip m_sizer_ams_tips = new wxBoxSizer(wxHORIZONTAL); - auto m_ams_tip = new Label(m_amswin, _L("AMS")); + m_ams_tip = new Label(m_amswin, _L("AMS")); m_ams_tip->SetFont(::Label::Body_12); m_ams_tip->SetBackgroundColour(*wxWHITE); - auto img_amsmapping_tip = new wxStaticBitmap(m_amswin, wxID_ANY, create_scaled_bitmap("enable_ams", this, 16), wxDefaultPosition, wxSize(FromDIP(16), FromDIP(16)), 0); - img_amsmapping_tip->SetBackgroundColour(*wxWHITE); + m_img_amsmapping_tip = new wxStaticBitmap(m_amswin, wxID_ANY, create_scaled_bitmap("enable_ams", this, 16), wxDefaultPosition, wxSize(FromDIP(16), FromDIP(16)), 0); + m_img_amsmapping_tip->SetBackgroundColour(*wxWHITE); m_sizer_ams_tips->Add(m_ams_tip, 0, wxTOP, FromDIP(5)); - m_sizer_ams_tips->Add(img_amsmapping_tip, 0, wxALL, FromDIP(3)); + m_sizer_ams_tips->Add(m_img_amsmapping_tip, 0, wxALL, FromDIP(3)); - img_amsmapping_tip->Bind(wxEVT_ENTER_WINDOW, [this, img_amsmapping_tip](auto& e) { - wxPoint img_pos = img_amsmapping_tip->ClientToScreen(wxPoint(0, 0)); - wxPoint popup_pos(img_pos.x, img_pos.y + img_amsmapping_tip->GetRect().height); + m_img_amsmapping_tip->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) { + wxPoint img_pos = m_img_amsmapping_tip->ClientToScreen(wxPoint(0, 0)); + wxPoint popup_pos(img_pos.x, img_pos.y + m_img_amsmapping_tip->GetRect().height); m_ams_introduce_popup.set_mode(true); m_ams_introduce_popup.Position(popup_pos, wxSize(0, 0)); m_ams_introduce_popup.Popup(); @@ -1883,7 +2293,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons wxPostEvent(this, close_event); #endif // __WXMSW__ }); - img_amsmapping_tip->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) { + m_img_amsmapping_tip->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) { m_ams_introduce_popup.Dismiss(); }); @@ -1900,8 +2310,8 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons m_sizer_ams_tips->Add(m_img_ams_backup, 0, wxALL, FromDIP(3)); m_sizer_ams_tips->Add(m_ams_backup_tip, 0, wxTOP, FromDIP(5)); - m_ams_backup_tip->Bind(wxEVT_ENTER_WINDOW, [this, img_amsmapping_tip](auto& e) {SetCursor(wxCURSOR_HAND); }); - m_img_ams_backup->Bind(wxEVT_ENTER_WINDOW, [this, img_amsmapping_tip](auto& e) {SetCursor(wxCURSOR_HAND); }); + m_ams_backup_tip->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_HAND); }); + m_img_ams_backup->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_HAND); }); m_ams_backup_tip->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_ARROW); }); m_img_ams_backup->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) {SetCursor(wxCURSOR_ARROW); }); @@ -1923,13 +2333,12 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons m_sizer_cans->Add(m_simplebook_ams, 0, wxLEFT | wxLEFT, FromDIP(10)); // ams mode - m_simplebook_cans = new wxSimplebook(m_simplebook_ams, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0); - m_simplebook_cans->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); + m_simplebook_generic_cans = new wxSimplebook(m_simplebook_ams, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0); + m_simplebook_generic_cans->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); // none ams mode m_none_ams_panel = new wxPanel(m_simplebook_ams, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0); m_none_ams_panel->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); - //m_none_ams_panel->SetDoubleBuffered(true); auto m_tip_none_ams = new wxStaticText(m_none_ams_panel, wxID_ANY, _L("AMS not connected"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER_HORIZONTAL); m_tip_none_ams->SetMinSize(wxSize(AMS_CANS_SIZE.x - FromDIP(20), -1)); @@ -1945,8 +2354,13 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons m_none_ams_panel->SetSizer(sizer_ams_panel_h); m_none_ams_panel->Layout(); - m_simplebook_ams->AddPage(m_simplebook_cans, wxEmptyString, true); + //extra ams mode + m_simplebook_extra_cans = new wxSimplebook(m_simplebook_ams, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0); + m_simplebook_extra_cans->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); + m_simplebook_ams->AddPage(m_none_ams_panel, wxEmptyString, false); + m_simplebook_ams->AddPage(m_simplebook_generic_cans, wxEmptyString, false); + m_simplebook_ams->AddPage(m_simplebook_extra_cans, wxEmptyString, false); m_panel_can->SetSizer(m_sizer_cans); m_panel_can->Layout(); @@ -1999,14 +2413,14 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons wxBoxSizer *m_sizer_button = new wxBoxSizer(wxVERTICAL); wxBoxSizer *m_sizer_button_area = new wxBoxSizer(wxHORIZONTAL); - m_button_extrusion_cali = new Button(m_button_area, _L("Cali")); + /*m_button_extrusion_cali = new Button(m_button_area, _L("Cali")); m_button_extrusion_cali->SetToolTip(_L("Calibration of extrusion")); m_button_extrusion_cali->SetBackgroundColor(btn_bg_green); m_button_extrusion_cali->SetBorderColor(btn_bd_green); m_button_extrusion_cali->SetTextColor(btn_text_green); m_button_extrusion_cali->SetFont(Label::Body_13); if (wxGetApp().app_config->get("language") == "de_DE") m_button_extrusion_cali->SetFont(Label::Body_9); - if (wxGetApp().app_config->get("language") == "fr_FR") m_button_extrusion_cali->SetFont(Label::Body_9); + if (wxGetApp().app_config->get("language") == "fr_FR") m_button_extrusion_cali->SetFont(Label::Body_9);*/ m_button_extruder_feed = new Button(m_button_area, _L("Load Filament")); m_button_extruder_feed->SetBackgroundColor(btn_bg_green); @@ -2025,7 +2439,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons if (wxGetApp().app_config->get("language") == "fr_FR") m_button_extruder_back->SetFont(Label::Body_9); m_sizer_button_area->Add(0, 0, 1, wxEXPAND, 0); - m_sizer_button_area->Add(m_button_extrusion_cali, 0, wxLEFT, FromDIP(5)); + //m_sizer_button_area->Add(m_button_extrusion_cali, 0, wxLEFT, FromDIP(5)); m_sizer_button_area->Add(m_button_extruder_back, 0, wxLEFT, FromDIP(6)); m_sizer_button_area->Add(m_button_extruder_feed, 0, wxLEFT, FromDIP(6)); @@ -2052,7 +2466,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons auto vams_panel = new wxWindow(m_panel_virtual, wxID_ANY); vams_panel->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR); - m_vams_lib = new AMSLib(vams_panel, wxID_ANY, m_vams_info); + m_vams_lib = new AMSLib(vams_panel, m_vams_info); m_vams_road = new AMSRoad(vams_panel, wxID_ANY, m_vams_info, -1, -1, wxDefaultPosition, AMS_CAN_ROAD_SIZE); m_vams_lib->Bind(wxEVT_LEFT_DOWN, [this](auto& e) { @@ -2082,8 +2496,8 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons wxBoxSizer* m_vams_top_sizer = new wxBoxSizer(wxVERTICAL); m_vams_top_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(14)); - m_vams_top_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(2) + AMS_REFRESH_SIZE.y); - m_vams_top_sizer->Add(m_vams_lib, 1, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(4)); + m_vams_top_sizer->Add(0, 0, 0, wxEXPAND | wxTOP, AMS_REFRESH_SIZE.y); + m_vams_top_sizer->Add(m_vams_lib, 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(4)); m_vams_top_sizer->Add(m_vams_road, 0, wxALL, 0); //extra road @@ -2105,11 +2519,11 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons auto m_vams_tip = new wxStaticText(m_amswin, wxID_ANY, _L("Ext Spool")); m_vams_tip->SetFont(::Label::Body_12); m_vams_tip->SetBackgroundColour(*wxWHITE); - auto img_vams_tip = new wxStaticBitmap(m_amswin, wxID_ANY, create_scaled_bitmap("enable_ams", this, 16), wxDefaultPosition, wxSize(FromDIP(16), FromDIP(16)), 0); - img_vams_tip->SetBackgroundColour(*wxWHITE); - img_vams_tip->Bind(wxEVT_ENTER_WINDOW, [this, img_vams_tip](auto& e) { - wxPoint img_pos = img_vams_tip->ClientToScreen(wxPoint(0, 0)); - wxPoint popup_pos(img_pos.x, img_pos.y + img_vams_tip->GetRect().height); + m_img_vams_tip = new wxStaticBitmap(m_amswin, wxID_ANY, create_scaled_bitmap("enable_ams", this, 16), wxDefaultPosition, wxSize(FromDIP(16), FromDIP(16)), 0); + m_img_vams_tip->SetBackgroundColour(*wxWHITE); + m_img_vams_tip->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) { + wxPoint img_pos = m_img_vams_tip->ClientToScreen(wxPoint(0, 0)); + wxPoint popup_pos(img_pos.x, img_pos.y + m_img_vams_tip->GetRect().height); m_ams_introduce_popup.set_mode(false); m_ams_introduce_popup.Position(popup_pos, wxSize(0, 0)); m_ams_introduce_popup.Popup(); @@ -2120,12 +2534,12 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons #endif // __WXMSW__ }); - img_vams_tip->Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& e) { + m_img_vams_tip->Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& e) { m_ams_introduce_popup.Dismiss(); }); m_sizer_vams_tips->Add(m_vams_tip, 0, wxTOP, FromDIP(5)); - m_sizer_vams_tips->Add(img_vams_tip, 0, wxALL, FromDIP(3)); + m_sizer_vams_tips->Add(m_img_vams_tip, 0, wxALL, FromDIP(3)); m_vams_extra_road = new AMSVirtualRoad(m_amswin, wxID_ANY); m_vams_extra_road->SetMinSize(wxSize(m_panel_virtual->GetSize().x + FromDIP(16), -1)); @@ -2309,7 +2723,7 @@ AMSControl::AMSControl(wxWindow *parent, wxWindowID id, const wxPoint &pos, cons UpdateStepCtrl(false); - m_button_extrusion_cali->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(AMSControl::on_extrusion_cali), NULL, this); + //m_button_extrusion_cali->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(AMSControl::on_extrusion_cali), NULL, this); m_button_extruder_feed->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(AMSControl::on_filament_load), NULL, this); m_button_extruder_back->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(AMSControl::on_filament_unload), NULL, this); @@ -2355,8 +2769,8 @@ void AMSControl::on_retry() void AMSControl::init_scaled_buttons() { - m_button_extrusion_cali->SetMinSize(wxSize(-1, FromDIP(24))); - m_button_extrusion_cali->SetCornerRadius(FromDIP(12)); + //m_button_extrusion_cali->SetMinSize(wxSize(-1, FromDIP(24))); + //m_button_extrusion_cali->SetCornerRadius(FromDIP(12)); m_button_extruder_feed->SetMinSize(wxSize(-1, FromDIP(24))); m_button_extruder_feed->SetCornerRadius(FromDIP(12)); m_button_extruder_back->SetMinSize(wxSize(-1, FromDIP(24))); @@ -2396,8 +2810,8 @@ wxColour AMSControl::GetCanColour(std::string amsid, std::string canid) void AMSControl::SetActionState(bool button_status[]) { - if (button_status[ActionButton::ACTION_BTN_CALI]) m_button_extrusion_cali->Enable(); - else m_button_extrusion_cali->Disable(); + /*if (button_status[ActionButton::ACTION_BTN_CALI]) m_button_extrusion_cali->Enable(); + else m_button_extrusion_cali->Disable();*/ if (button_status[ActionButton::ACTION_BTN_LOAD]) m_button_extruder_feed->Enable(); else m_button_extruder_feed->Disable(); @@ -2406,34 +2820,49 @@ void AMSControl::SetActionState(bool button_status[]) else m_button_extruder_back->Disable(); } -void AMSControl::EnterNoneAMSMode() +void AMSControl::EnterNoneAMSMode(bool support_vt_load) { - if(m_is_none_ams_mode) return; - m_simplebook_amsitems->Hide(); + m_vams_lib->m_ams_model = m_ext_model; + if(m_is_none_ams_mode == AMSModel::NO_AMS) return; m_panel_top->Hide(); - m_simplebook_amsitems->SetSelection(1); - m_simplebook_ams->SetSelection(1); + m_simplebook_amsitems->Hide(); + m_simplebook_amsitems->SetSelection(0); + + m_simplebook_ams->SetSelection(0); m_extruder->no_ams_mode(true); m_button_ams_setting->Hide(); m_button_guide->Hide(); - //m_button_retry->Hide(); - m_button_extruder_feed->Show(); - m_button_extruder_back->Show(); + if (support_vt_load) { + m_button_extruder_feed->Show(); + m_button_extruder_back->Show(); + } else { + m_button_extruder_feed->Hide(); + m_button_extruder_back->Hide(); + } ShowFilamentTip(false); m_amswin->Layout(); m_amswin->Fit(); Layout(); - m_is_none_ams_mode = true; + m_is_none_ams_mode = AMSModel::NO_AMS; } -void AMSControl::ExitNoneAMSMode() +void AMSControl::EnterGenericAMSMode() { - if(!m_is_none_ams_mode) return; - m_simplebook_amsitems->Show(); + m_vams_lib->m_ams_model = m_ext_model; + if(m_is_none_ams_mode == AMSModel::GENERIC_AMS) return; m_panel_top->Show(); - m_simplebook_ams->SetSelection(0); - m_simplebook_amsitems->SetSelection(0); + m_simplebook_amsitems->Show(); + m_simplebook_amsitems->SetSelection(1); + + m_vams_lib->m_ams_model = AMSModel::GENERIC_AMS; + m_ams_tip->SetLabel(_L("AMS")); + m_img_vams_tip->SetBitmap(create_scaled_bitmap("enable_ams", this, 16)); + m_img_vams_tip->Enable(); + m_img_amsmapping_tip->SetBitmap(create_scaled_bitmap("enable_ams", this, 16)); + m_img_amsmapping_tip->Enable(); + + m_simplebook_ams->SetSelection(1); m_extruder->no_ams_mode(false); m_button_ams_setting->Show(); m_button_guide->Show(); @@ -2444,7 +2873,39 @@ void AMSControl::ExitNoneAMSMode() m_amswin->Layout(); m_amswin->Fit(); Layout(); - m_is_none_ams_mode = false; + m_is_none_ams_mode = AMSModel::GENERIC_AMS; +} + +void AMSControl::EnterExtraAMSMode() +{ + m_vams_lib->m_ams_model = m_ext_model; + if(m_is_none_ams_mode == AMSModel::EXTRA_AMS) return; + m_panel_top->Hide(); + m_simplebook_amsitems->Show(); + m_simplebook_amsitems->SetSelection(1); + + + m_vams_lib->m_ams_model = AMSModel::EXTRA_AMS; + m_ams_tip->SetLabel(_L("AMS-Extra")); + m_img_vams_tip->SetBitmap(create_scaled_bitmap("enable_ams_disable", this, 16)); + m_img_vams_tip->Disable(); + m_img_amsmapping_tip->SetBitmap(create_scaled_bitmap("enable_ams_disable", this, 16)); + m_img_amsmapping_tip->Disable(); + + m_simplebook_ams->SetSelection(2); + m_extruder->no_ams_mode(false); + m_button_ams_setting->Show(); + m_button_guide->Show(); + m_button_retry->Show(); + m_button_extruder_feed->Show(); + m_button_extruder_back->Show(); + ShowFilamentTip(true); + m_amswin->Layout(); + m_amswin->Fit(); + Layout(); + Refresh(true); + m_is_none_ams_mode = AMSModel::EXTRA_AMS; + } void AMSControl::EnterCalibrationMode(bool read_to_calibration) @@ -2502,7 +2963,7 @@ void AMSControl::msw_rescale() m_extruder->msw_rescale(); m_vams_extra_road->msw_rescale(); - m_button_extrusion_cali->SetMinSize(wxSize(-1, FromDIP(24))); + //m_button_extrusion_cali->SetMinSize(wxSize(-1, FromDIP(24))); m_button_extruder_feed->SetMinSize(wxSize(-1, FromDIP(24))); m_button_extruder_back->SetMinSize(wxSize(-1, FromDIP(24))); m_button_ams_setting->SetMinSize(wxSize(FromDIP(25), FromDIP(24))); @@ -2521,56 +2982,58 @@ void AMSControl::msw_rescale() void AMSControl::UpdateStepCtrl(bool is_extrusion) { - m_filament_load_step->DeleteAllItems(); - m_filament_unload_step->DeleteAllItems(); - m_filament_vt_load_step->DeleteAllItems(); - - if(is_extrusion){ - wxString FILAMENT_LOAD_STEP_STRING[LOAD_STEP_COUNT] = { + wxString FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_COUNT] = { + _L("Idling..."), _L("Heat the nozzle"), _L("Cut filament"), _L("Pull back current filament"), _L("Push new filament into extruder"), _L("Purge old filament"), - }; - - for (int i = 0; i < LOAD_STEP_COUNT; i++) { - m_filament_load_step->AppendItem(FILAMENT_LOAD_STEP_STRING[i]); - } - }else{ - wxString FILAMENT_LOAD_STEP_STRING[LOAD_WITH_TEMP_STEP_COUNT] = { - _L("Heat the nozzle"), - _L("Push new filament into extruder"), - _L("Purge old filament"), - }; - - for (int i = 0; i < LOAD_WITH_TEMP_STEP_COUNT; i++) { - m_filament_load_step->AppendItem(FILAMENT_LOAD_STEP_STRING[i]); - } - } - - wxString VT_TRAY_LOAD_STEP_STRING[VT_LOAD_STEP_COUNT] = { - _L("Heat the nozzle"), - _L("Push new filament into the extruder"), - _L("Grab new filament"), - _L("Purge old filament"), + _L("Feed Filament"), + _L("Confirm extruded"), + _L("Check filament location") }; - wxString FILAMENT_UNLOAD_STEP_STRING[UNLOAD_STEP_COUNT] = { - _L("Heat the nozzle"), - _L("Cut filament"), - _L("Pull back current filament") - }; + m_filament_load_step->DeleteAllItems(); + m_filament_unload_step->DeleteAllItems(); + m_filament_vt_load_step->DeleteAllItems(); -// for (int i = 0; i < LOAD_STEP_COUNT; i++) { -// m_filament_load_step->AppendItem(FILAMENT_LOAD_STEP_STRING[i]); -// } - for (int i = 0; i < UNLOAD_STEP_COUNT; i++) { - m_filament_unload_step->AppendItem(FILAMENT_UNLOAD_STEP_STRING[i]); + if (m_ams_model == AMSModel::GENERIC_AMS) { + if (is_extrusion) { + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]); + } + else { + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]); + } + + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]); + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]); } - for (int i = 0; i < VT_LOAD_STEP_COUNT; i++) { - m_filament_vt_load_step->AppendItem(VT_TRAY_LOAD_STEP_STRING[i]); + else if (m_ams_model == AMSModel::EXTRA_AMS) { + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]); + m_filament_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]); + + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CHECK_POSITION]); + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_CUT_FILAMENT]); + m_filament_unload_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PULL_CURR_FILAMENT]); } + + m_filament_vt_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_HEAT_NOZZLE]); + m_filament_vt_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PUSH_NEW_FILAMENT]); + m_filament_vt_load_step->AppendItem( _L("Grab new filament")); + m_filament_vt_load_step->AppendItem(FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_PURGE_OLD_FILAMENT]); } void AMSControl::CreateAms() @@ -2587,7 +3050,13 @@ void AMSControl::CreateAms() std::vector ams_info{ams1, ams2, ams3, ams4}; std::vector::iterator it; Freeze(); - for (it = ams_info.begin(); it != ams_info.end(); it++) { AddAms(*it, true); } + for (it = ams_info.begin(); it != ams_info.end(); it++) { + AddAmsItems(*it); + AddAms(*it); + AddExtraAms(*it); + m_ams_info.push_back(*it); + } + m_sizer_top->Layout(); Thaw(); } @@ -2606,25 +3075,24 @@ void AMSControl::Reset() std::vector ams_info{ams1, ams2, ams3, ams4}; std::vector::iterator it; - UpdateAms(ams_info, false, false, true); + UpdateAms(ams_info, false, true); m_current_show_ams = ""; m_current_ams = ""; m_current_senect = ""; } -void AMSControl::show_noams_mode(bool show, bool support_virtual_tray, bool support_extrustion_cali) +void AMSControl::show_noams_mode() { - show_vams(support_virtual_tray); - m_sizer_ams_tips->Show(support_virtual_tray); + show_vams(true); + m_sizer_ams_tips->Show(true); - if (!support_extrustion_cali) - m_button_extrusion_cali->Hide(); - else { - //m_button_extrusion_cali->Show(); - m_button_extrusion_cali->Hide(); + if (m_ams_model == AMSModel::NO_AMS) { + EnterNoneAMSMode(); + } else if(m_ams_model == AMSModel::GENERIC_AMS){ + EnterGenericAMSMode(); + } else if (m_ams_model == AMSModel::EXTRA_AMS) { + EnterExtraAMSMode(); } - - show?ExitNoneAMSMode() : EnterNoneAMSMode(); } void AMSControl::show_auto_refill(bool show) @@ -2695,7 +3163,7 @@ void AMSControl::reset_vams() } -void AMSControl::UpdateAms(std::vector info, bool keep_selection, bool has_extrusion_cali, bool is_reset) +void AMSControl::UpdateAms(std::vector info, bool keep_selection, bool is_reset) { std::string curr_ams_id = GetCurentAms(); std::string curr_can_id = GetCurrentCan(curr_ams_id); @@ -2705,6 +3173,12 @@ void AMSControl::UpdateAms(std::vector info, bool keep_selection, bool // update item m_ams_info = info; + if (m_ams_model == AMSModel::GENERIC_AMS){ + m_ams_cans_list = m_ams_generic_cans_list; + } + else if (m_ams_model == AMSModel::EXTRA_AMS) { + m_ams_cans_list = m_ams_extra_cans_list; + } if (info.size() > 1) { m_simplebook_amsitems->Show(); @@ -2738,7 +3212,7 @@ void AMSControl::UpdateAms(std::vector info, bool keep_selection, bool if (ifo.ams_id == cans->amsIndex) { cans->amsCans->m_info = ifo; cans->amsCans->Update(ifo); - cans->amsCans->show_sn_value(true); + cans->amsCans->show_sn_value(m_ams_model == AMSModel::EXTRA_AMS?false:true); } } } @@ -2750,37 +3224,46 @@ void AMSControl::UpdateAms(std::vector info, bool keep_selection, bool } } -void AMSControl::AddAms(AMSinfo info, bool refresh) +void AMSControl::AddAmsItems(AMSinfo info) { - if (m_ams_count >= AMS_CONTROL_MAX_COUNT) return; - - // item auto amsitem = new AMSItem(m_panel_top, wxID_ANY, info); - amsitem->Bind(wxEVT_LEFT_DOWN, [this, amsitem](wxMouseEvent &e) { + amsitem->Bind(wxEVT_LEFT_DOWN, [this, amsitem](wxMouseEvent& e) { SwitchAms(amsitem->m_amsinfo.ams_id); e.Skip(); - }); + }); - AmsItems *item = new AmsItems(); + AmsItems* item = new AmsItems(); item->amsIndex = info.ams_id; - item->amsItem = amsitem; + item->amsItem = amsitem; m_ams_item_list.Add(item); - m_sizer_top->Add(amsitem, 0, wxALIGN_CENTER|wxRIGHT, 6); + m_sizer_top->Add(amsitem, 0, wxALIGN_CENTER | wxRIGHT, 6); +} - AmsCansWindow *canswin = new AmsCansWindow(); - auto amscans = new AmsCans(m_simplebook_cans, wxID_ANY, info); +void AMSControl::AddAms(AMSinfo info) +{ + AmsCansWindow* canswin = new AmsCansWindow(); + auto amscans = new AmsCans(m_simplebook_generic_cans, info, AMSModel::GENERIC_AMS); canswin->amsIndex = info.ams_id; - canswin->amsCans = amscans; - m_ams_cans_list.Add(canswin); + canswin->amsCans = amscans; + m_ams_generic_cans_list.Add(canswin); - m_simplebook_cans->AddPage(amscans, wxEmptyString, false); - amscans->m_selection = m_simplebook_cans->GetPageCount() - 1; + m_simplebook_generic_cans->AddPage(amscans, wxEmptyString, false); + amscans->m_selection = m_simplebook_generic_cans->GetPageCount() - 1; +} - if (refresh) { m_sizer_top->Layout(); } - m_ams_count++; - m_ams_info.push_back(info); +void AMSControl::AddExtraAms(AMSinfo info) +{ + AmsCansWindow* canswin = new AmsCansWindow(); + auto amscans = new AmsCans(m_simplebook_extra_cans, info, AMSModel::EXTRA_AMS); + + canswin->amsIndex = info.ams_id; + canswin->amsCans = amscans; + m_ams_extra_cans_list.Add(canswin); + + m_simplebook_extra_cans->AddPage(amscans, wxEmptyString, false); + amscans->m_selection = m_simplebook_extra_cans->GetPageCount() - 1; } void AMSControl::SwitchAms(std::string ams_id) @@ -2817,7 +3300,13 @@ void AMSControl::SwitchAms(std::string ams_id) for (auto i = 0; i < m_ams_cans_list.GetCount(); i++) { AmsCansWindow *cans = m_ams_cans_list[i]; if (cans->amsCans->m_info.ams_id == ams_id) { - m_simplebook_cans->SetSelection(cans->amsCans->m_selection); + + if (m_ams_model == AMSModel::GENERIC_AMS) { + m_simplebook_generic_cans->SetSelection(cans->amsCans->m_selection); + } + else if (m_ams_model == AMSModel::EXTRA_AMS) { + m_simplebook_extra_cans->SetSelection(cans->amsCans->m_selection); + } } } @@ -2841,8 +3330,21 @@ void AMSControl::SwitchAms(std::string ams_id) } } -void AMSControl::SetFilamentStep(int item_idx, FilamentStepType f_type, bool is_extrusion_exist) +void AMSControl::SetFilamentStep(int item_idx, FilamentStepType f_type) { + wxString FILAMENT_CHANGE_STEP_STRING[FilamentStep::STEP_COUNT] = { + _L("Idling..."), + _L("Heat the nozzle"), + _L("Cut filament"), + _L("Pull back current filament"), + _L("Push new filament into extruder"), + _L("Purge old filament"), + _L("Feed Filament"), + _L("Confirm extruded"), + _L("Check filament location") + }; + + if (item_idx == FilamentStep::STEP_IDLE) { m_simplebook_right->SetSelection(0); m_filament_load_step->Idle(); @@ -2851,12 +3353,18 @@ void AMSControl::SetFilamentStep(int item_idx, FilamentStepType f_type, bool is_ return; } + wxString step_str = wxEmptyString; + if (item_idx < FilamentStep::STEP_COUNT) { + step_str = FILAMENT_CHANGE_STEP_STRING[item_idx]; + } + if (f_type == FilamentStepType::STEP_TYPE_LOAD) { if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) { if (m_simplebook_right->GetSelection() != 1) { m_simplebook_right->SetSelection(1); } - m_filament_load_step->SelectItem(item_idx - 1); + + m_filament_load_step->SelectItem( m_filament_load_step->GetItemUseText(step_str) ); } else { m_filament_load_step->Idle(); } @@ -2865,24 +3373,20 @@ void AMSControl::SetFilamentStep(int item_idx, FilamentStepType f_type, bool is_ if (m_simplebook_right->GetSelection() != 2) { m_simplebook_right->SetSelection(2); } - m_filament_unload_step->SelectItem(item_idx - 1); + m_filament_unload_step->SelectItem( m_filament_unload_step->GetItemUseText(step_str) ); } else { m_filament_unload_step->Idle(); } } else if (f_type == FilamentStepType::STEP_TYPE_VT_LOAD) { m_simplebook_right->SetSelection(3); - if (item_idx == STEP_HEAT_NOZZLE) { - m_filament_vt_load_step->SelectItem(0); - } - else if (item_idx == STEP_FEED_FILAMENT) { - m_filament_vt_load_step->SelectItem(1); - } - else if (item_idx == STEP_CONFIRM_EXTRUDED) { - m_filament_vt_load_step->SelectItem(2); - } - else if (item_idx == STEP_PURGE_OLD_FILAMENT) { - m_filament_vt_load_step->SelectItem(3); + if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) { + if (item_idx == STEP_CONFIRM_EXTRUDED) { + m_filament_vt_load_step->SelectItem(2); + } + else { + m_filament_vt_load_step->SelectItem( m_filament_vt_load_step->GetItemUseText(step_str) ); + } } else { m_filament_vt_load_step->Idle(); @@ -2890,7 +3394,7 @@ void AMSControl::SetFilamentStep(int item_idx, FilamentStepType f_type, bool is_ } else { if (item_idx > 0 && item_idx < FilamentStep::STEP_COUNT) { m_simplebook_right->SetSelection(1); - m_filament_load_step->SelectItem(item_idx - 1); + m_filament_load_step->SelectItem( m_filament_load_step->GetItemUseText(step_str) ); } else { m_filament_load_step->Idle(); @@ -2914,14 +3418,6 @@ void AMSControl::ShowFilamentTip(bool hasams) m_tip_load_info->SetMinSize(AMS_STEP_SIZE); } -void AMSControl::SetHumidity(std::string amsid, int humidity) -{ - for (auto i = 0; i < m_ams_item_list.GetCount(); i++) { - AmsItems *item = m_ams_item_list[i]; - if (amsid == item->amsItem->m_amsinfo.ams_id) { item->amsItem->SetHumidity(humidity); } - } -} - bool AMSControl::Enable(bool enable) { for (auto i = 0; i < m_ams_item_list.GetCount(); i++) { @@ -2933,7 +3429,7 @@ bool AMSControl::Enable(bool enable) AmsCansWindow *cans = m_ams_cans_list[i]; cans->amsCans->Enable(enable); } - m_button_extrusion_cali->Enable(enable); + //m_button_extrusion_cali->Enable(enable); m_button_extruder_feed->Enable(enable); m_button_extruder_back->Enable(enable); m_button_ams_setting->Enable(enable); @@ -2942,28 +3438,59 @@ bool AMSControl::Enable(bool enable) return wxWindow::Enable(enable); } -void AMSControl::SetExtruder(bool on_off, bool is_vams, wxColour col) +void AMSControl::SetExtruder(bool on_off, bool is_vams, std::string ams_now, wxColour col) { - if (!on_off) { - m_extruder->TurnOff(); - m_vams_extra_road->OnVamsLoading(false); - m_extruder->OnVamsLoading(false); - m_vams_road->OnVamsLoading(false); - } else { - m_extruder->TurnOn(col); - m_extruder->OnAmsLoading(true, col); - } + if (m_ams_model == AMSModel::GENERIC_AMS || m_ext_model == AMSModel::GENERIC_AMS ) { + if (!on_off) { + m_extruder->TurnOff(); + m_vams_extra_road->OnVamsLoading(false); + m_extruder->OnVamsLoading(false); + m_vams_road->OnVamsLoading(false); + } + else { + m_extruder->TurnOn(col); - if (is_vams && on_off) { - m_extruder->OnAmsLoading(false, col); - m_vams_extra_road->OnVamsLoading(true, col); - m_extruder->OnVamsLoading(true, col); - m_vams_road->OnVamsLoading(true, col); + if (ams_now != GetCurentShowAms()) { + m_extruder->OnAmsLoading(false, col); + } + else { + m_extruder->OnAmsLoading(true, col); + } + } + + if (is_vams && on_off) { + m_extruder->OnAmsLoading(false); + m_vams_extra_road->OnVamsLoading(true, col); + m_extruder->OnVamsLoading(true, col); + m_vams_road->OnVamsLoading(true, col); + } + else { + m_vams_extra_road->OnVamsLoading(false); + m_extruder->OnVamsLoading(false); + m_vams_road->OnVamsLoading(false); + } } - else { - m_vams_extra_road->OnVamsLoading(false, col); - m_extruder->OnVamsLoading(false, col); - m_vams_road->OnVamsLoading(false, col); + else if (m_ams_model == AMSModel::EXTRA_AMS || m_ext_model == AMSModel::EXTRA_AMS) { + if (!is_vams && !on_off) { + m_extruder->TurnOff(); + m_extruder->OnVamsLoading(false); + m_vams_extra_road->OnVamsLoading(false); + m_vams_road->OnVamsLoading(false); + } + else { + m_extruder->TurnOn(col); + } + + if (is_vams && on_off) { + m_vams_extra_road->OnVamsLoading(true, col); + m_extruder->OnVamsLoading(true, col); + m_vams_road->OnVamsLoading(true, col); + } + else { + m_vams_extra_road->OnVamsLoading(false); + m_extruder->OnVamsLoading(false); + m_vams_road->OnVamsLoading(false); + } } } @@ -2996,29 +3523,40 @@ void AMSControl::SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadTy m_last_tray_id = canid; - if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) { - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE); - m_extruder->OnAmsLoading(false); - } + if (m_ams_model == AMSModel::GENERIC_AMS) { + if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) { + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE); + m_extruder->OnAmsLoading(false); + } - if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) { - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); - m_extruder->OnAmsLoading(false); - } + if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) { + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); + m_extruder->OnAmsLoading(false); + } - if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) { - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2); - if (m_current_show_ams == ams_id) { + if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) { + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2); + if (m_current_show_ams == ams_id) { + m_extruder->OnAmsLoading(true, cans->amsCans->GetTagColr(canid)); + } + } + + if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) { + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2); + cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_3); m_extruder->OnAmsLoading(true, cans->amsCans->GetTagColr(canid)); - } + } } - - if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) { - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1); - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2); - cans->amsCans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_3); - m_extruder->OnAmsLoading(true, cans->amsCans->GetTagColr(canid)); + else if (m_ams_model == AMSModel::EXTRA_AMS) { + cans->amsCans->SetAmsStepExtra(canid, type, step); + if (step != AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) { + m_extruder->OnAmsLoading(true, cans->amsCans->GetTagColr(canid)); + } + else { + m_extruder->OnAmsLoading(false); + } } for (auto i = 0; i < m_ams_info.size(); i++) { diff --git a/src/slic3r/GUI/Widgets/AMSControl.hpp b/src/slic3r/GUI/Widgets/AMSControl.hpp index bf74d0a11..92351262f 100644 --- a/src/slic3r/GUI/Widgets/AMSControl.hpp +++ b/src/slic3r/GUI/Widgets/AMSControl.hpp @@ -35,6 +35,12 @@ namespace Slic3r { namespace GUI { +enum AMSModel { + NO_AMS = 0, + GENERIC_AMS = 1, + EXTRA_AMS = 2 +}; + enum ActionButton { ACTION_BTN_CALI = 0, ACTION_BTN_LOAD = 1, @@ -105,6 +111,7 @@ enum FilamentStep { STEP_PURGE_OLD_FILAMENT, STEP_FEED_FILAMENT, STEP_CONFIRM_EXTRUDED, + STEP_CHECK_POSITION, STEP_COUNT, }; @@ -118,11 +125,11 @@ enum FilamentStepType { #define AMS_ITEM_SIZE wxSize(FromDIP(82), FromDIP(27)) #define AMS_ITEM_HUMIDITY_SIZE wxSize(FromDIP(120), FromDIP(27)) #define AMS_CAN_LIB_SIZE wxSize(FromDIP(58), FromDIP(80)) -#define AMS_CAN_ROAD_SIZE wxSize(FromDIP(66), FromDIP(60)) +#define AMS_CAN_ROAD_SIZE wxSize(FromDIP(66), FromDIP(70)) #define AMS_CAN_ITEM_HEIGHT_SIZE FromDIP(27) -#define AMS_CANS_SIZE wxSize(FromDIP(284), FromDIP(186)) -#define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), FromDIP(186)) -#define AMS_STEP_SIZE wxSize(FromDIP(172), FromDIP(186)) +#define AMS_CANS_SIZE wxSize(FromDIP(284), FromDIP(196)) +#define AMS_CANS_WINDOW_SIZE wxSize(FromDIP(264), FromDIP(196)) +#define AMS_STEP_SIZE wxSize(FromDIP(172), FromDIP(196)) #define AMS_REFRESH_SIZE wxSize(FromDIP(30), FromDIP(30)) #define AMS_EXTRUDER_SIZE wxSize(FromDIP(86), FromDIP(72)) #define AMS_EXTRUDER_BITMAP_SIZE wxSize(FromDIP(36), FromDIP(55)) @@ -161,8 +168,8 @@ class AMSrefresh : public wxWindow { public: AMSrefresh(); - AMSrefresh(wxWindow *parent, wxWindowID id, wxString number, Caninfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); - AMSrefresh(wxWindow *parent, wxWindowID id, int number, Caninfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); + AMSrefresh(wxWindow *parent, wxString number, Caninfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); + AMSrefresh(wxWindow *parent, int number, Caninfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); ~AMSrefresh(); void PlayLoading(); void StopLoading(); @@ -243,7 +250,7 @@ public: void has_ams(bool hams) {m_has_vams = hams; Refresh();}; void no_ams_mode(bool mode) {m_none_ams_mode = mode; Refresh();}; - bool m_none_ams_mode{false}; + bool m_none_ams_mode{true}; bool m_has_vams{false}; bool m_vams_loading{false}; bool m_ams_loading{false}; @@ -284,13 +291,15 @@ Description:AMSLib class AMSLib : public wxWindow { public: - AMSLib(wxWindow *parent, wxWindowID id, Caninfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); + AMSLib(wxWindow *parent, Caninfo info); void create(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); public: wxColour GetLibColour(); Caninfo m_info; MachineObject* m_obj = {nullptr}; - int m_can_index; + int m_can_index = 0; + AMSModel m_ams_model; + void Update(Caninfo info, bool refresh = true); void UnableSelected() { m_unable_selected = true; }; void EableSelected() { m_unable_selected = false; }; @@ -303,7 +312,7 @@ public: virtual bool Enable(bool enable = true); void set_disable_mode(bool disable) { m_disable_mode = disable; } void msw_rescale(); - + void on_pass_road(bool pass); protected: wxStaticBitmap *m_edit_bitmp = {nullptr}; @@ -314,6 +323,15 @@ protected: ScalableBitmap m_bitmap_readonly_light; ScalableBitmap m_bitmap_transparent; + ScalableBitmap m_bitmap_extra_tray_left; + ScalableBitmap m_bitmap_extra_tray_right; + + ScalableBitmap m_bitmap_extra_tray_left_hover; + ScalableBitmap m_bitmap_extra_tray_right_hover; + + ScalableBitmap m_bitmap_extra_tray_left_selected; + ScalableBitmap m_bitmap_extra_tray_right_selected; + bool m_unable_selected = {false}; bool m_enable = {false}; bool m_selected = {false}; @@ -326,13 +344,18 @@ protected: wxColour m_road_def_color; wxColour m_lib_color; bool m_disable_mode{ false }; + bool m_pass_road{false}; void on_enter_window(wxMouseEvent &evt); void on_leave_window(wxMouseEvent &evt); void on_left_down(wxMouseEvent &evt); void paintEvent(wxPaintEvent &evt); void render(wxDC &dc); - void doRender(wxDC &dc); + void render_extra_text(wxDC& dc); + void render_generic_text(wxDC& dc); + void doRender(wxDC& dc); + void render_extra_lib(wxDC& dc); + void render_generic_lib(wxDC& dc); }; /************************************************* @@ -364,9 +387,11 @@ public: ScalableBitmap ams_humidity_3; ScalableBitmap ams_humidity_4; + int m_humidity = { 0 }; bool m_show_humidity = { false }; bool m_vams_loading{false}; + AMSModel m_ams_model; void OnVamsLoading(bool load, wxColour col = AMS_CONTROL_GRAY500); void SetPassRoadColour(wxColour col); @@ -399,9 +424,6 @@ public: void OnLeaveWindow(wxMouseEvent &evt); void OnSelected(); void UnSelected(); - void ShowHumidity(); - void HideHumidity(); - void SetHumidity(int humidity); virtual bool Enable(bool enable = true); AMSinfo m_amsinfo; @@ -413,8 +435,6 @@ protected: int m_space = {5}; bool m_hover = {false}; bool m_selected = {false}; - bool m_show_humidity = {false}; - int m_humidity = {0}; ScalableBitmap* m_ts_bitmap_cube; void paintEvent(wxPaintEvent &evt); @@ -455,32 +475,45 @@ class AmsCans : public wxWindow { public: AmsCans(); - AmsCans(wxWindow *parent, wxWindowID id, AMSinfo info, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize); + AmsCans(wxWindow *parent, AMSinfo info, AMSModel model); void Update(AMSinfo info); - void create(wxWindow *parent, wxWindowID id, AMSinfo info, const wxPoint &pos, const wxSize &size); - void AddCan(Caninfo caninfo, int canindex, int maxcan); + void create(wxWindow *parent); + void AddCan(Caninfo caninfo, int canindex, int maxcan, wxBoxSizer* sizer); void SetDefSelectCan(); void SelectCan(std::string canid); - wxColour GetTagColr(wxString canid); - void SetAmsStep(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step); - //wxColour GetCanColour(wxString canid); void PlayRridLoading(wxString canid); void StopRridLoading(wxString canid); void msw_rescale(); void show_sn_value(bool show); + void SetAmsStepExtra(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step); + void SetAmsStep(wxString canid, AMSPassRoadType type, AMSPassRoadSTEP step); + void SetAmsStep(std::string can_id); + void paintEvent(wxPaintEvent& evt); + void render(wxDC& dc); + void doRender(wxDC& dc); + wxColour GetTagColr(wxString canid); std::string GetCurrentCan(); public: + ScalableBitmap m_bitmap_extra_framework; + int m_canlib_selection = { -1 }; + int m_selection = { 0 }; + int m_can_count = { 0 }; + AMSModel m_ams_model; std::string m_canlib_id; - int m_canlib_selection = {-1}; - int m_selection = {0}; - int m_can_count = {0}; + + std::string m_road_canid; + wxColour m_road_colour; + CanLibsHash m_can_lib_list; CansRoadsHash m_can_road_list; CanrefreshsHash m_can_refresh_list; AMSinfo m_info; wxBoxSizer * sizer_can = {nullptr}; + wxBoxSizer * sizer_can_middle = {nullptr}; + wxBoxSizer * sizer_can_left = {nullptr}; + wxBoxSizer * sizer_can_right = {nullptr}; AMSPassRoadSTEP m_step = {AMSPassRoadSTEP ::AMS_ROAD_STEP_NONE}; }; @@ -532,16 +565,16 @@ public: void init_scaled_buttons(); protected: - int m_ams_count = {0}; - - std::map m_ams_selection; - std::vector m_ams_info; - std::string m_current_ams; std::string m_current_show_ams; - + std::map m_ams_selection; + AmsItemsHash m_ams_item_list; + + std::vector m_ams_info; AmsCansHash m_ams_cans_list; + AmsCansHash m_ams_generic_cans_list; + AmsCansHash m_ams_extra_cans_list; AMSextruder *m_extruder = {nullptr}; @@ -551,7 +584,10 @@ protected: wxSimplebook *m_simplebook_calibration = {nullptr}; wxSimplebook *m_simplebook_amsitems = {nullptr}; wxSimplebook *m_simplebook_ams = {nullptr}; - wxSimplebook *m_simplebook_cans = {nullptr}; + + wxSimplebook *m_simplebook_generic_cans= {nullptr}; + wxSimplebook *m_simplebook_extra_cans = {nullptr}; + wxSimplebook *m_simplebook_bottom = {nullptr}; wxStaticText *m_tip_right_top = {nullptr}; @@ -564,6 +600,8 @@ protected: wxBoxSizer* m_sizer_vams_tips = {nullptr}; Label* m_ams_backup_tip = {nullptr}; + Label* m_ams_tip = {nullptr}; + Caninfo m_vams_info; StaticBox* m_panel_virtual = {nullptr}; AMSLib* m_vams_lib = {nullptr}; @@ -584,6 +622,8 @@ protected: Button *m_button_extruder_back = {nullptr}; wxStaticBitmap* m_button_ams_setting = {nullptr}; wxStaticBitmap* m_img_ams_backup = {nullptr}; + wxStaticBitmap* m_img_amsmapping_tip = {nullptr}; + wxStaticBitmap* m_img_vams_tip = {nullptr}; ScalableBitmap m_button_ams_setting_normal; ScalableBitmap m_button_ams_setting_hover; ScalableBitmap m_button_ams_setting_press; @@ -597,16 +637,23 @@ protected: std::string m_last_ams_id; std::string m_last_tray_id; + public: std::string GetCurentAms(); std::string GetCurentShowAms(); std::string GetCurrentCan(std::string amsid); wxColour GetCanColour(std::string amsid, std::string canid); - bool m_is_none_ams_mode{false}; + AMSModel m_ams_model{AMSModel::NO_AMS}; + AMSModel m_ext_model{AMSModel::NO_AMS}; + AMSModel m_is_none_ams_mode{AMSModel::NO_AMS}; + + void SetAmsModel(AMSModel mode, AMSModel ext_mode) {m_ams_model = mode; m_ext_model = ext_mode;}; + void SetActionState(bool button_status[]); - void EnterNoneAMSMode(); - void ExitNoneAMSMode(); + void EnterNoneAMSMode(bool support_vt_load = false); + void EnterGenericAMSMode(); + void EnterExtraAMSMode(); void EnterCalibrationMode(bool read_to_calibration); void ExitcClibrationMode(); @@ -617,15 +664,16 @@ public: void PlayRridLoading(wxString amsid, wxString canid); void StopRridLoading(wxString amsid, wxString canid); - void SetFilamentStep(int item_idx, FilamentStepType f_type, bool is_extrusion_exist = false); + void SetFilamentStep(int item_idx, FilamentStepType f_type); void ShowFilamentTip(bool hasams = true); - void SetHumidity(std::string amsid, int humidity); void UpdateStepCtrl(bool is_extrusion_exist); void CreateAms(); - void UpdateAms(std::vector info, bool keep_selection = true, bool has_extrusion_cali = true, bool is_reset = false); - void AddAms(AMSinfo info, bool refresh = true); - void SetExtruder(bool on_off, bool is_vams, wxColour col); + void UpdateAms(std::vector info, bool keep_selection = true, bool is_reset = false); + void AddAms(AMSinfo info); + void AddAmsItems(AMSinfo info); + void AddExtraAms(AMSinfo info); + void SetExtruder(bool on_off, bool is_vams, std::string ams_now, wxColour col); void SetAmsStep(std::string ams_id, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step); void SwitchAms(std::string ams_id); @@ -639,7 +687,7 @@ public: void on_clibration_cancel_click(wxMouseEvent &event); void Reset(); - void show_noams_mode(bool show, bool support_virtual_tray, bool support_extrustion_cali); + void show_noams_mode(); void show_auto_refill(bool show); void show_vams(bool show); void show_vams_kn_value(bool show); diff --git a/src/slic3r/GUI/Widgets/StepCtrl.cpp b/src/slic3r/GUI/Widgets/StepCtrl.cpp index c7071a564..d9a3349fb 100644 --- a/src/slic3r/GUI/Widgets/StepCtrl.cpp +++ b/src/slic3r/GUI/Widgets/StepCtrl.cpp @@ -87,6 +87,19 @@ wxString StepCtrlBase::GetItemText(unsigned int item) const return item < steps.size() ? steps[item] : wxString{}; } +int StepCtrlBase::GetItemUseText(wxString txt) const +{ + for(int i = 0; i < steps.size(); i++){ + if (steps[i] == txt) { + return i; + } + else { + continue; + } + } + return 0; +} + void StepCtrlBase::SetItemText(unsigned int item, wxString const &value) { if (item >= steps.size()) return; diff --git a/src/slic3r/GUI/Widgets/StepCtrl.hpp b/src/slic3r/GUI/Widgets/StepCtrl.hpp index c7c5ebd47..63df3625e 100644 --- a/src/slic3r/GUI/Widgets/StepCtrl.hpp +++ b/src/slic3r/GUI/Widgets/StepCtrl.hpp @@ -53,7 +53,8 @@ public: void Idle(); wxString GetItemText(unsigned int item) const; - void SetItemText(unsigned int item, wxString const &value); + int GetItemUseText(wxString txt) const; + void SetItemText(unsigned int item, wxString const& value); private: // some useful events