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

Inheritance diagram for Slic3r::GUI::MaterialItem:

Collaboration diagram for Slic3r::GUI::MaterialItem:

Public Member Functions
	MaterialItem (wxWindow *parent, wxColour mcolour, wxString mname, std::string filament_id=std::string())
	~MaterialItem ()
void	allow_paint_dropdown (bool flag)
void	set_ams_text (const wxString &txt)
void	set_ams_info (wxColour col, wxString txt, int ctype=0, std::vector< wxColour > cols=std::vector< wxColour >(), bool record_back_info=false)
void	set_material_cols (int ctype, const std::vector< wxColour > &cols)
void	reset_ams_info ()
virtual void	reset_valid_info ()
void	set_nozzle_info (const wxString &mapped_nozzle_str)
void	disable ()
void	enable ()
void	on_normal ()
void	on_selected ()
void	on_warning ()
bool	is_selected () const
bool	is_warning () const
void	msw_rescale ()
void	paintEvent (wxPaintEvent &evt)
virtual void	render (wxDC &dc)
void	match (bool mat)
virtual void	doRender (wxDC &dc)

Public Attributes
std::string	m_filament_id
wxColour	m_material_coloul
int	m_material_ctype = 0
std::vector< wxColour >	m_material_cols
wxString	m_material_name
wxString	m_mapped_nozzle_str
wxColour	m_ams_coloul
wxString	m_ams_name
int	m_ams_ctype = 0
std::vector< wxColour >	m_ams_cols = std::vector<wxColour>()
wxColour	m_back_ams_coloul
wxString	m_back_ams_name
int	m_back_ams_ctype = 0
std::vector< wxColour >	m_back_ams_cols = std::vector<wxColour>()
ScalableBitmap	m_arraw_bitmap_gray
ScalableBitmap	m_arraw_bitmap_white
ScalableBitmap	m_transparent_mitem
ScalableBitmap	m_filament_wheel_transparent
ScalableBitmap	m_ams_wheel_mitem
ScalableBitmap	m_ams_not_match
ScalableBitmap	m_rack_nozzle_bitmap
bool	m_selected {false}
bool	m_warning {false}
bool	m_match {true}
bool	m_enable {true}

Protected Member Functions
void	messure_size ()

Protected Attributes
int	m_text_pos_y = -1
bool	m_dropdown_allow_painted = true
wxString	m_mapping_text

Detailed Description

Constructor & Destructor Documentation

◆ MaterialItem()

Slic3r::GUI::MaterialItem::MaterialItem	(	wxWindow *	parent,
		wxColour	mcolour,
		wxString	mname,
		std::string	filament_id = std::string() )

    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
 {
    m_arraw_bitmap_gray  = ScalableBitmap(this, "drop_down2", FromDIP(8));
    m_arraw_bitmap_white =  ScalableBitmap(this, "topbar_dropdown", 12);
    m_transparent_mitem          = ScalableBitmap(this, "transparent_material_up", 20);
    m_filament_wheel_transparent = ScalableBitmap(this,   "filament_transparent", 25);//wxGetApp().dark_mode() ? "filament_dark_transparent"
    //m_ams_wheel_mitem = ScalableBitmap(this, "ams_wheel", FromDIP(25));
    m_ams_wheel_mitem = ScalableBitmap(this, "ams_wheel_narrow", 25);
    m_ams_not_match = ScalableBitmap(this, "filament_not_mactch", 25);
    m_rack_nozzle_bitmap = ScalableBitmap(this, "dev_rack_nozzle_print_job", 22);
 
    m_material_coloul = mcolour;
    m_material_name = mname;
    m_ams_coloul      = wxColour(0xEE,0xEE,0xEE);
 
    m_filament_id = filament_id;
 
#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    messure_size();
    SetBackgroundColour(*wxWHITE);
 
    Bind(wxEVT_PAINT, &MaterialItem::paintEvent, this);
    wxGetApp().UpdateDarkUI(this);
 }

References m_ams_coloul, m_ams_not_match, m_ams_wheel_mitem, m_arraw_bitmap_gray, m_arraw_bitmap_white, m_filament_id, m_filament_wheel_transparent, m_material_coloul, m_material_name, m_rack_nozzle_bitmap, m_transparent_mitem, messure_size(), and paintEvent().

Referenced by Slic3r::GUI::MaterialSyncItem::MaterialSyncItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~MaterialItem()

Slic3r::GUI::MaterialItem::~MaterialItem ( )

112{}

Member Function Documentation

◆ allow_paint_dropdown()

void Slic3r::GUI::MaterialItem::allow_paint_dropdown ( bool flag )

                                                 {
    if (m_dropdown_allow_painted != flag) {
        m_dropdown_allow_painted = flag;
    }
}

References m_dropdown_allow_painted.

Referenced by Slic3r::GUI::SyncAmsInfoDialog::generate_override_fix_ams_list().

Here is the caller graph for this function:

◆ disable()

void Slic3r::GUI::MaterialItem::disable ( )

{
    if (IsEnabled()) {
        m_enable = false;
    }
}

References m_enable.

◆ doRender()

void Slic3r::GUI::MaterialItem::doRender ( wxDC & dc )

virtual

Reimplemented in Slic3r::GUI::MaterialSyncItem.

{
    wxSize size = GetSize();
    auto mcolor = m_material_coloul;
    auto acolor = m_ams_coloul;
    change_the_opacity(acolor);
 
    if (mcolor.Alpha() == 0)
    {
        dc.DrawBitmap(m_transparent_mitem.bmp(), FromDIP(1), FromDIP(1));
    }
 
    if (!IsEnabled())
    {
        mcolor = wxColour(0x90, 0x90, 0x90);
        acolor = wxColour(0x90, 0x90, 0x90);
    }
 
    //top
    dc.SetPen(*wxTRANSPARENT_PEN);
    if (m_material_cols.size() > 1 && IsEnabled()) {
        int top_h = FromDIP(20);
        bool drawn = false;
 
        wxGraphicsContext* gc = dc.GetGraphicsContext();
        if (gc) {
            double r = FromDIP(5);
            auto make_path = [&](double x, double w, bool left_round, bool right_round) {
                wxGraphicsPath p = gc->CreatePath();
                double rl = left_round  ? std::min<double>(r, std::min<double>(w, top_h)) : 0.0;
                double rr = right_round ? std::min<double>(r, std::min<double>(w, top_h)) : 0.0;
                p.MoveToPoint(x, top_h);
                p.AddLineToPoint(x, rl);
                if (rl > 0) p.AddArc(x + rl, rl, rl, M_PI, -M_PI / 2, true);
                p.AddLineToPoint(x + w - rr, 0);
                if (rr > 0) p.AddArc(x + w - rr, rr, rr, -M_PI / 2, 0, true);
                p.AddLineToPoint(x + w, top_h);
                p.CloseSubpath();
                return p;
            };
 
            if (m_material_ctype == 0) {
                wxGraphicsPath path = make_path(0, size.x, true, true);
                wxGraphicsGradientStops stops(m_material_cols.front(), m_material_cols.back());
                for (size_t i = 1; i + 1 < m_material_cols.size(); i++) {
                    float pos = (float)i / (m_material_cols.size() - 1);
                    stops.Add(m_material_cols[i], pos);
                }
                gc->SetBrush(gc->CreateLinearGradientBrush(0, 0, size.x, 0, stops));
                gc->FillPath(path);
            } else {
                int cols_size = m_material_cols.size();
                for (int i = 0; i < cols_size; i++) {
                    double x0 = (double)size.x * i / cols_size;
                    double w  = (i == cols_size - 1) ? (size.x - x0) : ((double)size.x / cols_size);
                    wxGraphicsPath seg = make_path(x0, w, i == 0, i == cols_size - 1);
                    gc->SetBrush(gc->CreateBrush(wxBrush(m_material_cols[i])));
                    gc->FillPath(seg);
                }
            }
            drawn = true;
        }
 
        if (!drawn) {
            if (m_material_ctype == 0) {
                int seg = m_material_cols.size() - 1;
                int gw = std::round((double)size.x / seg);
                for (int i = 0; i < seg; i++) {
                    int x0 = gw * i;
                    int w  = (i == seg - 1) ? (size.x - x0) : gw;
                    fill_gradient_rect_east(dc, wxRect(x0, 0, w, top_h), m_material_cols[i], m_material_cols[i + 1]);
                }
            } else {
                int cols_size = m_material_cols.size();
                int cw = std::round((double)size.x / cols_size);
                for (int i = 0; i < cols_size; i++) {
                    dc.SetBrush(wxBrush(m_material_cols[i]));
                    int x0 = cw * i;
                    int w  = (i == cols_size - 1) ? (size.x - x0) : cw;
                    dc.DrawRectangle(x0, 0, w, top_h);
                }
            }
        }
    } else {
        dc.SetBrush(wxBrush(mcolor));
        dc.DrawRoundedRectangle(0, 0, size.x, FromDIP(20), 5);
 
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(mcolor));
        dc.DrawRectangle(0, FromDIP(10), size.x, FromDIP(10));
    }
 
    // materials name
    auto up = 0;
    auto material_name_colour = mcolor.GetLuminance() < 0.6 ? *wxWHITE : wxColour(0x26, 0x2E, 0x30);
    if (mcolor.Alpha() == 0) { material_name_colour = wxColour(0x26, 0x2E, 0x30); }
    dc.SetTextForeground(material_name_colour);
 
    dc.SetFont(::Label::Body_12);
    if (dc.GetTextExtent(m_material_name).x > GetSize().x - 10)
    {
        dc.SetFont(::Label::Body_10);
    }
 
    auto material_txt_size = dc.GetTextExtent(m_material_name);
    dc.DrawText(m_material_name, wxPoint((GetSize().x - material_txt_size.x) / 2, (FromDIP(20) - material_txt_size.y) / 2));
 
    dc.SetPen(wxColour(0xAC, 0xAC, 0xAC));
    dc.DrawLine(FromDIP(1), FromDIP(20), FromDIP(size.x), FromDIP(20));
    up += FromDIP(20);
    up += FromDIP(2); // spacing
 
    //bottom rectangle in wheel bitmap, size is MATERIAL_REC_WHEEL_SIZE(22)
    auto paint_recty = up + (m_ams_wheel_mitem.GetBmpSize().y - MATERIAL_REC_WHEEL_SIZE.y) / 2;
    auto left = (size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3);
    auto right = left + MATERIAL_REC_WHEEL_SIZE.x - FromDIP(3);
    dc.SetPen(*wxTRANSPARENT_PEN);
    //bottom
    if (m_ams_cols.size() > 1)
    {
        int gwidth = std::round(MATERIAL_REC_WHEEL_SIZE.x / (m_ams_cols.size() - 1));
        //gradient
        if (m_ams_ctype == 0)
        {
            for (int i = 0; i < m_ams_cols.size() - 1; i++)
            {
                auto rect = wxRect(left, paint_recty, right - left, MATERIAL_REC_WHEEL_SIZE.y);
                fill_gradient_rect_east(dc, rect, m_ams_cols[i], m_ams_cols[i + 1]);
                left += gwidth;
            }
        }
        else
        {
            int cols_size = m_ams_cols.size();
            for (int i = 0; i < cols_size; i++)
            {
                dc.SetBrush(wxBrush(m_ams_cols[i]));
                float x = left + ((float)MATERIAL_REC_WHEEL_SIZE.x) * i / cols_size;
                if (i != cols_size - 1)
                {
                    dc.DrawRoundedRectangle(x - FromDIP(LEFT_OFFSET), paint_recty, ((float)MATERIAL_REC_WHEEL_SIZE.x) / cols_size + FromDIP(3), MATERIAL_REC_WHEEL_SIZE.y, 3);
                }
                else
                {
                    dc.DrawRoundedRectangle(x - FromDIP(LEFT_OFFSET), paint_recty, ((float)MATERIAL_REC_WHEEL_SIZE.x) / cols_size - FromDIP(1), MATERIAL_REC_WHEEL_SIZE.y, 3);
                }
            }
        }
    }
    else
    {
        if (m_match)
        {
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(wxColour(acolor)));
            dc.DrawRectangle((size.x / 2 - MATERIAL_REC_WHEEL_SIZE.x) / 2 + FromDIP(3) - FromDIP(LEFT_OFFSET), paint_recty, MATERIAL_REC_WHEEL_SIZE.x - FromDIP(1),
                MATERIAL_REC_WHEEL_SIZE.y);
        }
    }
 
    if (m_match)
    {
        dc.SetPen(wxPen(wxGetApp().dark_mode() ? wxColour(107, 107, 107) : wxColour(0xAC, 0xAC, 0xAC), FromDIP(1)));
    }
    else
    {
        dc.SetPen(wxPen(wxColour(234, 31, 48), FromDIP(1)));
    }
 
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.DrawRoundedRectangle(FromDIP(0), FromDIP(0), size.x - FromDIP(0), size.y, 5);
 
    if (m_selected)
    {
        dc.SetPen(wxPen(wxColour("#009688"), FromDIP(2))); // ORCA selected item border color (Orca accent)
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), 5);
    } else if (m_warning) {
        dc.SetPen(wxPen(wxColour(0xFF, 0x6F, 0x00), FromDIP(2)));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawRoundedRectangle(FromDIP(1), FromDIP(1), size.x - FromDIP(1), size.y - FromDIP(1), 5);
    }
    //#endif
 
    auto wheel_left = (GetSize().x / 2 - m_ams_wheel_mitem.GetBmpSize().x) / 2 + FromDIP(2) - FromDIP(LEFT_OFFSET);
    auto wheel_top = up;
 
    if (!m_match)
    {
        wheel_left = (size.x - m_ams_not_match.GetBmpWidth()) / 2 - FromDIP(LEFT_OFFSET);
        dc.DrawBitmap(m_ams_not_match.bmp(), wheel_left, wheel_top);
    }
    else
    {
        if (acolor.Alpha() == 0)
        {
            dc.DrawBitmap(m_filament_wheel_transparent.bmp(), wheel_left, wheel_top);
        }
        else
        {
            dc.DrawBitmap(m_ams_wheel_mitem.bmp(), wheel_left, wheel_top);
        }
    }
 
    // text and arrow
    dc.SetTextForeground(StateColor::darkModeColorFor(wxColour(0x26, 0x2E, 0x30)));
 
    int text_pos_x = 0;
    int text_pos_y = 0;
    auto mapping_txt_size = wxSize(0, 0);
    if (m_mapping_text.size() >= 4)
    {
        m_mapping_text.insert(m_mapping_text.size() / 2, "\n");
        WxFontUtils::get_suitable_font_size(FromDIP(13), dc);
        mapping_txt_size = dc.GetTextExtent(m_mapping_text);
        text_pos_y = up + (m_ams_wheel_mitem.GetBmpSize().y - mapping_txt_size.y) / 2;
        text_pos_x = mapping_txt_size.x / 4;
    }
    else
    {
        dc.SetFont(::Label::Head_12);
        mapping_txt_size = dc.GetTextExtent(m_mapping_text);
        text_pos_y = up + (m_ams_wheel_mitem.GetBmpSize().y - mapping_txt_size.y) / 2;
        text_pos_x = 0;
    }
 
    int arrow_left = size.x - m_arraw_bitmap_white.GetBmpSize().x - FromDIP(4) - FromDIP(LEFT_OFFSET);
    if (m_match)
    {
        dc.DrawText(m_mapping_text, wxPoint(GetSize().x / 2 + (GetSize().x / 2 - mapping_txt_size.x) / 2 - FromDIP(8) - FromDIP(LEFT_OFFSET) + text_pos_x, text_pos_y));
 
        int arrow_y = text_pos_y + (mapping_txt_size.y - m_arraw_bitmap_white.GetBmpHeight()) / 2;
        if ((acolor.Red() > 160 && acolor.Green() > 160 && acolor.Blue() > 160) && (acolor.Red() < 180 && acolor.Green() < 180 && acolor.Blue() < 180))
        {
            dc.DrawBitmap(m_arraw_bitmap_white.bmp(), arrow_left, arrow_y);
        }
        else
        {
            dc.DrawBitmap(m_arraw_bitmap_gray.bmp(), arrow_left, arrow_y);
        }
    }
 
    up += m_ams_wheel_mitem.GetBmpSize().y;
 
 
    if (!m_mapped_nozzle_str.IsEmpty()) {
        wxPen dashed_pen(wxColour("#CECECE"), 1, wxPENSTYLE_SHORT_DASH); // Orca: WXCOLOUR_GREY400 macro not in scope here
        dc.SetPen(dashed_pen);
        up += FromDIP(4); // spacing
        dc.DrawLine(FromDIP(1), up, FromDIP(size.x), up);
 
        int bitmap_y = up + (size.y - up - m_rack_nozzle_bitmap.GetBmpHeight()) / 2;
        int bitmap_l = wheel_left + (m_ams_wheel_mitem.GetBmpWidth() - m_rack_nozzle_bitmap.GetBmpWidth()) / 2 + FromDIP(2);
        dc.DrawBitmap(m_rack_nozzle_bitmap.bmp(), bitmap_l, bitmap_y);
 
        const wxString wrapped_nozzle_str = s_wrap_mapped_nozzle_str(m_mapped_nozzle_str);
        dc.SetFont(::Label::Head_12);
        // Orca: no box-fit get_suitable_font_size overload here; the wrapped slot string is short, so the
        // fixed Head_12 label font (set above) renders it cleanly.
        const auto& text_size = dc.GetTextExtent(wrapped_nozzle_str);
        int text_x = (size.x + bitmap_l + m_rack_nozzle_bitmap.GetBmpWidth() - text_size.x) / 2;
        int text_y = up + (size.y - up - text_size.y) / 2;
        dc.DrawText(wrapped_nozzle_str, text_x, text_y);
    }
}

References Label::Body_10, Label::Body_12, Slic3r::change_the_opacity(), StateColor::darkModeColorFor(), Slic3r::GUI::fill_gradient_rect_east(), Slic3r::GUI::WxFontUtils::get_suitable_font_size(), Label::Head_12, Slic3r::GUI::LEFT_OFFSET, m_ams_coloul, m_ams_cols, m_ams_ctype, m_ams_not_match, m_ams_wheel_mitem, m_arraw_bitmap_gray, m_arraw_bitmap_white, m_filament_wheel_transparent, m_mapped_nozzle_str, m_mapping_text, m_match, m_material_coloul, m_material_cols, m_material_ctype, m_material_name, M_PI, m_rack_nozzle_bitmap, m_selected, m_transparent_mitem, m_warning, MATERIAL_REC_WHEEL_SIZE, and Slic3r::GUI::s_wrap_mapped_nozzle_str().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable()

void Slic3r::GUI::MaterialItem::enable ( )

{
    if (!IsEnabled()) {
        m_enable = true;
    }
}

References m_enable.

◆ is_selected()

bool Slic3r::GUI::MaterialItem::is_selected ( ) const

inline

132{ return m_selected;}

References m_selected.

◆ is_warning()

bool Slic3r::GUI::MaterialItem::is_warning ( ) const

inline

133{ return m_warning;}

References m_warning.

◆ match()

void Slic3r::GUI::MaterialItem::match ( bool mat )

{
    m_match = mat;
    Refresh();
}

References m_match.

◆ messure_size()

void Slic3r::GUI::MaterialItem::messure_size ( )

protected

{
    if (m_mapped_nozzle_str.empty()) {
        SetSize(wxSize(FromDIP(65), FromDIP(50)));
        SetMinSize(wxSize(FromDIP(65), FromDIP(50)));
        SetMaxSize(wxSize(FromDIP(65), FromDIP(50)));
    } else {
        const int line_count = s_get_mapped_nozzle_str_line_count(m_mapped_nozzle_str);
        const int item_height = FromDIP(84 + std::max(0, line_count - 1) * 10);
        SetSize(wxSize(FromDIP(65), item_height));
        SetMinSize(wxSize(FromDIP(65), item_height));
        SetMaxSize(wxSize(FromDIP(65), item_height));
    }
}

References m_mapped_nozzle_str, and Slic3r::GUI::s_get_mapped_nozzle_str_line_count().

Referenced by MaterialItem(), reset_ams_info(), set_ams_info(), set_ams_text(), and set_nozzle_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ msw_rescale()

void Slic3r::GUI::MaterialItem::msw_rescale ( )

                               {
    m_arraw_bitmap_gray.msw_rescale();
    m_arraw_bitmap_white.msw_rescale();
    m_transparent_mitem.msw_rescale();
    m_ams_wheel_mitem.msw_rescale();
}

References m_ams_wheel_mitem, m_arraw_bitmap_gray, m_arraw_bitmap_white, and m_transparent_mitem.

◆ on_normal()

void Slic3r::GUI::MaterialItem::on_normal ( )

{
    if (m_selected || m_warning) {
        m_selected = false;
        m_warning  = false;
        Refresh();
    }
}

References m_selected, and m_warning.

Referenced by Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), and Slic3r::GUI::SendMultiMachinePage::sync_ams_list().

Here is the caller graph for this function:

◆ on_selected()

void Slic3r::GUI::MaterialItem::on_selected ( )

{
    if (!m_selected) {
        m_selected = true;
        Refresh();
    }
}

References m_selected.

Referenced by Slic3r::GUI::SelectMachineDialog::reset_and_sync_ams_list(), Slic3r::GUI::SyncAmsInfoDialog::reset_and_sync_ams_list(), Slic3r::GUI::SelectMachineDialog::set_default_from_sdcard(), and Slic3r::GUI::SendMultiMachinePage::sync_ams_list().

Here is the caller graph for this function:

◆ on_warning()

void Slic3r::GUI::MaterialItem::on_warning ( )

{
    if (!m_warning) {
        m_warning = true;
        Refresh();
    }
}

References m_warning.

◆ paintEvent()

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

{
    wxPaintDC dc(this);
    render(dc);
}

References render().

Referenced by MaterialItem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ render()

void Slic3r::GUI::MaterialItem::render ( wxDC & dc )

virtual

Reimplemented in Slic3r::GUI::MaterialSyncItem.

{
    if (m_ams_name.empty()) {
        m_mapping_text = "-";
    } else {
        m_mapping_text = m_ams_name;
    }
 
    if (m_mapping_text == "-") { m_match = false;}
    else {m_match = true;}
 
#ifdef __WXMSW__
    wxSize     size = GetSize();
    wxMemoryDC memdc;
    wxBitmap   bmp(size.x, size.y);
    memdc.SelectObject(bmp);
    memdc.Blit({0, 0}, size, &dc, {0, 0});
 
    {
        wxGCDC dc2(memdc);
        doRender(dc2);
    }
 
    memdc.SelectObject(wxNullBitmap);
    dc.DrawBitmap(bmp, 0, 0);
#else
    doRender(dc);
#endif
}

References doRender(), m_ams_name, m_mapping_text, and m_match.

Referenced by paintEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_ams_info()

void Slic3r::GUI::MaterialItem::reset_ams_info ( )

                                  {
    m_ams_name   = "-";
    m_ams_coloul = wxColour(0xCE, 0xCE, 0xCE);
    m_ams_cols.clear();
    m_ams_ctype = 0;
    m_mapped_nozzle_str.Clear();
    messure_size();
    Refresh();
}

References m_ams_coloul, m_ams_cols, m_ams_ctype, m_ams_name, m_mapped_nozzle_str, and messure_size().

Referenced by Slic3r::GUI::SyncAmsInfoDialog::reset_ams_material().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset_valid_info()

void Slic3r::GUI::MaterialItem::reset_valid_info ( )

virtual

                                    {
    set_ams_info(m_back_ams_coloul, m_back_ams_name, m_back_ams_ctype, m_back_ams_cols);
}

References m_back_ams_coloul, m_back_ams_cols, m_back_ams_ctype, m_back_ams_name, and set_ams_info().

Here is the call graph for this function:

◆ set_ams_info()

void Slic3r::GUI::MaterialItem::set_ams_info	(	wxColour	col,
		wxString	txt,
		int	ctype = 0,
		std::vector< wxColour >	cols = std::vector<wxColour>(),
		bool	record_back_info = false )

{
    auto need_refresh = false;
    if (record_back_info) {
        m_back_ams_cols = cols;
        m_back_ams_ctype = ctype;
        m_back_ams_coloul = col;
        m_back_ams_name  = txt;
    }
    if (m_ams_cols != cols) { m_ams_cols = cols; need_refresh = true; }
    if (m_ams_ctype != ctype) { m_ams_ctype = ctype; need_refresh = true; }
    if (m_ams_coloul != col) { m_ams_coloul = col; need_refresh = true;}
    if (m_ams_name != txt) { m_ams_name = txt; need_refresh = true; }
    if (need_refresh) {
        messure_size();
        Refresh();
    }
    BOOST_LOG_TRIVIAL(info) << "set_ams_info " << m_ams_name;
}

References m_ams_coloul, m_ams_cols, m_ams_ctype, m_ams_name, m_back_ams_coloul, m_back_ams_cols, m_back_ams_ctype, m_back_ams_name, and messure_size().

Referenced by Slic3r::GUI::SelectMachineDialog::on_set_finish_mapping(), Slic3r::GUI::SendMultiMachinePage::on_set_finish_mapping(), Slic3r::GUI::SendMultiMachinePage::OnSelectRadio(), Slic3r::GUI::SelectMachineDialog::reset_ams_material(), reset_valid_info(), Slic3r::GUI::SendMultiMachinePage::sync_ams_list(), and Slic3r::GUI::SelectMachineDialog::sync_ams_mapping_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_ams_text()

void Slic3r::GUI::MaterialItem::set_ams_text ( const wxString & txt )

{
    if (m_ams_name != txt) {
        m_ams_name = txt;
        messure_size();
        Refresh();
    }
}

References m_ams_name, and messure_size().

Here is the call graph for this function:

◆ set_material_cols()

void Slic3r::GUI::MaterialItem::set_material_cols	(	int	ctype,
		const std::vector< wxColour > &	cols )

                                                                               {
    if (m_material_ctype != ctype || m_material_cols != cols) {
        m_material_ctype = ctype;
        m_material_cols = cols;
        Refresh();
    }
}

References m_material_cols, and m_material_ctype.

◆ set_nozzle_info()

void Slic3r::GUI::MaterialItem::set_nozzle_info ( const wxString & mapped_nozzle_str )

{
    if (m_mapped_nozzle_str != mapped_nozzle_str) {
        m_mapped_nozzle_str = mapped_nozzle_str;
        messure_size();
        Refresh();
    }
}