juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-10-05 06:41:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
7fa74693550a9bfa505508c5398cc55353e70ba5
OrcaSlicer/src/slic3r/GUI/Widgets/FanControl.cpp
T
Hanif Koh 7fa7469355 Add the GUI Includes the First Pass Missed 
Covers headers that only became editable once they compiled on their own, and wx symbols whose suggested header changed as the clang-tidy ignore list grew after the src/slic3r/GUI pass.
2026-10-02 18:08:04 +08:00

1142 lines
39 KiB
C++
Raw Blame History

#include "FanControl.hpp"
#include "Label.hpp"
#include "../BitmapCache.hpp"
#include "../I18N.hpp"
#include "../GUI_App.hpp"
#include "../MsgDialog.hpp"
#include "json_diff.hpp"
#include <wx/anybutton.h>
#include <wx/event.h>
#include <wx/checklst.h>
#include <wx/gdicmn.h>
#include <wx/dcclient.h>
#include <wx/dc.h>
#include <wx/chartype.h>
#include "slic3r/GUI/Widgets/StateColor.hpp"
#include <wx/colour.h>
#include "slic3r/GUI/DeviceCore/DevFan.h"
#include <boost/log/trivial.hpp>
#include <cmath>
#include <algorithm>
#include <wx/panel.h>
#include "slic3r/GUI/SelectMachine.hpp"
#include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
#include <map>
#include <wx/simplebook.h>
#include <wx/dcgraph.h>
#include <wx/string.h>
#include <wx/stattext.h>
#include <wx/sizer.h>
namespace Slic3r { namespace GUI {
wxDEFINE_EVENT(EVT_FAN_SWITCH_ON, wxCommandEvent);
wxDEFINE_EVENT(EVT_FAN_SWITCH_OFF, wxCommandEvent);
wxDEFINE_EVENT(EVT_FAN_ADD, wxCommandEvent);
wxDEFINE_EVENT(EVT_FAN_DEC, wxCommandEvent);
wxDEFINE_EVENT(EVT_FAN_CHANGED, wxCommandEvent);
constexpr int time_out = 6;
static bool not_show_fan_speed_warning_dlg = false;
/*************************************************
Description:Fan
**************************************************/
Fan::Fan(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
create(parent, id, pos, size);
}
void Fan::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
m_current_speeds = 0;
wxWindow::Create(parent, id, pos, size, wxBORDER_NONE);
SetBackgroundColour(*wxWHITE);
m_rotate_offsets.push_back(RotateOffSet{ 2.5, wxPoint(-FromDIP(16), FromDIP(11)) });
m_rotate_offsets.push_back(RotateOffSet{ 2.2, wxPoint(-FromDIP(20), FromDIP(11)) });
m_rotate_offsets.push_back(RotateOffSet{ 1.7, wxPoint(-FromDIP(24), FromDIP(12)) });
m_rotate_offsets.push_back(RotateOffSet{ 1.2, wxPoint(-FromDIP(22), FromDIP(4)) });
m_rotate_offsets.push_back(RotateOffSet{ 0.7, wxPoint(-FromDIP(17), -FromDIP(6)) });
m_rotate_offsets.push_back(RotateOffSet{ 0.3, wxPoint(-FromDIP(8), -FromDIP(11)) });
m_rotate_offsets.push_back(RotateOffSet{ 6.1, wxPoint(-FromDIP(0), -FromDIP(9)) });
m_rotate_offsets.push_back(RotateOffSet{ 5.5, wxPoint(-FromDIP(4), -FromDIP(2)) });
m_rotate_offsets.push_back(RotateOffSet{ 5.1, wxPoint(-FromDIP(3), FromDIP(5)) });
m_rotate_offsets.push_back(RotateOffSet{ 4.6, wxPoint(-FromDIP(3), FromDIP(14)) });
m_rotate_offsets.push_back(RotateOffSet{ 4.0, wxPoint(-FromDIP(2), FromDIP(11)) });
//auto m_bitmap_pointer = ScalableBitmap(this, "fan_pointer", FromDIP(25));
//m_img_pointer = m_bitmap_pointer.bmp().ConvertToImage();
m_bitmap_bk = ScalableBitmap(this, "fan_dash_bk", 80);
for (auto i = 0; i <= 10; i++) {
#ifdef __APPLE__
auto m_bitmap_scale = ScalableBitmap(this, wxString::Format("fan_scale_%d", i).ToStdString(), 60);
m_bitmap_scales.push_back(m_bitmap_scale);
#else
auto m_bitmap_scale = ScalableBitmap(this, wxString::Format("fan_scale_%d", i).ToStdString(), 46);
m_bitmap_scales.push_back(m_bitmap_scale);
#endif
}
//#ifdef __APPLE__
// SetMinSize(wxSize(FromDIP(100), FromDIP(100) + FromDIP(6)));
// SetMaxSize(wxSize(FromDIP(100), FromDIP(100) + FromDIP(6)));
//#else
SetMinSize(wxSize(m_bitmap_bk.GetBmpSize().x, m_bitmap_bk.GetBmpSize().y + FromDIP(6)));
SetMaxSize(wxSize(m_bitmap_bk.GetBmpSize().x, m_bitmap_bk.GetBmpSize().y + FromDIP(6)));
//#endif // __APPLE__
Bind(wxEVT_PAINT, &Fan::paintEvent, this);
}
void Fan::set_fan_speeds(int g)
{
m_current_speeds = g;
Refresh();
}
void Fan::post_event(wxCommandEvent &&event)
{
/*event.SetString(m_info.can_id);
event.SetEventObject(m_parent);
wxPostEvent(m_parent, event);
event.Skip();*/
}
void Fan::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
render(dc);
}
void Fan::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 Fan::doRender(wxDC& dc)
{
auto rpm = wxT("rpm");
wxSize size = GetSize();
dc.DrawBitmap(m_bitmap_bk.bmp(), wxPoint(0,0));
//fan scale
/*auto central_point = wxPoint(size.x / 2, size.y / 2 + FromDIP(15));
dc.DrawBitmap(m_bitmap_scale_0.bmp(), central_point.x - FromDIP(38), central_point.y);
dc.DrawBitmap(m_bitmap_scale_1.bmp(), central_point.x - FromDIP(40), central_point.y - FromDIP(17));
dc.DrawBitmap(m_bitmap_scale_2.bmp(), central_point.x - FromDIP(40), central_point.y - FromDIP(36));
dc.DrawBitmap(m_bitmap_scale_3.bmp(), central_point.x - FromDIP(32), central_point.y - FromDIP(48));
dc.DrawBitmap(m_bitmap_scale_4.bmp(), central_point.x - FromDIP(18), central_point.y - FromDIP(53));
dc.DrawBitmap(m_bitmap_scale_5.bmp(), central_point.x - FromDIP(0), central_point.y - FromDIP(53));
dc.DrawBitmap(m_bitmap_scale_6.bmp(), central_point.x + FromDIP(18), central_point.y - FromDIP(48));
dc.DrawBitmap(m_bitmap_scale_7.bmp(), central_point.x + FromDIP(31), central_point.y - FromDIP(36));
dc.DrawBitmap(m_bitmap_scale_8.bmp(), central_point.x + FromDIP(36), central_point.y - FromDIP(17));
dc.DrawBitmap(m_bitmap_scale_9.bmp(), central_point.x + FromDIP(28), central_point.y);*/
//fan pointer
//auto pointer_central_point = wxPoint((size.x - m_img_pointer.GetSize().x) / 2, (size.y - m_img_pointer.GetSize().y) / 2);
//auto bmp = m_img_pointer.Rotate(m_rotate_offsets[m_current_speeds].rotate, wxPoint(size.x / 2,size.y / 2));
auto central_point = wxPoint((size.x - m_bitmap_scales[m_current_speeds].GetBmpSize().x) / 2, (size.y - m_bitmap_scales[m_current_speeds].GetBmpSize().y) / 2 - FromDIP(4));
dc.DrawBitmap(m_bitmap_scales[m_current_speeds].bmp(), central_point.x, central_point.y);
//fan val
dc.SetTextForeground(DRAW_TEXT_COLOUR);
dc.SetFont(::Label::Head_13);
auto speeds = wxString::Format("%d%%", m_current_speeds * 10);
dc.DrawText(speeds, (size.x - dc.GetTextExtent(speeds).x) / 2 + FromDIP(2), size.y - dc.GetTextExtent(speeds).y - FromDIP(5));
//rpm
//dc.SetFont(::Label::Body_13);
//dc.DrawText(rpm, (size.x - dc.GetTextExtent(rpm).x) / 2, size.y - dc.GetTextExtent(rpm).y);
}
void Fan::msw_rescale()
{
m_bitmap_bk.msw_rescale();
}
void Fan::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
wxWindow::DoSetSize(x, y, width, height, sizeFlags);
}
/*************************************************
Description:FanOperate
**************************************************/
FanOperate::FanOperate(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
m_current_speeds = 0;
m_min_speeds = 1;
m_max_speeds = 10;
create(parent, id, pos, size);
wxGetApp().UpdateDarkUIWin(this);
}
void FanOperate::create(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
{
wxWindow::Create(parent, id, pos, size, wxBORDER_NONE);
SetBackgroundColour(*wxWHITE);
m_bitmap_add = ScalableBitmap(this, "fan_control_add", 24);
m_bitmap_decrease = ScalableBitmap(this, "fan_control_decrease", 24);
SetMinSize(wxSize(FromDIP(SIZE_OF_FAN_OPERATE.x), FromDIP(SIZE_OF_FAN_OPERATE.y)));
Bind(wxEVT_PAINT, &FanOperate::paintEvent, this);
Bind(wxEVT_ENTER_WINDOW, [this](auto& e) { SetCursor(wxCURSOR_HAND);});
Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) { SetCursor(wxCURSOR_ARROW);});
Bind(wxEVT_LEFT_DOWN, &FanOperate::on_left_down, this);
}
void FanOperate::on_left_down(wxMouseEvent& event)
{
auto mouse_pos = ClientToScreen(event.GetPosition());
auto win_pos = ClientToScreen(wxPoint(0, 0));
auto decrease_fir = FromDIP(24);
auto add_fir = GetSize().x - FromDIP(24);
if (mouse_pos.x > win_pos.x && mouse_pos.x < (decrease_fir + win_pos.x) && mouse_pos.y > win_pos.y && mouse_pos.y < (win_pos.y + GetSize().y)) {
decrease_fan_speeds();
return;
}
if (mouse_pos.x > (add_fir + win_pos.x) && mouse_pos.x < (win_pos.x + GetSize().x) && mouse_pos.y > win_pos.y && mouse_pos.y < (win_pos.y + GetSize().y)) {
add_fan_speeds();
return;
}
}
void FanOperate::set_machine_obj(MachineObject *obj)
{
m_obj = obj;
}
void FanOperate::set_fan_speeds(int g)
{
m_current_speeds = g;
Refresh();
}
bool FanOperate::check_printing_state()
{
if (m_obj && !not_show_fan_speed_warning_dlg && m_obj->is_in_printing()) {
MessageDialog msg_wingow(nullptr, _L("Changing fan speed during printing may affect print quality, please choose carefully."), "", wxICON_WARNING | wxCANCEL | wxOK);
msg_wingow.SetButtonLabel(wxID_OK, _L("Change Anyway"));
not_show_fan_speed_warning_dlg = true;
return (msg_wingow.ShowModal() == wxID_OK);
}
return true;
}
void FanOperate::add_fan_speeds()
{
if (!check_printing_state()) {
return;
}
if (m_current_speeds + 1 > m_max_speeds) return;
set_fan_speeds(++m_current_speeds);
post_event(wxCommandEvent(EVT_FAN_ADD));
post_event(wxCommandEvent(EVT_FAN_SWITCH_ON));
}
void FanOperate::decrease_fan_speeds()
{
if (!check_printing_state()) {
return;
}
//turn off
if (m_current_speeds - 1 < m_min_speeds) {
m_current_speeds = 0;
set_fan_speeds(m_current_speeds);
post_event(wxCommandEvent(EVT_FAN_SWITCH_OFF));
}
else {
set_fan_speeds(--m_current_speeds);
}
post_event(wxCommandEvent(EVT_FAN_DEC));
}
void FanOperate::post_event(wxCommandEvent &&event)
{
event.SetInt(m_current_speeds);
event.SetEventObject(this);
wxPostEvent(this, event);
event.Skip();
}
void FanOperate::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
render(dc);
}
void FanOperate::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 FanOperate::doRender(wxDC& dc)
{
wxSize size = GetSize();
dc.SetPen(wxPen(DRAW_OPERATE_LINE_COLOUR));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0,0,size.x,size.y,5);
//splt
auto left_fir = size.x / 3;
dc.DrawBitmap(m_bitmap_decrease.bmp(), 0, (size.y - m_bitmap_decrease.GetBmpHeight()) / 2);
dc.DrawBitmap(m_bitmap_add.bmp(), size.x - m_bitmap_add.GetBmpWidth(), (size.y - m_bitmap_add.GetBmpSize().y) / 2);
wxPoint pot(m_bitmap_decrease.GetBmpWidth(), (size.y - m_bitmap_decrease.GetBmpHeight()) / 2);
dc.DrawLine(pot.x, 0, pot.x, size.y);
dc.DrawLine(size.x - m_bitmap_add.GetBmpWidth(), 0, size.x - m_bitmap_add.GetBmpWidth(), size.y);
//txt
dc.SetFont(::Label::Body_12);
dc.SetTextForeground(StateColor::darkModeColorFor(wxColour("#898989")));
wxString text = wxString::Format("%d%%", m_current_speeds * 10);
wxSize text_size = dc.GetTextExtent(text);
auto text_width = size.x - m_bitmap_decrease.GetBmpWidth() * 2;
dc.DrawText(text, wxPoint(pot.x + (text_width - text_size.x) / 2, (size.y - text_size.y) / 2));
}
void FanOperate::msw_rescale() {
m_bitmap_add.msw_rescale();
m_bitmap_decrease.msw_rescale();
Refresh();
}
static void nop_deleter_fan_control(FanControlNew* ){}
/*************************************************
Description:FanControlNew
**************************************************/
FanControlNew::FanControlNew(wxWindow *parent, const AirDuctData &fan_data, int mode_id, int part_id, wxWindowID id, const wxPoint &pos, const wxSize &size)
: wxWindow(parent, id, pos, size)
, m_fan_data(fan_data)
, m_mode_id(mode_id)
, m_part_id(part_id)
{
SetMaxSize(wxSize(FromDIP(180), FromDIP(80)));
SetMinSize(wxSize(FromDIP(180), FromDIP(80)));
m_bitmap_fan = new ScalableBitmap(this, "fan_icon", 20);
m_bitmap_toggle_off = new ScalableBitmap(this, "toggle_off", 16);
m_bitmap_toggle_on = new ScalableBitmap(this, "toggle_on", 16);
SetBackgroundColour(wxColour(248, 248, 248));
wxBoxSizer* m_sizer_main = new wxBoxSizer(wxHORIZONTAL);
//m_sizer_main->Add(0, 0, 0, wxLEFT, FromDIP(18));
wxBoxSizer* sizer_control = new wxBoxSizer(wxVERTICAL);
wxBoxSizer* sizer_control_top = new wxBoxSizer(wxHORIZONTAL);
m_sizer_control_bottom = new wxBoxSizer(wxVERTICAL);
m_static_bitmap_fan = new wxStaticBitmap(this, wxID_ANY, m_bitmap_fan->bmp(), wxDefaultPosition, wxDefaultSize);
m_static_name = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END | wxALIGN_CENTER_HORIZONTAL);
m_static_name->SetBackgroundColour(wxColour(248, 248, 248));
m_static_name->SetFont(Label::Head_16);
m_static_name->SetMinSize(wxSize(FromDIP(100), -1));
m_static_name->SetMaxSize(wxSize(FromDIP(100), -1));
m_switch_button = new wxStaticBitmap(this, wxID_ANY, m_bitmap_toggle_off->bmp(), wxDefaultPosition, wxDefaultSize, 0);
m_switch_button->Bind(wxEVT_ENTER_WINDOW, [this](auto& e) { SetCursor(wxCURSOR_HAND); });
m_switch_button->Bind(wxEVT_LEAVE_WINDOW, [this](auto& e) { SetCursor(wxCURSOR_RIGHT_ARROW); });
m_switch_button->Bind(wxEVT_LEFT_DOWN, &FanControlNew::on_swith_fan, this);
sizer_control_top->Add(m_static_bitmap_fan, 0, wxLEFT | wxTOP, FromDIP(8));
sizer_control_top->Add(m_static_name, 0, wxLEFT | wxTOP, FromDIP(5));
sizer_control_top->Add(0, 0, 1, wxEXPAND, 0);
sizer_control_top->Add(m_switch_button, 0, wxALIGN_RIGHT | wxRIGHT | wxTOP, FromDIP(5));
sizer_control->Add(sizer_control_top, 0, wxEXPAND, 0);
m_static_status_name = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END | wxALIGN_CENTER_HORIZONTAL);
m_static_status_name->SetForegroundColour(wxColour("#009688"));
m_static_status_name->SetBackgroundColour(wxColour(248, 248, 248));
m_static_status_name->SetFont(Label::Head_16);
m_static_status_name->SetMinSize(wxSize(FromDIP(100), -1));
m_static_status_name->SetMaxSize(wxSize(FromDIP(100), -1));
m_fan_operate = new FanOperate(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_fan_operate->Bind(EVT_FAN_SWITCH_ON, [this](const wxCommandEvent &e) {
m_current_speed = e.GetInt();
m_switch_button->SetBitmap(m_bitmap_toggle_on->bmp());
m_switch_fan = true;
});
m_fan_operate->Bind(EVT_FAN_SWITCH_OFF, [this](const wxCommandEvent &e) {
m_current_speed = e.GetInt();
m_switch_button->SetBitmap(m_bitmap_toggle_off->bmp());
m_switch_fan = false;
});
m_fan_operate->Bind(EVT_FAN_ADD, [this](const wxCommandEvent &e) {
m_current_speed = e.GetInt();
command_control_fan();
});
m_fan_operate->Bind(EVT_FAN_DEC, [this](const wxCommandEvent& e) {
m_current_speed = e.GetInt();
command_control_fan();
});
m_sizer_control_bottom->Add(m_static_status_name, 0, wxLEFT | wxALIGN_CENTER, FromDIP(30));
m_sizer_control_bottom->Add(m_fan_operate, 0, wxALL, FromDIP(5));
sizer_control->Add(m_sizer_control_bottom, 0, wxALL | wxEXPAND, 0);
m_sizer_main->Add(sizer_control, 0, wxALIGN_CENTER, 0);
update_mode();
#if __APPLE__
Bind(wxEVT_LEFT_DOWN, &FanControlNew::on_left_down, this);
#endif
this->SetSizer(m_sizer_main);
this->Layout();
m_sizer_main->Fit(this);
wxGetApp().UpdateDarkUIWin(this);
}
void FanControlNew::on_left_down(wxMouseEvent& evt)
{
//auto mouse_pos = GetParent()->ClientToScreen(evt.GetPosition());
//auto tag_pos = m_fan_operate->ScreenToClient(mouse_pos);
//evt.SetPosition(tag_pos);
m_fan_operate->on_left_down(evt);
}
void FanControlNew::msw_rescale()
{
m_bitmap_fan->msw_rescale();
m_static_bitmap_fan->SetBitmap(m_bitmap_fan->bmp());
m_bitmap_toggle_off->msw_rescale();
m_bitmap_toggle_on->msw_rescale();
if (m_switch_fan)
{
m_switch_button->SetBitmap(m_bitmap_toggle_on->bmp());
}
else
{
m_switch_button->SetBitmap(m_bitmap_toggle_off->bmp());
}
m_fan_operate->msw_rescale();
Layout();
Refresh();
}
void FanControlNew::command_control_fan()
{
if (m_current_speed < 0 || m_current_speed > 10) { return; }
BOOST_LOG_TRIVIAL(info) << "Functions Need to be supplemented! :FanControlNew::command_control_fan. the speed may change";
if (m_obj) {
if (!m_obj->is_enable_np){
int speed = floor(m_current_speed * float(25.5));
m_obj->GetFan()->command_control_fan(m_part_id, speed);
} else {
m_obj->GetFan()->command_control_fan_new(m_part_id, m_current_speed * 10);
}
post_event();
}
}
bool FanControlNew::check_printing_state()
{
if (m_obj && !not_show_fan_speed_warning_dlg && m_obj->is_in_printing()) {
MessageDialog msg_wingow(nullptr, _L("Changing fan speed during printing may affect print quality, please choose carefully."), "", wxICON_WARNING | wxCANCEL | wxOK);
msg_wingow.SetButtonLabel(wxID_OK, _L("Change Anyway"));
not_show_fan_speed_warning_dlg = true;
return (msg_wingow.ShowModal() == wxID_OK);
}
return true;
}
void FanControlNew::on_swith_fan(wxMouseEvent& evt)
{
if (!check_printing_state()) {
return;
}
int speed = 0;
if (m_switch_fan) {
m_switch_button->SetBitmap(m_bitmap_toggle_off->bmp());
m_switch_fan = false;
}
else {
speed = 255;
m_switch_button->SetBitmap(m_bitmap_toggle_on->bmp());
m_switch_fan = true;
}
set_fan_speed(speed);
command_control_fan();
}
void FanControlNew::on_swith_fan(bool on)
{
m_switch_fan = on;
if (m_switch_fan) {
m_switch_button->SetBitmap(m_bitmap_toggle_on->bmp());
}
else {
m_switch_button->SetBitmap(m_bitmap_toggle_off->bmp());
}
}
void FanControlNew::update_mode()
{
int cur_mode = m_mode_id;
if (cur_mode < 0) {
m_static_status_name->Hide();
m_fan_operate->Show();
} else {
auto mode = m_fan_data.modes[cur_mode];
auto it = std::find(mode.off.begin(), mode.off.end(), m_part_id);
if (it != mode.off.end()) {
m_show_mode = 2;
m_static_status_name->SetLabelText(_L("Off"));
} else {
auto it_ctrl = std::find(mode.ctrl.begin(), mode.ctrl.end(), m_part_id);
if (it_ctrl == mode.ctrl.end()) {
m_show_mode = 1;
m_static_status_name->SetLabelText(_L("Auto"));
} else {
m_show_mode = 0;
}
}
if (m_show_mode == 0) {
m_static_status_name->Hide();
m_switch_button->Show();
m_fan_operate->Show();
} else {
m_static_status_name->Show();
m_switch_button->Hide();
m_fan_operate->Hide();
}
}
}
void FanControlNew::set_machine_obj(MachineObject* obj)
{
m_update_already = true;
m_obj = obj;
if (m_fan_operate)
m_fan_operate->set_machine_obj(obj);
}
void FanControlNew::set_name(wxString name)
{
if (name.Contains('(') && name.Contains(')'))
{
wxClientDC dc(m_static_name);
dc.SetFont(m_static_name->GetFont());
if (dc.GetTextExtent(name).GetWidth() > m_static_name->GetSize().GetWidth())
{
const wxString& name_without_brackets = name.BeforeFirst('(');
const wxString& bracket_content = name.Right(name.Length() - name_without_brackets.Length());
const wxString& content = name_without_brackets + "\n" + bracket_content;
m_static_name->SetLabelText(content);
Layout();
return;
}
}
m_static_name->SetLabelText(name);
Layout();
}
void FanControlNew::set_fan_speed(int g)
{
if (g < 0 || g > 255) return;
int speed = round(float(g) / float(25.5));
if (m_current_speed != speed) {
m_current_speed = speed;
m_fan_operate->set_fan_speeds(m_current_speed);
if (m_current_speed <= 0) {
on_swith_fan(false);
}
else {
on_swith_fan(true);
}
}
}
void FanControlNew::set_fan_speed_percent(int speed)
{
if (m_current_speed != speed) {
m_current_speed = speed;
m_fan_operate->set_fan_speeds(m_current_speed);
if (m_current_speed <= 0) {
on_swith_fan(false);
} else {
on_swith_fan(true);
}
}
}
void FanControlNew::set_fan_switch(bool s)
{
}
void FanControlNew::post_event()
{
auto event = wxCommandEvent(EVT_FAN_CHANGED);
event.SetString(wxString::Format("%d", m_current_speed));
event.SetEventObject(GetParent());
wxPostEvent(GetParent(), event);
event.Skip();
}
/*************************************************
Description:FanControlPopupNew
**************************************************/
static void nop_deleter_fan_control_popup(FanControlPopupNew *) {}
FanControlPopupNew::FanControlPopupNew(wxWindow* parent, MachineObject* obj, const AirDuctData& data)
: wxDialog(parent, wxID_ANY, wxEmptyString)
{
SetBackgroundColour(*wxWHITE);
init_names(obj);
m_data = data;
m_obj = obj;
m_sizer_main = new wxBoxSizer(wxVERTICAL);
int part_size = data.parts.size();
int grid_column = part_size > 1 ? 2 : 1;
m_radio_btn_sizer = new wxGridSizer(0, 2, FromDIP(3), FromDIP(3));
m_sizer_fanControl = new wxGridSizer(0, grid_column, FromDIP(3), FromDIP(10));
m_mode_sizer = new wxBoxSizer(wxHORIZONTAL);
m_mode_sizer->Add(m_radio_btn_sizer, 0, wxALIGN_CENTRE_VERTICAL, 0);
m_mode_text = new Label(this);
m_mode_text->SetBackgroundColour(*wxWHITE);
m_sub_mode_panel = new wxPanel(this, wxID_ANY);
m_sub_mode_panel->SetBackgroundColour(wxColour(248, 248, 248));
m_sub_mode_sizer = new wxBoxSizer(wxVERTICAL);
m_sub_mode_panel->SetSizer(m_sub_mode_sizer);
m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(23));
m_sizer_main->Add(m_mode_sizer, 0, wxALIGN_CENTER_HORIZONTAL | wxLEFT | wxRIGHT, FromDIP(30));
m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(10));
m_sizer_main->Add(m_mode_text, 0, wxLEFT, FromDIP(35));
m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(10));
m_sizer_main->Add(m_sub_mode_panel, 0, wxLEFT | wxRIGHT, FromDIP(30));
m_sizer_main->Add(m_sizer_fanControl, 0, wxALIGN_CENTER_HORIZONTAL | wxLEFT | wxRIGHT, 0);
m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(16));
CreateDuct();
SetSizer(m_sizer_main);
Layout();
Fit();
this->Centre(wxBOTH);
Bind(wxEVT_PAINT, &FanControlPopupNew::paintEvent, this);
#if __APPLE__
Bind(wxEVT_LEFT_DOWN, &FanControlPopupNew::on_left_down, this);
#endif
#ifdef __WXOSX__
Bind(wxEVT_IDLE, [](wxIdleEvent& evt) {});
#endif
Bind(wxEVT_SHOW, &FanControlPopupNew::on_show, this);
Bind(EVT_FAN_CHANGED, &FanControlPopupNew::on_fan_changed, this);
}
void FanControlPopupNew::CreateDuct()
{
m_radio_btn_sizer->Clear(true);
//m_radio_btn_sizer->SetCols(m_data.modes.size());
m_mode_switch_btns.clear();
auto iter = m_data.modes.begin();
while (iter != m_data.modes.end()) {
int mode_id = iter->second.id;
const wxString& text = wxString::Format("%s", radio_btn_name[AIR_DUCT(mode_id)]);
if (text.empty()) { BOOST_LOG_TRIVIAL(error) << "FanControlPopupNew::CreateDuct: radio_btn_name is empty";}
SendModeSwitchButton *radio_btn = new SendModeSwitchButton(this, text, m_data.curren_mode == mode_id);
radio_btn->Bind(wxEVT_LEFT_DOWN, &FanControlPopupNew::on_mode_changed, this);
m_mode_switch_btns[mode_id] = radio_btn;
m_radio_btn_sizer->Add(radio_btn, wxALL, FromDIP(5));
iter++;
}
//tips
UpdateParts();
//update data
if (!m_data.modes.empty())
{
for (const auto& part : m_data.parts)
{
auto part_id = part.id;
auto part_state = part.state;
auto it = m_fan_control_list.find(part_id);
if (it != m_fan_control_list.end())
{
auto fan_control = m_fan_control_list[part_id];
fan_control->set_fan_speed_percent(part_state / 10);
}
}
}
else
{
if (m_obj)
{
int cooling_fan_speed = round(m_obj->GetFan()->GetCoolingFanSpeed() / float(25.5));
int big_fan1_speed = round(m_obj->GetFan()->GetBigFan1Speed() / float(25.5));
int big_fan2_speed = round(m_obj->GetFan()->GetBigFan2Speed() / float(25.5));
update_fan_data(AIR_FUN::FAN_COOLING_0_AIRDOOR, cooling_fan_speed);
update_fan_data(AIR_FUN::FAN_REMOTE_COOLING_0_IDX, big_fan1_speed);
update_fan_data(AIR_FUN::FAN_CHAMBER_0_IDX, big_fan2_speed);
}
}
}
void FanControlPopupNew::UpdateParts()
{
auto text = label_text[AIR_DUCT(m_data.curren_mode)];
if (m_mode_text->GetLabelText() != text)
{
m_mode_text->SetLabelText(text);
m_mode_text->Wrap(FromDIP(400));
}
UpdatePartSubMode();
for (const auto& part : m_data.parts) {
auto part_id = part.id;
auto part_name = get_fan_func_name(m_data.curren_mode, m_data.m_sub_mode, AIR_FUN(part_id));
auto fan_control = m_fan_control_list[part_id];
if (!fan_control)
{
fan_control = new FanControlNew(this, m_data, m_data.curren_mode, part_id, wxID_ANY, wxDefaultPosition, wxDefaultSize);
m_fan_control_list[part_id] = fan_control;
m_sizer_fanControl->Add(fan_control, 0, wxALL, FromDIP(5));
}
fan_control->set_machine_obj(m_obj);
fan_control->set_name(part_name);
fan_control->update_fan_data(m_data);
fan_control->set_mode_id(m_data.curren_mode);
fan_control->update_mode();
}
for (const auto& btn_iter : m_mode_switch_btns) {
if (btn_iter.first == m_data.curren_mode) {
btn_iter.second->setSelected(true);
} else {
btn_iter.second->setSelected(false);
}
}
Layout();
Fit();
}
void FanControlPopupNew::UpdatePartSubMode()
{
// Submode for cooling filter
if (AIR_DUCT(m_data.curren_mode) == AIR_DUCT::AIR_DUCT_COOLING_FILT && m_data.IsSupportCoolingFilter()) {
if (!m_cooling_filter_switch_panel) {
m_cooling_filter_switch_panel = new FanControlNewSwitchPanel(m_sub_mode_panel, _L("Filter"), _L("Enabling filtration redirects the right fan to filter gas, which may reduce cooling performance."));
m_cooling_filter_switch_panel->Bind(EVT_FANCTRL_SWITCH, [this] (wxCommandEvent& evt)
{
if (m_obj && m_obj->is_in_printing()) {
MessageDialog msg_wingow(nullptr, _L("Enabling filtration during printing may reduce cooling and affect print quality. Please choose carefully."), "", wxICON_WARNING | wxCANCEL | wxOK);
msg_wingow.SetButtonLabel(wxID_OK, _L("Change Anyway"));
if (msg_wingow.ShowModal() != wxID_OK) { return; }
}
int submode = m_cooling_filter_switch_panel->IsSwitchOn() ? 1 : 0;
command_control_air_duct(m_data.curren_mode, submode);
});
m_sub_mode_sizer->Add(m_cooling_filter_switch_panel, 0, wxALL, FromDIP(5));
}
m_cooling_filter_switch_panel->SetSwitchOn(m_data.IsCoolingFilerOn());
} else {
delete m_cooling_filter_switch_panel;
m_cooling_filter_switch_panel = nullptr;
}
}
void FanControlPopupNew::update_fan_data(MachineObject *obj)
{
if (!obj)
return;
if (m_obj != obj) {
m_obj = obj;
init_names(m_obj);
}
if (m_air_duct_time_out > 0) {
m_air_duct_time_out--;
return;
}
if (m_fan_set_time_out > 0) {
m_fan_set_time_out--;
return;
}
if (!obj->GetFan()->GetAirDuctData().modes.empty()) {
update_fan_data(obj->GetFan()->GetAirDuctData());
} else {
int cooling_fan_speed = round(obj->GetFan()->GetCoolingFanSpeed() / float(25.5));
int big_fan1_speed = round(obj->GetFan()->GetBigFan1Speed() / float(25.5));
int big_fan2_speed = round(obj->GetFan()->GetBigFan2Speed() / float(25.5));
update_fan_data(AIR_FUN::FAN_COOLING_0_AIRDOOR, cooling_fan_speed);
update_fan_data(AIR_FUN::FAN_REMOTE_COOLING_0_IDX, big_fan1_speed);
update_fan_data(AIR_FUN::FAN_CHAMBER_0_IDX, big_fan2_speed);
}
}
void FanControlPopupNew::update_fan_data(const AirDuctData &data)
{
if (m_data == data) { return; }
m_data = data;
for (const auto& part : m_data.parts) {
auto part_id = part.id;
auto part_state = part.state;
auto it = m_fan_control_list.find(part_id);
if (it != m_fan_control_list.end()) {
auto fan_control = m_fan_control_list[part_id];
fan_control->set_fan_speed_percent(part_state / 10);
}
}
UpdateParts();
}
void FanControlPopupNew::update_fan_data(AIR_FUN id, int speed)
{
for (auto& part : m_data.parts) {
auto part_id = part.id;
if (id == part_id) {
part.state = speed;
auto it = m_fan_control_list.find(part_id);
if (it != m_fan_control_list.end()) {
auto fan_control = m_fan_control_list[part_id];
fan_control->update_mode();
fan_control->set_fan_speed_percent(speed);
}
}
}
}
void FanControlPopupNew::on_left_down(wxMouseEvent& evt)
{
auto mouse_pos = ClientToScreen(evt.GetPosition());
for (const auto& iter : m_mode_switch_btns) {
SendModeSwitchButton* sw_it = iter.second;
auto win_pos = sw_it->ClientToScreen(wxPoint(0, 0));
auto size = sw_it->GetSize();
if (mouse_pos.x > win_pos.x && mouse_pos.x < (win_pos.x + sw_it->GetSize().x) && mouse_pos.y > win_pos.y &&
mouse_pos.y < (win_pos.y + sw_it->GetSize().y)) {
evt.SetId(sw_it->GetId());
on_mode_changed(evt);
}
}
for (auto fan_it : m_fan_control_list){
auto fan = fan_it.second;
auto win_pos = fan->m_switch_button->ClientToScreen(wxPoint(0, 0));
auto size = fan->m_switch_button->GetSize();
if (mouse_pos.x > win_pos.x && mouse_pos.x < (win_pos.x + fan->m_switch_button->GetSize().x) && mouse_pos.y > win_pos.y &&
mouse_pos.y < (win_pos.y + fan->m_switch_button->GetSize().y)) {
fan->on_swith_fan(evt);
}
fan->on_left_down(evt);
}
Layout();
Fit();
Refresh();
evt.Skip();
}
void FanControlPopupNew::post_event(int fan_type, wxString speed)
{
// id, speed
wxCommandEvent event(EVT_FAN_CHANGED);
event.SetInt(fan_type);
event.SetString(speed);
event.SetEventObject(GetParent());
wxPostEvent(GetParent(), event);
event.Skip();
}
void FanControlPopupNew::on_show(wxShowEvent& evt)
{
wxGetApp().UpdateDlgDarkUI(this);
}
void FanControlPopupNew::command_control_air_duct(int mode_id, int submode)
{
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", control air duct, id = " << mode_id;
if (m_obj) {
m_obj->GetFan()->command_control_air_duct(mode_id, submode, [](const json& reply) {});
m_air_duct_time_out = time_out;
m_data.curren_mode = mode_id;
m_data.m_sub_mode = submode;
this->UpdateParts();
}
}
void FanControlPopupNew::msw_rescale()
{
for (const auto& btn_iter : m_mode_switch_btns) { btn_iter.second->msw_rescale(); }
for (const auto& fan_iter : m_fan_control_list) { fan_iter.second->msw_rescale(); }
}
void FanControlPopupNew::paintEvent(wxPaintEvent& evt)
{
wxPaintDC dc(this);
dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
dc.SetBrush(*wxTRANSPARENT_BRUSH);
dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}
void FanControlPopupNew::on_mode_changed(const wxMouseEvent &event)
{
/* go check*/
if (m_obj && m_obj->is_in_printing())
{
SendModeSwitchButton* btn = dynamic_cast<SendModeSwitchButton*> (event.GetEventObject());
if (btn && !btn->isSelected())
{
MessageDialog msg_wingow(nullptr, _L("The selected material only supports the current fan mode, and it can't be changed during printing."), "", wxICON_WARNING | wxOK);
msg_wingow.ShowModal();
return;
}
}
/* update buttons*/
for (const auto& btn_iter : m_mode_switch_btns)
{
if (btn_iter.second->GetId() == event.GetId())
{
if (!btn_iter.second->isSelected())
{
btn_iter.second->setSelected(true);
command_control_air_duct(btn_iter.first);
}
}
else
{
btn_iter.second->setSelected(false);
}
}
Layout();
Fit();
Refresh();
}
void FanControlPopupNew::on_fan_changed(const wxCommandEvent &event)
{
m_fan_set_time_out = time_out;
}
void FanControlPopupNew::init_names(MachineObject* obj) {
//Iint fan/door/func/duct name lists
radio_btn_name[AIR_DUCT::AIR_DUCT_COOLING_FILT] = _L("Cooling");
radio_btn_name[AIR_DUCT::AIR_DUCT_HEATING_INTERNAL_FILT] = _L("Heating");
radio_btn_name[AIR_DUCT::AIR_DUCT_EXHAUST] = _L("Exhaust");
radio_btn_name[AIR_DUCT::AIR_DUCT_FULL_COOLING] = _L("Full Cooling");
radio_btn_name[AIR_DUCT::AIR_DUCT_INIT] = _L("Init");
air_door_func_name[AIR_DOOR::AIR_DOOR_FUNC_CHAMBER] = _L("Chamber");
air_door_func_name[AIR_DOOR::AIR_DOOR_FUNC_INNERLOOP] = _L("Innerloop");
air_door_func_name[AIR_DOOR::AIR_DOOR_FUNC_TOP] = L("Top");/*UNUSED*/
label_text[AIR_DUCT::AIR_DUCT_NONE] = _L("The fan controls the temperature during printing to improve print quality. "
"The system automatically adjusts the fan's switch and speed "
"according to different printing materials.");
label_text[AIR_DUCT::AIR_DUCT_COOLING_FILT] = _L("Cooling mode is suitable for printing PLA/PETG/TPU materials and filters the chamber air.");
label_text[AIR_DUCT::AIR_DUCT_HEATING_INTERNAL_FILT] = _L("Heating mode is suitable for printing ABS/ASA/PC/PA materials and circulates filters the chamber air.");
label_text[AIR_DUCT::AIR_DUCT_EXHAUST] = _L("Exhaust");
label_text[AIR_DUCT::AIR_DUCT_FULL_COOLING] = _L("Strong cooling mode is suitable for printing PLA/TPU materials. In this mode, the printouts will be fully cooled.");
label_text[AIR_DUCT::AIR_DUCT_INIT] = _L("Init");
// special texts
if (obj) {
const std::string& special_cooling_text = DevPrinterConfigUtil::get_fan_text(obj->printer_type, "special_cooling_text");
if (!special_cooling_text.empty()) {
// Possible runtime values of special_cooling_text, marked for extraction.
static const char *const markers[] = {
L("Cooling mode is suitable for printing PLA/PETG/TPU materials."),
L("Cooling mode is suitable for printing PLA/PETG/TPU materials and filters the chamber air."),
};
(void) markers;
label_text[AIR_DUCT::AIR_DUCT_COOLING_FILT] = _L(special_cooling_text);
}
}
}
wxString FanControlPopupNew::get_fan_func_name(int mode, int submode, AIR_FUN func) const
{
if (m_obj)
{
const std::string& func_text = DevPrinterConfigUtil::get_fan_text(m_obj->printer_type, mode, (int)func, submode);
if (!func_text.empty())
{
// Possible runtime values of func_text, marked for extraction.
static const char *const markers[] = {
L_CONTEXT("Right(Aux)", "air_duct"),
L_CONTEXT("Right(Filter)", "air_duct"),
L_CONTEXT("Left(Aux)", "air_duct"),
};
(void) markers;
return _L_CONTEXT(func_text, "air_duct");
}
}
static std::map<AIR_FUN, wxString> s_fan_func_name
{
{ AIR_FUN::FAN_HEAT_BREAK_0_IDX, _L_CONTEXT("Hotend", "Hotend Heat Breaker Fan") },
{ AIR_FUN::FAN_COOLING_0_AIRDOOR, _L("Parts") },
{ AIR_FUN::FAN_REMOTE_COOLING_0_IDX, _L("Aux") },
{ AIR_FUN::FAN_CHAMBER_0_IDX, _L("Exhaust") },
{ AIR_FUN::FAN_HEAT_BREAK_1_IDX, _L("Nozzle1") },
{ AIR_FUN::FAN_MC_BOARD_0_IDX, _L("MC Board") },
{ AIR_FUN::FAN_INNNER_LOOP_FAN_0_IDX, _L("Heat") },
};
auto iter = s_fan_func_name.find(func);
return (iter != s_fan_func_name.end()) ? iter->second : wxString::Format(_L("Fan"));
}
wxDEFINE_EVENT(EVT_FANCTRL_SWITCH, wxCommandEvent);
FanControlNewSwitchPanel::FanControlNewSwitchPanel(wxWindow* parent, const wxString& title, const wxString& tips, bool on)
: wxWindow(parent, wxID_ANY), switch_state_on(on)
{
Label* label = new Label(this);
label->SetBackgroundColour(wxColour(248, 248, 248));
label->SetLabelText(title);
m_bitmap_toggle_off = new ScalableBitmap(this, "toggle_off", 19);
m_bitmap_toggle_on = new ScalableBitmap(this, "toggle_on", 19);
if (switch_state_on) {
m_switch_btn = new wxStaticBitmap(this, wxID_ANY, m_bitmap_toggle_on->bmp());
} else {
m_switch_btn = new wxStaticBitmap(this, wxID_ANY, m_bitmap_toggle_off->bmp());
}
m_switch_btn->Bind(wxEVT_LEFT_DOWN, &FanControlNewSwitchPanel::on_left_down, this);
wxSizer* m_label_sizer = new wxBoxSizer(wxHORIZONTAL);
m_label_sizer->Add(label, 0, wxALIGN_LEFT, 0);
m_label_sizer->AddSpacer(FromDIP(10));
m_label_sizer->Add(0, 1, wxEXPAND, FromDIP(10));
m_label_sizer->Add(m_switch_btn, 0, wxALIGN_RIGHT, 0);
Label* tips_label = new Label(this);
tips_label->SetBackgroundColour(wxColour(248, 248, 248));
tips_label->SetLabelText(tips);
tips_label->Wrap(FromDIP(400));
wxSizer* m_sizer_main = new wxBoxSizer(wxVERTICAL);
m_sizer_main->Add(m_label_sizer, 0, wxALL | wxALIGN_LEFT, FromDIP(5));
m_sizer_main->Add(tips_label, 0, wxALL | wxALIGN_LEFT, FromDIP(5));
SetSizer(m_sizer_main);
SetBackgroundColour(wxColour(248, 248, 248));
Layout();
wxGetApp().UpdateDarkUIWin(this);
}
void FanControlNewSwitchPanel::SetSwitchOn(bool on)
{
if (switch_state_on != on) {
switch_state_on = on;
switch_state_on ? m_switch_btn->SetBitmap(m_bitmap_toggle_on->bmp()) : m_switch_btn->SetBitmap(m_bitmap_toggle_off->bmp());
Refresh();
}
}
void FanControlNewSwitchPanel::on_left_down(wxMouseEvent& event) {
switch_state_on = !switch_state_on;
switch_state_on ? m_switch_btn->SetBitmap(m_bitmap_toggle_on->bmp()) : m_switch_btn->SetBitmap(m_bitmap_toggle_off->bmp());
event.Skip();
wxCommandEvent evt(EVT_FANCTRL_SWITCH);
wxPostEvent(this, evt);
evt.Skip();
}
}
} // namespace Slic3r::GUI
Reference in New Issue View Git Blame Copy Permalink