Slic3r::GUI::FanControlPopupNew Class Reference

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

Inheritance diagram for Slic3r::GUI::FanControlPopupNew:

Collaboration diagram for Slic3r::GUI::FanControlPopupNew:

Public Member Functions
	FanControlPopupNew (wxWindow *parent, MachineObject *obj, const AirDuctData &data)
	~FanControlPopupNew ()
void	update_fan_data (MachineObject *obj)
void	msw_rescale ()

Private Member Functions
void	init_names (MachineObject *obj)
wxString	get_fan_func_name (int mode, int submode, AIR_FUN func) const
void	CreateDuct ()
void	UpdateParts ()
void	UpdatePartSubMode ()
void	update_fan_data (const AirDuctData &data)
void	update_fan_data (AIR_FUN id, int speed)
void	on_mode_changed (const wxMouseEvent &event)
void	on_fan_changed (const wxCommandEvent &event)
void	on_left_down (wxMouseEvent &evt)
void	post_event (int fan_type, wxString speed)
void	on_show (wxShowEvent &evt)
void	paintEvent (wxPaintEvent &evt)
void	command_control_air_duct (int mode_id, int submode=-1)

Private Attributes
wxBoxSizer *	m_sizer_main { nullptr }
wxGridSizer *	m_radio_btn_sizer { nullptr }
wxGridSizer *	m_sizer_fanControl { nullptr }
wxBoxSizer *	m_mode_sizer { nullptr }
std::unordered_map< int, SendModeSwitchButton * >	m_mode_switch_btns
Label *	m_mode_text
wxPanel *	m_sub_mode_panel { nullptr }
wxBoxSizer *	m_sub_mode_sizer { nullptr }
FanControlNewSwitchPanel *	m_cooling_filter_switch_panel { nullptr }
std::map< int, FanControlNew * >	m_fan_control_list
MachineObject *	m_obj {nullptr}
AirDuctData	m_data
int	m_air_duct_time_out { 0 }
int	m_fan_set_time_out { 0 }
std::map< AIR_DUCT, wxString >	radio_btn_name
std::map< AIR_DOOR, wxString >	air_door_func_name
std::map< AIR_DUCT, wxString >	label_text

Detailed Description

Constructor & Destructor Documentation

FanControlPopupNew()

Slic3r::GUI::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);
}

References CreateDuct(), init_names(), m_data, m_mode_sizer, m_mode_text, m_obj, m_radio_btn_sizer, m_sizer_fanControl, m_sizer_main, m_sub_mode_panel, m_sub_mode_sizer, on_fan_changed(), on_left_down(), on_show(), paintEvent(), and Slic3r::AirDuctData::parts.

Here is the call graph for this function:

~FanControlPopupNew()

Slic3r::GUI::FanControlPopupNew::~FanControlPopupNew ( )

inline

{};

Member Function Documentation

command_control_air_duct()

void Slic3r::GUI::FanControlPopupNew::command_control_air_duct ( int mode_id, int submode = -1 )

private

{
    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();
    }
}

References m_air_duct_time_out, m_data, m_obj, Slic3r::GUI::time_out, and UpdateParts().

Referenced by on_mode_changed(), and UpdatePartSubMode().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateDuct()

void Slic3r::GUI::FanControlPopupNew::CreateDuct ( )

private

{
    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);
        }
    }
}

References Slic3r::FAN_CHAMBER_0_IDX, Slic3r::FAN_COOLING_0_AIRDOOR, Slic3r::FAN_REMOTE_COOLING_0_IDX, m_data, m_fan_control_list, m_mode_switch_btns, m_obj, m_radio_btn_sizer, on_mode_changed(), radio_btn_name, update_fan_data(), and UpdateParts().

Referenced by FanControlPopupNew().

Here is the call graph for this function:

Here is the caller graph for this function:

get_fan_func_name()

wxString Slic3r::GUI::FanControlPopupNew::get_fan_func_name ( int mode, int submode, AIR_FUN func ) const

private

{
    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"));
}

References _L, _L_CONTEXT, Slic3r::FAN_CHAMBER_0_IDX, Slic3r::FAN_COOLING_0_AIRDOOR, Slic3r::FAN_HEAT_BREAK_0_IDX, Slic3r::FAN_HEAT_BREAK_1_IDX, Slic3r::FAN_INNNER_LOOP_FAN_0_IDX, Slic3r::FAN_MC_BOARD_0_IDX, Slic3r::FAN_REMOTE_COOLING_0_IDX, Slic3r::DevPrinterConfigUtil::get_fan_text(), L_CONTEXT, and m_obj.

Referenced by UpdateParts().

Here is the call graph for this function:

Here is the caller graph for this function:

init_names()

void Slic3r::GUI::FanControlPopupNew::init_names ( MachineObject * obj )

private

                                                      {
 
    //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);
        }
    }
}

References _L, Slic3r::AIR_DOOR_FUNC_CHAMBER, Slic3r::AIR_DOOR_FUNC_INNERLOOP, air_door_func_name, Slic3r::AIR_DOOR_FUNC_TOP, Slic3r::AIR_DUCT_COOLING_FILT, Slic3r::AIR_DUCT_EXHAUST, Slic3r::AIR_DUCT_FULL_COOLING, Slic3r::AIR_DUCT_HEATING_INTERNAL_FILT, Slic3r::AIR_DUCT_INIT, Slic3r::AIR_DUCT_NONE, Slic3r::DevPrinterConfigUtil::get_fan_text(), L, label_text, Slic3r::MachineObject::printer_type, and radio_btn_name.

Referenced by FanControlPopupNew(), and update_fan_data().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::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(); }
}

References m_fan_control_list, and m_mode_switch_btns.

on_fan_changed()

void Slic3r::GUI::FanControlPopupNew::on_fan_changed ( const wxCommandEvent & event )

private

{
    m_fan_set_time_out = time_out;
}

References m_fan_set_time_out, and Slic3r::GUI::time_out.

Referenced by FanControlPopupNew().

Here is the caller graph for this function:

on_left_down()

void Slic3r::GUI::FanControlPopupNew::on_left_down ( wxMouseEvent & evt )

private

{
    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();
}

References m_fan_control_list, m_mode_switch_btns, on_mode_changed(), and Slic3r::GUI::wxMouseEvent.

Referenced by FanControlPopupNew().

Here is the call graph for this function:

Here is the caller graph for this function:

on_mode_changed()

void Slic3r::GUI::FanControlPopupNew::on_mode_changed ( const wxMouseEvent & event )

private

{
    /* 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();
}

References _L, command_control_air_duct(), Slic3r::GUI::SendModeSwitchButton::isSelected(), m_mode_switch_btns, m_obj, Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::wxMouseEvent.

Referenced by CreateDuct(), and on_left_down().

Here is the call graph for this function:

Here is the caller graph for this function:

on_show()

void Slic3r::GUI::FanControlPopupNew::on_show ( wxShowEvent & evt )

private

{
    wxGetApp().UpdateDlgDarkUI(this);
}

Referenced by FanControlPopupNew().

Here is the caller graph for this function:

paintEvent()

void Slic3r::GUI::FanControlPopupNew::paintEvent ( wxPaintEvent & evt )

private

{
    wxPaintDC dc(this);
    dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}

Referenced by FanControlPopupNew().

Here is the caller graph for this function:

post_event()

void Slic3r::GUI::FanControlPopupNew::post_event ( int fan_type, wxString speed )

private

{
    // id, speed
    wxCommandEvent event(EVT_FAN_CHANGED);
    event.SetInt(fan_type);
    event.SetString(speed);
    event.SetEventObject(GetParent());
    wxPostEvent(GetParent(), event);
    event.Skip();
}

update_fan_data() [1/3]

void Slic3r::GUI::FanControlPopupNew::update_fan_data ( AIR_FUN id, int speed )

private

{
    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);
            }
        }
    }
}

References m_data, and m_fan_control_list.

update_fan_data() [2/3]

void Slic3r::GUI::FanControlPopupNew::update_fan_data ( const AirDuctData & data )

private

{
    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();
}

References m_data, m_fan_control_list, and UpdateParts().

Referenced by CreateDuct(), and update_fan_data().

Here is the call graph for this function:

Here is the caller graph for this function:

update_fan_data() [3/3]

void Slic3r::GUI::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);
    }
}

References Slic3r::FAN_CHAMBER_0_IDX, Slic3r::FAN_COOLING_0_AIRDOOR, Slic3r::FAN_REMOTE_COOLING_0_IDX, Slic3r::DevFan::GetAirDuctData(), Slic3r::DevFan::GetBigFan1Speed(), Slic3r::DevFan::GetBigFan2Speed(), Slic3r::DevFan::GetCoolingFanSpeed(), Slic3r::MachineObject::GetFan(), init_names(), m_air_duct_time_out, m_fan_set_time_out, m_obj, Slic3r::AirDuctData::modes, and update_fan_data().

Here is the call graph for this function:

UpdateParts()

void Slic3r::GUI::FanControlPopupNew::UpdateParts ( )

private

{
    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();
}

References get_fan_func_name(), label_text, m_data, m_fan_control_list, m_mode_switch_btns, m_mode_text, m_obj, m_sizer_fanControl, and UpdatePartSubMode().

Referenced by command_control_air_duct(), CreateDuct(), and update_fan_data().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdatePartSubMode()

void Slic3r::GUI::FanControlPopupNew::UpdatePartSubMode ( )

private

{
    // 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_CONTEXT("Filter", "air_duct"), _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;
    }
}

References _L, _L_CONTEXT, Slic3r::AIR_DUCT_COOLING_FILT, command_control_air_duct(), m_cooling_filter_switch_panel, m_data, m_obj, m_sub_mode_panel, m_sub_mode_sizer, Slic3r::GUI::MsgDialog::SetButtonLabel(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by UpdateParts().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

air_door_func_name

std::map<AIR_DOOR, wxString> Slic3r::GUI::FanControlPopupNew::air_door_func_name

private

Referenced by init_names().

label_text

std::map<AIR_DUCT, wxString> Slic3r::GUI::FanControlPopupNew::label_text

private

Referenced by init_names(), and UpdateParts().

m_air_duct_time_out

int Slic3r::GUI::FanControlPopupNew::m_air_duct_time_out { 0 }

private

{ 0 };

Referenced by command_control_air_duct(), and update_fan_data().

m_cooling_filter_switch_panel

FanControlNewSwitchPanel* Slic3r::GUI::FanControlPopupNew::m_cooling_filter_switch_panel { nullptr }

private

{ nullptr };

Referenced by UpdatePartSubMode().

m_data

AirDuctData Slic3r::GUI::FanControlPopupNew::m_data

private

Referenced by FanControlPopupNew(), command_control_air_duct(), CreateDuct(), update_fan_data(), update_fan_data(), UpdateParts(), and UpdatePartSubMode().

m_fan_control_list

std::map<int, FanControlNew*> Slic3r::GUI::FanControlPopupNew::m_fan_control_list

private

Referenced by CreateDuct(), msw_rescale(), on_left_down(), update_fan_data(), update_fan_data(), and UpdateParts().

m_fan_set_time_out

int Slic3r::GUI::FanControlPopupNew::m_fan_set_time_out { 0 }

private

{ 0 };

Referenced by on_fan_changed(), and update_fan_data().

m_mode_sizer

wxBoxSizer* Slic3r::GUI::FanControlPopupNew::m_mode_sizer { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew().

m_mode_switch_btns

std::unordered_map<int, SendModeSwitchButton*> Slic3r::GUI::FanControlPopupNew::m_mode_switch_btns

private

Referenced by CreateDuct(), msw_rescale(), on_left_down(), on_mode_changed(), and UpdateParts().

m_mode_text

Label* Slic3r::GUI::FanControlPopupNew::m_mode_text

private

Referenced by FanControlPopupNew(), and UpdateParts().

m_obj

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

private

{nullptr};

Referenced by FanControlPopupNew(), command_control_air_duct(), CreateDuct(), get_fan_func_name(), on_mode_changed(), update_fan_data(), UpdateParts(), and UpdatePartSubMode().

m_radio_btn_sizer

wxGridSizer* Slic3r::GUI::FanControlPopupNew::m_radio_btn_sizer { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew(), and CreateDuct().

m_sizer_fanControl

wxGridSizer* Slic3r::GUI::FanControlPopupNew::m_sizer_fanControl { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew(), and UpdateParts().

m_sizer_main

wxBoxSizer* Slic3r::GUI::FanControlPopupNew::m_sizer_main { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew().

m_sub_mode_panel

wxPanel* Slic3r::GUI::FanControlPopupNew::m_sub_mode_panel { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew(), and UpdatePartSubMode().

m_sub_mode_sizer

wxBoxSizer* Slic3r::GUI::FanControlPopupNew::m_sub_mode_sizer { nullptr }

private

{ nullptr };

Referenced by FanControlPopupNew(), and UpdatePartSubMode().

radio_btn_name

std::map<AIR_DUCT, wxString> Slic3r::GUI::FanControlPopupNew::radio_btn_name

private

Referenced by CreateDuct(), and init_names().

---

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

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