Slic3r::GUI::AmsMapingPopup Class Reference

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

Inheritance diagram for Slic3r::GUI::AmsMapingPopup:

Collaboration diagram for Slic3r::GUI::AmsMapingPopup:

Public Types
using	ResetCallback = std::function<void(const std::string&)>

Public Member Functions
	AmsMapingPopup (wxWindow *parent, bool use_in_sync_dialog=false)
	~AmsMapingPopup ()
bool	get_use_in_sync_dialog ()
void	set_sizer_title (wxBoxSizer *sizer, wxString text)
wxBoxSizer *	create_split_sizer (wxWindow *parent, wxString text)
void	set_send_win (wxWindow *win)
void	update_materials_list (std::vector< std::string > list)
void	set_tag_texture (std::string texture)
void	update (MachineObject *obj, const std::vector< FilamentInfo > &ams_mapping_result, bool use_dynamic_switch=false, std::optional< PrintFromType > print_type=std::nullopt)
void	update_rack_select (MachineObject *obj, bool use_dynamic_switch, std::optional< PrintFromType > print_type)
void	update_items_check_state (const std::vector< FilamentInfo > &ams_mapping_result)
void	update_ams_data_multi_machines ()
void	add_ams_mapping (std::vector< TrayData > tray_data, bool remain_detect_flag, wxWindow *container, wxBoxSizer *sizer)
void	add_ext_ams_mapping (TrayData tray_data, MappingItem *item)
void	set_current_filament_id (int id)
int	get_current_filament_id ()
bool	is_match_material (std::string material) const
void	on_left_down (wxMouseEvent &evt)
virtual void	OnDismiss () wxOVERRIDE
virtual bool	ProcessLeftDown (wxMouseEvent &event) wxOVERRIDE
void	paintEvent (wxPaintEvent &evt)
void	set_parent_item (MaterialItem *item)
void	set_show_type (ShowType type)
void	set_only_show_ext_spool (bool)
std::vector< TrayData >	parse_ams_mapping (const std::map< std::string, DevAms *, NumericStrCompare > &amsList)
void	reset_ams_info ()
void	set_reset_callback (ResetCallback callback)
void	show_reset_button ()
void	set_material_index_str (std::string str)
const std::string &	get_material_index_str ()
void	msw_rescale ()
void	EnableExtMappingFilaTypeCheck (bool to_check=true)
bool	Create (wxWindow *parent, int flags=wxBORDER_NONE)

Public Attributes
MaterialItem *	m_parent_item { nullptr }
wxWindow *	send_win { nullptr }
std::vector< std::string >	m_materials_list
std::vector< wxBoxSizer * >	m_amsmapping_container_sizer_list
std::vector< MappingContainer * >	m_amsmapping_container_list
std::vector< MappingItem * >	m_mapping_item_list
bool	m_has_unmatch_filament {false}
int	m_current_filament_id
ShowType	m_show_type {ShowType::RIGHT}
std::string	m_tag_material
wxScrolledWindow *	m_scrolled_window {nullptr}
wxBoxSizer *	m_sizer_main {nullptr}
wxBoxSizer *	m_sizer_main_h {nullptr}
wxBoxSizer *	m_sizer_ams_v {nullptr}
wxBoxSizer *	m_sizer_ams {nullptr}
wxBoxSizer *	m_sizer_ams_left {nullptr}
wxBoxSizer *	m_sizer_ams_right {nullptr}
wxBoxSizer *	m_sizer_ams_left_horizonal {nullptr}
wxBoxSizer *	m_sizer_ams_right_horizonal {nullptr}
wxBoxSizer *	m_sizer_ams_basket_left { nullptr }
wxBoxSizer *	m_sizer_ams_basket_right { nullptr }
wxBoxSizer *	m_sizer_list {nullptr}
MappingItem *	m_left_extra_slot {nullptr}
MappingItem *	m_right_extra_slot {nullptr}
wxPanel *	m_left_marea_panel {nullptr}
wxPanel *	m_right_marea_panel { nullptr }
wxPanel *	m_left_first_text_panel {nullptr}
wxPanel *	m_right_first_text_panel {nullptr}
wgtMsgPanel *	m_ams_tips_msg_panel {nullptr}
wxPanel *	m_split_line_panel {nullptr}
wxBoxSizer *	m_left_split_ams_sizer {nullptr}
wxBoxSizer *	m_right_split_ams_sizer {nullptr}
wxBoxSizer *	m_right_split_ext_sizer { nullptr }
Label *	m_left_tips {nullptr}
Label *	m_right_tips {nullptr}
ScalableButton *	m_reset_btn {nullptr}
wxString	m_single_tip_text
wxString	m_left_tip_text
wxString	m_right_tip_text
wxString	m_ams_tips_panel_text
wxBoxSizer *	m_sizer_split_ams_left
wxBoxSizer *	m_sizer_split_ams_right
bool	m_mapping_from_multi_machines {false}

Protected Member Functions
virtual bool	ShouldDismissOnTopWindowDeactivate ()

Private Member Functions
void	update_title (MachineObject *obj)
void	update_ams_tips (MachineObject *obj)
void	update_mapping_items (MachineObject *obj, const std::vector< FilamentInfo > &ams_mapping_result, bool use_dynamic_switch)
void	OnNozzleMappingSelected (wxCommandEvent &evt)
void	update_flush_waste (MachineObject *obj)

Private Attributes
bool	m_use_in_sync_dialog = false
bool	m_ext_mapping_filatype_check = true
wxStaticText *	m_title_text { nullptr }
wgtDeviceNozzleRackSelect *	m_rack_nozzle_select {nullptr}
DevIconLabel *	m_flush_warning_panel
std::weak_ptr< DevNozzleRack >	m_rack
ResetCallback	m_reset_callback {nullptr}
std::string	m_material_index

Detailed Description

Member Typedef Documentation

ResetCallback

using Slic3r::GUI::AmsMapingPopup::ResetCallback = std::function<void(const std::string&)>

Constructor & Destructor Documentation

AmsMapingPopup()

Slic3r::GUI::AmsMapingPopup::AmsMapingPopup	(	wxWindow *	parent,
		bool	use_in_sync_dialog = false )

                                                                        :
    PopupWindow(parent, wxBORDER_NONE | wxPU_CONTAINS_CONTROLS), m_use_in_sync_dialog(use_in_sync_dialog)
 {
     Bind(wxEVT_PAINT, &AmsMapingPopup::paintEvent, this);
 
#ifdef __APPLE__
     Bind(wxEVT_LEFT_DOWN, &AmsMapingPopup::on_left_down, this);
     Bind(wxEVT_MOTION, &AmsMapingPopup::on_mouse_move, this);
#endif
 
     SetBackgroundColour(*wxWHITE);
 
     m_sizer_main = new wxBoxSizer(wxVERTICAL);
     m_sizer_main_h = new wxBoxSizer(wxHORIZONTAL);
     m_sizer_ams = new wxBoxSizer(wxHORIZONTAL);
     m_sizer_ams_left = new wxBoxSizer(wxVERTICAL);
     m_sizer_ams_right = new wxBoxSizer(wxVERTICAL);
     m_sizer_ams_left_horizonal = new wxBoxSizer(wxHORIZONTAL);
     m_sizer_ams_right_horizonal = new wxBoxSizer(wxHORIZONTAL);
     m_sizer_ams_basket_left = new wxBoxSizer(wxVERTICAL);
     m_sizer_ams_basket_right = new wxBoxSizer(wxVERTICAL);
 
     auto title_panel = new wxPanel(this, wxID_ANY);
     title_panel->SetBackgroundColour(StateColor::darkModeColorFor("#F1F1F1"));
     title_panel->SetSize(wxSize(-1, FromDIP(30)));
     title_panel->SetMinSize(wxSize(-1, FromDIP(30)));
 
     m_scrolled_window = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxHSCROLL);
     m_scrolled_window->SetBackgroundColour(*wxWHITE);
     m_scrolled_window->SetScrollRate(0, FromDIP(20));
 
     wxBoxSizer *title_sizer_h= new wxBoxSizer(wxHORIZONTAL);
     wxBoxSizer *title_sizer_v = new wxBoxSizer(wxVERTICAL);
 
     m_title_text = new wxStaticText(title_panel, wxID_ANY, _L("AMS Slots"));
     m_title_text->SetForegroundColour(wxColour("#262E30"));
     m_title_text->SetFont(::Label::Body_16);
     title_sizer_v->Add(m_title_text, 0, wxALIGN_LEFT | wxLEFT,  FromDIP(15));
     title_sizer_h->Add(title_sizer_v, 1, wxALIGN_CENTER, 5);
     title_panel->SetSizer(title_sizer_h);
     title_panel->Layout();
     title_panel->Fit();
 
     m_left_marea_panel = new wxPanel(m_scrolled_window);
     m_left_marea_panel->SetName("left");
     m_right_marea_panel = new wxPanel(m_scrolled_window);
     m_right_marea_panel->SetName("right");
     m_left_first_text_panel  = new wxPanel(m_left_marea_panel);
     m_right_first_text_panel = new wxPanel(m_right_marea_panel);
     auto sizer_temp = new wxBoxSizer(wxHORIZONTAL);
     /*left ext*/
     m_left_extra_slot = new MappingItem(m_left_marea_panel);
     m_left_extra_slot->m_ams_id = VIRTUAL_TRAY_DEPUTY_ID;
     m_left_extra_slot->m_slot_id = 0;
     m_left_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
     m_left_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
     m_left_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
 
     auto left_panel = new wxPanel(m_left_marea_panel);
     left_panel->SetSize(wxSize(FromDIP(182), FromDIP(60)));
     left_panel->SetMinSize(wxSize(FromDIP(182), FromDIP(60)));
     left_panel->SetMaxSize(wxSize(FromDIP(182), FromDIP(60)));
 
     sizer_temp->Add(m_left_extra_slot);
     sizer_temp->Add(left_panel);
 
     /*right ext*/
     m_right_extra_slot = new MappingItem(m_right_marea_panel);
     m_right_extra_slot->m_ams_id = VIRTUAL_TRAY_MAIN_ID;
     m_right_extra_slot->m_slot_id = 0;
     m_right_extra_slot->SetSize(wxSize(FromDIP(48), FromDIP(60)));
     m_right_extra_slot->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
     m_right_extra_slot->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
 
     std::string amp_pt = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
     m_single_tip_text = _L("Please select from the following filaments");
     m_left_tip_text = wxString::Format(_L("Select filament that installed to the %s"),
         _L(DevPrinterConfigUtil::get_toolhead_display_name(amp_pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)));
     m_right_tip_text = wxString::Format(_L("Select filament that installed to the %s"),
         _L(DevPrinterConfigUtil::get_toolhead_display_name(amp_pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)));
 
     m_left_tips = new Label(m_left_first_text_panel);
     m_left_tips->SetForegroundColour(StateColor::darkModeColorFor("0x262E30"));
     m_left_tips->SetBackgroundColour(StateColor::darkModeColorFor("0xFFFFFF"));
     m_left_tips->SetFont(::Label::Body_13);
     m_left_tips->SetLabel(m_left_tip_text);
     m_left_first_text_panel->SetSizer(m_sizer_ams_left_horizonal);
 
     m_sizer_ams_left->Add(m_left_first_text_panel, 0, wxEXPAND | wxBOTTOM | wxTOP , FromDIP(8));
     m_left_split_ams_sizer = create_split_sizer(m_left_marea_panel, _L("Left AMS"));
     m_sizer_ams_left->Add(m_left_split_ams_sizer, 0, wxEXPAND, 0);
     m_sizer_ams_left->Add(m_sizer_ams_basket_left, 0, wxEXPAND|wxTOP, FromDIP(8));
     m_sizer_ams_left->Add(create_split_sizer(m_left_marea_panel, _L("External")), 0, wxEXPAND|wxTOP, FromDIP(8));
     //m_sizer_ams_left->Add(m_left_extra_slot, 0, wxEXPAND|wxTOP, FromDIP(8));
     m_sizer_ams_left->Add(sizer_temp, 0, wxEXPAND | wxTOP, FromDIP(8));
 
     m_right_tips = new Label(m_right_first_text_panel);
     m_right_tips->SetForegroundColour(StateColor::darkModeColorFor("0x262E30"));
     m_right_tips->SetBackgroundColour(StateColor::darkModeColorFor("0xFFFFFF"));
     m_right_tips->SetFont(::Label::Body_13);
     m_right_tips->SetLabel(m_right_tip_text);
 
     m_sizer_ams_right_horizonal->AddStretchSpacer();
 
     m_reset_btn = new ScalableButton(m_scrolled_window, wxID_ANY, wxGetApp().dark_mode() ? "erase_dark" : "erase", wxEmptyString, wxDefaultSize, wxDefaultPosition,
                                      wxBU_EXACTFIT | wxNO_BORDER, true, 14);
     m_reset_btn->SetName(wxGetApp().dark_mode() ? "erase_dark" : "erase");
     m_reset_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) { reset_ams_info(); });
     m_reset_btn->SetBackgroundColour(*wxWHITE);
     m_reset_btn->SetToolTip(_L("Reset current filament mapping"));
 
     m_sizer_ams_right_horizonal->AddStretchSpacer();
     m_sizer_ams_right_horizonal->AddSpacer(FromDIP(5));
     m_reset_btn->Hide();
     m_right_first_text_panel->SetSizer(m_sizer_ams_right_horizonal);
     const int same_height = 20;
     m_left_first_text_panel->SetMaxSize(wxSize(-1, FromDIP(same_height)));
     m_right_first_text_panel->SetMaxSize(wxSize(-1, FromDIP(same_height)));
 
     // content_sizer
     wxSizer *content_ams_sizer = new wxBoxSizer(wxVERTICAL);
     m_right_split_ams_sizer = create_split_sizer(m_right_marea_panel, _L("Right AMS"));
     m_right_split_ext_sizer = create_split_sizer(m_right_marea_panel, _L("External"));
     content_ams_sizer->Add(m_right_split_ams_sizer, 0, wxEXPAND, 0);
     content_ams_sizer->Add(m_sizer_ams_basket_right, 0, wxEXPAND | wxTOP, FromDIP(8));
     content_ams_sizer->Add(m_right_split_ext_sizer, 0, wxEXPAND | wxTOP, FromDIP(8));
     content_ams_sizer->Add(m_right_extra_slot, 0, wxEXPAND | wxTOP, FromDIP(8));
 
     wxSizer *content_sizer = new wxBoxSizer(wxHORIZONTAL);
     content_sizer->Add(content_ams_sizer, 1, wxEXPAND | wxLEFT);
 
     m_flush_warning_panel = new DevIconLabel(m_right_marea_panel, "warning", ""); // Orca: dev_warning icon absent; use the shipped generic warning glyph
     m_flush_warning_panel->SetAllBackgroundColor(StateColor::darkModeColorFor("#FFFFE0"));
     m_flush_warning_panel->GetLabelItem()->SetForegroundColour(StateColor::darkModeColorFor("#F09A17"));
     m_flush_warning_panel->Show(false);
 
     m_sizer_ams_right->Add(m_right_first_text_panel, 0, wxEXPAND | wxBOTTOM | wxTOP, FromDIP(8));
     m_sizer_ams_right->Add(m_flush_warning_panel, 0, wxBOTTOM | wxALIGN_LEFT, FromDIP(8));
     m_sizer_ams_right->Add(content_sizer, 0, wxEXPAND, 0);
 
     m_rack_nozzle_select = new wgtDeviceNozzleRackSelect(m_scrolled_window);
     m_rack_nozzle_select->Bind(EVT_NOZZLE_SELECT_CHANGED, &AmsMapingPopup::OnNozzleMappingSelected, this);
     m_rack_nozzle_select->Bind(EVT_NOZZLE_SELECT_CLICKED, [this](wxCommandEvent &e) { this->Dismiss(); });
     m_rack_nozzle_select->Show(false);
 
     m_ams_tips_msg_panel = new wgtMsgPanel(m_scrolled_window);
 
     m_left_marea_panel->SetSizer(m_sizer_ams_left);
     m_right_marea_panel->SetSizer(m_sizer_ams_right);
 
     m_sizer_ams_v = new wxBoxSizer(wxVERTICAL);
 
     m_split_line_panel = new wxPanel(m_scrolled_window, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(1), -1));
     m_split_line_panel->SetBackgroundColour(*wxWHITE);
     m_split_line_panel->Bind(wxEVT_PAINT, [this](wxPaintEvent& evt) {
         wxPaintDC dc(m_split_line_panel);
         dc.SetPen(wxPen(wxColour(0xAC, 0xAC, 0xAC), 1, wxPENSTYLE_SHORT_DASH));
         dc.DrawLine(0, FromDIP(20), 0, m_sizer_ams->GetSize().GetHeight());
     });
 
     //m_sizer_ams->Add(m_left_marea_panel, 0, wxEXPAND, FromDIP(0));
     m_sizer_ams->Add(m_left_marea_panel, 0, wxRIGHT, FromDIP(10));
     m_sizer_ams->Add(m_split_line_panel, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(7));
     m_sizer_ams->Add(m_right_marea_panel, 0, wxEXPAND | wxLEFT, FromDIP(10));
 
     m_sizer_ams_v->Add(m_reset_btn, 0, wxALIGN_RIGHT);
     m_sizer_ams_v->Add(m_sizer_ams, 0, wxEXPAND | wxBOTTOM, FromDIP(30));
     m_sizer_ams_v->AddStretchSpacer();
     m_sizer_ams_v->Add(m_ams_tips_msg_panel, 0, wxEXPAND | wxBOTTOM, FromDIP(10)); // Orca: wxBOTTOM (REF uses the wxEdge enum by mistake)
 
     m_sizer_main_h->Add(m_sizer_ams_v, 0, wxEXPAND | wxRIGHT, FromDIP(10));
     m_sizer_main_h->Add(m_rack_nozzle_select, 0, wxEXPAND | wxTOP | wxLEFT, FromDIP(15));
 
     m_scrolled_window->SetSizer(m_sizer_main_h);
     m_sizer_main->Add(title_panel, 0, wxEXPAND | wxALL, FromDIP(2));
     m_sizer_main->Add(m_scrolled_window, 1, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(14));
     m_sizer_main->Add( 0, 0, 0, wxTOP, FromDIP(14));
 
     SetSizer(m_sizer_main);
     Layout();
     Fit();
 
     Bind(wxEVT_SHOW, [this](wxShowEvent& e) {
         if (e.IsShown() && m_parent_item)
         {
             auto show_pos = m_parent_item->ClientToScreen(wxPoint(0, 0));
             int  display_idx = wxDisplay::GetFromWindow(m_parent_item);
 
             if (display_idx == wxNOT_FOUND)
                 display_idx = 0;
 
             wxRect screen_size = wxDisplay(display_idx).GetClientArea();
             auto   parent_size = m_parent_item->GetRect();
             auto   content_size = m_sizer_main_h->GetMinSize();
             int    popup_width  = content_size.x + FromDIP(28);
             int    popup_height = content_size.y;
             wxSize popup_size(popup_width, popup_height);
 
              // Horizontal Direction Processing
              if (show_pos.x + popup_size.x > screen_size.GetRight())
              {
                  show_pos.x = screen_size.GetRight() - popup_size.x;
              }
 
              //if popup size bigger than screen
              if (show_pos.x < screen_size.GetLeft())
              {
                  show_pos.x = screen_size.GetLeft();
                  m_scrolled_window->SetMaxSize(wxSize(screen_size.GetWidth(), popup_height));
                  m_scrolled_window->SetMinSize(wxSize(screen_size.GetWidth(), popup_height));
                  m_scrolled_window->SetScrollRate(FromDIP(10), FromDIP(20));
              }
              else
              {
                  m_scrolled_window->SetMaxSize(wxSize(popup_width, popup_height));
                  m_scrolled_window->SetMinSize(wxSize(popup_width, popup_height));
                  m_scrolled_window->SetScrollRate(0, FromDIP(20));
              }
 
              //Vertical Direction Processing
              int available_height_below = screen_size.GetBottom() - (show_pos.y + parent_size.height);
              int available_height_above = show_pos.y - screen_size.GetTop();
 
              if (popup_size.y <= available_height_below)
              {
                   show_pos.y = show_pos.y + parent_size.height;
              }
              else if (popup_size.y <= available_height_above)
              {
                  show_pos.y = show_pos.y - popup_size.y - FromDIP(34) - FromDIP(14);// title_height = FromDIP(30) + FromDIP(4)  padding = FromDIP(14)
              }
              else
              {
                  int max_available_height;
 
                  if (available_height_below >= available_height_above) {
                      show_pos.y           = show_pos.y + parent_size.height;
                      max_available_height = available_height_below;
                  } else {
                      show_pos.y           = screen_size.GetTop();
                      max_available_height = available_height_above;
                  }
 
                  int title_and_padding = FromDIP(30) + FromDIP(4) + FromDIP(14);
                  int max_scroll_height = max_available_height - title_and_padding;
 
                  m_scrolled_window->SetMaxSize(wxSize(m_scrolled_window->GetMaxSize().x,max_scroll_height));
              }
              Layout();
              Fit();
              this->Move(show_pos);
         }
     });
 }

References PopupWindow::PopupWindow(), _L, Label::Body_13, Label::Body_16, create_split_sizer(), StateColor::darkModeColorFor(), DEPUTY_EXTRUDER_ID, Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), Slic3r::LowerCase, m_ams_tips_msg_panel, m_flush_warning_panel, m_left_extra_slot, m_left_first_text_panel, m_left_marea_panel, m_left_split_ams_sizer, m_left_tip_text, m_left_tips, m_parent_item, m_rack_nozzle_select, m_reset_btn, m_right_extra_slot, m_right_first_text_panel, m_right_marea_panel, m_right_split_ams_sizer, m_right_split_ext_sizer, m_right_tip_text, m_right_tips, m_scrolled_window, m_single_tip_text, m_sizer_ams, m_sizer_ams_basket_left, m_sizer_ams_basket_right, m_sizer_ams_left, m_sizer_ams_left_horizonal, m_sizer_ams_right, m_sizer_ams_right_horizonal, m_sizer_ams_v, m_sizer_main, m_sizer_main_h, m_split_line_panel, m_title_text, m_use_in_sync_dialog, MAIN_EXTRUDER_ID, Slic3r::Nozzle, on_left_down(), OnNozzleMappingSelected(), paintEvent(), reset_ams_info(), VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, and wxStaticText.

Here is the call graph for this function:

~AmsMapingPopup()

Slic3r::GUI::AmsMapingPopup::~AmsMapingPopup ( )

inline

{};

Member Function Documentation

add_ams_mapping()

void Slic3r::GUI::AmsMapingPopup::add_ams_mapping	(	std::vector< TrayData >	tray_data,
		bool	remain_detect_flag,
		wxWindow *	container,
		wxBoxSizer *	sizer )

{
    sizer->Add(0, 0, 0, wxLEFT, FromDIP(6));
 
    for (auto i = 0; i < tray_data.size(); i++) {
 
        // set button
        MappingItem* m_mapping_item = new MappingItem(container);
        m_mapping_item->send_win = send_win;
        m_mapping_item->m_ams_id = tray_data[i].ams_id;
        m_mapping_item->m_slot_id = tray_data[i].slot_id;
        // Orca: transition_tridid here has no total-extruder-count overload; label the virtual (ext)
        // slots Ext-R / Ext-L inline in the two-nozzle left+right views (matches that overload's result).
        if ((m_show_type == ShowType::LEFT_AND_RIGHT || m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC)
            && (tray_data[i].id == VIRTUAL_TRAY_MAIN_ID || tray_data[i].id == VIRTUAL_TRAY_DEPUTY_ID)) {
            m_mapping_item->set_tray_index(tray_data[i].id == VIRTUAL_TRAY_MAIN_ID ? _L("Ext-R") : _L("Ext-L"));
        } else {
            m_mapping_item->set_tray_index(wxGetApp().transition_tridid(tray_data[i].id));
        }
 
        m_mapping_item->SetSize(wxSize(FromDIP(48), FromDIP(60)));
        m_mapping_item->SetMinSize(wxSize(FromDIP(48), FromDIP(60)));
        m_mapping_item->SetMaxSize(wxSize(FromDIP(48), FromDIP(60)));
 
        // traversal if can pick the item or not
        bool can_pick_the_item = true;
        std::optional<wxString> item_tooltip_msg;
        // check filament area
        if (m_use_in_sync_dialog) {
            if (can_pick_the_item) {
                if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
                    can_pick_the_item = !devPrinterUtil::IsVirtualSlot(m_mapping_item->m_ams_id);
                    if (!can_pick_the_item) {
                        item_tooltip_msg = _L(
                            "External spools are not supported since Filament Track Switch has been installed. If you want to use an external spool, please uninstall it.");
                    }
                }
            }
        }
        else {
            if (can_pick_the_item) {
                // LEFT_AND_RIGHT — the fallback when a filament has no entry in the
                // nozzle map — keeps both panels pickable.
                auto parent = container->GetParent();
                if (parent == m_left_marea_panel) {
                    can_pick_the_item = (m_show_type == ShowType::LEFT || m_show_type == ShowType::LEFT_AND_RIGHT);
                } else if (parent == m_right_marea_panel) {
                    if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
                        can_pick_the_item = !devPrinterUtil::IsVirtualSlot(m_mapping_item->m_ams_id);
                        if (!can_pick_the_item) {
                            item_tooltip_msg = _L(
                                "External spools are not supported since Filament Track Switch has been installed. If you want to use an external spool, please uninstall it.");
                        }
                    } else if (m_show_type != ShowType::RIGHT && m_show_type != ShowType::LEFT_AND_RIGHT) {
                        can_pick_the_item = false;
                    }
                }
            }
        }
 
        // check filament type
        if (can_pick_the_item) {
            if (tray_data[i].type == NORMAL && !is_match_material(tray_data[i].filament_type)){
                can_pick_the_item = false;
            } else if(tray_data[i].type == EMPTY){
                // Mapping to an empty slot is only allowed from the multi-machine send page,
                // which maps onto EMPTY placeholder trays.
                can_pick_the_item = m_mapping_from_multi_machines;
            }
        }
 
        wxColour display_color;
        if (can_pick_the_item) {
            display_color = tray_data[i].type == NORMAL ? tray_data[i].colour : wxColour(0xCE, 0xCE, 0xCE);
        } else {
            display_color = wxColour(0xEE, 0xEE, 0xEE);
        }
 
        wxString display_name;
        if (tray_data[i].type == THIRD) {
            display_name = "?";
        } else if (tray_data[i].type == EMPTY) {
            display_name = "-";
        } else {
            display_name = tray_data[i].name;
        }
 
        m_mapping_item->set_data(m_tag_material, display_color, display_name, remain_detect_flag, tray_data[i], !can_pick_the_item, item_tooltip_msg);
        m_mapping_item->Bind(wxEVT_LEFT_DOWN, [this, can_pick_the_item, m_mapping_item](wxMouseEvent& e) {
            if (can_pick_the_item) {
                m_mapping_item->send_event(m_current_filament_id);
                Dismiss();
            }
        });
 
        sizer->Add(0, 0, 0, wxRIGHT, FromDIP(6));
        sizer->Add(m_mapping_item, 0, wxTOP, FromDIP(1));
        m_mapping_item_list.push_back(m_mapping_item);
    }
}

References _L, Slic3r::GUI::EMPTY, Slic3r::filament_type(), is_match_material(), Slic3r::devPrinterUtil::IsVirtualSlot(), Slic3r::GUI::LEFT, Slic3r::GUI::LEFT_AND_RIGHT, Slic3r::GUI::LEFT_AND_RIGHT_DYNAMIC, Slic3r::GUI::MappingItem::m_ams_id, m_current_filament_id, m_left_marea_panel, m_mapping_from_multi_machines, m_mapping_item_list, m_right_marea_panel, m_show_type, Slic3r::GUI::MappingItem::m_slot_id, m_tag_material, m_use_in_sync_dialog, Slic3r::GUI::NORMAL, Slic3r::GUI::RIGHT, Slic3r::GUI::MappingItem::send_event(), send_win, Slic3r::GUI::MappingItem::send_win, Slic3r::GUI::MappingItem::set_data(), Slic3r::GUI::MappingItem::set_tray_index(), Slic3r::GUI::THIRD, VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, and Slic3r::GUI::wxMouseEvent.

Referenced by update_ams_data_multi_machines(), and update_mapping_items().

Here is the call graph for this function:

Here is the caller graph for this function:

add_ext_ams_mapping()

void Slic3r::GUI::AmsMapingPopup::add_ext_ams_mapping	(	TrayData	tray_data,
		MappingItem *	item )

{
#ifdef __APPLE__
    m_mapping_item_list.push_back(item);
#endif
    // set button
    if (tray_data.type == NORMAL) {
        if (is_match_material(tray_data.filament_type)) {
            item->set_data(m_tag_material, tray_data.colour, tray_data.name, false, tray_data);
        } else {
            item->set_data(m_tag_material, m_ext_mapping_filatype_check ? wxColour(0xEE, 0xEE, 0xEE) : tray_data.colour, tray_data.name, false, tray_data, true);
            m_has_unmatch_filament = true;
        }
 
        item->Bind(wxEVT_LEFT_DOWN, [this, tray_data, item](wxMouseEvent& e) {
            if (!item->GetParent() || !item->GetParent()->IsEnabled()) return;
            if (m_ext_mapping_filatype_check && !is_match_material(tray_data.filament_type)) return;
            item->send_event(m_current_filament_id);
            Dismiss();
        });
    }
 
 
    // temp
    if (tray_data.type == EMPTY) {
        item->set_data(m_tag_material, wxColour(0xCE, 0xCE, 0xCE), "-", false, tray_data);
        item->Bind(wxEVT_LEFT_DOWN, [this, tray_data, item](wxMouseEvent& e) {
            if (!item->GetParent() || !item->GetParent()->IsEnabled()) return;
            item->send_event(m_current_filament_id);
            Dismiss();
        });
    }
 
    // third party
    if (tray_data.type == THIRD) {
        item->set_data(m_tag_material, tray_data.colour, "?", false, tray_data);
        //item->set_data(wxColour(0xCE, 0xCE, 0xCE), "?", tray_data);
        item->Bind(wxEVT_LEFT_DOWN, [this, tray_data, item](wxMouseEvent& e) {
            if (!item->GetParent() || !item->GetParent()->IsEnabled()) return;
            item->send_event(m_current_filament_id);
            Dismiss();
        });
    }
 
    item->set_tray_index(_L("Ext"));
}

References _L, Slic3r::GUI::TrayData::colour, Slic3r::GUI::EMPTY, Slic3r::GUI::TrayData::filament_type, is_match_material(), m_current_filament_id, m_ext_mapping_filatype_check, m_has_unmatch_filament, m_mapping_item_list, m_tag_material, Slic3r::GUI::TrayData::name, Slic3r::GUI::NORMAL, Slic3r::GUI::MappingItem::send_event(), Slic3r::GUI::MappingItem::set_data(), Slic3r::GUI::MappingItem::set_tray_index(), Slic3r::GUI::THIRD, Slic3r::GUI::TrayData::type, and Slic3r::GUI::wxMouseEvent.

Referenced by update_mapping_items().

Here is the call graph for this function:

Here is the caller graph for this function:

Create()

bool PopupWindow::Create ( wxWindow * parent, int flags = wxBORDER_NONE )

inherited

{
    if (!wxPopupTransientWindow::Create(parent, style))
        return false;
#ifdef __WXGTK__
    GetTopParent(parent)->Bind(wxEVT_ACTIVATE, &PopupWindow::topWindowActiavate, this);
#endif
#ifdef __WXOSX__
    if (style & wxPU_CONTAINS_CONTROLS)
    for (auto evt : {wxEVT_LEFT_DOWN, wxEVT_LEFT_UP, wxEVT_LEFT_DCLICK, wxEVT_MOTION, wxEVT_MOUSEWHEEL})
        Bind(evt, &PopupWindow::OnMouseEvent2, this);
#endif
    return true;
}

References GetTopParent(), and style.

Referenced by PopupWindow(), and DropDown::Create().

Here is the call graph for this function:

Here is the caller graph for this function:

create_split_sizer()

wxBoxSizer * Slic3r::GUI::AmsMapingPopup::create_split_sizer	(	wxWindow *	parent,
		wxString	text )

 {
    wxBoxSizer* sizer_split_ams = new wxBoxSizer(wxHORIZONTAL);
    auto ams_title_text = new Label(parent, text);
    ams_title_text->SetFont(::Label::Body_13);
    ams_title_text->SetBackgroundColour(*wxWHITE);
    ams_title_text->SetForegroundColour(0x909090);
    auto m_split_left_line = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_split_left_line->SetBackgroundColour(0xeeeeee);
    m_split_left_line->SetMinSize(wxSize(-1, 1));
    m_split_left_line->SetMaxSize(wxSize(-1, 1));
    sizer_split_ams->Add(0, 0, 0, wxEXPAND, 0);
    sizer_split_ams->Add(ams_title_text, 0, wxALIGN_CENTER, 0);
    sizer_split_ams->Add(m_split_left_line, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND, 0);
    return sizer_split_ams;
 }

References Label::Body_13.

Referenced by AmsMapingPopup().

Here is the caller graph for this function:

EnableExtMappingFilaTypeCheck()

void Slic3r::GUI::AmsMapingPopup::EnableExtMappingFilaTypeCheck ( bool to_check = true )

inline

{ m_ext_mapping_filatype_check = to_check;} ;

References m_ext_mapping_filatype_check.

get_current_filament_id()

int Slic3r::GUI::AmsMapingPopup::get_current_filament_id ( )

inline

{return m_current_filament_id;};

References m_current_filament_id.

get_material_index_str()

const std::string & Slic3r::GUI::AmsMapingPopup::get_material_index_str ( )

inline

{ return m_material_index; }

References m_material_index.

get_use_in_sync_dialog()

bool Slic3r::GUI::AmsMapingPopup::get_use_in_sync_dialog ( )

inline

{ return m_use_in_sync_dialog; }

References m_use_in_sync_dialog.

is_match_material()

bool Slic3r::GUI::AmsMapingPopup::is_match_material

(

std::string

material

)

const

{
    return m_tag_material == material ? true : false;
}

References m_tag_material.

Referenced by add_ams_mapping(), add_ext_ams_mapping(), and on_left_down().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::AmsMapingPopup::msw_rescale

(

)

{
    m_left_extra_slot->msw_rescale();
    m_right_extra_slot->msw_rescale();
    for (auto item : m_mapping_item_list) { item->msw_rescale(); }
    for (auto container : m_amsmapping_container_list) { container->msw_rescale(); }
 
    m_flush_warning_panel->Rescale();
    m_rack_nozzle_select->Rescale();
 
    Fit();
    Refresh();
};

References m_amsmapping_container_list, m_flush_warning_panel, m_left_extra_slot, m_mapping_item_list, m_rack_nozzle_select, and m_right_extra_slot.

on_left_down()

void Slic3r::GUI::AmsMapingPopup::on_left_down

(

wxMouseEvent &

evt

)

{
    auto pos = ClientToScreen(evt.GetPosition());
    {//deal m_reset_btn
        auto& item   = m_reset_btn;
        auto  p_rect = item->ClientToScreen(wxPoint(0, 0));
        auto  left   = item->GetSize();
        if (pos.x > p_rect.x && pos.y > p_rect.y && pos.x < (p_rect.x + item->GetSize().x) && pos.y < (p_rect.y + item->GetSize().y)) {
            reset_ams_info();
            evt.StopPropagation();
            return;
        }
    }
    for (MappingItem *item : m_mapping_item_list) {
        auto p_rect = item->ClientToScreen(wxPoint(0, 0));
        auto left = item->GetSize();
 
        if (pos.x > p_rect.x && pos.y > p_rect.y && pos.x < (p_rect.x + item->GetSize().x) && pos.y < (p_rect.y + item->GetSize().y)) {
            if (item->m_tray_data.type == TrayType::NORMAL) {
                if (!m_ext_mapping_filatype_check && (item->m_ams_id == VIRTUAL_TRAY_MAIN_ID || item->m_ams_id == VIRTUAL_TRAY_DEPUTY_ID)) {
                    // Do nothing
                } else {
                    if(!is_match_material(item->m_tray_data.filament_type)) { return; }
                }
            }
 
            if (item->m_tray_data.type == TrayType::EMPTY && !m_mapping_from_multi_machines) return;
            if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC && devPrinterUtil::IsVirtualSlot(item->m_ams_id)) return;
 
            if ((m_show_type == ShowType::LEFT && item->GetParent()->GetName() == "left") ||
                (m_show_type == ShowType::RIGHT && item->GetParent()->GetName() == "right") ||
                m_show_type == ShowType::LEFT_AND_RIGHT ||
                m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
                item->send_event(m_current_filament_id);
                Dismiss();
                break;
            }
        }
    }
    evt.Skip();
}

References Slic3r::GUI::EMPTY, is_match_material(), Slic3r::devPrinterUtil::IsVirtualSlot(), Slic3r::GUI::LEFT, Slic3r::GUI::LEFT_AND_RIGHT, Slic3r::GUI::LEFT_AND_RIGHT_DYNAMIC, m_current_filament_id, m_ext_mapping_filatype_check, m_mapping_from_multi_machines, m_mapping_item_list, m_reset_btn, m_show_type, Slic3r::GUI::NORMAL, reset_ams_info(), Slic3r::GUI::RIGHT, VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, and Slic3r::GUI::wxMouseEvent.

Referenced by AmsMapingPopup().

Here is the call graph for this function:

Here is the caller graph for this function:

OnDismiss()

void Slic3r::GUI::AmsMapingPopup::OnDismiss ( )

virtual

{
#ifdef __APPLE__
    if (m_tip_popup && m_tip_popup->IsShown ())
        m_tip_popup->Hide();
#endif
}

OnNozzleMappingSelected()

void Slic3r::GUI::AmsMapingPopup::OnNozzleMappingSelected ( wxCommandEvent & evt )

private

{
    if (auto ptr = m_rack.lock()) {
        MachineObject* obj = ptr->GetNozzleSystem()->GetOwner();
        obj->get_nozzle_mapping_result()->SetManualNozzleMappingByFila(m_current_filament_id, m_rack_nozzle_select->GetSelectedNozzlePosID());
        update_flush_waste(obj);
    }
 
    evt.Skip();
    Dismiss();
}

References Slic3r::MachineObject::get_nozzle_mapping_result(), Slic3r::MachineObject::GetNozzleSystem(), Slic3r::DevNozzleSystem::GetOwner(), m_current_filament_id, m_rack, m_rack_nozzle_select, and update_flush_waste().

Referenced by AmsMapingPopup().

Here is the call graph for this function:

Here is the caller graph for this function:

paintEvent()

void Slic3r::GUI::AmsMapingPopup::paintEvent

(

wxPaintEvent &

evt

)

{
    wxPaintDC dc(this);
    dc.SetPen(wxPen(StateColor::darkModeColorFor(wxColour("#009688")), FromDIP(2))); // Orca: colorful accent border for separation (dark-mode aware)
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.DrawRoundedRectangle(0, 0, GetSize().x, GetSize().y, 0);
}

References StateColor::darkModeColorFor().

Referenced by AmsMapingPopup().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_ams_mapping()

std::vector< TrayData > Slic3r::GUI::AmsMapingPopup::parse_ams_mapping

(

const std::map< std::string, DevAms *, NumericStrCompare > &

amsList

)

{
    std::vector<TrayData> m_tray_data;
    for (auto ams_iter = amsList.begin(); ams_iter != amsList.end(); ams_iter++) {
        BOOST_LOG_TRIVIAL(trace) << "ams_mapping ams id " << ams_iter->first.c_str();
 
        auto    ams_indx  = atoi(ams_iter->first.c_str());
        DevAms* ams_group = ams_iter->second;
        std::map<std::string, DevAmsTray*>::const_iterator tray_iter;
 
        for (tray_iter = ams_group->GetTrays().cbegin(); tray_iter != ams_group->GetTrays().cend(); tray_iter++) {
            DevAmsTray* tray_data = tray_iter->second;
            TrayData    td;
 
            td.id = ams_indx * AMS_TOTAL_COUNT + atoi(tray_data->id.c_str());
 
            if (!tray_data->is_exists) {
                td.type = EMPTY;
            } else {
                if (!tray_data->is_tray_info_ready()) {
                    td.type = THIRD;
                } else {
                    td.type          = NORMAL;
                    td.remain        = tray_data->remain;
                    td.colour        = DevAmsTray::decode_color(tray_data->color);
                    td.name          = tray_data->get_display_filament_type();
                    td.filament_type = tray_data->get_filament_type();
                }
            }
 
            m_tray_data.push_back(td);
        }
    }
 
    return m_tray_data;
}

References AMS_TOTAL_COUNT, Slic3r::DevAmsTray::color, Slic3r::GUI::TrayData::colour, Slic3r::DevAmsTray::decode_color(), Slic3r::GUI::EMPTY, Slic3r::GUI::TrayData::filament_type, Slic3r::DevAmsTray::get_display_filament_type(), Slic3r::DevAmsTray::get_filament_type(), Slic3r::DevAms::GetTrays(), Slic3r::DevAmsTray::id, Slic3r::GUI::TrayData::id, Slic3r::DevAmsTray::is_exists, Slic3r::DevAmsTray::is_tray_info_ready(), Slic3r::GUI::TrayData::name, Slic3r::GUI::NORMAL, Slic3r::DevAmsTray::remain, Slic3r::GUI::TrayData::remain, Slic3r::GUI::THIRD, Slic3r::trace(), and Slic3r::GUI::TrayData::type.

Here is the call graph for this function:

ProcessLeftDown()

bool Slic3r::GUI::AmsMapingPopup::ProcessLeftDown ( wxMouseEvent & event )

virtual

{
    return PopupWindow::ProcessLeftDown(event);
}

References Slic3r::GUI::wxMouseEvent.

reset_ams_info()

void Slic3r::GUI::AmsMapingPopup::reset_ams_info

(

)

 {
     if (m_reset_callback) {
         m_reset_callback(m_material_index);
     }
 }

References m_material_index, and m_reset_callback.

Referenced by AmsMapingPopup(), and on_left_down().

Here is the caller graph for this function:

set_current_filament_id()

void Slic3r::GUI::AmsMapingPopup::set_current_filament_id ( int id )

inline

{ m_current_filament_id = id; };

References m_current_filament_id.

set_material_index_str()

void Slic3r::GUI::AmsMapingPopup::set_material_index_str ( std::string str )

inline

{ m_material_index = str; }

References m_material_index.

set_only_show_ext_spool()

void Slic3r::GUI::AmsMapingPopup::set_only_show_ext_spool ( bool )

inline

{}

set_parent_item()

void Slic3r::GUI::AmsMapingPopup::set_parent_item ( MaterialItem * item )

inline

{m_parent_item = item;};

References m_parent_item, and set_parent_item().

Referenced by set_parent_item().

Here is the call graph for this function:

Here is the caller graph for this function:

set_reset_callback()

void Slic3r::GUI::AmsMapingPopup::set_reset_callback

(

ResetCallback

callback

)

                                                              {
     m_reset_callback = callback;
}

References m_reset_callback.

set_send_win()

void Slic3r::GUI::AmsMapingPopup::set_send_win ( wxWindow * win )

inline

{send_win = win;};

References send_win.

set_show_type()

void Slic3r::GUI::AmsMapingPopup::set_show_type ( ShowType type )

inline

{ m_show_type = type; };

References m_show_type.

set_sizer_title()

void Slic3r::GUI::AmsMapingPopup::set_sizer_title	(	wxBoxSizer *	sizer,
		wxString	text )

                                                                      {
     if (!sizer) { return; }
     wxSizerItemList items = sizer->GetChildren();
     for (wxSizerItemList::iterator it = items.begin(); it != items.end(); ++it) {
         wxSizerItem *item       = *it;
         auto         temp_label = dynamic_cast<Label *>((item->GetWindow()));
         if (temp_label) {
             temp_label->SetLabel(text);
             break;
         }
     }
 }

Referenced by update(), and update_ams_data_multi_machines().

Here is the caller graph for this function:

set_tag_texture()

void Slic3r::GUI::AmsMapingPopup::set_tag_texture

(

std::string

texture

)

{
    m_tag_material = texture;
}

References m_tag_material.

ShouldDismissOnTopWindowDeactivate()

virtual bool PopupWindow::ShouldDismissOnTopWindowDeactivate ( )

inlineprotectedvirtualinherited

Reimplemented in DropDown.

{ return true; }

show_reset_button()

void Slic3r::GUI::AmsMapingPopup::show_reset_button

(

)

                                       {
    m_reset_btn->Show();
}

References m_reset_btn.

update()

void Slic3r::GUI::AmsMapingPopup::update	(	MachineObject *	obj,
		const std::vector< FilamentInfo > &	ams_mapping_result,
		bool	use_dynamic_switch = false,
		std::optional< PrintFromType >	print_type = std::nullopt )

{
    if (!obj) { return; } // Orca: guard before use (REF logs before its null check)
 
    BOOST_LOG_TRIVIAL(info) << "ams_mapping total count " << obj->GetFilaSystem()->GetAmsCount();
 
    for (auto& ams_container : m_amsmapping_container_list) {
        ams_container->Destroy();
    }
 
    m_amsmapping_container_list.clear();
    m_amsmapping_container_sizer_list.clear();
    m_mapping_item_list.clear();
 
    /*title*/
    update_title(obj);
 
    /*ams mapping*/
    update_ams_tips(obj);
    update_mapping_items(obj, ams_mapping_result, use_dynamic_switch);
 
    /*rack*/
    update_rack_select(obj, use_dynamic_switch, print_type);
    update_flush_waste(obj);
 
    if (wxGetApp().dark_mode() && m_reset_btn->GetName() != "erase_dark") {
        m_reset_btn->SetName("erase_dark");
        m_reset_btn->SetBitmap(ScalableBitmap(m_right_first_text_panel, "erase_dark", 14).bmp());
    } else if (!wxGetApp().dark_mode() && m_reset_btn->GetName() != "erase") {
        m_reset_btn->SetName("erase");
        m_reset_btn->SetBitmap(ScalableBitmap(m_right_first_text_panel, "erase", 14).bmp());
    }
 
    size_t extruder_num = obj->GetExtderSystem()->GetTotalExtderCount();
    if (extruder_num == 1) {
        m_left_marea_panel->Hide();
        m_left_extra_slot->Hide();
        m_split_line_panel->Hide();
        m_right_marea_panel->Show();
        m_right_marea_panel->Enable(true);
        m_right_extra_slot->Show();
        m_right_extra_slot->Enable(true);
        m_right_split_ext_sizer->Show(true);
        set_sizer_title(m_right_split_ams_sizer, _L("AMS"));
    } else if (extruder_num > 1) {
        if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
            m_left_marea_panel->Show(false);
            m_left_extra_slot->Show(false);
            m_right_extra_slot->Show(false);
            m_left_split_ams_sizer->Show(false);
            m_right_split_ams_sizer->Show(false);
            m_right_split_ext_sizer->Show(false);
            m_split_line_panel->Hide();
 
            m_right_marea_panel->Show();
            m_right_marea_panel->Enable(true);
        } else {
 
            m_left_marea_panel->Show();
            m_left_extra_slot->Show();
            m_split_line_panel->Show();
            m_right_marea_panel->Show();
            m_right_extra_slot->Show();
            m_right_split_ext_sizer->Show(true);
            m_left_tips->SetLabel(m_left_tip_text);
            m_right_tips->SetLabel(m_right_tip_text);
            set_sizer_title(m_left_split_ams_sizer, _L("Left AMS"));
            set_sizer_title(m_right_split_ams_sizer, _L("Right AMS"));
            if (m_show_type == ShowType::LEFT) {
                m_left_marea_panel->Enable(true);
                m_left_extra_slot->Enable(true);
                m_right_marea_panel->Enable(false);
                m_right_extra_slot->Enable(false);
                if (m_use_in_sync_dialog) {
                    m_left_tips->SetLabel(m_single_tip_text);
                    m_right_tips->SetLabel("");
                }
            } else if (m_show_type == ShowType::RIGHT) {
                m_left_marea_panel->Enable(false);
                m_left_extra_slot->Enable(false);
                m_right_marea_panel->Enable(true);
                m_right_extra_slot->Enable(true);
                if (m_use_in_sync_dialog) {
                    // m_right_tips->SetLabel(m_single_tip_text);
                    m_left_tips->SetLabel("");
                }
            } else if (m_show_type == ShowType::LEFT_AND_RIGHT) {
                m_left_marea_panel->Enable(true);
                m_left_extra_slot->Enable(true);
                m_right_marea_panel->Enable(true);
                m_right_extra_slot->Enable(true);
                if (m_use_in_sync_dialog) {
                    m_left_tips->SetLabel(m_single_tip_text);
                    m_right_tips->SetLabel("");
                }
            } else if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
                m_left_marea_panel->Show(false);
                m_left_extra_slot->Show(false);
                m_right_extra_slot->Show(false);
                m_left_split_ams_sizer->Show(false);
                m_right_split_ams_sizer->Show(false);
                m_right_split_ext_sizer->Show(false);
                m_split_line_panel->Hide();
 
                m_right_marea_panel->Show();
                m_right_marea_panel->Enable(true);
            }
        }
    }
 
    Layout();
    Fit();
    Refresh();
}

References _L, Slic3r::MachineObject::GetExtderSystem(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::DevExtderSystem::GetTotalExtderCount(), Slic3r::GUI::LEFT, Slic3r::GUI::LEFT_AND_RIGHT, Slic3r::GUI::LEFT_AND_RIGHT_DYNAMIC, m_amsmapping_container_list, m_amsmapping_container_sizer_list, m_left_extra_slot, m_left_marea_panel, m_left_split_ams_sizer, m_left_tip_text, m_left_tips, m_mapping_item_list, m_reset_btn, m_right_extra_slot, m_right_first_text_panel, m_right_marea_panel, m_right_split_ams_sizer, m_right_split_ext_sizer, m_right_tip_text, m_right_tips, m_show_type, m_single_tip_text, m_split_line_panel, m_use_in_sync_dialog, Slic3r::GUI::RIGHT, set_sizer_title(), update_ams_tips(), update_flush_waste(), update_mapping_items(), update_rack_select(), and update_title().

Here is the call graph for this function:

update_ams_data_multi_machines()

void Slic3r::GUI::AmsMapingPopup::update_ams_data_multi_machines

(

)

{
    m_mapping_from_multi_machines = true;
 
    std::vector<TrayData> tray_datas;
    for (int i = 0; i < 4; ++i) {
        TrayData td;
        td.id = i;
        td.type = EMPTY;
        td.colour = wxColour(166, 169, 170);
        td.name = "";
        td.filament_type = "";
        td.ctype = 0;
        tray_datas.push_back(td);
    }
 
    for (auto& ams_container : m_amsmapping_container_list) {
        ams_container->Destroy();
    }
 
    m_amsmapping_container_list.clear();
    m_amsmapping_container_sizer_list.clear();
    m_mapping_item_list.clear();
 
    if (wxGetApp().dark_mode() && m_reset_btn->GetName() != "erase_dark") {
        m_reset_btn->SetName("erase_dark");
        m_reset_btn->SetBitmap(ScalableBitmap(m_right_first_text_panel, "erase_dark", 14).bmp());
    } else if (!wxGetApp().dark_mode() && m_reset_btn->GetName() != "erase") {
        m_reset_btn->SetName("erase");
        m_reset_btn->SetBitmap(ScalableBitmap(m_right_first_text_panel, "erase", 14).bmp());
    }
 
    size_t nozzle_nums = 1;
    m_show_type = ShowType::RIGHT;
 
    m_left_marea_panel->Hide();
    m_left_extra_slot->Hide();
    // m_left_marea_panel->Show();
    m_right_marea_panel->Show();
    set_sizer_title(m_right_split_ams_sizer, _L("AMS"));
    // m_right_tips->SetLabel(m_single_tip_text);
    m_right_extra_slot->Hide();
    m_left_extra_slot->Hide();
 
 
 
    /*ams*/
    bool                            has_left_ams = false, has_right_ams = false;
    std::list<MappingContainer*>   left_one_slot_containers;
    std::list<MappingContainer*>   right_one_slot_containers;
    std::vector<MappingContainer*> left_four_slots_containers;
    std::vector<MappingContainer*> right_four_slot_containers;
    for (int i = 0; i < 1; i++) {
        int ams_indx = 0;
        int ams_type = 1;
        int nozzle_id = 0;
 
        if (ams_type >= 1 && ams_type <= 3) { // 1:ams 2:ams-lite 3:n3f
 
            auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL);
            auto ams_mapping_item_container = new MappingContainer(nozzle_id == 0 ? m_right_marea_panel : m_left_marea_panel, "AMS-1", 4);
            ams_mapping_item_container->SetName(nozzle_id == 0 ? m_right_marea_panel->GetName() : m_left_marea_panel->GetName());
            ams_mapping_item_container->SetSizer(sizer_mapping_list);
            ams_mapping_item_container->Layout();
 
            m_has_unmatch_filament = false;
            ams_mapping_item_container->Show();
            add_ams_mapping(tray_datas, false, ams_mapping_item_container, sizer_mapping_list);
            m_amsmapping_container_sizer_list.push_back(sizer_mapping_list);
            m_amsmapping_container_list.push_back(ams_mapping_item_container);
 
            if (nozzle_id == 0) {
                has_right_ams = true;
                if (ams_mapping_item_container->get_slots_num() == 1) {
                    right_one_slot_containers.push_back(ams_mapping_item_container);
                } else {
                    right_four_slot_containers.push_back(ams_mapping_item_container);
                }
            } else if (nozzle_id == 1) {
                has_left_ams = true;
                if (ams_mapping_item_container->get_slots_num() == 1) {
                    left_one_slot_containers.push_back(ams_mapping_item_container);
                } else {
                    left_four_slots_containers.push_back(ams_mapping_item_container);
                }
            }
        } else if (ams_type == 4) { // 4:n3s
        }
    }
 
    _add_containers(this, left_one_slot_containers, left_four_slots_containers, m_sizer_ams_basket_left);
    _add_containers(this, right_one_slot_containers, right_four_slot_containers, m_sizer_ams_basket_right);
    m_left_split_ams_sizer->Show(has_left_ams);
    m_right_split_ams_sizer->Show(has_right_ams);
    //update_items_check_state(ams_mapping_result);
 
    Layout();
    Fit();
}

References Slic3r::GUI::_add_containers(), _L, add_ams_mapping(), Slic3r::GUI::TrayData::colour, Slic3r::GUI::TrayData::ctype, Slic3r::GUI::EMPTY, Slic3r::GUI::TrayData::filament_type, Slic3r::GUI::TrayData::id, m_amsmapping_container_list, m_amsmapping_container_sizer_list, m_has_unmatch_filament, m_left_extra_slot, m_left_marea_panel, m_left_split_ams_sizer, m_mapping_from_multi_machines, m_mapping_item_list, m_reset_btn, m_right_extra_slot, m_right_first_text_panel, m_right_marea_panel, m_right_split_ams_sizer, m_show_type, m_sizer_ams_basket_left, m_sizer_ams_basket_right, Slic3r::GUI::TrayData::name, Slic3r::GUI::RIGHT, set_sizer_title(), and Slic3r::GUI::TrayData::type.

Here is the call graph for this function:

update_ams_tips()

void Slic3r::GUI::AmsMapingPopup::update_ams_tips ( MachineObject * obj )

private

{
    const auto& full_config = wxGetApp().preset_bundle->full_config();
    size_t nozzle_nums = full_config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size();
    if (m_ams_tips_msg_panel) {
        m_ams_tips_msg_panel->Clear();
        if (nozzle_nums == 2 && m_show_type != ShowType::LEFT_AND_RIGHT) {
            m_ams_tips_msg_panel->AddMessage(_L("To learn about the filaments matching rules."),
                                             "#FF6F00", ""); // Orca: dropped vendor help link
        }
 
        if (obj && obj->GetFilaSwitch()->IsInstalled()) {
            const auto& msg = _L("External spools are not supported since Filament Track Switch has been installed. If you want to use an external spool, please uninstall it.");
            m_ams_tips_msg_panel->AddMessage(msg, "#FF6F00", "");
        }
 
        m_ams_tips_msg_panel->Layout();
        m_ams_tips_msg_panel->Fit();
        m_ams_tips_msg_panel->Show(m_ams_tips_msg_panel->GetMessageCount() > 0);
    }
}

References _L, Slic3r::MachineObject::GetFilaSwitch(), Slic3r::DevFilaSwitch::IsInstalled(), Slic3r::GUI::LEFT_AND_RIGHT, m_ams_tips_msg_panel, and m_show_type.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_flush_waste()

void Slic3r::GUI::AmsMapingPopup::update_flush_waste ( MachineObject * obj )

private

{
    if (!obj) {
        m_flush_warning_panel->Hide();
        return;
    };
 
    float flush_waste_base = obj->get_nozzle_mapping_result()->GetFlushWeightBase();
    float flush_waste_current = obj->get_nozzle_mapping_result()->GetFlushWeightCurrent();
    if ((flush_waste_base != -1) && (flush_waste_current != -1) && flush_waste_current > flush_waste_base){
        m_flush_warning_panel->SetLabel(wxString::Format(_L("Printing with the current nozzle may produce an extra %0.2f g of waste."), flush_waste_current - flush_waste_base));
        m_flush_warning_panel->Show();
    } else {
        m_flush_warning_panel->Hide();
    }
}

References _L, Slic3r::MachineObject::get_nozzle_mapping_result(), and m_flush_warning_panel.

Referenced by OnNozzleMappingSelected(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_items_check_state()

void Slic3r::GUI::AmsMapingPopup::update_items_check_state

(

const std::vector< FilamentInfo > &

ams_mapping_result

)

{
    /*update check states*/
    if (m_parent_item) {
        auto update_item_check_state = [&ams_mapping_result, this](MappingItem* item) {
            if (item) {
                for (const auto& mapping_res : ams_mapping_result) {
                    if (mapping_res.id == this->m_current_filament_id) {
                        if (mapping_res.ams_id == std::to_string(item->m_ams_id) &&
                            mapping_res.slot_id == std::to_string(item->m_slot_id)) {
                            item->set_checked(true);
                        } else {
                            item->set_checked(false);
                        }
 
                        return;
                    }
                }
 
                item->set_checked(false);
            }
        };
 
        update_item_check_state(m_left_extra_slot);
        update_item_check_state(m_right_extra_slot);
        for (auto mapping_item : m_mapping_item_list) {
            update_item_check_state(mapping_item);
        }
    }
}

References m_left_extra_slot, m_mapping_item_list, m_parent_item, and m_right_extra_slot.

Referenced by update_mapping_items().

Here is the caller graph for this function:

update_mapping_items()

void Slic3r::GUI::AmsMapingPopup::update_mapping_items ( MachineObject * obj, const std::vector< FilamentInfo > & ams_mapping_result, bool use_dynamic_switch )

private

{
    std::list<MappingContainer*>   left_one_slot_containers;
    std::list<MappingContainer*>   right_one_slot_containers;
    std::vector<MappingContainer*> left_four_slots_containers;
    std::vector<MappingContainer*> right_four_slot_containers;
 
    const auto& ams_list = obj->GetFilaSystem()->GetAmsList();
    for (auto ams_iter = ams_list.begin(); ams_iter != ams_list.end(); ams_iter++) {
        const auto& extruder_set = ams_iter->second->GetBindedExtruderSet();
        if (extruder_set.size() <= 0) {
            continue;
        }
 
        wxPanel* target_panel = nullptr;
        if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
            target_panel = m_right_marea_panel;
        } else {
            int extruder_id = *extruder_set.begin();
            if (extruder_id == MAIN_EXTRUDER_ID) {
                target_panel = m_right_marea_panel;
            } else if (extruder_id == DEPUTY_EXTRUDER_ID) {
                target_panel = m_left_marea_panel;
            }
        }
 
        if (!target_panel) {
            continue;
        }
 
        auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL);
        auto ams_mapping_item_container = new MappingContainer(target_panel, ams_iter->second->GetDisplayName(), ams_iter->second->GetSlotCount());
        ams_mapping_item_container->SetName(target_panel->GetName());
        ams_mapping_item_container->SetSizer(sizer_mapping_list);
        ams_mapping_item_container->Layout();
 
        BOOST_LOG_TRIVIAL(trace) << "ams_mapping ams id " << ams_iter->first.c_str();
 
        DevAms* ams_group = ams_iter->second;
        auto ams_type = ams_group->GetAmsType();
        std::vector<TrayData>                      tray_datas;
        std::map<std::string, DevAmsTray*>::const_iterator tray_iter;
        for (tray_iter = ams_group->GetTrays().cbegin(); tray_iter != ams_group->GetTrays().cend(); tray_iter++) {
            const auto& td_opt = sGetTrayData(tray_iter->second, ams_group->GetAmsId(), ams_type);
            if (td_opt.has_value()) {
                tray_datas.push_back(td_opt.value());
            }
        }
 
        ams_mapping_item_container->Show();
        add_ams_mapping(tray_datas, obj->GetFilaSystem()->IsDetectRemainEnabled(), ams_mapping_item_container, sizer_mapping_list);
        m_amsmapping_container_sizer_list.push_back(sizer_mapping_list);
        m_amsmapping_container_list.push_back(ams_mapping_item_container);
 
        if (target_panel == m_right_marea_panel) {
            if (ams_mapping_item_container->get_slots_num() == 1) {
                right_one_slot_containers.push_back(ams_mapping_item_container);
            } else {
                right_four_slot_containers.push_back(ams_mapping_item_container);
            }
        } else if (target_panel == m_left_marea_panel) {
            if (ams_mapping_item_container->get_slots_num() == 1) {
                left_one_slot_containers.push_back(ams_mapping_item_container);
            } else {
                left_four_slots_containers.push_back(ams_mapping_item_container);
            }
        }
    }
 
    for (int i = obj->vt_slot.size() - 1; i >= 0; i--) {
        DevAmsTray* tray_data = &obj->vt_slot[i];
        const auto& td_opt = sGetTrayData(tray_data, tray_data->id, DevAmsType::EXT_SPOOL);
        if (!td_opt.has_value()) {
            continue;
        }
 
        if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
            auto sizer_mapping_list = new wxBoxSizer(wxHORIZONTAL);
            // TRN Short labels of the external spool of the right and left nozzle
            const auto& shown_name = td_opt->ams_id == VIRTUAL_TRAY_MAIN_ID ? _L("Ext-R") : _L("Ext-L");
            auto ams_mapping_item_container = new MappingContainer(m_right_marea_panel, shown_name, 1);
            ams_mapping_item_container->SetName(m_right_marea_panel->GetName());
            ams_mapping_item_container->SetSizer(sizer_mapping_list);
            ams_mapping_item_container->Layout();
 
            std::vector<TrayData>  tray_datas;
            tray_datas.push_back(td_opt.value());
            add_ams_mapping(tray_datas, false, ams_mapping_item_container, sizer_mapping_list);
            m_amsmapping_container_sizer_list.push_back(sizer_mapping_list);
            m_amsmapping_container_list.push_back(ams_mapping_item_container);
            right_one_slot_containers.push_back(ams_mapping_item_container);
        } else {
            if (td_opt->ams_id == VIRTUAL_TRAY_MAIN_ID) {
                m_right_extra_slot->send_win = send_win;
                add_ext_ams_mapping(td_opt.value(), m_right_extra_slot);
            } else if (td_opt->ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
                m_left_extra_slot->send_win = send_win;
                add_ext_ams_mapping(td_opt.value(), m_left_extra_slot);
            }
        }
    }
 
    _add_containers(this, left_one_slot_containers, left_four_slots_containers, m_sizer_ams_basket_left);
    _add_containers(this, right_one_slot_containers, right_four_slot_containers, m_sizer_ams_basket_right);
    if (m_show_type != ShowType::LEFT_AND_RIGHT_DYNAMIC){
        m_left_split_ams_sizer->Show(!left_one_slot_containers.empty() || !left_four_slots_containers.empty());
        m_right_split_ams_sizer->Show(!right_one_slot_containers.empty() || !right_four_slot_containers.empty());
    } else {
        m_left_split_ams_sizer->Show(false);
        m_right_split_ams_sizer->Show(false);
    }
 
    update_items_check_state(ams_mapping_result);
}

References Slic3r::GUI::_add_containers(), _L, add_ams_mapping(), add_ext_ams_mapping(), DEPUTY_EXTRUDER_ID, Slic3r::EXT_SPOOL, Slic3r::DevAms::GetAmsId(), Slic3r::DevAms::GetAmsType(), Slic3r::MachineObject::GetFilaSystem(), Slic3r::DevAms::GetTrays(), Slic3r::DevAmsTray::id, Slic3r::GUI::LEFT_AND_RIGHT_DYNAMIC, m_amsmapping_container_list, m_amsmapping_container_sizer_list, m_left_extra_slot, m_left_marea_panel, m_left_split_ams_sizer, m_right_extra_slot, m_right_marea_panel, m_right_split_ams_sizer, m_show_type, m_sizer_ams_basket_left, m_sizer_ams_basket_right, MAIN_EXTRUDER_ID, send_win, Slic3r::GUI::sGetTrayData(), Slic3r::trace(), update_items_check_state(), VIRTUAL_TRAY_DEPUTY_ID, VIRTUAL_TRAY_MAIN_ID, and Slic3r::MachineObject::vt_slot.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_materials_list()

void Slic3r::GUI::AmsMapingPopup::update_materials_list

(

std::vector< std::string >

list

)

{
    m_materials_list = list;
}

References m_materials_list.

update_rack_select()

void Slic3r::GUI::AmsMapingPopup::update_rack_select	(	MachineObject *	obj,
		bool	use_dynamic_switch,
		std::optional< PrintFromType >	print_type )

{
    // Orca: MachineObject has no GetNozzleRack() convenience; route through the nozzle system instead.
    m_rack = obj ? obj->GetNozzleSystem()->GetNozzleRack() : nullptr;
 
    bool show_rack_select_area = false;
    if (!m_mapping_from_multi_machines && !m_use_in_sync_dialog &&
        obj && obj->GetNozzleSystem()->GetNozzleRack()->IsSupported() &&
        print_from_type.has_value() && print_from_type.value() == PrintFromType::FROM_NORMAL) {
        const auto& nozzle_pos_vec = obj->get_nozzle_mapping_result()->GetMappedNozzlePosVecByFilaId(m_current_filament_id);
        m_rack_nozzle_select->UpdatSelectedNozzles(obj->GetNozzleSystem()->GetNozzleRack(), nozzle_pos_vec, use_dynamic_switch, print_from_type);
        show_rack_select_area = true;
    }
 
    if (show_rack_select_area != m_rack_nozzle_select->IsShown()) {
        m_right_tip_text = show_rack_select_area ? _L("Select Filament && Hotends") : _L("Select Filament");
        m_right_tips->SetLabel(m_right_tip_text);
        m_rack_nozzle_select->Show(show_rack_select_area);
        Layout();
        Fit();
    }
}

References _L, Slic3r::GUI::FROM_NORMAL, Slic3r::MachineObject::get_nozzle_mapping_result(), Slic3r::DevNozzleSystem::GetNozzleRack(), Slic3r::MachineObject::GetNozzleSystem(), m_current_filament_id, m_mapping_from_multi_machines, m_rack, m_rack_nozzle_select, m_right_tip_text, m_right_tips, and m_use_in_sync_dialog.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_title()

void Slic3r::GUI::AmsMapingPopup::update_title ( MachineObject * obj )

private

{
    const auto& full_config = wxGetApp().preset_bundle->full_config();
    size_t nozzle_nums = full_config.option<ConfigOptionFloatsNullable>("nozzle_diameter")->values.size();
    if (nozzle_nums > 1) {
        m_split_line_panel->Show();
        if (m_show_type == ShowType::LEFT) {
            wxString nozzle_name = obj ? _L(DevPrinterConfigUtil::get_toolhead_display_name(
                obj->printer_type, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)) : _L("left nozzle");
            m_title_text->SetLabelText(wxString::Format(_L("Please select the filament installed on the %s."), nozzle_name));
            return;
        } else if (m_show_type == ShowType::RIGHT) {
            wxString nozzle_name = obj ? _L(DevPrinterConfigUtil::get_toolhead_display_name(
                obj->printer_type, MAIN_EXTRUDER_ID, ToolHeadComponent::Nozzle, ToolHeadNameCase::LowerCase)) : _L("right nozzle");
            m_title_text->SetLabelText(wxString::Format(_L("Please select the filament installed on the %s."), nozzle_name));
            return;
        } else if (m_show_type == ShowType::LEFT_AND_RIGHT_DYNAMIC) {
            m_title_text->SetLabelText(_L("Please select the filament."));
            return;
        }
    } else if (nozzle_nums == 1) {
        m_split_line_panel->Hide();
    }
 
    m_title_text->SetLabelText(_L("Nozzle"));
}

References _L, DEPUTY_EXTRUDER_ID, Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), Slic3r::GUI::LEFT, Slic3r::GUI::LEFT_AND_RIGHT_DYNAMIC, Slic3r::LowerCase, m_show_type, m_split_line_panel, m_title_text, MAIN_EXTRUDER_ID, Slic3r::Nozzle, Slic3r::MachineObject::printer_type, and Slic3r::GUI::RIGHT.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_ams_tips_msg_panel

wgtMsgPanel* Slic3r::GUI::AmsMapingPopup::m_ams_tips_msg_panel {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), and update_ams_tips().

m_ams_tips_panel_text

wxString Slic3r::GUI::AmsMapingPopup::m_ams_tips_panel_text

m_amsmapping_container_list

std::vector<MappingContainer*> Slic3r::GUI::AmsMapingPopup::m_amsmapping_container_list

Referenced by msw_rescale(), update(), update_ams_data_multi_machines(), and update_mapping_items().

m_amsmapping_container_sizer_list

std::vector<wxBoxSizer*> Slic3r::GUI::AmsMapingPopup::m_amsmapping_container_sizer_list

Referenced by update(), update_ams_data_multi_machines(), and update_mapping_items().

m_current_filament_id

int Slic3r::GUI::AmsMapingPopup::m_current_filament_id

Referenced by add_ams_mapping(), add_ext_ams_mapping(), get_current_filament_id(), on_left_down(), OnNozzleMappingSelected(), set_current_filament_id(), and update_rack_select().

m_ext_mapping_filatype_check

bool Slic3r::GUI::AmsMapingPopup::m_ext_mapping_filatype_check = true

private

Referenced by add_ext_ams_mapping(), EnableExtMappingFilaTypeCheck(), and on_left_down().

m_flush_warning_panel

DevIconLabel* Slic3r::GUI::AmsMapingPopup::m_flush_warning_panel

private

Referenced by AmsMapingPopup(), msw_rescale(), and update_flush_waste().

m_has_unmatch_filament

bool Slic3r::GUI::AmsMapingPopup::m_has_unmatch_filament {false}

{false};

Referenced by add_ext_ams_mapping(), and update_ams_data_multi_machines().

m_left_extra_slot

MappingItem* Slic3r::GUI::AmsMapingPopup::m_left_extra_slot {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), msw_rescale(), update(), update_ams_data_multi_machines(), update_items_check_state(), and update_mapping_items().

m_left_first_text_panel

wxPanel* Slic3r::GUI::AmsMapingPopup::m_left_first_text_panel {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_left_marea_panel

wxPanel* Slic3r::GUI::AmsMapingPopup::m_left_marea_panel {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), add_ams_mapping(), update(), update_ams_data_multi_machines(), and update_mapping_items().

m_left_split_ams_sizer

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_left_split_ams_sizer {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), update(), update_ams_data_multi_machines(), and update_mapping_items().

m_left_tip_text

wxString Slic3r::GUI::AmsMapingPopup::m_left_tip_text

Referenced by AmsMapingPopup(), and update().

m_left_tips

Label* Slic3r::GUI::AmsMapingPopup::m_left_tips {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), and update().

m_mapping_from_multi_machines

bool Slic3r::GUI::AmsMapingPopup::m_mapping_from_multi_machines {false}

{false};

Referenced by add_ams_mapping(), on_left_down(), update_ams_data_multi_machines(), and update_rack_select().

m_mapping_item_list

std::vector<MappingItem*> Slic3r::GUI::AmsMapingPopup::m_mapping_item_list

Referenced by add_ams_mapping(), add_ext_ams_mapping(), msw_rescale(), on_left_down(), update(), update_ams_data_multi_machines(), and update_items_check_state().

m_material_index

std::string Slic3r::GUI::AmsMapingPopup::m_material_index

private

Referenced by get_material_index_str(), reset_ams_info(), and set_material_index_str().

m_materials_list

std::vector<std::string> Slic3r::GUI::AmsMapingPopup::m_materials_list

Referenced by update_materials_list().

m_parent_item

MaterialItem* Slic3r::GUI::AmsMapingPopup::m_parent_item { nullptr }

{ nullptr };

Referenced by AmsMapingPopup(), set_parent_item(), and update_items_check_state().

m_rack

std::weak_ptr<DevNozzleRack> Slic3r::GUI::AmsMapingPopup::m_rack

private

Referenced by OnNozzleMappingSelected(), and update_rack_select().

m_rack_nozzle_select

wgtDeviceNozzleRackSelect* Slic3r::GUI::AmsMapingPopup::m_rack_nozzle_select {nullptr}

private

{nullptr};

Referenced by AmsMapingPopup(), msw_rescale(), OnNozzleMappingSelected(), and update_rack_select().

m_reset_btn

ScalableButton* Slic3r::GUI::AmsMapingPopup::m_reset_btn {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), on_left_down(), show_reset_button(), update(), and update_ams_data_multi_machines().

m_reset_callback

ResetCallback Slic3r::GUI::AmsMapingPopup::m_reset_callback {nullptr}

private

{nullptr};

Referenced by reset_ams_info(), and set_reset_callback().

m_right_extra_slot

MappingItem* Slic3r::GUI::AmsMapingPopup::m_right_extra_slot {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), msw_rescale(), update(), update_ams_data_multi_machines(), update_items_check_state(), and update_mapping_items().

m_right_first_text_panel

wxPanel* Slic3r::GUI::AmsMapingPopup::m_right_first_text_panel {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), update(), and update_ams_data_multi_machines().

m_right_marea_panel

wxPanel* Slic3r::GUI::AmsMapingPopup::m_right_marea_panel { nullptr }

{ nullptr }; // used as right if both left and right sides shown. used as single panel if only one side shown.

Referenced by AmsMapingPopup(), add_ams_mapping(), update(), update_ams_data_multi_machines(), and update_mapping_items().

m_right_split_ams_sizer

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_right_split_ams_sizer {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), update(), update_ams_data_multi_machines(), and update_mapping_items().

m_right_split_ext_sizer

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_right_split_ext_sizer { nullptr }

{ nullptr };

Referenced by AmsMapingPopup(), and update().

m_right_tip_text

wxString Slic3r::GUI::AmsMapingPopup::m_right_tip_text

Referenced by AmsMapingPopup(), update(), and update_rack_select().

m_right_tips

Label* Slic3r::GUI::AmsMapingPopup::m_right_tips {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), update(), and update_rack_select().

m_scrolled_window

wxScrolledWindow* Slic3r::GUI::AmsMapingPopup::m_scrolled_window {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_show_type

ShowType Slic3r::GUI::AmsMapingPopup::m_show_type {ShowType::RIGHT}

{ShowType::RIGHT};

Referenced by add_ams_mapping(), on_left_down(), set_show_type(), update(), update_ams_data_multi_machines(), update_ams_tips(), update_mapping_items(), and update_title().

m_single_tip_text

wxString Slic3r::GUI::AmsMapingPopup::m_single_tip_text

Referenced by AmsMapingPopup(), and update().

m_sizer_ams

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_ams_basket_left

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_basket_left { nullptr }

{ nullptr };

Referenced by AmsMapingPopup(), update_ams_data_multi_machines(), and update_mapping_items().

m_sizer_ams_basket_right

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_basket_right { nullptr }

{ nullptr };

Referenced by AmsMapingPopup(), update_ams_data_multi_machines(), and update_mapping_items().

m_sizer_ams_left

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_left {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_ams_left_horizonal

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_left_horizonal {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_ams_right

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_right {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_ams_right_horizonal

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_right_horizonal {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_ams_v

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_ams_v {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_list

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_list {nullptr}

{nullptr};

m_sizer_main

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

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_main_h

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_main_h {nullptr}

{nullptr};

Referenced by AmsMapingPopup().

m_sizer_split_ams_left

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_split_ams_left

m_sizer_split_ams_right

wxBoxSizer* Slic3r::GUI::AmsMapingPopup::m_sizer_split_ams_right

m_split_line_panel

wxPanel* Slic3r::GUI::AmsMapingPopup::m_split_line_panel {nullptr}

{nullptr};

Referenced by AmsMapingPopup(), update(), and update_title().

m_tag_material

std::string Slic3r::GUI::AmsMapingPopup::m_tag_material

Referenced by add_ams_mapping(), add_ext_ams_mapping(), is_match_material(), and set_tag_texture().

m_title_text

wxStaticText* Slic3r::GUI::AmsMapingPopup::m_title_text { nullptr }

private

{ nullptr };

Referenced by AmsMapingPopup(), and update_title().

m_use_in_sync_dialog

bool Slic3r::GUI::AmsMapingPopup::m_use_in_sync_dialog = false

private

Referenced by AmsMapingPopup(), add_ams_mapping(), get_use_in_sync_dialog(), update(), and update_rack_select().

send_win

wxWindow* Slic3r::GUI::AmsMapingPopup::send_win { nullptr }

{ nullptr };

Referenced by add_ams_mapping(), set_send_win(), and update_mapping_items().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/AmsMappingPopup.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/AmsMappingPopup.cpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/AmsMappingPopupUpdate.cpp