Slic3r::GUI::AMSControl Class Reference

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

Inheritance diagram for Slic3r::GUI::AMSControl:

Collaboration diagram for Slic3r::GUI::AMSControl:

Public Member Functions
	AMSControl (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
	~AMSControl ()
void	on_retry ()
std::string	GetCurentAms ()
std::string	GetCurentShowAms (AMSPanelPos pos=AMSPanelPos::RIGHT_PANEL)
std::string	GetCurrentCan (std::string amsid)
bool	IsAmsInRightPanel (std::string ams_id)
wxColour	GetCanColour (std::string amsid, std::string canid)
void	createAms (wxSimplebook *parent, int &idx, AMSinfo info, AMSPanelPos pos)
void	createAmsPanel (wxSimplebook *parent, int &idx, std::vector< AMSinfo > infos, const std::string &series_name, const std::string &printer_type, AMSPanelPos pos, int total_ext_num)
AMSRoadShowMode	findFirstMode (AMSPanelPos pos)
void	SetAmsModel (AMSModel mode, AMSModel ext_mode)
void	AmsSelectedSwitch (wxCommandEvent &event)
void	EnableLoadFilamentBtn (bool enable, const std::string &ams_id, const std::string &can_id, const wxString &tips)
void	EnableUnLoadFilamentBtn (bool enable, const std::string &ams_id, const std::string &can_id, const wxString &tips)
void	EnterNoneAMSMode ()
void	EnterGenericAMSMode ()
void	EnterExtraAMSMode ()
void	PlayRridLoading (wxString amsid, wxString canid)
void	StopRridLoading (wxString amsid, wxString canid)
void	ShowFilamentTip (bool hasams=true)
std::tuple< bool, bool >	isFilaSwitchReady ()
void	show_switcher_status (bool show)
void	UpdatePassRoad (std::string ams_id, AMSPassRoadType type, AMSPassRoadSTEP step)
void	CreateAms ()
void	CreateAmsDoubleNozzle (const std::string &series_name, const std::string &printer_type)
void	CreateAmsSingleNozzle (const std::string &series_name, const std::string &printer_type)
void	ClearAms ()
void	UpdateAmsDryControl (MachineObject *obj)
void	UpdateAms (const std::string &series_name, const std::string &printer_type, std::vector< AMSinfo > ams_info, std::vector< AMSinfo > ext_info, DevExtderSystem data, std::string dev_id, MachineObject *obj=nullptr, bool is_reset=true, bool test=false)
std::vector< AMSinfo >	GenerateSimulateData ()
void	AddAms (AMSinfo info, AMSPanelPos pos=AMSPanelPos::LEFT_PANEL)
void	AddAmsPreview (AMSinfo info, AMSModel type)
void	AddAms (std::vector< AMSinfo > single_info, const std::string &series_name, const std::string &printer_type, AMSPanelPos pos=AMSPanelPos::LEFT_PANEL)
void	AddAmsPreview (std::vector< AMSinfo >single_info, AMSPanelPos pos)
void	SetExtruder (bool on_off, int nozzle_id, std::string ams_id, std::string slot_id)
void	SetAmsStep (std::string ams_id, std::string canid, AMSPassRoadType type, AMSPassRoadSTEP step)
void	SwitchAms (std::string ams_id)
void	msw_rescale ()
void	on_filament_load (wxCommandEvent &event)
void	on_filament_unload (wxCommandEvent &event)
void	auto_refill (wxCommandEvent &event)
void	on_ams_setting_click (wxMouseEvent &event)
void	on_extrusion_cali (wxCommandEvent &event)
void	on_ams_setting_click (wxCommandEvent &event)
void	on_clibration_again_click (wxMouseEvent &event)
void	on_clibration_cancel_click (wxMouseEvent &event)
void	Reset ()
void	show_noams_mode ()
void	show_auto_refill (bool show)
void	enable_ams_setting (bool en)
void	show_vams_kn_value (bool show)
void	post_event (wxEvent &&event)
virtual bool	Enable (bool enable=true)
void	parse_object (MachineObject *obj)

Public Attributes
AMSModel	m_ams_model {AMSModel::EXT_AMS}
AMSModel	m_ext_model {AMSModel::EXT_AMS}
AMSModel	m_is_none_ams_mode {AMSModel::EXT_AMS}
bool	m_single_nozzle_no_ams = { true }
std::string	m_current_select

Protected Attributes
std::string	m_current_ams
std::string	m_current_slot_left
std::string	m_current_slot_right
std::string	m_current_show_ams_left
std::string	m_current_show_ams_right
std::map< std::string, int >	m_ams_selection
std::map< std::string, AMSPreview * >	m_ams_preview_list
std::vector< AMSinfo >	m_ams_info
std::vector< AMSinfo >	m_ext_info
std::map< std::string, AmsItem * >	m_ams_item_list
std::map< std::string, AMSExtImage * >	m_ext_image_list
std::string	m_dev_id
std::vector< std::vector< std::string > >	m_item_ids { {}, {} }
std::vector< std::pair< std::string, std::string > >	pair_id
int	m_total_ext_count = 1
AMSextruder *	m_extruder {nullptr}
SwitcherImage *	m_switcher {nullptr}
AMSRoadDownPart *	m_down_road { nullptr }
wxBoxSizer *	m_sizer_body {nullptr}
wxPanel *	tipPanel {nullptr}
wxBoxSizer *	tipSizer {nullptr}
wxStaticBitmap *	icon {nullptr}
wxStaticText *	tipText {nullptr}
wxBoxSizer *	m_sizer_ams_items {nullptr}
wxScrolledWindow *	m_panel_prv_left {nullptr}
wxScrolledWindow *	m_panel_prv_right {nullptr}
wxBoxSizer *	m_sizer_prv_left {nullptr}
wxBoxSizer *	m_sizer_prv_right {nullptr}
wxBoxSizer *	m_sizer_ams_body {nullptr}
wxBoxSizer *	m_sizer_ams_area_left {nullptr}
wxBoxSizer *	m_sizer_ams_area_right {nullptr}
wxBoxSizer *	m_sizer_down_road { nullptr }
wxBoxSizer *	m_sizer_ams_option {nullptr}
wxBoxSizer *	m_sizer_option_left {nullptr}
wxBoxSizer *	m_sizer_option_mid {nullptr}
wxBoxSizer *	m_sizer_option_right {nullptr}
AmsIntroducePopup	m_ams_introduce_popup
wxSimplebook *	m_simplebook_ams_left {nullptr}
wxSimplebook *	m_simplebook_ams_right { nullptr }
wxSimplebook *	m_simplebook_bottom {nullptr}
wxPanel *	m_panel_down_road { nullptr }
int	m_left_page_index = 0
int	m_right_page_index = 0
wxStaticText *	m_tip_right_top {nullptr}
Label *	m_tip_load_info {nullptr}
wxWindow *	m_amswin {nullptr}
wxBoxSizer *	m_vams_sizer {nullptr}
wxBoxSizer *	m_sizer_vams_tips {nullptr}
Label *	m_ams_tip {nullptr}
Caninfo	m_vams_info
StaticBox *	m_panel_virtual {nullptr}
AMSLib *	m_vams_lib {nullptr}
AMSRoad *	m_vams_road {nullptr}
wxBoxSizer *	m_sizer_right_tip {nullptr}
wxBoxSizer *	m_sizer_ams_tips {nullptr}
::StepIndicator *	m_filament_load_step {nullptr}
::StepIndicator *	m_filament_unload_step {nullptr}
::StepIndicator *	m_filament_vt_load_step {nullptr}
Button *	m_button_extruder_feed {nullptr}
Button *	m_button_extruder_back {nullptr}
Button *	m_button_auto_refill { 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
AmsHumidityTipPopup	m_Humidity_tip_popup
uiAmsPercentHumidityDryPopup *	m_percent_humidity_dry_popup
AMSDryCtrWin *	m_ams_dry_ctr_win
std::string	m_last_ams_id = ""
std::string	m_last_tray_id = ""

Private Member Functions
std::string	get_filament_id (const std::string &ams_id, const std::string &can_id)

Detailed Description

Constructor & Destructor Documentation

AMSControl()

Slic3r::GUI::AMSControl::AMSControl	(	wxWindow *	parent,
		wxWindowID	id = wxID_ANY,
		const wxPoint &	pos = wxDefaultPosition,
		const wxSize &	size = wxDefaultSize )

    : wxSimplebook(parent, wxID_ANY, pos, size)
    , m_Humidity_tip_popup(AmsHumidityTipPopup(this))
    , m_percent_humidity_dry_popup(new uiAmsPercentHumidityDryPopup(this))
    , m_ams_introduce_popup(AmsIntroducePopup(this))
    , m_ams_dry_ctr_win(new AMSDryCtrWin(this))
{
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (dev) {
        MachineObject *obj = dev->get_selected_machine();
        parse_object(obj);
    }
 
    SetBackgroundColour(*wxWHITE);
    // normal mode
    //Freeze();
    m_sizer_body = new wxBoxSizer(wxVERTICAL);
    m_amswin                 = new wxWindow(this, wxID_ANY);
    m_amswin->SetBackgroundColour(*wxWHITE);
    m_amswin->SetSize(wxSize(FromDIP(578), -1));
    m_amswin->SetMinSize(wxSize(FromDIP(578), -1));
 
 
    m_sizer_ams_items = new wxBoxSizer(wxHORIZONTAL);
 
    /*right items*/
    m_panel_prv_left = new wxScrolledWindow(m_amswin, wxID_ANY);
    m_panel_prv_left->SetScrollRate(10, 0);
    m_panel_prv_left->SetSize(AMS_ITEMS_PANEL_SIZE);
    m_panel_prv_left->SetMinSize(AMS_ITEMS_PANEL_SIZE);
    //m_panel_prv_left->SetBackgroundColour(0x4169E1);
    m_panel_prv_left->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
    m_sizer_prv_left = new wxBoxSizer(wxHORIZONTAL);
    m_panel_prv_left->SetSizer(m_sizer_prv_left);
    m_panel_prv_left->Layout();
    //m_sizer_items_left->Fit(m_panel_prv_left);
 
    /*right items*/
    m_panel_prv_right = new wxScrolledWindow(m_amswin, wxID_ANY);
    m_panel_prv_right->SetScrollRate(10, 0);
    m_panel_prv_right->SetSize(AMS_ITEMS_PANEL_SIZE);
    m_panel_prv_right->SetMinSize(AMS_ITEMS_PANEL_SIZE);
    //m_panel_prv_right->SetBackgroundColour(0x4169E1);
    m_panel_prv_right->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
    m_sizer_prv_right = new wxBoxSizer(wxHORIZONTAL);
    m_panel_prv_right->SetSizer(m_sizer_prv_right);
    m_panel_prv_right->Layout();
    //m_sizer_items_right->Fit(m_panel_prv_right);
 
    /*m_sizer_ams_items->Add(m_panel_prv_left, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(5));
    m_sizer_ams_items->Add(m_panel_prv_right, 0, wxALIGN_CENTER|wxLEFT|wxRIGHT, FromDIP(5));*/
    m_sizer_ams_items->Add(m_panel_prv_left, 0, wxLEFT | wxRIGHT, FromDIP(5));
    m_sizer_ams_items->Add(m_panel_prv_right, 0, wxLEFT | wxRIGHT, FromDIP(5));
 
    //m_panel_prv_right->Hide();
 
    //m_sizer_ams_body = new wxBoxSizer(wxHORIZONTAL);
 
    m_sizer_ams_body = new wxBoxSizer(wxHORIZONTAL);
 
    //ams area
    m_sizer_ams_area_left = new wxBoxSizer(wxHORIZONTAL);
    m_sizer_ams_area_right = new wxBoxSizer(wxHORIZONTAL);
    m_sizer_down_road = new wxBoxSizer(wxHORIZONTAL);
 
    m_simplebook_ams_left = new wxSimplebook(m_amswin, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0);
    m_simplebook_ams_left->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
    //m_sizer_ams_area_left->Add(m_simplebook_ams_left, 0, wxLEFT | wxRIGHT, FromDIP(5));
    m_sizer_ams_area_left->Add(m_simplebook_ams_left, 0, wxALIGN_CENTER, 0);
 
    m_simplebook_ams_right = new wxSimplebook(m_amswin, wxID_ANY, wxDefaultPosition, AMS_CANS_WINDOW_SIZE, 0);
    m_simplebook_ams_right->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
    //m_sizer_ams_area_right->Add(m_simplebook_ams_right, 0, wxLEFT | wxRIGHT, FromDIP(5));
    m_sizer_ams_area_right->Add(m_simplebook_ams_right, 0, wxALIGN_CENTER, 0);
 
    m_panel_down_road = new wxPanel(m_amswin, wxID_ANY, wxDefaultPosition, AMS_DOWN_ROAD_SIZE, 0);
    m_panel_down_road->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
 
    m_down_road = new AMSRoadDownPart(m_panel_down_road, wxID_ANY, wxDefaultPosition, AMS_DOWN_ROAD_SIZE);
    m_sizer_down_road->Add(m_panel_down_road, 0, wxTOP, 0);
 
    // ams mode
    //
    m_simplebook_ams_right->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);
 
 
    m_sizer_ams_area_left->Layout();
    m_sizer_ams_area_right->Layout();
 
 
    m_sizer_ams_option = new wxBoxSizer(wxHORIZONTAL);
    m_sizer_option_left = new wxBoxSizer(wxHORIZONTAL);
    m_sizer_option_mid = new wxBoxSizer(wxHORIZONTAL);
    m_sizer_option_right = new wxBoxSizer(wxHORIZONTAL);
 
    auto m_panel_option_left    = new wxPanel(m_amswin);
    auto m_panel_option_right   = new wxPanel(m_amswin);
 
    m_panel_option_left->SetBackgroundColour(*wxWHITE);
    m_panel_option_right->SetBackgroundColour(*wxWHITE);
 
    m_panel_option_left->SetSizer(m_sizer_option_left);
    m_panel_option_right->SetSizer(m_sizer_option_right);
 
    m_panel_option_left->SetMinSize(wxSize(FromDIP(180), -1));
    m_panel_option_left->SetMaxSize(wxSize(FromDIP(180), -1));
 
    m_panel_option_right->SetMinSize(wxSize(FromDIP(180), -1));
    m_panel_option_right->SetMaxSize(wxSize(FromDIP(180), -1));
 
    /*option left*/
    m_button_auto_refill = new Button(m_panel_option_left, _L("Auto Refill"));
    m_button_auto_refill->SetStyle(ButtonStyle::Regular, ButtonType::Choice);
 
    m_button_ams_setting_normal = ScalableBitmap(this, "ams_setting_normal", 24);
    m_button_ams_setting_hover = ScalableBitmap(this, "ams_setting_hover", 24);
    m_button_ams_setting_press = ScalableBitmap(this, "ams_setting_press", 24);
 
    m_button_ams_setting = new wxStaticBitmap(m_panel_option_left, wxID_ANY, m_button_ams_setting_normal.bmp(), wxDefaultPosition, wxSize(FromDIP(24), FromDIP(24)));
    m_button_ams_setting->SetMinSize(wxSize(FromDIP(24), FromDIP(24)));
    m_button_ams_setting->SetMaxSize(wxSize(FromDIP(24), FromDIP(24)));
    m_sizer_option_left->Add(m_button_auto_refill, 0, wxALIGN_CENTER, 0);
    m_sizer_option_left->Add(0, 0, 0, wxLEFT, FromDIP(20));
    m_sizer_option_left->Add(m_button_ams_setting, 0, wxALIGN_CENTER, 0);
 
 
    /*option mid*/
    m_extruder = new AMSextruder(m_amswin, wxID_ANY, m_total_ext_count, wxDefaultPosition, AMS_EXTRUDER_SIZE);
    m_sizer_option_mid->Add( m_extruder, 0, wxALIGN_CENTER, 0 );
 
    // Orca: filament-switch routing glyph; hidden by default so it stays inert (zero layout impact)
    // on any printer without a Filament Track Switch. Shown from UpdateAms only when installed.
    m_switcher = new SwitcherImage(m_amswin, wxID_ANY, "fila_switch", wxSize(FromDIP(29), FromDIP(16)), wxDefaultPosition);
    m_switcher->Hide();
    m_sizer_option_mid->Add(m_switcher, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
 
 
    /*option right*/
    m_button_extruder_feed = new Button(m_panel_option_right, _L("Load"));
    m_button_extruder_feed->SetStyle(ButtonStyle::Confirm, ButtonType::Choice);
    m_button_extruder_feed->EnableTooltipEvenDisabled();
 
 
    if (wxGetApp().app_config->get("language") == "de_DE") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "fr_FR") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "ru_RU") m_button_extruder_feed->SetLabel("Load");
    if (wxGetApp().app_config->get("language") == "nl_NL") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "hu_HU") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "ja_JP") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "sv_SE") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "cs_CZ") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "uk_UA") m_button_extruder_feed->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "pt_BR") m_button_extruder_feed->SetLabel("Load");
 
    m_button_extruder_back = new Button(m_panel_option_right, _L("Unload"));
    m_button_auto_refill->SetStyle(ButtonStyle::Regular, ButtonType::Choice);
    m_button_extruder_back->EnableTooltipEvenDisabled();
 
    if (wxGetApp().app_config->get("language") == "de_DE") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "fr_FR") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "ru_RU") m_button_extruder_back->SetLabel("Unload");
    if (wxGetApp().app_config->get("language") == "nl_NL") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "hu_HU") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "ja_JP") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "sv_SE") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "cs_CZ") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "uk_UA") m_button_extruder_back->SetFont(Label::Body_9);
    if (wxGetApp().app_config->get("language") == "pt_BR") m_button_extruder_back->SetLabel("Unload");
 
 
    //m_sizer_option_right->Add(0, 0, 1, wxEXPAND, 0);
    m_sizer_option_right->Add(m_button_extruder_back, 0, wxLEFT, FromDIP(0));
    m_sizer_option_right->Add(m_button_extruder_feed, 0, wxLEFT, FromDIP(20));
 
    m_panel_option_left->Layout();
    m_panel_option_right->Layout();
 
    m_sizer_ams_option->Add(m_panel_option_left, 0, wxALIGN_TOP, 0);
    m_sizer_ams_option->Add( 0, 0, 1, wxEXPAND, 0);
    m_sizer_ams_option->Add(m_sizer_option_mid, 0, wxALIGN_TOP, 0);
    m_sizer_ams_option->Add( 0, 0, 1, wxEXPAND, 0);
    m_sizer_ams_option->Add(m_panel_option_right, 0, wxALIGN_TOP, 0);
 
 
    m_sizer_ams_body->Add(m_sizer_ams_area_left, wxALIGN_CENTER, 0);
    m_sizer_ams_body->AddSpacer(FromDIP(10));
    m_sizer_ams_body->Add(m_sizer_ams_area_right, wxALIGN_CENTER, 0);
 
    m_sizer_body->Add(m_sizer_ams_items, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(10));
    m_sizer_body->Add(m_sizer_ams_body, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_down_road, 0, wxALIGN_CENTER, 0);
    m_sizer_body->Add(m_sizer_ams_option, 0, wxEXPAND, 0);
 
    m_amswin->SetSizer(m_sizer_body);
    m_amswin->Layout();
    m_amswin->Fit();
    //Thaw();
 
    SetSize(m_amswin->GetSize());
    SetMinSize(m_amswin->GetSize());
 
 
    AddPage(m_amswin, wxEmptyString, false);
 
 
    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);
    m_button_auto_refill->Connect(wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler(AMSControl::auto_refill), NULL, this);
 
    m_button_ams_setting->Bind(wxEVT_ENTER_WINDOW, [this](wxMouseEvent& e) {
        m_button_ams_setting->SetBitmap(m_button_ams_setting_hover.bmp());
        e.Skip();
    });
    m_button_ams_setting->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& e) {
        m_button_ams_setting->SetBitmap(m_button_ams_setting_press.bmp());
        on_ams_setting_click(e);
        e.Skip();
    });
 
    m_button_ams_setting->Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& e) {
        m_button_ams_setting->SetBitmap(m_button_ams_setting_normal.bmp());
        e.Skip();
    });
 
    Bind(EVT_AMS_SHOW_HUMIDITY_TIPS, [this](wxCommandEvent& evt) {
        uiAmsHumidityInfo *info    = (uiAmsHumidityInfo *) evt.GetClientData();
        if (info)
        {
            Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
            MachineObject *obj = nullptr;
            if (dev) {
                obj = dev->get_selected_machine();
            }
 
            if (info->ams_type == AMSModel::GENERIC_AMS)
            {
                wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
                wxPoint popup_pos(img_pos.x - m_Humidity_tip_popup.GetSize().GetWidth() + FromDIP(150), img_pos.y - FromDIP(80));
                m_Humidity_tip_popup.Position(popup_pos, wxSize(0, 0));
 
                int humidity_value = info->humidity_display_idx;
                if (humidity_value > 0 && humidity_value <= 5) { m_Humidity_tip_popup.set_humidity_level(humidity_value); }
                m_Humidity_tip_popup.Popup();
            } else if (obj && obj->is_support_remote_dry && (info->ams_type == AMSModel::N3F_AMS || info->ams_type == AMSModel::N3S_AMS)){
                m_ams_dry_ctr_win->set_ams_id(info->ams_id);
 
                wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
                wxPoint popup_pos(img_pos.x - m_ams_dry_ctr_win->GetSize().GetWidth() + FromDIP(150), img_pos.y - FromDIP(80));
                m_ams_dry_ctr_win->Move(popup_pos);
                m_ams_dry_ctr_win->ShowModal();
            } else {
                m_percent_humidity_dry_popup->UpdateInfo(info);
 
                wxPoint img_pos = ClientToScreen(wxPoint(0, 0));
                wxPoint popup_pos(img_pos.x - m_percent_humidity_dry_popup->GetSize().GetWidth() + FromDIP(150), img_pos.y - FromDIP(80));
                m_percent_humidity_dry_popup->Move(popup_pos);
                m_percent_humidity_dry_popup->ShowModal();
            }
        }
 
        delete info;
    });
    Bind(EVT_AMS_ON_SELECTED, &AMSControl::AmsSelectedSwitch, this);
}

References _L, AMS_CANS_WINDOW_SIZE, AMS_CONTROL_DEF_BLOCK_BK_COLOUR, AMS_DOWN_ROAD_SIZE, AMS_EXTRUDER_SIZE, Slic3r::GUI::uiAmsHumidityInfo::ams_id, AMS_ITEMS_PANEL_SIZE, Slic3r::GUI::uiAmsHumidityInfo::ams_type, AmsSelectedSwitch(), auto_refill(), Label::Body_9, Choice, Confirm, Slic3r::GUI::GENERIC_AMS, Slic3r::DeviceManager::get_selected_machine(), Slic3r::GUI::uiAmsHumidityInfo::humidity_display_idx, Slic3r::MachineObject::is_support_remote_dry, m_ams_dry_ctr_win, m_ams_introduce_popup, m_amswin, m_button_ams_setting, m_button_ams_setting_hover, m_button_ams_setting_normal, m_button_ams_setting_press, m_button_auto_refill, m_button_extruder_back, m_button_extruder_feed, m_down_road, m_extruder, m_Humidity_tip_popup, m_panel_down_road, m_panel_prv_left, m_panel_prv_right, m_percent_humidity_dry_popup, m_simplebook_ams_left, m_simplebook_ams_right, m_sizer_ams_area_left, m_sizer_ams_area_right, m_sizer_ams_body, m_sizer_ams_items, m_sizer_ams_option, m_sizer_body, m_sizer_down_road, m_sizer_option_left, m_sizer_option_mid, m_sizer_option_right, m_sizer_prv_left, m_sizer_prv_right, m_switcher, m_total_ext_count, Slic3r::GUI::N3F_AMS, Slic3r::GUI::N3S_AMS, on_ams_setting_click(), on_filament_load(), on_filament_unload(), parse_object(), Regular, and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

~AMSControl()

Slic3r::GUI::AMSControl::~AMSControl

(

)

{
    if (m_ams_dry_ctr_win) {
        delete m_ams_dry_ctr_win;
    }
}

References m_ams_dry_ctr_win.

Member Function Documentation

AddAms() [1/2]

void Slic3r::GUI::AMSControl::AddAms	(	AMSinfo	info,
		AMSPanelPos	pos = AMSPanelPos::LEFT_PANEL )

{
    if (m_total_ext_count > 1){
        if (info.routes_to_main_extruder()){
            createAms(m_simplebook_ams_right, m_right_page_index, info, AMSPanelPos::RIGHT_PANEL);
        }
        else if (!info.routes_to_main_extruder()){
            createAms(m_simplebook_ams_left, m_left_page_index, info, AMSPanelPos::LEFT_PANEL);
        }
    }
    else if (m_total_ext_count == 1){
        createAms(m_simplebook_ams_left, m_left_page_index, info, AMSPanelPos::LEFT_PANEL);
    }
    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
    m_simplebook_ams_left->Refresh();
    m_simplebook_ams_right->Refresh();
 
}

References createAms(), Slic3r::GUI::LEFT_PANEL, m_left_page_index, m_right_page_index, m_simplebook_ams_left, m_simplebook_ams_right, m_total_ext_count, Slic3r::GUI::RIGHT_PANEL, and Slic3r::GUI::AMSinfo::routes_to_main_extruder().

Referenced by CreateAms(), CreateAmsDoubleNozzle(), and CreateAmsSingleNozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

AddAms() [2/2]

void Slic3r::GUI::AMSControl::AddAms	(	std::vector< AMSinfo >	single_info,
		const std::string &	series_name,
		const std::string &	printer_type,
		AMSPanelPos	pos = AMSPanelPos::LEFT_PANEL )

{
     if (single_info.size() <= 0){
        return;
    }
    if (m_total_ext_count == 2) {
        if (single_info[0].routes_to_main_extruder()) {
            createAmsPanel(m_simplebook_ams_right, m_right_page_index, single_info, series_name, printer_type, AMSPanelPos::RIGHT_PANEL, m_total_ext_count);
        }
        else if (!single_info[0].routes_to_main_extruder()) {
            createAmsPanel(m_simplebook_ams_left, m_left_page_index, single_info, series_name, printer_type, AMSPanelPos::LEFT_PANEL, m_total_ext_count);
        }
    }
    else if (m_total_ext_count == 1) {
        if (pos == AMSPanelPos::RIGHT_PANEL) {
            createAmsPanel(m_simplebook_ams_right, m_right_page_index, single_info, series_name, printer_type, AMSPanelPos::RIGHT_PANEL, m_total_ext_count);
        }
        else {
            createAmsPanel(m_simplebook_ams_left, m_left_page_index, single_info, series_name, printer_type, AMSPanelPos::LEFT_PANEL, m_total_ext_count);
        }
    }
 
    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Layout();
    m_simplebook_ams_left->Refresh();
    m_simplebook_ams_right->Refresh();
}

References createAmsPanel(), Slic3r::GUI::LEFT_PANEL, m_left_page_index, m_right_page_index, m_simplebook_ams_left, m_simplebook_ams_right, m_total_ext_count, and Slic3r::GUI::RIGHT_PANEL.

Here is the call graph for this function:

AddAmsPreview() [1/2]

void Slic3r::GUI::AMSControl::AddAmsPreview	(	AMSinfo	info,
		AMSModel	type )

{
    AMSPreview *ams_prv = nullptr;
 
    if (info.routes_to_main_extruder())
    {
        ams_prv = new AMSPreview(m_panel_prv_right, wxID_ANY, info, type);
        m_sizer_prv_right->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
    }
    else if (!info.routes_to_main_extruder())
    {
        ams_prv = new AMSPreview(m_panel_prv_left, wxID_ANY, info, type);
        m_sizer_prv_left->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
    }
 
    if (ams_prv){
        ams_prv->Bind(wxEVT_LEFT_DOWN, [this, ams_prv](wxMouseEvent &e) {
            SwitchAms(ams_prv->get_ams_id());
            e.Skip();
        });
        m_ams_preview_list[info.ams_id] = ams_prv;
    }
}

References Slic3r::GUI::AMSinfo::ams_id, Slic3r::GUI::AMSPreview::get_ams_id(), m_ams_preview_list, m_panel_prv_left, m_panel_prv_right, m_sizer_prv_left, m_sizer_prv_right, Slic3r::GUI::AMSinfo::routes_to_main_extruder(), SwitchAms(), and Slic3r::GUI::wxMouseEvent.

Referenced by CreateAms(), CreateAmsDoubleNozzle(), and CreateAmsSingleNozzle().

Here is the call graph for this function:

Here is the caller graph for this function:

AddAmsPreview() [2/2]

void Slic3r::GUI::AMSControl::AddAmsPreview	(	std::vector< AMSinfo >	single_info,
		AMSPanelPos	pos )

                                                                             {
    if (single_info.size() <= 0) return;
 
    AMSPreview* ams_prv = nullptr;
    AMSPreview* ams_prv2 = nullptr;
    if (pos == AMSPanelPos::RIGHT_PANEL){
        ams_prv = new AMSPreview(m_panel_prv_right, wxID_ANY, single_info[0], single_info[0].ams_type);
        m_sizer_prv_right->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
        if (single_info.size() == 2)
        {
            ams_prv2 = new AMSPreview(m_panel_prv_right, wxID_ANY, single_info[1], single_info[1].ams_type);
            m_sizer_prv_right->Add(ams_prv2, 0, wxALIGN_CENTER | wxLEFT, 0);
        }
    }
    else
    {
        ams_prv = new AMSPreview(m_panel_prv_left, wxID_ANY, single_info[0], single_info[0].ams_type);
        m_sizer_prv_left->Add(ams_prv, 0, wxALIGN_CENTER | wxLEFT, FromDIP(6));
        if (single_info.size() == 2)
        {
            ams_prv2 = new AMSPreview(m_panel_prv_left, wxID_ANY, single_info[1], single_info[1].ams_type);
            m_sizer_prv_left->Add(ams_prv2, 0, wxALIGN_CENTER | wxLEFT, 0);
        }
    }
 
    if (ams_prv) {
        ams_prv->Bind(wxEVT_LEFT_DOWN, [this, ams_prv](wxMouseEvent& e) {
            SwitchAms(ams_prv->get_ams_id());
            e.Skip();
            });
        m_ams_preview_list[single_info[0].ams_id] = ams_prv;
    }
    if (ams_prv2) {
        ams_prv2->Bind(wxEVT_LEFT_DOWN, [this, ams_prv2](wxMouseEvent& e) {
            SwitchAms(ams_prv2->get_ams_id());
            e.Skip();
            });
        m_ams_preview_list[single_info[1].ams_id] = ams_prv2;
    }
}

References Slic3r::GUI::AMSPreview::get_ams_id(), m_ams_preview_list, m_panel_prv_left, m_panel_prv_right, m_sizer_prv_left, m_sizer_prv_right, Slic3r::GUI::RIGHT_PANEL, SwitchAms(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

AmsSelectedSwitch()

void Slic3r::GUI::AMSControl::AmsSelectedSwitch

(

wxCommandEvent &

event

)

                                                        {
    std::string ams_id_selected = std::to_string(event.GetInt());
    if (m_current_ams != ams_id_selected){
        m_current_ams = ams_id_selected;
    }
    if (m_current_show_ams_left != ams_id_selected && m_current_show_ams_left != "") {
        auto item = m_ams_item_list[m_current_show_ams_left];
        if (!item) return;
        try{
            const auto& can_lib_list = item->get_can_lib_list();
            for (auto can : can_lib_list) {
                can.second->UnSelected();
            }
        }
        catch (...){
            ;
        }
    }
    else if (m_current_show_ams_right != ams_id_selected && m_current_show_ams_right != "") {
        auto item = m_ams_item_list[m_current_show_ams_right];
        if (!item) return;
        try {
            const auto &can_lib_list = item->get_can_lib_list();
            for (auto can : can_lib_list) {
                can.second->UnSelected();
            }
        }
        catch (...) {
            ;
        }
    }
}

References m_ams_item_list, m_current_ams, m_current_show_ams_left, and m_current_show_ams_right.

Referenced by AMSControl().

Here is the caller graph for this function:

auto_refill()

void Slic3r::GUI::AMSControl::auto_refill

(

wxCommandEvent &

event

)

{
    post_event(SimpleEvent(EVT_AMS_FILAMENT_BACKUP));
}

References post_event().

Referenced by AMSControl().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearAms()

void Slic3r::GUI::AMSControl::ClearAms

(

)

                          {
    m_simplebook_ams_right->DeleteAllPages();
    m_simplebook_ams_left->DeleteAllPages();
    m_simplebook_ams_right->DestroyChildren();
    m_simplebook_ams_left->DestroyChildren();
    m_simplebook_ams_right->Layout();
    m_simplebook_ams_left->Layout();
    m_simplebook_ams_right->Refresh();
    m_simplebook_ams_left->Refresh();
 
    for (auto it : m_ams_preview_list) {
        delete it.second;
    }
    m_ams_preview_list.clear();
    m_ext_image_list.clear();
 
    m_left_page_index = 0;
    m_right_page_index = 0;
 
    m_ams_item_list.clear();
    m_sizer_prv_right->Clear();
    m_sizer_prv_left->Clear();
    m_item_ids = { {}, {} };
    pair_id.clear();
}

References m_ams_item_list, m_ams_preview_list, m_ext_image_list, m_item_ids, m_left_page_index, m_right_page_index, m_simplebook_ams_left, m_simplebook_ams_right, m_sizer_prv_left, m_sizer_prv_right, and pair_id.

Referenced by Reset(), and UpdateAms().

Here is the caller graph for this function:

CreateAms()

void Slic3r::GUI::AMSControl::CreateAms

(

)

{
    auto caninfo0_0 = Caninfo{"def_can_0", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL};
    auto caninfo0_1 = Caninfo{"def_can_1", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo0_2 = Caninfo{"def_can_2", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo0_3 = Caninfo{"def_can_3", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
 
    auto caninfo1_0 = Caninfo{ "def_can_0", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_1 = Caninfo{ "def_can_1", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_2 = Caninfo{ "def_can_2", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_3 = Caninfo{ "def_can_3", (""), *wxWHITE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
 
    AMSinfo                        ams1 = AMSinfo{"0", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0};
    AMSinfo                        ams2 = AMSinfo{"1", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
    AMSinfo                        ams3 = AMSinfo{"2", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
    AMSinfo                        ams4 = AMSinfo{"3", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
 
    AMSinfo                        ams5 = AMSinfo{ "4", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams6 = AMSinfo{ "5", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams7 = AMSinfo{ "6", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams8 = AMSinfo{ "7", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    std::vector<AMSinfo>           ams_info{ams1, ams2, ams3, ams4, ams5, ams6, ams7, ams8 };
    std::vector<AMSinfo>::iterator it;
    //Freeze();
    for (it = ams_info.begin(); it != ams_info.end(); it++) {
        AddAmsPreview(*it, AMSModel::GENERIC_AMS);
        AddAms(*it);
        //AddExtraAms(*it);
        m_ams_info.push_back(*it);
    }
    if (m_single_nozzle_no_ams)
    {
        m_simplebook_ams_left->Hide();
    }
    else {
        m_sizer_prv_left->Layout();
        m_sizer_prv_right->Layout();
    }
    //Thaw();
}

References AddAms(), AddAmsPreview(), Slic3r::GUI::AMS_CAN_TYPE_VIRTUAL, Slic3r::GUI::GENERIC_AMS, m_ams_info, m_simplebook_ams_left, m_single_nozzle_no_ams, m_sizer_prv_left, and m_sizer_prv_right.

Here is the call graph for this function:

createAms()

void Slic3r::GUI::AMSControl::createAms	(	wxSimplebook *	parent,
		int &	idx,
		AMSinfo	info,
		AMSPanelPos	pos )

                                                                                        {
    auto ams_item = new AmsItem(parent, info, info.ams_type, pos);
    parent->InsertPage(idx, ams_item, wxEmptyString, true);
    ams_item->set_selection(idx);
    idx++;
 
    m_ams_item_list[info.ams_id] = ams_item;
}

References Slic3r::GUI::AMSinfo::ams_id, Slic3r::GUI::AMSinfo::ams_type, and m_ams_item_list.

Referenced by AddAms().

Here is the caller graph for this function:

CreateAmsDoubleNozzle()

void Slic3r::GUI::AMSControl::CreateAmsDoubleNozzle	(	const std::string &	series_name,
		const std::string &	printer_type )

{
    std::vector<AMSinfo> single_info_left;
    std::vector<AMSinfo> single_info_right;
 
    //Freeze();
    // Orca: place each AMS by its switch inlet when a Filament Track Switch is installed, else by the pinned
    // nozzle_id (routes_to_main_extruder). Switch-less machines are unaffected; ext spools keep nozzle_id.
    for (auto ams_info = m_ams_info.begin(); ams_info != m_ams_info.end(); ams_info++){
        if (ams_info->cans.size() == GENERIC_AMS_SLOT_NUM){
            ams_info->routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(ams_info->ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(ams_info->ams_id);
            AddAmsPreview(*ams_info, ams_info->ams_type);
            AddAms(*ams_info);
        }
        else if (ams_info->cans.size() == 1){
 
            if (ams_info->routes_to_main_extruder()){
                single_info_right.push_back(*ams_info);
                if (single_info_right.size() == 2){
                    single_info_right[0].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_right[0].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_right[0].ams_id);
                    single_info_right[1].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_right[1].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_right[1].ams_id);
                    AddAms(single_info_right, series_name, printer_type);
                    AddAmsPreview(single_info_right, AMSPanelPos::RIGHT_PANEL);
                    pair_id.push_back(std::make_pair(single_info_right[0].ams_id, single_info_right[1].ams_id));
                    single_info_right.clear();
                }
            }
            else if (!ams_info->routes_to_main_extruder()){
                single_info_left.push_back(*ams_info);
                if (single_info_left.size() == 2){
                    single_info_left[0].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_left[0].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_left[0].ams_id);
                    single_info_left[1].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_left[1].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_left[1].ams_id);
                    AddAms(single_info_left, series_name, printer_type);
                    AddAmsPreview(single_info_left, AMSPanelPos::LEFT_PANEL);
                    pair_id.push_back(std::make_pair(single_info_left[0].ams_id, single_info_left[1].ams_id));
                    single_info_left.clear();
                }
            }
        }
    }
    if (m_ext_info.size() <= 1) {
        BOOST_LOG_TRIVIAL(trace) << "vt_slot empty!";
        assert(0);
        return;
    }
    AMSinfo ext_info;
    for (auto info : m_ext_info){
        if (info.ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID)){
            ext_info = info;
            single_info_right.push_back(ext_info);
            break;
        }
    }
    //wait add
 
 
    single_info_right[0].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_right[0].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_right[0].ams_id);
    if (single_info_right.size() == 2){
        single_info_right[1].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_right[1].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_right[1].ams_id);
        pair_id.push_back(std::make_pair(single_info_right[0].ams_id, single_info_right[1].ams_id));
    }
    AddAms(single_info_right, series_name, printer_type);
    AddAmsPreview(single_info_right, AMSPanelPos::RIGHT_PANEL);
    single_info_right.clear();
 
    for (auto info : m_ext_info) {
        if (info.ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
            ext_info = info;
            single_info_left.push_back(ext_info);
            break;
        }
    }
    //wait add
    single_info_left[0].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_left[0].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_left[0].ams_id);
    if (single_info_left.size() == 2){
        single_info_left[1].routes_to_main_extruder() ? m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info_left[1].ams_id) : m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info_left[1].ams_id);
        pair_id.push_back(std::make_pair(single_info_left[0].ams_id, single_info_left[1].ams_id));
    }
    AddAmsPreview(single_info_left, AMSPanelPos::LEFT_PANEL);
    AddAms(single_info_left, series_name, printer_type);
    single_info_left.clear();
 
    m_sizer_prv_left->Layout();
    m_sizer_prv_right->Layout();
    m_simplebook_ams_left->Show();
    m_simplebook_ams_right->Show();
    if (m_ams_info.size() > 0){
        m_panel_prv_left->Show();
        m_panel_prv_right->Show();
    }
    else{
        m_panel_prv_left->Hide();
        m_panel_prv_right->Hide();
    }
    m_simplebook_ams_left->SetSelection(0);
    m_simplebook_ams_right->SetSelection(0);
 
    auto left_init_mode = findFirstMode(AMSPanelPos::LEFT_PANEL);
    auto right_init_mode = findFirstMode(AMSPanelPos::RIGHT_PANEL);
 
 
    m_down_road->UpdateLeft(2, left_init_mode);
    m_down_road->UpdateRight(2, right_init_mode);
 
    m_extruder->updateNozzleNum(2);
 
    m_current_show_ams_left = m_item_ids[DEPUTY_EXTRUDER_ID].size() > 0 ? m_item_ids[DEPUTY_EXTRUDER_ID][0] : "";
    m_current_show_ams_right = m_item_ids[MAIN_EXTRUDER_ID].size() > 0 ? m_item_ids[MAIN_EXTRUDER_ID][0] : "";
 
    m_current_ams = "";
    m_down_road->UpdatePassRoad(AMSPanelPos::LEFT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    m_extruder->OnAmsLoading(false, DEPUTY_EXTRUDER_ID);
    m_down_road->UpdatePassRoad(AMSPanelPos::RIGHT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    m_extruder->OnAmsLoading(false, MAIN_EXTRUDER_ID);
 
    m_amswin->Layout();
    m_amswin->Fit();
 
    //Thaw();
}

References AddAms(), AddAmsPreview(), Slic3r::GUI::AMS_ROAD_STEP_NONE, DEPUTY_EXTRUDER_ID, findFirstMode(), GENERIC_AMS_SLOT_NUM, Slic3r::GUI::LEFT_PANEL, m_ams_info, m_amswin, m_current_ams, m_current_show_ams_left, m_current_show_ams_right, m_down_road, m_ext_info, m_extruder, m_item_ids, m_panel_prv_left, m_panel_prv_right, m_simplebook_ams_left, m_simplebook_ams_right, m_sizer_prv_left, m_sizer_prv_right, MAIN_EXTRUDER_ID, pair_id, Slic3r::GUI::RIGHT_PANEL, Slic3r::trace(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Referenced by UpdateAms().

Here is the call graph for this function:

Here is the caller graph for this function:

createAmsPanel()

void Slic3r::GUI::AMSControl::createAmsPanel	(	wxSimplebook *	parent,
		int &	idx,
		std::vector< AMSinfo >	infos,
		const std::string &	series_name,
		const std::string &	printer_type,
		AMSPanelPos	pos,
		int	total_ext_num )

{
    if (infos.size() <= 0) return;
 
    wxPanel* book_panel = new wxPanel(parent);
    wxBoxSizer* book_sizer = new wxBoxSizer(wxHORIZONTAL);
    book_panel->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
    book_panel->SetSize(AMS_PANEL_SIZE);
    book_panel->SetMinSize(AMS_PANEL_SIZE);
 
    AmsItem* ams1 = nullptr, * ams2 = nullptr;
    ams1 = new AmsItem(book_panel, infos[0], infos[0].ams_type, pos);
    if (ams1->get_ext_image()) { ams1->get_ext_image()->setTotalExtNum(series_name, printer_type, total_ext_num); }
 
    if (infos.size() == MAX_AMS_NUM_IN_PANEL) {    //n3s and ? in a panel
        ams2 = new AmsItem(book_panel, infos[1], infos[1].ams_type, pos);
        if (ams2->get_ext_image()) { ams2->get_ext_image()->setTotalExtNum(series_name, printer_type, total_ext_num); }
 
        if (pos == AMSPanelPos::LEFT_PANEL) {
            book_sizer->Add(ams1, 0, wxLEFT, FromDIP(4));
            book_sizer->Add(ams2, 0, wxLEFT, FromDIP(30));
        }
        else {
            book_sizer->Add(ams1, 0, wxLEFT, FromDIP(72));
            book_sizer->Add(ams2, 0, wxLEFT, FromDIP(30));
        }
    }
    else {   //only an ext in a panel
        if (ams1->get_ext_image()) { ams1->get_ext_image()->setShowAmsExt(false);}
 
        if (ams1->get_ams_model() == AMSModel::EXT_AMS) {
            if (ams1->get_ext_type() == LITE_EXT) {
                //book_sizer->Add(ams1, 0, wxALIGN_CENTER_HORIZONTAL, 0);
                book_sizer->Add(ams1, 0, wxLEFT, (book_panel->GetSize().x - ams1->GetSize().x) / 2);
            }
            else{
                auto ext_image = new AMSExtImage(book_panel, pos, m_total_ext_count, false);
                book_sizer->Add(ams1, 0, wxLEFT, FromDIP(30));
                book_sizer->Add(ext_image, 0, wxEXPAND | wxLEFT, FromDIP(30));
                ext_image->setTotalExtNum(series_name, printer_type, total_ext_num);
                m_ext_image_list[infos[0].ams_id] = ext_image;
            }
        }
    }
 
    book_panel->SetSizer(book_sizer);
    book_panel->Layout();
    book_panel->Fit();
 
    parent->InsertPage(idx, book_panel, wxEmptyString, true);
    ams1->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
    ams1->set_selection(idx);
    m_ams_item_list[infos[0].ams_id] = ams1;
    if (ams2) {
        ams2->SetBackgroundColour(StateColor::darkModeColorFor(AMS_CONTROL_DEF_LIB_BK_COLOUR));
        ams2->set_selection(idx);
        m_ams_item_list[infos[1].ams_id] = ams2;
    }
    idx++;
}

References AMS_CONTROL_DEF_LIB_BK_COLOUR, AMS_PANEL_SIZE, StateColor::darkModeColorFor(), Slic3r::GUI::EXT_AMS, Slic3r::GUI::AmsItem::get_ams_model(), Slic3r::GUI::AmsItem::get_ext_image(), Slic3r::GUI::AmsItem::get_ext_type(), Slic3r::GUI::LEFT_PANEL, Slic3r::GUI::LITE_EXT, m_ams_item_list, m_ext_image_list, m_total_ext_count, MAX_AMS_NUM_IN_PANEL, Slic3r::GUI::AmsItem::set_selection(), Slic3r::GUI::AMSExtImage::setShowAmsExt(), and Slic3r::GUI::AMSExtImage::setTotalExtNum().

Referenced by AddAms().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateAmsSingleNozzle()

void Slic3r::GUI::AMSControl::CreateAmsSingleNozzle	(	const std::string &	series_name,
		const std::string &	printer_type )

{
    std::vector<int>m_item_nums{0,0};
    std::vector<AMSinfo> single_info;
 
    //Freeze();
 
    //add ams data
    for (auto ams_info = m_ams_info.begin(); ams_info != m_ams_info.end(); ams_info++) {
        if (ams_info->cans.size() == GENERIC_AMS_SLOT_NUM) {
            m_item_ids[DEPUTY_EXTRUDER_ID].push_back(ams_info->ams_id);
            AddAmsPreview(*ams_info, ams_info->ams_type);
            AddAms(*ams_info, AMSPanelPos::LEFT_PANEL);
            //AddExtraAms(*ams_info);
        }
        else if (ams_info->cans.size() == 1) {
            m_item_ids[DEPUTY_EXTRUDER_ID].push_back(ams_info->ams_id);
            AddAmsPreview(*ams_info, ams_info->ams_type);
            AddAms(*ams_info, AMSPanelPos::LEFT_PANEL);
 
            /*single_info.push_back(*ams_info);
            if (single_info.size() == MAX_AMS_NUM_IN_PANEL) {
                m_item_ids[DEPUTY_NOZZLE_ID].push_back(single_info[0].ams_id);
                m_item_ids[DEPUTY_NOZZLE_ID].push_back(single_info[1].ams_id);
                m_item_nums[DEPUTY_NOZZLE_ID]++;
                pair_id.push_back(std::make_pair(single_info[0].ams_id, single_info[1].ams_id));
                AddAmsPreview(single_info, AMSPanelPos::LEFT_PANEL);
                AddAms(single_info, AMSPanelPos::LEFT_PANEL);
                single_info.clear();
            }*/
        }
    }
    if (single_info.size() > 0){
        m_item_ids[DEPUTY_EXTRUDER_ID].push_back(single_info[0].ams_id);
        m_item_nums[DEPUTY_EXTRUDER_ID]++;
        AddAms(single_info, series_name, printer_type, AMSPanelPos::LEFT_PANEL);
        AddAmsPreview(single_info, AMSPanelPos::LEFT_PANEL);
        single_info.clear();
    }
 
    // data ext data
    if (m_ext_info.size() <= 0){
        BOOST_LOG_TRIVIAL(trace) << "vt_slot empty!";
        return;
    }
 
    single_info.push_back(m_ext_info[0]);
    m_item_ids[MAIN_EXTRUDER_ID].push_back(single_info[0].ams_id);
    AddAms(single_info, series_name, printer_type, AMSPanelPos::RIGHT_PANEL);
    auto left_init_mode = findFirstMode(AMSPanelPos::LEFT_PANEL);
    auto right_init_mode = findFirstMode(AMSPanelPos::RIGHT_PANEL);
 
    m_panel_prv_right->Hide();
    m_panel_prv_left->Hide();
    if (m_ams_info.size() > 0){
        m_simplebook_ams_left->Show();
        m_simplebook_ams_right->Show();
        m_simplebook_ams_left->SetSelection(0);
        m_simplebook_ams_right->SetSelection(0);
 
        if (m_ams_info.size() > 1){
            m_sizer_prv_right->Layout();
            m_panel_prv_right->Show();
        }
        m_down_road->UpdateLeft(1, left_init_mode);
        m_down_road->UpdateRight(1, right_init_mode);
    }
    else {
        m_panel_prv_left->Hide();
        m_panel_prv_right->Hide();
        m_simplebook_ams_left->Hide();
        m_simplebook_ams_right->Show();
 
        m_simplebook_ams_right->SetSelection(0);
        m_down_road->UpdateLeft(1, left_init_mode);
        m_down_road->UpdateRight(1, right_init_mode);
    }
    m_current_show_ams_left = m_item_ids[DEPUTY_EXTRUDER_ID].size() > 0 ? m_item_ids[DEPUTY_EXTRUDER_ID][0] : "";
    m_current_show_ams_right = m_item_ids[MAIN_EXTRUDER_ID].size() > 0 ? m_item_ids[MAIN_EXTRUDER_ID][0] : "";
    m_current_ams = "";
 
    m_down_road->UpdatePassRoad(AMSPanelPos::LEFT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    m_down_road->UpdatePassRoad(AMSPanelPos::RIGHT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    m_extruder->updateNozzleNum(1);
    m_extruder->OnAmsLoading(false, MAIN_EXTRUDER_ID);
 
    m_amswin->Layout();
    m_amswin->Fit();
 
    //Refresh();
    //Thaw();
}

References AddAms(), AddAmsPreview(), Slic3r::GUI::AMS_ROAD_STEP_NONE, DEPUTY_EXTRUDER_ID, findFirstMode(), GENERIC_AMS_SLOT_NUM, Slic3r::GUI::LEFT_PANEL, m_ams_info, m_amswin, m_current_ams, m_current_show_ams_left, m_current_show_ams_right, m_down_road, m_ext_info, m_extruder, m_item_ids, m_panel_prv_left, m_panel_prv_right, m_simplebook_ams_left, m_simplebook_ams_right, m_sizer_prv_right, MAIN_EXTRUDER_ID, Slic3r::GUI::RIGHT_PANEL, and Slic3r::trace().

Referenced by UpdateAms().

Here is the call graph for this function:

Here is the caller graph for this function:

Enable()

bool Slic3r::GUI::AMSControl::Enable ( bool enable = true )

virtual

{
    for (auto prv_it : m_ams_preview_list) {
        AMSPreview* prv = prv_it.second;
        prv->Enable(enable);
    }
 
    for (auto item_it : m_ams_item_list) {
        AmsItem* item = item_it.second;
        item->Enable(enable);
    }
 
    m_button_extruder_feed->Enable(enable);
    m_button_extruder_back->Enable(enable);
    m_button_auto_refill->Enable(enable);
    m_button_ams_setting->Enable(enable);
 
    m_filament_load_step->Enable(enable);
    return wxWindow::Enable(enable);
}

References Slic3r::GUI::AMSPreview::Enable(), m_ams_item_list, m_ams_preview_list, m_button_ams_setting, m_button_auto_refill, m_button_extruder_back, m_button_extruder_feed, and m_filament_load_step.

Here is the call graph for this function:

enable_ams_setting()

void Slic3r::GUI::AMSControl::enable_ams_setting

(

bool

en

)

{
    m_button_ams_setting->Enable(en);
}

References m_button_ams_setting.

EnableLoadFilamentBtn()

void Slic3r::GUI::AMSControl::EnableLoadFilamentBtn	(	bool	enable,
		const std::string &	ams_id,
		const std::string &	can_id,
		const wxString &	tips )

{
    m_button_extruder_feed->Enable(enable);
    if (m_button_extruder_feed->GetToolTipText() != tips) {
        BOOST_LOG_TRIVIAL(info) << "ams_id=" << ams_id << ", can_id=" << can_id << "  Set Load Filament Button ToolTip : " << tips.ToUTF8();
        m_button_extruder_feed->SetToolTip(tips);
    }
}

References m_button_extruder_feed.

EnableUnLoadFilamentBtn()

void Slic3r::GUI::AMSControl::EnableUnLoadFilamentBtn	(	bool	enable,
		const std::string &	ams_id,
		const std::string &	can_id,
		const wxString &	tips )

{
    m_button_extruder_back->Enable(enable);
    if (m_button_extruder_back->GetToolTipText() != tips) {
        BOOST_LOG_TRIVIAL(info) << "ams_id=" << ams_id << ", can_id=" << can_id << "  Set Unload Filament Button ToolTip : " << tips.ToUTF8();
        m_button_extruder_back->SetToolTip(tips);
    }
}

References m_button_extruder_back.

EnterExtraAMSMode()

void Slic3r::GUI::AMSControl::EnterExtraAMSMode

(

)

{
    //m_vams_lib->m_ams_model = m_ext_model;
    if(m_is_none_ams_mode == AMSModel::AMS_LITE) return;
    m_panel_prv_left->Hide();
 
    m_simplebook_ams_left->SetSelection(2);
    m_extruder->no_ams_mode(false);
    m_amswin->Layout();
    m_amswin->Fit();
    Layout();
    Refresh(true);
    m_is_none_ams_mode = AMSModel::AMS_LITE;
 
}

References Slic3r::GUI::AMS_LITE, m_amswin, m_extruder, m_is_none_ams_mode, m_panel_prv_left, and m_simplebook_ams_left.

EnterGenericAMSMode()

void Slic3r::GUI::AMSControl::EnterGenericAMSMode

(

)

{
    if(m_is_none_ams_mode == AMSModel::GENERIC_AMS) return;
    m_extruder->no_ams_mode(false);
    m_amswin->Layout();
    m_amswin->Fit();
    Layout();
    m_is_none_ams_mode = AMSModel::GENERIC_AMS;
}

References Slic3r::GUI::GENERIC_AMS, m_amswin, m_extruder, and m_is_none_ams_mode.

Referenced by show_noams_mode().

Here is the caller graph for this function:

EnterNoneAMSMode()

void Slic3r::GUI::AMSControl::EnterNoneAMSMode

(

)

{
    //m_vams_lib->m_ams_model = m_ext_model;
    if(m_is_none_ams_mode == AMSModel::EXT_AMS) return;
    m_panel_prv_left->Hide();
 
    m_simplebook_ams_left->SetSelection(0);
    m_extruder->no_ams_mode(true);
    //m_button_ams_setting->Hide();
    //m_button_extruder_feed->Show();
    //m_button_extruder_back->Show();
 
    ShowFilamentTip(false);
    m_amswin->Layout();
    m_amswin->Fit();
    Layout();
    m_is_none_ams_mode = AMSModel::EXT_AMS;
}

References Slic3r::GUI::EXT_AMS, m_amswin, m_extruder, m_is_none_ams_mode, m_panel_prv_left, m_simplebook_ams_left, and ShowFilamentTip().

Here is the call graph for this function:

findFirstMode()

AMSRoadShowMode Slic3r::GUI::AMSControl::findFirstMode

(

AMSPanelPos

pos

)

                                                         {
    auto init_mode = AMSRoadShowMode::AMS_ROAD_MODE_NONE;
    std::string ams_id = "";
    if (pos == AMSPanelPos::LEFT_PANEL && m_item_ids[DEPUTY_EXTRUDER_ID].size() > 0){
        ams_id = m_item_ids[DEPUTY_EXTRUDER_ID][0];
    }
    else if (pos == AMSPanelPos::RIGHT_PANEL && m_item_ids[MAIN_EXTRUDER_ID].size() > 0){
        ams_id = m_item_ids[MAIN_EXTRUDER_ID][0];
    }
 
    auto item = m_ams_item_list.find(ams_id);
    if (ams_id.empty() || item == m_ams_item_list.end()) return init_mode;
 
    if (item->second->get_can_count() == GENERIC_AMS_SLOT_NUM) {
        if (item->second->get_ams_model() == AMSModel::AMS_LITE) return AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
        if (item->second->get_ams_model() == AMSModel::EXT_AMS && item->second->get_ext_type() == AMSModelOriginType::LITE_EXT) return AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
        return AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
    }
    else{
        for (auto ids : pair_id){
            if (ids.first == ams_id || ids.second == ams_id){
                return AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
            }
        }
        if (item->second->get_ams_model() == AMSModel::EXT_AMS && item->second->get_ext_type() == AMSModelOriginType::LITE_EXT) return AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE;
        if (item->second->get_ams_model() == AMSModel::N3S_AMS) return AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
        return AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
    }
}

References Slic3r::GUI::AMS_LITE, Slic3r::GUI::AMS_ROAD_MODE_AMS_LITE, Slic3r::GUI::AMS_ROAD_MODE_DOUBLE, Slic3r::GUI::AMS_ROAD_MODE_FOUR, Slic3r::GUI::AMS_ROAD_MODE_NONE, Slic3r::GUI::AMS_ROAD_MODE_SINGLE, Slic3r::GUI::AMS_ROAD_MODE_SINGLE_N3S, DEPUTY_EXTRUDER_ID, Slic3r::GUI::EXT_AMS, GENERIC_AMS_SLOT_NUM, Slic3r::GUI::LEFT_PANEL, Slic3r::GUI::LITE_EXT, m_ams_item_list, m_item_ids, MAIN_EXTRUDER_ID, Slic3r::GUI::N3S_AMS, pair_id, and Slic3r::GUI::RIGHT_PANEL.

Referenced by CreateAmsDoubleNozzle(), and CreateAmsSingleNozzle().

Here is the caller graph for this function:

GenerateSimulateData()

std::vector< AMSinfo > Slic3r::GUI::AMSControl::GenerateSimulateData

(

)

                                                    {
    auto caninfo0_0 = Caninfo{ "0", (""), *wxRED, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo0_1 = Caninfo{ "1", (""), *wxGREEN, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo0_2 = Caninfo{ "2", (""), *wxBLUE, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo0_3 = Caninfo{ "3", (""), *wxYELLOW, AMSCanType::AMS_CAN_TYPE_VIRTUAL };
 
    auto caninfo1_0 = Caninfo{ "0", (""), wxColour(255, 255, 0), AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_1 = Caninfo{ "1", (""), wxColour(255, 0, 255), AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_2 = Caninfo{ "2", (""), wxColour(0, 255, 255), AMSCanType::AMS_CAN_TYPE_VIRTUAL };
    auto caninfo1_3 = Caninfo{ "3", (""), wxColour(200, 80, 150), AMSCanType::AMS_CAN_TYPE_VIRTUAL };
 
    AMSinfo                        ams1 = AMSinfo{ "0", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
    AMSinfo                        ams2 = AMSinfo{ "1", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
    AMSinfo                        ams3 = AMSinfo{ "2", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
    AMSinfo                        ams4 = AMSinfo{ "3", std::vector<Caninfo>{caninfo0_0, caninfo0_1, caninfo0_2, caninfo0_3}, 0 };
 
    AMSinfo                        singleams1 = AMSinfo{ "0", std::vector<Caninfo>{caninfo0_0}, 0 };
    AMSinfo                        singleams2 = AMSinfo{ "1", std::vector<Caninfo>{caninfo0_0}, 0 };
    AMSinfo                        singleams3 = AMSinfo{ "2", std::vector<Caninfo>{caninfo0_0}, 0 };
    AMSinfo                        singleams4 = AMSinfo{ "3", std::vector<Caninfo>{caninfo0_0}, 0 };
    singleams1.ams_type = AMSModel::N3S_AMS;
    singleams2.ams_type = AMSModel::N3S_AMS;
    singleams3.ams_type = AMSModel::N3S_AMS;
    singleams4.ams_type = AMSModel::N3S_AMS;
 
    AMSinfo                        ams5 = AMSinfo{ "4", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams6 = AMSinfo{ "5", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams7 = AMSinfo{ "6", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
    AMSinfo                        ams8 = AMSinfo{ "7", std::vector<Caninfo>{caninfo1_0, caninfo1_1, caninfo1_2, caninfo1_3}, 1 };
 
    AMSinfo                        singleams5 = AMSinfo{ "4", std::vector<Caninfo>{caninfo1_0}, 1 };
    AMSinfo                        singleams6 = AMSinfo{ "5", std::vector<Caninfo>{caninfo1_0}, 1 };
    AMSinfo                        singleams7 = AMSinfo{ "6", std::vector<Caninfo>{caninfo1_0}, 1 };
    AMSinfo                        singleams8 = AMSinfo{ "7", std::vector<Caninfo>{caninfo1_0}, 1 };
    AMSinfo                        singleams9 = AMSinfo{ "8", std::vector<Caninfo>{caninfo1_0}, 1 };
    singleams5.ams_type = AMSModel::N3S_AMS;
    singleams6.ams_type = AMSModel::N3S_AMS;
    singleams7.ams_type = AMSModel::N3S_AMS;
    singleams8.ams_type = AMSModel::N3S_AMS;
    singleams9.ams_type = AMSModel::N3S_AMS;
 
    ams3.current_can_id = "2";
    ams3.current_step = AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2;
    ams5.current_can_id = "2";
    ams5.current_step = AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2;
    std::vector<AMSinfo>generic_ams = { ams1, ams2, ams3, ams4, ams5, ams6, ams7, ams8 };
    std::vector<AMSinfo>single_ams = { singleams1, singleams2, singleams3, singleams4, singleams5, singleams6, singleams7, singleams8, singleams9 };
    std::vector<AMSinfo>ams_info = { ams1, singleams2, ams3, singleams4, ams5, singleams6, ams7, singleams8, singleams9 };
    return ams_info;
}

References Slic3r::GUI::AMS_CAN_TYPE_VIRTUAL, Slic3r::GUI::AMS_ROAD_STEP_COMBO_LOAD_STEP2, Slic3r::GUI::AMSinfo::ams_type, Slic3r::GUI::AMSinfo::current_can_id, Slic3r::GUI::AMSinfo::current_step, and Slic3r::GUI::N3S_AMS.

get_filament_id()

std::string Slic3r::GUI::AMSControl::get_filament_id ( const std::string & ams_id, const std::string & can_id )

private

{
    for (const auto& ams_info : m_ams_info)
    {
        if (ams_info.ams_id == m_current_ams)
        {
            bool found = false;
            const auto& can_info = ams_info.get_caninfo(this->GetCurrentCan(m_current_ams), found);
            if (found)
            {
                return can_info.filament_id;
            }
        }
    }
 
    for (const auto& ext_info : m_ext_info)
    {
        if (ext_info.ams_id == m_current_ams)
        {
            bool found = false;
            const auto& can_info = ext_info.get_caninfo(this->GetCurrentCan(m_current_ams), found);
            if (found)
            {
                return can_info.filament_id;
            }
        }
    }
 
    return std::string();
}

References GetCurrentCan(), m_ams_info, m_current_ams, and m_ext_info.

Referenced by on_filament_load().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCanColour()

wxColour Slic3r::GUI::AMSControl::GetCanColour	(	std::string	amsid,
		std::string	canid )

{
    wxColour col = *wxWHITE;
    for (auto i = 0; i < m_ams_info.size(); i++) {
        if (m_ams_info[i].ams_id == amsid) {
            for (auto o = 0; o < m_ams_info[i].cans.size(); o++) {
                if (m_ams_info[i].cans[o].can_id == canid) {
                    col = m_ams_info[i].cans[o].material_colour;
                }
            }
        }
    }
    return col;
}

References m_ams_info.

GetCurentAms()

std::string Slic3r::GUI::AMSControl::GetCurentAms

(

)

                                   {
    return m_current_ams;
}

References m_current_ams.

GetCurentShowAms()

std::string Slic3r::GUI::AMSControl::GetCurentShowAms

(

AMSPanelPos

pos = AMSPanelPos::RIGHT_PANEL

)

                                                      {
    if (pos == AMSPanelPos::RIGHT_PANEL){
        return m_current_show_ams_right;
    }
    else{
        return m_current_show_ams_left;
    }
}

References m_current_show_ams_left, m_current_show_ams_right, and Slic3r::GUI::RIGHT_PANEL.

Referenced by SetAmsStep().

Here is the caller graph for this function:

GetCurrentCan()

std::string Slic3r::GUI::AMSControl::GetCurrentCan

(

std::string

amsid

)

{
    std::string current_can;
    for (auto ams_item : m_ams_item_list) {
        AmsItem* item = ams_item.second;
        if (item == nullptr){
            continue;
        }
        if (item->get_ams_id() == amsid) {
            current_can = item->GetCurrentCan();
            return current_can;
        }
    }
    return current_can;
}

References Slic3r::GUI::AmsItem::get_ams_id(), Slic3r::GUI::AmsItem::GetCurrentCan(), and m_ams_item_list.

Referenced by get_filament_id(), and on_filament_load().

Here is the call graph for this function:

Here is the caller graph for this function:

IsAmsInRightPanel()

bool Slic3r::GUI::AMSControl::IsAmsInRightPanel

(

std::string

ams_id

)

                                                   {
    if (m_total_ext_count == 2){
        // Orca: inlet-aware panel routing (see AMSinfo::routes_to_main_extruder)
        if (m_ams_item_list.find(ams_id) != m_ams_item_list.end() && m_ams_item_list[ams_id]->routes_to_main_extruder()) {
            return true;
        }
        else{
            return false;
        }
    }
    else{
        for (auto id : m_item_ids[MAIN_EXTRUDER_ID]){
            if (id == ams_id){
                return true;
            }
        }
        return false;
    }
}

References m_ams_item_list, m_item_ids, m_total_ext_count, and MAIN_EXTRUDER_ID.

Referenced by SetAmsStep(), and SwitchAms().

Here is the caller graph for this function:

isFilaSwitchReady()

std::tuple< bool, bool > Slic3r::GUI::AMSControl::isFilaSwitchReady

(

)

{
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return {false, false};
    MachineObject* obj = dev->get_selected_machine();
    if (!obj) return {false, false};
    // Orca: GetFilaSwitch() is a raw non-null accessor (BBS returns a shared_ptr).
    DevFilaSwitch* fila_switch = obj->GetFilaSwitch();
    if (fila_switch)
    {
        return {fila_switch->IsInstalled(), fila_switch->IsReady()};
    }
    return {false, false};
}

References Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetFilaSwitch(), Slic3r::DevFilaSwitch::IsInstalled(), and Slic3r::DevFilaSwitch::IsReady().

Referenced by UpdateAms().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::AMSControl::msw_rescale

(

)

{
    m_button_ams_setting_normal.msw_rescale();
    m_button_ams_setting_hover.msw_rescale();
    m_button_ams_setting_press.msw_rescale();
    m_button_ams_setting->SetBitmap(m_button_ams_setting_normal.bmp());
 
    m_extruder->msw_rescale();
 
    if (m_button_extruder_feed) m_button_extruder_feed->Rescale(); // ORCA
    if (m_button_extruder_back) m_button_extruder_back->Rescale(); // ORCA
    if (m_button_auto_refill) m_button_auto_refill->Rescale();     // ORCA
    if (m_button_ams_setting) m_button_ams_setting->SetMinSize(wxSize(FromDIP(25), FromDIP(24)));
 
 
    for (auto ams_item : m_ams_item_list) {
        if (ams_item.second){
            ams_item.second->msw_rescale();
        }
    }
    for (auto ams_prv : m_ams_preview_list) {
        if (ams_prv.second){
            ams_prv.second->msw_rescale();
        }
    }
    for (auto ext_img : m_ext_image_list) {
        if (ext_img.second) {
            ext_img.second->msw_rescale();
        }
    }
    if (m_down_road){
        m_down_road->msw_rescale();
    }
 
    if (m_percent_humidity_dry_popup){
        m_percent_humidity_dry_popup->msw_rescale();
    }
 
    if (m_ams_dry_ctr_win) {
        m_ams_dry_ctr_win->msw_rescale();
    }
 
    m_Humidity_tip_popup.msw_rescale();
 
    Layout();
    Refresh();
}

References m_ams_dry_ctr_win, m_ams_item_list, m_ams_preview_list, m_button_ams_setting, m_button_ams_setting_hover, m_button_ams_setting_normal, m_button_ams_setting_press, m_button_auto_refill, m_button_extruder_back, m_button_extruder_feed, m_down_road, m_ext_image_list, m_extruder, m_Humidity_tip_popup, and m_percent_humidity_dry_popup.

on_ams_setting_click() [1/2]

void Slic3r::GUI::AMSControl::on_ams_setting_click

(

wxCommandEvent &

event

)

References Slic3r::GUI::wxMouseEvent.

on_ams_setting_click() [2/2]

void Slic3r::GUI::AMSControl::on_ams_setting_click

(

wxMouseEvent &

event

)

{
    post_event(SimpleEvent(EVT_AMS_SETTINGS));
}

References post_event(), and Slic3r::GUI::wxMouseEvent.

Referenced by AMSControl().

Here is the call graph for this function:

Here is the caller graph for this function:

on_clibration_again_click()

void Slic3r::GUI::AMSControl::on_clibration_again_click

(

wxMouseEvent &

event

)

{ post_event(SimpleEvent(EVT_AMS_CLIBRATION_AGAIN)); }

References post_event(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_clibration_cancel_click()

void Slic3r::GUI::AMSControl::on_clibration_cancel_click

(

wxMouseEvent &

event

)

{ post_event(SimpleEvent(EVT_AMS_CLIBRATION_CANCEL)); }

References post_event(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_extrusion_cali()

void Slic3r::GUI::AMSControl::on_extrusion_cali

(

wxCommandEvent &

event

)

{
    for (auto i = 0; i < m_ams_info.size(); i++) {
        if (m_ams_info[i].ams_id == m_current_ams) { m_ams_info[i].current_action = AMSAction::AMS_ACTION_CALI; }
    }
    post_event(SimpleEvent(EVT_AMS_EXTRUSION_CALI));
}

References Slic3r::GUI::AMS_ACTION_CALI, m_ams_info, m_current_ams, and post_event().

Here is the call graph for this function:

on_filament_load()

void Slic3r::GUI::AMSControl::on_filament_load

(

wxCommandEvent &

event

)

{
    /*If the filament is unknown, show warning*/
    const auto& filament_id = get_filament_id(m_current_ams, GetCurrentCan(m_current_ams));
    if (filament_id.empty())
    {
        MessageDialog msg_dlg(nullptr, _L("Filament type is unknown which is required to perform this action. Please set target filament's informations."),
                              wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return;
    }
 
    for (auto i = 0; i < m_ams_info.size(); i++) {
        if (m_ams_info[i].ams_id == m_current_ams) { m_ams_info[i].current_action = AMSAction::AMS_ACTION_LOAD; }
    }
    post_event(SimpleEvent(EVT_AMS_LOAD));
}

References _L, Slic3r::GUI::AMS_ACTION_LOAD, get_filament_id(), GetCurrentCan(), m_ams_info, m_current_ams, post_event(), and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by AMSControl().

Here is the call graph for this function:

Here is the caller graph for this function:

on_filament_unload()

void Slic3r::GUI::AMSControl::on_filament_unload

(

wxCommandEvent &

event

)

{
    for (auto i = 0; i < m_ams_info.size(); i++) {
        if (m_ams_info[i].ams_id == m_current_ams) { m_ams_info[i].current_action = AMSAction::AMS_ACTION_UNLOAD; }
    }
    post_event(SimpleEvent(EVT_AMS_UNLOAD));
}

References Slic3r::GUI::AMS_ACTION_UNLOAD, m_ams_info, m_current_ams, and post_event().

Referenced by AMSControl().

Here is the call graph for this function:

Here is the caller graph for this function:

on_retry()

void Slic3r::GUI::AMSControl::on_retry

(

)

{
    post_event(wxCommandEvent(EVT_AMS_RETRY));
}

References post_event().

Here is the call graph for this function:

parse_object()

void Slic3r::GUI::AMSControl::parse_object

(

MachineObject *

obj

)

                                                {
    if (!obj || obj->GetFilaSystem()->GetAmsList().size() == 0)
    {
        return;
    }
    m_ams_info.clear();
    for (auto ams : obj->GetFilaSystem()->GetAmsList())
    {
        AMSinfo info;
        info.parse_ams_info(obj, ams.second);
        m_ams_info.push_back(info);
    }
}

References Slic3r::MachineObject::GetFilaSystem(), m_ams_info, and Slic3r::GUI::AMSinfo::parse_ams_info().

Referenced by AMSControl().

Here is the call graph for this function:

Here is the caller graph for this function:

PlayRridLoading()

void Slic3r::GUI::AMSControl::PlayRridLoading	(	wxString	amsid,
		wxString	canid )

{
    auto iter = m_ams_item_list.find(amsid.ToStdString());
 
    if (iter != m_ams_item_list.end()) {
        AmsItem* cans = iter->second;
        cans->PlayRridLoading(canid);
    }
}

References m_ams_item_list, and Slic3r::GUI::AmsItem::PlayRridLoading().

Here is the call graph for this function:

post_event()

void Slic3r::GUI::AMSControl::post_event

(

wxEvent &&

event

)

{
    event.SetEventObject(m_parent);
    wxPostEvent(m_parent, event);
}

Referenced by auto_refill(), on_ams_setting_click(), on_clibration_again_click(), on_clibration_cancel_click(), on_extrusion_cali(), on_filament_load(), on_filament_unload(), on_retry(), and SwitchAms().

Here is the caller graph for this function:

Reset()

void Slic3r::GUI::AMSControl::Reset

(

)

{
    m_ams_info.clear();
    m_ext_info.clear();
    m_dev_id.clear();
    ClearAms();
 
    Layout();
}

References ClearAms(), m_ams_info, m_dev_id, and m_ext_info.

Here is the call graph for this function:

SetAmsModel()

void Slic3r::GUI::AMSControl::SetAmsModel ( AMSModel mode, AMSModel ext_mode )

inline

{m_ams_model = mode; m_ext_model = ext_mode;};

References m_ams_model, and m_ext_model.

SetAmsStep()

void Slic3r::GUI::AMSControl::SetAmsStep	(	std::string	ams_id,
		std::string	canid,
		AMSPassRoadType	type,
		AMSPassRoadSTEP	step )

{
    AmsItem* ams = nullptr;
    auto amsit = m_ams_item_list.find(ams_id);
    bool in_same_page = false;
 
    if (amsit != m_ams_item_list.end()) {ams = amsit->second;}
    else {return;}
    if (ams == nullptr) return;
 
    m_last_ams_id = ams_id;
    m_last_tray_id = canid;
    int can_index = atoi(canid.c_str());
 
    std::vector<std::string> cur_left_ams;
    std::vector<std::string> cur_right_ams;
 
    std::string ams_id_left = GetCurentShowAms(AMSPanelPos::LEFT_PANEL);
    std::string ams_id_right = GetCurentShowAms(AMSPanelPos::RIGHT_PANEL);
 
    for (auto it : pair_id) {
        if ((ams_id_left == it.first || ams_id_left == it.second)) {
            cur_left_ams.push_back(it.first);
            cur_left_ams.push_back(it.second);
        }
        else if ((ams_id_right == it.first || ams_id_right == it.second)) {
            cur_right_ams.push_back(it.first);
            cur_right_ams.push_back(it.second);
        }
    }
 
    auto left = !IsAmsInRightPanel(ams_id);
    auto length = -1;
    auto model = AMSModel::AMS_LITE;
    auto in_pair = false;
 
    if (std::find(cur_left_ams.begin(), cur_left_ams.end(), ams_id) != cur_left_ams.end()) {
        in_same_page = true;
    }
 
    if (std::find(cur_right_ams.begin(), cur_right_ams.end(), ams_id) != cur_right_ams.end()) {
        in_same_page = true;
    }
 
    //Set path length in different case
    model  = ams->get_ams_model();
 
    if (ams->get_can_count() == GENERIC_AMS_SLOT_NUM) {
        length = left ? 129 : 145;
    } else if (ams->get_can_count() == 1) {
        for (auto it : pair_id){
            if (it.first == ams_id){
                length = left ? 218 : 124;
                in_pair = true;
                break;
            }
            else if (it.second == ams_id){
                length = left ? 124 : 232;
                in_pair = true;
                break;
            }
        }
 
        if (!in_pair && model == N3S_AMS) {
            length = left ? 129 : 232;
        }
    }
 
    if (model == AMSModel::AMS_LITE){
        length = left ? 145 : 45;
    }
    if (model == EXT_AMS && ams->get_ext_type() == AMSModelOriginType::LITE_EXT) {
 
       if (m_ams_info.size() == 0 && m_ext_info.size() == 1) {
           length = 13;
       } else {
           length = 145;
       }
    }
 
    if (model == EXT_AMS && ams->get_ext_type() == AMSModelOriginType::GENERIC_EXT) {
        if (m_ams_info.size() == 0 && m_ext_info.size() == 1) {
            left = true;
            length = 50;
        } else {
            /*check in pair*/
            if (in_pair) {
                length = left ? 110 : 232;
            } else {
                length = left ? 192 : 82;
            }
        }
    }
 
    for (auto i = 0; i < m_ams_info.size(); i++) {
        if (m_ams_info[i].ams_id == ams_id) {
            m_ams_info[i].current_step = step;
            m_ams_info[i].current_can_id = canid;
        }
    }
    for (auto i = 0; i < m_ext_info.size(); i++) {
        if (m_ext_info[i].ams_id == ams_id) {
            m_ext_info[i].current_step = step;
            m_ext_info[i].current_can_id = canid;
        }
    }
 
 
    AMSinfo info;
    if (m_ams_item_list.find(ams_id) != m_ams_item_list.end()) {
        info = m_ams_item_list[ams_id]->get_ams_info();
    }
    else{
        return;
    }
    if (can_index >= 0 && can_index < info.cans.size())
    {
        m_down_road->SetPassRoadColour(left, info.cans[can_index].material_colour);
    }
 
    AMSPanelPos pos = left ? AMSPanelPos::LEFT_PANEL : AMSPanelPos::RIGHT_PANEL;
 
    if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_NONE) {
        //cans->SetAmsStep(canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
        ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
        if (ams_id_left == ams_id || ams_id_right == ams_id || in_same_page) {
            m_down_road->UpdatePassRoad(pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
            m_extruder->OnAmsLoading(false, ams->get_nozzle_id());
        }
    }
 
    if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP1) {
        ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
        if (ams_id_left == ams_id || ams_id_right == ams_id || in_same_page) {
            m_down_road->UpdatePassRoad(pos, length, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
            m_extruder->OnAmsLoading(false, ams->get_nozzle_id());
        }
        else
        {
            m_down_road->UpdatePassRoad(pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_1);
        }
    }
 
    if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP2) {
        ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
        if (ams_id_left == ams_id || ams_id_right == ams_id || in_same_page) {
            m_down_road->UpdatePassRoad(pos, length, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
            m_extruder->OnAmsLoading(true, ams->get_nozzle_id(), ams->GetTagColr(canid));
        }
        else
        {
            m_down_road->UpdatePassRoad(pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_2);
        }
    }
    if (step == AMSPassRoadSTEP::AMS_ROAD_STEP_COMBO_LOAD_STEP3) {
        ams->SetAmsStep(ams_id, canid, type, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
        if (ams_id_left == ams_id || ams_id_right == ams_id || in_same_page)
        {
            m_down_road->UpdatePassRoad(pos, length, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
            m_extruder->OnAmsLoading(true, ams->get_nozzle_id(), ams->GetTagColr(canid));
        }
        else
        {
            m_down_road->UpdatePassRoad(pos, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_3);
        }
    }
}

References Slic3r::GUI::AMS_LITE, Slic3r::GUI::AMS_ROAD_STEP_1, Slic3r::GUI::AMS_ROAD_STEP_2, Slic3r::GUI::AMS_ROAD_STEP_3, Slic3r::GUI::AMS_ROAD_STEP_COMBO_LOAD_STEP1, Slic3r::GUI::AMS_ROAD_STEP_COMBO_LOAD_STEP2, Slic3r::GUI::AMS_ROAD_STEP_COMBO_LOAD_STEP3, Slic3r::GUI::AMS_ROAD_STEP_NONE, Slic3r::GUI::AMSinfo::cans, Slic3r::GUI::EXT_AMS, GENERIC_AMS_SLOT_NUM, Slic3r::GUI::GENERIC_EXT, Slic3r::GUI::AmsItem::get_ams_model(), Slic3r::GUI::AmsItem::get_can_count(), Slic3r::GUI::AmsItem::get_ext_type(), Slic3r::GUI::AmsItem::get_nozzle_id(), GetCurentShowAms(), Slic3r::GUI::AmsItem::GetTagColr(), IsAmsInRightPanel(), Slic3r::GUI::LEFT_PANEL, Slic3r::length(), Slic3r::GUI::LITE_EXT, m_ams_info, m_ams_item_list, m_down_road, m_ext_info, m_extruder, m_last_ams_id, m_last_tray_id, Slic3r::GUI::N3S_AMS, pair_id, Slic3r::GUI::RIGHT_PANEL, and Slic3r::GUI::AmsItem::SetAmsStep().

Here is the call graph for this function:

SetExtruder()

void Slic3r::GUI::AMSControl::SetExtruder	(	bool	on_off,
		int	nozzle_id,
		std::string	ams_id,
		std::string	slot_id )

{
    AmsItem *item = nullptr;
    if (m_ams_item_list.find(ams_id) != m_ams_item_list.end()) { item = m_ams_item_list[ams_id]; }
 
    if (on_off && item) {
        auto col = item->GetTagColr(slot_id);
        m_extruder->OnAmsLoading(true, nozzle_id, col);
    }
    else {
        m_extruder->OnAmsLoading(false, nozzle_id);
    }
}

References Slic3r::GUI::AmsItem::GetTagColr(), m_ams_item_list, and m_extruder.

Here is the call graph for this function:

show_auto_refill()

void Slic3r::GUI::AMSControl::show_auto_refill

(

bool

show

)

{
    if (m_button_auto_refill->IsShown() == show)
    {
        return;
    }
 
    m_button_auto_refill->Show(show);
    m_amswin->Layout();
    m_amswin->Fit();
}

References m_amswin, and m_button_auto_refill.

show_noams_mode()

void Slic3r::GUI::AMSControl::show_noams_mode

(

)

{
    EnterGenericAMSMode();
}

References EnterGenericAMSMode().

Here is the call graph for this function:

show_switcher_status()

void Slic3r::GUI::AMSControl::show_switcher_status

(

bool

show

)

{
    // Orca: never materialize the banner on printers that never request it, so the AMS control is
    // byte-identical without a Filament Track Switch (UpdateAms calls this with show=false every refresh).
    if (!show && tipPanel == nullptr) { return; }
 
    if (tipPanel == nullptr)
    {
        m_sizer_body->Add(0, 0, 1, wxEXPAND | wxTOP, FromDIP(5));
        tipPanel = new wxPanel(m_amswin);
        tipPanel->SetBackgroundColour(wxColour(255, 153, 0));
        tipSizer = new wxBoxSizer(wxHORIZONTAL);
        tipPanel->SetSizer(tipSizer);
        icon = new wxStaticBitmap(tipPanel, wxID_ANY,
            wxArtProvider::GetBitmap(wxART_INFORMATION, wxART_MESSAGE_BOX, wxSize(FromDIP(16), FromDIP(16))));
        tipSizer->Add(icon, 0, wxALL, FromDIP(8));
        tipText = new wxStaticText(tipPanel, wxID_ANY, _L("AMS has not been initialized. Please initialize it before use."));
        tipText->SetForegroundColour(wxColour(255, 255, 255));
        tipText->SetFont(wxFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
        tipText->Wrap(-1);
        tipText->SetMinSize(wxSize(-1, -1));
        tipSizer->Add(tipText, 0, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, FromDIP(8));
        m_sizer_body->Add(tipPanel, 1, wxEXPAND, 0);
    }
    if (tipPanel->IsShown() == show)
    {
        return;
    }
    tipPanel->Show(show);
    m_amswin->Layout();
    m_amswin->Fit();
}

References _L, icon, m_amswin, m_sizer_body, tipPanel, tipSizer, tipText, and wxStaticText.

Referenced by UpdateAms().

Here is the caller graph for this function:

show_vams_kn_value()

void Slic3r::GUI::AMSControl::show_vams_kn_value

(

bool

show

)

{
    //m_vams_lib->show_kn_value(show);
}

ShowFilamentTip()

void Slic3r::GUI::AMSControl::ShowFilamentTip

(

bool

hasams = true

)

{
    //m_simplebook_right->SetSelection(0);
    if (hasams) {
        m_tip_right_top->Show();
        m_tip_load_info->SetLabelText(_L("Choose an AMS slot then press \"Load\" or \"Unload\" button to automatically load or unload filament."));
    } else {
        // m_tip_load_info->SetLabelText(_L("Before loading, please make sure the filament is pushed into toolhead."));
        m_tip_right_top->Hide();
        m_tip_load_info->SetLabelText(wxEmptyString);
    }
 
    m_tip_load_info->SetMinSize(AMS_STEP_SIZE);
    m_tip_load_info->Wrap(AMS_STEP_SIZE.x - FromDIP(5));
    m_sizer_right_tip->Layout();
}

References _L, AMS_STEP_SIZE, m_sizer_right_tip, m_tip_load_info, and m_tip_right_top.

Referenced by EnterNoneAMSMode().

Here is the caller graph for this function:

StopRridLoading()

void Slic3r::GUI::AMSControl::StopRridLoading	(	wxString	amsid,
		wxString	canid )

{
    auto iter = m_ams_item_list.find(amsid.ToStdString());
 
    if (iter != m_ams_item_list.end()) {
        AmsItem* cans = iter->second;
        cans->StopRridLoading(canid);
    }
}

References m_ams_item_list, and Slic3r::GUI::AmsItem::StopRridLoading().

Here is the call graph for this function:

SwitchAms()

void Slic3r::GUI::AMSControl::SwitchAms

(

std::string

ams_id

)

{
    if(ams_id == m_current_show_ams_left || ams_id == m_current_show_ams_right){return;}
 
    bool is_in_right = IsAmsInRightPanel(ams_id);
    if (is_in_right){
        m_current_show_ams_right = ams_id;
        m_down_road->UpdatePassRoad(AMSPanelPos::RIGHT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    }
    else{
        m_current_show_ams_left = ams_id;
        m_down_road->UpdatePassRoad(AMSPanelPos::LEFT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
    }
 
 
    for (auto prv_it : m_ams_preview_list) {
        AMSPreview* prv = prv_it.second;
        if (prv->get_ams_id() == m_current_show_ams_left || prv->get_ams_id() == m_current_show_ams_right) {
            prv->OnSelected();
            m_current_select = ams_id;
 
            bool ready_selected = false;
            for (auto item_it : m_ams_item_list) {
                AmsItem* item = item_it.second;
                if (item->get_ams_id() == ams_id) {
                    for (auto lib_it : item->get_can_lib_list()) {
                        AMSLib* lib = lib_it.second;
                        if (lib->is_selected()) {
                            ready_selected = true;
                        }
                    }
                }
            }
            if (is_in_right){
                m_current_show_ams_right = ams_id;
            }
            else{
                m_current_show_ams_left = ams_id;
            }
 
        } else {
            prv->UnSelected();
        }
    }
 
    for (auto ams_item : m_ams_item_list) {
        AmsItem* item = ams_item.second;
        if (item->get_ams_id() == ams_id) {
            auto ids = item->get_panel_pos() == AMSPanelPos::LEFT_PANEL ? m_item_ids[DEPUTY_EXTRUDER_ID] : m_item_ids[MAIN_EXTRUDER_ID];
            auto pos = item->get_panel_pos();
            for (auto id : ids) {
                if (id == item->get_ams_id()) {
                    pos == AMSPanelPos::LEFT_PANEL ? m_simplebook_ams_left->SetSelection(item->get_selection()) : m_simplebook_ams_right->SetSelection(item->get_selection());
                    if (item->get_can_count() == GENERIC_AMS_SLOT_NUM) {
                        if (item->get_ams_model() == AMSModel::AMS_LITE) {
                            if (pos == AMSPanelPos::LEFT_PANEL) {
                                m_down_road->UpdateLeft(m_total_ext_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE);
                            } else {
                                m_down_road->UpdateRight(m_total_ext_count, AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE);
                            }
                        }
                        else {
                            if (pos == AMSPanelPos::LEFT_PANEL) {
                                m_down_road->UpdateLeft(m_total_ext_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR);
                            } else {
                                m_down_road->UpdateRight(m_total_ext_count, AMSRoadShowMode::AMS_ROAD_MODE_FOUR);
                            }
                        }
                    }
                    else {
                        AMSRoadShowMode mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE;
 
                        if (item->get_ams_model() == AMSModel::N3S_AMS)
                            mode = AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S;
 
                        for (auto it : pair_id) {
                            if (it.first == ams_id || it.second == ams_id) {
                                mode = AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE;
                                break;
                            }
                        }
                        pos == AMSPanelPos::LEFT_PANEL ? m_down_road->UpdateLeft(m_total_ext_count, mode)
                            : m_down_road->UpdateRight(m_total_ext_count, mode);
                        if (pos == AMSPanelPos::LEFT_PANEL) {
                            m_down_road->UpdatePassRoad(AMSPanelPos::LEFT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
                        } else {
                            m_down_road->UpdatePassRoad(AMSPanelPos::RIGHT_PANEL, -1, AMSPassRoadSTEP::AMS_ROAD_STEP_NONE);
                        }
                    }
                }
            }
        }
    }
 
    post_event(SimpleEvent(EVT_AMS_SWITCH));
}

References Slic3r::GUI::AMS_LITE, Slic3r::GUI::AMS_ROAD_MODE_AMS_LITE, Slic3r::GUI::AMS_ROAD_MODE_DOUBLE, Slic3r::GUI::AMS_ROAD_MODE_FOUR, Slic3r::GUI::AMS_ROAD_MODE_SINGLE, Slic3r::GUI::AMS_ROAD_MODE_SINGLE_N3S, Slic3r::GUI::AMS_ROAD_STEP_NONE, DEPUTY_EXTRUDER_ID, GENERIC_AMS_SLOT_NUM, Slic3r::GUI::AmsItem::get_ams_id(), Slic3r::GUI::AMSPreview::get_ams_id(), Slic3r::GUI::AmsItem::get_ams_model(), Slic3r::GUI::AmsItem::get_can_count(), Slic3r::GUI::AmsItem::get_can_lib_list(), Slic3r::GUI::AmsItem::get_panel_pos(), Slic3r::GUI::AmsItem::get_selection(), Slic3r::GUI::AMSLib::is_selected(), IsAmsInRightPanel(), Slic3r::GUI::LEFT_PANEL, m_ams_item_list, m_ams_preview_list, m_current_select, m_current_show_ams_left, m_current_show_ams_right, m_down_road, m_item_ids, m_simplebook_ams_left, m_simplebook_ams_right, m_total_ext_count, MAIN_EXTRUDER_ID, Slic3r::GUI::N3S_AMS, Slic3r::GUI::AMSPreview::OnSelected(), pair_id, post_event(), Slic3r::GUI::RIGHT_PANEL, and Slic3r::GUI::AMSPreview::UnSelected().

Referenced by AddAmsPreview(), and AddAmsPreview().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateAms()

void Slic3r::GUI::AMSControl::UpdateAms	(	const std::string &	series_name,
		const std::string &	printer_type,
		std::vector< AMSinfo >	ams_info,
		std::vector< AMSinfo >	ext_info,
		DevExtderSystem	data,
		std::string	dev_id,
		MachineObject *	obj = nullptr,
		bool	is_reset = true,
		bool	test = false )

{
    if (!test){
        // update item
        bool fresh = false;
 
        // basic check
        if (m_ams_info.size() == ams_info.size() && m_total_ext_count == data.GetTotalExtderCount() && m_dev_id == dev_id && m_ext_info.size() == ext_info.size())
        {
            for (int i = 0; i < m_ams_info.size(); i++){
                if (m_ams_info[i].ams_id != ams_info[i].ams_id){
                    fresh = true;
                }
 
                // Orca: rebuild when the panel assignment changes; inlet-aware so a Filament Track Switch
                // re-plug (same pinned nozzle_id, different inlet) still refreshes placement.
                if (m_ams_info[i].routes_to_main_extruder() != ams_info[i].routes_to_main_extruder()) {
                    fresh = true;
                }
            }
        }
        else{
            fresh = true;
        }
 
        m_ams_info.clear();
        m_ams_info = ams_info;
        m_total_ext_count = data.GetTotalExtderCount();
        m_ext_info.clear();
        m_ext_info = ext_info;
        m_dev_id = dev_id;
        if (fresh){
            ClearAms();
            if (m_total_ext_count >= 2){
                CreateAmsDoubleNozzle(series_name, printer_type);
            }else{
                CreateAmsSingleNozzle(series_name, printer_type);
            }
            SetSize(wxSize(FromDIP(578), -1));
            SetMinSize(wxSize(FromDIP(578), -1));
            Layout();
        }
        // update cans
 
        for (auto ams_item : m_ams_item_list) {
            if (ams_item.second == nullptr){
                continue;
            }
            std::string ams_id = ams_item.second->get_ams_id();
            AmsItem* cans = ams_item.second;
            if (cans->get_ams_id() == std::to_string(VIRTUAL_TRAY_MAIN_ID) || cans->get_ams_id() == std::to_string(VIRTUAL_TRAY_DEPUTY_ID)) {
                for (auto ifo : m_ext_info) {
                    if (ifo.ams_id == ams_id) {
                        cans->UpdateInfo(ifo);
                        cans->show_sn_value(m_ams_model == AMSModel::AMS_LITE ? false : true);
                    }
                }
            }
            else{
                for (auto ifo : m_ams_info) {
                    if (ifo.ams_id == ams_id) {
                        cans->UpdateInfo(ifo);
                        cans->show_sn_value(m_ams_model == AMSModel::AMS_LITE ? false : true);
                    }
                }
            }
        }
 
        // 2D mode (laser/cut) makes every spool view-only: show the read-only (eye) icon while the spool
        // stays clickable to open the read-only filament dialog.
        // Orca: gated on the device mode via MachineObject::is_fdm_type(); obj is null for callers that do
        // not supply it, leaving spools editable.
        const bool view_only = obj && !obj->is_fdm_type();
        for (auto ams_item : m_ams_item_list) {
            if (ams_item.second == nullptr) { continue; }
            for (auto lib_it : ams_item.second->get_can_lib_list()) {
                if (lib_it.second) { lib_it.second->set_view_only(view_only); }
            }
        }
 
        for (auto ams_prv : m_ams_preview_list) {
            std::string id = ams_prv.second->get_ams_id();
            auto item = m_ams_item_list.find(id);
            if (item != m_ams_item_list.end())
            { ams_prv.second->UpdateInfo(item->second->get_ams_info());
            }
        }
    }
 
    /*update humidity popup*/
    if (m_percent_humidity_dry_popup->IsShown())
    {
        std::string target_id = m_percent_humidity_dry_popup->get_owner_ams_id();
        for (const auto& the_info : ams_info)
        {
            if (target_id == the_info.ams_id)
            {
                uiAmsHumidityInfo humidity_info;
                humidity_info.ams_id = the_info.ams_id;
                humidity_info.humidity_display_idx = the_info.get_humidity_display_idx();
                humidity_info.humidity_percent = the_info.humidity_raw;
                humidity_info.left_dry_time = the_info.left_dray_time;
                humidity_info.current_temperature = the_info.current_temperature;
                m_percent_humidity_dry_popup->UpdateInfo(&humidity_info);
                break;
            }
        }
    }
 
    /*update ams extruder*/
    if (m_extruder->updateNozzleNum(m_total_ext_count, series_name))
    {
        m_amswin->Layout();
    }
 
    /*update switch status*/
    // Orca: inert on any printer without a Filament Track Switch — install is false, so the banner is
    // never materialized, the glyph stays hidden, and every ShowRoad(true) below is a no-op.
    const auto [install, ready] = isFilaSwitchReady();
    show_switcher_status(install && (!ready));
    bool isShow = install && m_total_ext_count >= 2;
    if (m_switcher->IsShown() != isShow)
    {
        m_switcher->Show(isShow);
        m_sizer_body->Layout();
        m_sizer_body->Fit(this);
        this->Layout();
        this->Refresh(true);
        this->Update();
    }
 
    /*update ext road visibility when fila switch installed*/
    bool road_visibility_changed = false;
    for (auto& [ams_id, ams_item] : m_ams_item_list) {
        if (!ams_item) continue;
        // Orca: drop the external-spool road (AMSModel::EXT_AMS) while the switch routes all filament.
        const bool should_show_road = !(install && ams_item->get_ams_model() == AMSModel::EXT_AMS);
        if (ams_item->ShowRoad(should_show_road)) { road_visibility_changed = true; }
    }
    if (road_visibility_changed) { m_amswin->Layout(); }
}

References Slic3r::GUI::uiAmsHumidityInfo::ams_id, Slic3r::GUI::AMS_LITE, ClearAms(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), Slic3r::GUI::uiAmsHumidityInfo::current_temperature, Slic3r::GUI::EXT_AMS, Slic3r::GUI::AmsItem::get_ams_id(), Slic3r::DevExtderSystem::GetTotalExtderCount(), Slic3r::GUI::uiAmsHumidityInfo::humidity_display_idx, Slic3r::GUI::uiAmsHumidityInfo::humidity_percent, Slic3r::MachineObject::is_fdm_type(), isFilaSwitchReady(), Slic3r::GUI::uiAmsHumidityInfo::left_dry_time, m_ams_info, m_ams_item_list, m_ams_model, m_ams_preview_list, m_amswin, m_dev_id, m_ext_info, m_extruder, m_percent_humidity_dry_popup, m_sizer_body, m_switcher, m_total_ext_count, Slic3r::GUI::AmsItem::show_sn_value(), show_switcher_status(), Slic3r::GUI::AmsItem::UpdateInfo(), VIRTUAL_TRAY_DEPUTY_ID, and VIRTUAL_TRAY_MAIN_ID.

Here is the call graph for this function:

UpdateAmsDryControl()

void Slic3r::GUI::AMSControl::UpdateAmsDryControl

(

MachineObject *

obj

)

{
    if (!m_ams_dry_ctr_win->IsShown()) {
        return;
    }
 
    if (!obj || !obj->GetFilaSystem()) {
        m_ams_dry_ctr_win->Close();
        return;
    }
 
    std::weak_ptr<DevFilaSystem> weak_fila_system = obj->GetFilaSystem();
 
    if (auto locaked_fila_system = weak_fila_system.lock()) {
        m_ams_dry_ctr_win->update(locaked_fila_system, obj);
    } else {
        m_ams_dry_ctr_win->Close();
        return;
    }
}

References Slic3r::MachineObject::GetFilaSystem(), and m_ams_dry_ctr_win.

Here is the call graph for this function:

UpdatePassRoad()

void Slic3r::GUI::AMSControl::UpdatePassRoad	(	std::string	ams_id,
		AMSPassRoadType	type,
		AMSPassRoadSTEP	step )

References Slic3r::GUI::LEFT_PANEL, and Slic3r::GUI::wxMouseEvent.

Member Data Documentation

icon

wxStaticBitmap* Slic3r::GUI::AMSControl::icon {nullptr}

protected

{nullptr};

Referenced by show_switcher_status().

m_ams_dry_ctr_win

AMSDryCtrWin* Slic3r::GUI::AMSControl::m_ams_dry_ctr_win

protected

Referenced by AMSControl(), ~AMSControl(), msw_rescale(), and UpdateAmsDryControl().

m_ams_info

std::vector<AMSinfo> Slic3r::GUI::AMSControl::m_ams_info

protected

Referenced by CreateAms(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), get_filament_id(), GetCanColour(), on_extrusion_cali(), on_filament_load(), on_filament_unload(), parse_object(), Reset(), SetAmsStep(), and UpdateAms().

m_ams_introduce_popup

AmsIntroducePopup Slic3r::GUI::AMSControl::m_ams_introduce_popup

protected

Referenced by AMSControl().

m_ams_item_list

std::map<std::string, AmsItem*> Slic3r::GUI::AMSControl::m_ams_item_list

protected

Referenced by AmsSelectedSwitch(), ClearAms(), createAms(), createAmsPanel(), Enable(), findFirstMode(), GetCurrentCan(), IsAmsInRightPanel(), msw_rescale(), PlayRridLoading(), SetAmsStep(), SetExtruder(), StopRridLoading(), SwitchAms(), and UpdateAms().

m_ams_model

AMSModel Slic3r::GUI::AMSControl::m_ams_model {AMSModel::EXT_AMS}

{AMSModel::EXT_AMS};

Referenced by SetAmsModel(), and UpdateAms().

m_ams_preview_list

std::map<std::string, AMSPreview*> Slic3r::GUI::AMSControl::m_ams_preview_list

protected

Referenced by AddAmsPreview(), AddAmsPreview(), ClearAms(), Enable(), msw_rescale(), SwitchAms(), and UpdateAms().

m_ams_selection

std::map<std::string, int> Slic3r::GUI::AMSControl::m_ams_selection

protected

m_ams_tip

Label* Slic3r::GUI::AMSControl::m_ams_tip {nullptr}

protected

{nullptr};

m_amswin

wxWindow* Slic3r::GUI::AMSControl::m_amswin {nullptr}

protected

{nullptr};

Referenced by AMSControl(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), EnterExtraAMSMode(), EnterGenericAMSMode(), EnterNoneAMSMode(), show_auto_refill(), show_switcher_status(), and UpdateAms().

m_button_ams_setting

wxStaticBitmap* Slic3r::GUI::AMSControl::m_button_ams_setting {nullptr}

protected

{nullptr};

Referenced by AMSControl(), Enable(), enable_ams_setting(), and msw_rescale().

m_button_ams_setting_hover

ScalableBitmap Slic3r::GUI::AMSControl::m_button_ams_setting_hover

protected

Referenced by AMSControl(), and msw_rescale().

m_button_ams_setting_normal

ScalableBitmap Slic3r::GUI::AMSControl::m_button_ams_setting_normal

protected

Referenced by AMSControl(), and msw_rescale().

m_button_ams_setting_press

ScalableBitmap Slic3r::GUI::AMSControl::m_button_ams_setting_press

protected

Referenced by AMSControl(), and msw_rescale().

m_button_auto_refill

Button* Slic3r::GUI::AMSControl::m_button_auto_refill { nullptr }

protected

{ nullptr };

Referenced by AMSControl(), Enable(), msw_rescale(), and show_auto_refill().

m_button_extruder_back

Button* Slic3r::GUI::AMSControl::m_button_extruder_back {nullptr}

protected

{nullptr};

Referenced by AMSControl(), Enable(), EnableUnLoadFilamentBtn(), and msw_rescale().

m_button_extruder_feed

Button* Slic3r::GUI::AMSControl::m_button_extruder_feed {nullptr}

protected

{nullptr};

Referenced by AMSControl(), Enable(), EnableLoadFilamentBtn(), and msw_rescale().

m_current_ams

std::string Slic3r::GUI::AMSControl::m_current_ams

protected

Referenced by AmsSelectedSwitch(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), get_filament_id(), GetCurentAms(), on_extrusion_cali(), on_filament_load(), and on_filament_unload().

m_current_select

std::string Slic3r::GUI::AMSControl::m_current_select

Referenced by SwitchAms().

m_current_show_ams_left

std::string Slic3r::GUI::AMSControl::m_current_show_ams_left

protected

Referenced by AmsSelectedSwitch(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), GetCurentShowAms(), and SwitchAms().

m_current_show_ams_right

std::string Slic3r::GUI::AMSControl::m_current_show_ams_right

protected

Referenced by AmsSelectedSwitch(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), GetCurentShowAms(), and SwitchAms().

m_current_slot_left

std::string Slic3r::GUI::AMSControl::m_current_slot_left

protected

m_current_slot_right

std::string Slic3r::GUI::AMSControl::m_current_slot_right

protected

m_dev_id

std::string Slic3r::GUI::AMSControl::m_dev_id

protected

Referenced by Reset(), and UpdateAms().

m_down_road

AMSRoadDownPart* Slic3r::GUI::AMSControl::m_down_road { nullptr }

protected

{ nullptr };

Referenced by AMSControl(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), msw_rescale(), SetAmsStep(), and SwitchAms().

m_ext_image_list

std::map<std::string, AMSExtImage*> Slic3r::GUI::AMSControl::m_ext_image_list

protected

Referenced by ClearAms(), createAmsPanel(), and msw_rescale().

m_ext_info

std::vector<AMSinfo> Slic3r::GUI::AMSControl::m_ext_info

protected

Referenced by CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), get_filament_id(), Reset(), SetAmsStep(), and UpdateAms().

m_ext_model

AMSModel Slic3r::GUI::AMSControl::m_ext_model {AMSModel::EXT_AMS}

{AMSModel::EXT_AMS};

Referenced by SetAmsModel().

m_extruder

AMSextruder* Slic3r::GUI::AMSControl::m_extruder {nullptr}

protected

{nullptr};

Referenced by AMSControl(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), EnterExtraAMSMode(), EnterGenericAMSMode(), EnterNoneAMSMode(), msw_rescale(), SetAmsStep(), SetExtruder(), and UpdateAms().

m_filament_load_step

::StepIndicator* Slic3r::GUI::AMSControl::m_filament_load_step {nullptr}

protected

{nullptr};

Referenced by Enable().

m_filament_unload_step

::StepIndicator* Slic3r::GUI::AMSControl::m_filament_unload_step {nullptr}

protected

{nullptr};

m_filament_vt_load_step

::StepIndicator* Slic3r::GUI::AMSControl::m_filament_vt_load_step {nullptr}

protected

{nullptr};

m_Humidity_tip_popup

AmsHumidityTipPopup Slic3r::GUI::AMSControl::m_Humidity_tip_popup

protected

Referenced by AMSControl(), and msw_rescale().

m_img_ams_backup

wxStaticBitmap* Slic3r::GUI::AMSControl::m_img_ams_backup {nullptr}

protected

{nullptr};

m_img_amsmapping_tip

wxStaticBitmap* Slic3r::GUI::AMSControl::m_img_amsmapping_tip {nullptr}

protected

{nullptr};

m_img_vams_tip

wxStaticBitmap* Slic3r::GUI::AMSControl::m_img_vams_tip {nullptr}

protected

{nullptr};

m_is_none_ams_mode

AMSModel Slic3r::GUI::AMSControl::m_is_none_ams_mode {AMSModel::EXT_AMS}

{AMSModel::EXT_AMS};

Referenced by EnterExtraAMSMode(), EnterGenericAMSMode(), and EnterNoneAMSMode().

m_item_ids

std::vector<std::vector<std::string> > Slic3r::GUI::AMSControl::m_item_ids { {}, {} }

protected

{ {}, {} };

Referenced by ClearAms(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), findFirstMode(), IsAmsInRightPanel(), and SwitchAms().

m_last_ams_id

std::string Slic3r::GUI::AMSControl::m_last_ams_id = ""

protected

Referenced by SetAmsStep().

m_last_tray_id

std::string Slic3r::GUI::AMSControl::m_last_tray_id = ""

protected

Referenced by SetAmsStep().

m_left_page_index

int Slic3r::GUI::AMSControl::m_left_page_index = 0

protected

Referenced by AddAms(), AddAms(), and ClearAms().

m_panel_down_road

wxPanel* Slic3r::GUI::AMSControl::m_panel_down_road { nullptr }

protected

{ nullptr };

Referenced by AMSControl().

m_panel_prv_left

wxScrolledWindow* Slic3r::GUI::AMSControl::m_panel_prv_left {nullptr}

protected

{nullptr};

Referenced by AMSControl(), AddAmsPreview(), AddAmsPreview(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), EnterExtraAMSMode(), and EnterNoneAMSMode().

m_panel_prv_right

wxScrolledWindow* Slic3r::GUI::AMSControl::m_panel_prv_right {nullptr}

protected

{nullptr};

Referenced by AMSControl(), AddAmsPreview(), AddAmsPreview(), CreateAmsDoubleNozzle(), and CreateAmsSingleNozzle().

m_panel_virtual

StaticBox* Slic3r::GUI::AMSControl::m_panel_virtual {nullptr}

protected

{nullptr};

m_percent_humidity_dry_popup

uiAmsPercentHumidityDryPopup* Slic3r::GUI::AMSControl::m_percent_humidity_dry_popup

protected

Referenced by AMSControl(), msw_rescale(), and UpdateAms().

m_right_page_index

int Slic3r::GUI::AMSControl::m_right_page_index = 0

protected

Referenced by AddAms(), AddAms(), and ClearAms().

m_simplebook_ams_left

wxSimplebook* Slic3r::GUI::AMSControl::m_simplebook_ams_left {nullptr}

protected

{nullptr};

Referenced by AMSControl(), AddAms(), AddAms(), ClearAms(), CreateAms(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), EnterExtraAMSMode(), EnterNoneAMSMode(), and SwitchAms().

m_simplebook_ams_right

wxSimplebook* Slic3r::GUI::AMSControl::m_simplebook_ams_right { nullptr }

protected

{ nullptr };

Referenced by AMSControl(), AddAms(), AddAms(), ClearAms(), CreateAmsDoubleNozzle(), CreateAmsSingleNozzle(), and SwitchAms().

m_simplebook_bottom

wxSimplebook* Slic3r::GUI::AMSControl::m_simplebook_bottom {nullptr}

protected

{nullptr};

m_single_nozzle_no_ams

bool Slic3r::GUI::AMSControl::m_single_nozzle_no_ams = { true }

{ true };

Referenced by CreateAms().

m_sizer_ams_area_left

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_area_left {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_ams_area_right

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_area_right {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_ams_body

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_body {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_ams_items

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_items {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_ams_option

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_option {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_ams_tips

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_ams_tips {nullptr}

protected

{nullptr};

m_sizer_body

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_body {nullptr}

protected

{nullptr};

Referenced by AMSControl(), show_switcher_status(), and UpdateAms().

m_sizer_down_road

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_down_road { nullptr }

protected

{ nullptr };

Referenced by AMSControl().

m_sizer_option_left

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_option_left {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_option_mid

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_option_mid {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_option_right

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_option_right {nullptr}

protected

{nullptr};

Referenced by AMSControl().

m_sizer_prv_left

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_prv_left {nullptr}

protected

{nullptr};

Referenced by AMSControl(), AddAmsPreview(), AddAmsPreview(), ClearAms(), CreateAms(), and CreateAmsDoubleNozzle().

m_sizer_prv_right

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_prv_right {nullptr}

protected

{nullptr};

Referenced by AMSControl(), AddAmsPreview(), AddAmsPreview(), ClearAms(), CreateAms(), CreateAmsDoubleNozzle(), and CreateAmsSingleNozzle().

m_sizer_right_tip

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_right_tip {nullptr}

protected

{nullptr};

Referenced by ShowFilamentTip().

m_sizer_vams_tips

wxBoxSizer* Slic3r::GUI::AMSControl::m_sizer_vams_tips {nullptr}

protected

{nullptr};

m_switcher

SwitcherImage* Slic3r::GUI::AMSControl::m_switcher {nullptr}

protected

{nullptr};       // Orca: filament-switch routing glyph (hidden unless a switch is installed)

Referenced by AMSControl(), and UpdateAms().

m_tip_load_info

Label* Slic3r::GUI::AMSControl::m_tip_load_info {nullptr}

protected

{nullptr};

Referenced by ShowFilamentTip().

m_tip_right_top

wxStaticText* Slic3r::GUI::AMSControl::m_tip_right_top {nullptr}

protected

{nullptr};

Referenced by ShowFilamentTip().

m_total_ext_count

int Slic3r::GUI::AMSControl::m_total_ext_count = 1

protected

Referenced by AMSControl(), AddAms(), AddAms(), createAmsPanel(), IsAmsInRightPanel(), SwitchAms(), and UpdateAms().

m_vams_info

Caninfo Slic3r::GUI::AMSControl::m_vams_info

protected

m_vams_lib

AMSLib* Slic3r::GUI::AMSControl::m_vams_lib {nullptr}

protected

{nullptr};

m_vams_road

AMSRoad* Slic3r::GUI::AMSControl::m_vams_road {nullptr}

protected

{nullptr};

m_vams_sizer

wxBoxSizer* Slic3r::GUI::AMSControl::m_vams_sizer {nullptr}

protected

{nullptr};

pair_id

std::vector<std::pair<std::string, std::string> > Slic3r::GUI::AMSControl::pair_id

protected

Referenced by ClearAms(), CreateAmsDoubleNozzle(), findFirstMode(), SetAmsStep(), and SwitchAms().

tipPanel

wxPanel* Slic3r::GUI::AMSControl::tipPanel {nullptr}

protected

{nullptr};

Referenced by show_switcher_status().

tipSizer

wxBoxSizer* Slic3r::GUI::AMSControl::tipSizer {nullptr}

protected

{nullptr};

Referenced by show_switcher_status().

tipText

wxStaticText* Slic3r::GUI::AMSControl::tipText {nullptr}

protected

{nullptr};

Referenced by show_switcher_status().

---

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

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