Slic3r::GUI::AMSRoadDownPart Class Reference

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

Inheritance diagram for Slic3r::GUI::AMSRoadDownPart:

Collaboration diagram for Slic3r::GUI::AMSRoadDownPart:

Public Member Functions
	AMSRoadDownPart ()
	AMSRoadDownPart (wxWindow *parent, wxWindowID id, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
void	create (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize)
void	UpdateLeft (int nozzle_num, AMSRoadShowMode mode)
void	UpdateRight (int nozzle_num, AMSRoadShowMode mode)
void	OnVamsLoading (bool load, wxColour col=AMS_CONTROL_GRAY500)
void	SetPassRoadColour (bool left, wxColour col)
void	SetShowMode (AMSRoadShowMode left_mode, AMSRoadShowMode right_mode)
void	UpdatePassRoad (AMSPanelPos pos, int len, AMSPassRoadSTEP step)
void	paintEvent (wxPaintEvent &evt)
void	render (wxDC &dc)
void	doRender (wxDC &dc)
void	msw_rescale ()

Private Attributes
int	m_nozzle_num = {1}
AMSRoadShowMode	m_left_rode_mode = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR}
AMSRoadShowMode	m_right_rode_mode = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR}
bool	m_selected = {false}
int	m_left_road_length = {-1}
int	m_right_road_length = {-1}
AMSPassRoadSTEP	m_pass_road_left_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE}
AMSPassRoadSTEP	m_pass_road_right_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE}
std::map< int, wxColour >	m_road_color

Detailed Description

Constructor & Destructor Documentation

AMSRoadDownPart() [1/2]

Slic3r::GUI::AMSRoadDownPart::AMSRoadDownPart

(

)

{}

Referenced by AMSRoadDownPart().

Here is the caller graph for this function:

AMSRoadDownPart() [2/2]

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

    : AMSRoadDownPart()
{
    /*m_info = info;
    m_canindex = canindex;*/
    // road type
    m_road_color[0] = AMS_CONTROL_GRAY500;
    m_road_color[1] = AMS_CONTROL_GRAY500;
    m_left_rode_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
    m_right_rode_mode = AMSRoadShowMode::AMS_ROAD_MODE_FOUR;
    m_selected = false;
 
    m_left_road_length = -1;
    m_right_road_length = -1;
    create(parent, id, pos, size);
    this->SetMinSize(AMS_DOWN_ROAD_SIZE);
    this->SetSize(AMS_DOWN_ROAD_SIZE);
 
    Bind(wxEVT_PAINT, &AMSRoadDownPart::paintEvent, this);
    wxWindow::SetBackgroundColour(*wxWHITE);
 
}

References AMSRoadDownPart(), AMS_CONTROL_GRAY500, AMS_DOWN_ROAD_SIZE, Slic3r::GUI::AMS_ROAD_MODE_FOUR, create(), m_left_road_length, m_left_rode_mode, m_right_road_length, m_right_rode_mode, m_road_color, m_selected, and paintEvent().

Here is the call graph for this function:

Member Function Documentation

create()

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

{ wxWindow::Create(parent, id, pos, size); }

Referenced by AMSRoadDownPart().

Here is the caller graph for this function:

doRender()

void Slic3r::GUI::AMSRoadDownPart::doRender

(

wxDC &

dc

)

{
    wxSize size = GetSize();
    wxPoint left_nozzle_pos = wxPoint(std::ceil((float)size.x / 2 - FromDIP(8)), FromDIP(258));
    wxPoint right_nozzle_pos = wxPoint(std::ceil((float)size.x / 2 + FromDIP(6)), FromDIP(258));
    /*if (m_road_color.Alpha() == 0) { dc.SetPen(wxPen(*wxWHITE, m_passroad_width, wxPENSTYLE_SOLID)); }
    else { dc.SetPen(wxPen(m_road_color, m_passroad_width, wxPENSTYLE_SOLID)); }*/
    dc.SetPen(wxPen(AMS_CONTROL_GRAY500, 2, wxPENSTYLE_SOLID));
    auto xpos = left_nozzle_pos.x;
    if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_NONE){
        auto length = 50;
        if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE || m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE)
            length = -13;
        dc.DrawLine(left_nozzle_pos.x - FromDIP(length), (size.y / 2), (left_nozzle_pos.x), (size.y / 2));
        dc.DrawLine(left_nozzle_pos.x - FromDIP(length), (0), left_nozzle_pos.x - FromDIP(length), (size.y / 2));
        dc.DrawLine(left_nozzle_pos.x, size.y / 2, left_nozzle_pos.x, size.y);
    }
    else {
        switch (m_left_rode_mode)
        {
        case AMSRoadShowMode::AMS_ROAD_MODE_FOUR:
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), 0, left_nozzle_pos.x - FromDIP((129)), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE:
            dc.DrawLine(left_nozzle_pos.x - FromDIP(218), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP(110), 0, left_nozzle_pos.x - FromDIP(110), (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP(218), 0, left_nozzle_pos.x - FromDIP(218), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE:
            dc.DrawLine(left_nozzle_pos.x - FromDIP(192), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP(192), 0, left_nozzle_pos.x - FromDIP(192), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S:
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), 0, left_nozzle_pos.x - FromDIP((129)), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
            dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
            break;
        default:
            break;
        }
 
        switch (m_right_rode_mode)
        {
        case AMSRoadShowMode::AMS_ROAD_MODE_FOUR:
            dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(131), (size.y / 2));
            dc.DrawLine(right_nozzle_pos.x + FromDIP(131), 0, right_nozzle_pos.x + FromDIP(131), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_DOUBLE:
            dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(218), (size.y / 2));
            dc.DrawLine(right_nozzle_pos.x + FromDIP(110), 0, right_nozzle_pos.x + FromDIP(110), (size.y / 2));
            dc.DrawLine(right_nozzle_pos.x + FromDIP(218), 0, right_nozzle_pos.x + FromDIP(218), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE:
            dc.DrawLine(right_nozzle_pos.x, (size.y / 2), right_nozzle_pos.x + FromDIP(68), (size.y / 2));
            dc.DrawLine(right_nozzle_pos.x + FromDIP(68), 0, right_nozzle_pos.x + FromDIP(68), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_SINGLE_N3S:
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), (size.y / 2), left_nozzle_pos.x, (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x - FromDIP((129)), 0, left_nozzle_pos.x - FromDIP((129)), (size.y / 2));
            break;
        case AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE:
            dc.DrawLine(left_nozzle_pos.x, (size.y / 2), left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            dc.DrawLine(left_nozzle_pos.x + FromDIP(145), 0, left_nozzle_pos.x + FromDIP(145), (size.y / 2));
            break;
        default:
            break;
        }
    }
 
    if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
        if (m_nozzle_num == 2) {
            /*dc.DrawLine(FromDIP(left_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(left_nozzle_pos.x), FromDIP(size.y));
            dc.DrawLine(FromDIP(right_nozzle_pos.x), FromDIP(size.y / 2), FromDIP(right_nozzle_pos.x), FromDIP(size.y));*/
            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
            dc.DrawLine((right_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y));
        }
        else {
            if (m_right_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE && m_left_rode_mode != AMSRoadShowMode::AMS_ROAD_MODE_NONE) {
                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (right_nozzle_pos.x), (size.y / 2));
            }
            dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
        }
    }
 
 
    /*if (m_nozzle_mode == AMSRoadDownPartMode::AMS_ROAD_MODE_SINGLE)
    {
        dc.DrawLine(left_nozzle_pos.x, left_nozzle_pos.y, FromDIP(left_nozzle_pos.x + 30), left_nozzle_pos.y);
    }*/
    //dc.SetBrush(wxBrush(*wxBLUE));
 
    if (m_pass_road_right_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_pass_road_right_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
        dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[0]), 4, wxPENSTYLE_SOLID));
        if (m_right_road_length > 0) {
            if (m_right_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
                /* dc.SetPen(wxPen(*wxRED));
                 dc.DrawLine(right_nozzle_pos.x, 0, right_nozzle_pos.x + , size.y / 2);
                 xpos = left_nozzle_pos.x;
                 if (m_nozzle_num >= 2) xpos = right_nozzle_pos.x;
                 dc.SetPen(wxPen(*wxGREEN));
                 dc.DrawLine(xpos, size.y / 2, right_nozzle_pos.x, size.y / 2);
                 dc.SetPen(wxPen(*wxYELLOW));
                 dc.DrawLine(xpos, size.y / 2, xpos, size.y);*/
                int x   = left_nozzle_pos.x;
                int len = m_right_road_length;
                if (m_nozzle_num == 2) {
                    x   = right_nozzle_pos.x;
                    len = len - 14;
                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
            }
            else{
                int x = left_nozzle_pos.x;
                int len = m_right_road_length;
                if (m_nozzle_num == 2) {
                    x = right_nozzle_pos.x;
                    len = len - 14;
                }
                dc.DrawLine(((x)), (size.y / 2), x + FromDIP(len), (size.y / 2));
                dc.DrawLine(x + FromDIP(len), (0), x + FromDIP(len), (size.y / 2));
                dc.DrawLine((x), (size.y / 2), (x), (size.y));
            }
        }
    }
 
    if (m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_2 || m_pass_road_left_step == AMSPassRoadSTEP::AMS_ROAD_STEP_3) {
        dc.SetPen(wxPen(_get_diff_clr(this, m_road_color[1]), 4, wxPENSTYLE_SOLID));
        if (m_left_road_length > 0) {
            if (m_left_rode_mode == AMSRoadShowMode::AMS_ROAD_MODE_AMS_LITE){
                dc.DrawLine(left_nozzle_pos.x, 0, left_nozzle_pos.x, size.y);
            }
            else{
                dc.DrawLine((left_nozzle_pos.x - FromDIP(m_left_road_length)), (size.y / 2), (left_nozzle_pos.x), (size.y / 2));
                dc.DrawLine((left_nozzle_pos.x), (size.y / 2), (left_nozzle_pos.x), (size.y));
                dc.DrawLine(left_nozzle_pos.x - FromDIP(m_left_road_length), (0), left_nozzle_pos.x - FromDIP(m_left_road_length), (size.y / 2));
            }
        }
    }
}

References Slic3r::GUI::_get_diff_clr(), AMS_CONTROL_GRAY500, Slic3r::GUI::AMS_ROAD_MODE_AMS_LITE, Slic3r::GUI::AMS_ROAD_MODE_DOUBLE, Slic3r::GUI::AMS_ROAD_MODE_FOUR, Slic3r::GUI::AMS_ROAD_MODE_NONE, Slic3r::GUI::AMS_ROAD_MODE_SINGLE, Slic3r::GUI::AMS_ROAD_MODE_SINGLE_N3S, Slic3r::GUI::AMS_ROAD_STEP_2, Slic3r::GUI::AMS_ROAD_STEP_3, Slic3r::length(), m_left_road_length, m_left_rode_mode, m_nozzle_num, m_pass_road_left_step, m_pass_road_right_step, m_right_road_length, m_right_rode_mode, and m_road_color.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::AMSRoadDownPart::msw_rescale

(

)

                                  {
    Layout();
    Fit();
    Refresh();
}

OnVamsLoading()

void Slic3r::GUI::AMSRoadDownPart::OnVamsLoading	(	bool	load,
		wxColour	col = AMS_CONTROL_GRAY500 )

{
    /*m_vams_loading = load;
    if(load)m_road_color = col;
    Refresh();*/
}

References load().

Here is the call graph for this function:

paintEvent()

void Slic3r::GUI::AMSRoadDownPart::paintEvent

(

wxPaintEvent &

evt

)

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

References render().

Referenced by AMSRoadDownPart().

Here is the call graph for this function:

Here is the caller graph for this function:

render()

void Slic3r::GUI::AMSRoadDownPart::render

(

wxDC &

dc

)

{
#ifdef __WXMSW__
    wxSize     size = GetSize();
    wxMemoryDC memdc;
    wxBitmap   bmp(size.x, size.y);
    memdc.SelectObject(bmp);
    memdc.Blit({ 0, 0 }, size, &dc, { 0, 0 });
 
    {
        wxGCDC dc2(memdc);
        doRender(dc2);
    }
 
    memdc.SelectObject(wxNullBitmap);
    dc.DrawBitmap(bmp, 0, 0);
#else
    doRender(dc);
#endif
}

References doRender().

Referenced by paintEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

SetPassRoadColour()

void Slic3r::GUI::AMSRoadDownPart::SetPassRoadColour	(	bool	left,
		wxColour	col )

{
    if (left)
    {
        if (m_road_color[DEPUTY_EXTRUDER_ID] == col)
        {
            return;
        }
        m_road_color[DEPUTY_EXTRUDER_ID] = col;
    }
    else
    {
        if (m_road_color[MAIN_EXTRUDER_ID] == col)
        {
            return;
        }
        m_road_color[MAIN_EXTRUDER_ID] = col;
    }
 
    Refresh();
}

References DEPUTY_EXTRUDER_ID, m_road_color, and MAIN_EXTRUDER_ID.

SetShowMode()

void Slic3r::GUI::AMSRoadDownPart::SetShowMode	(	AMSRoadShowMode	left_mode,
		AMSRoadShowMode	right_mode )

{
    if (m_left_rode_mode == left_mode && m_right_rode_mode == right_mode) { return; }
 
    m_left_rode_mode = left_mode;
    m_right_rode_mode = right_mode;
    Refresh();
}

References m_left_rode_mode, and m_right_rode_mode.

UpdateLeft()

void Slic3r::GUI::AMSRoadDownPart::UpdateLeft	(	int	nozzle_num,
		AMSRoadShowMode	mode )

{
    if (nozzle_num == m_nozzle_num && m_left_rode_mode == mode) { return;}
 
    this->m_left_rode_mode = mode;
    m_nozzle_num = nozzle_num;
    Refresh();
}

References m_left_rode_mode, and m_nozzle_num.

UpdatePassRoad()

void Slic3r::GUI::AMSRoadDownPart::UpdatePassRoad	(	AMSPanelPos	pos,
		int	len,
		AMSPassRoadSTEP	step )

                                                                                   {
    if (m_nozzle_num >= 2){
        if (pos == AMSPanelPos::LEFT_PANEL){
            if (m_left_road_length == len && m_pass_road_left_step == step){ return; }
            m_left_road_length = len;;
            m_pass_road_left_step = step;
        }
        else{
            if (m_right_road_length == len && m_pass_road_right_step == step) { return; }
            m_right_road_length = len;
            m_pass_road_right_step = step;
        }
    }
    else{
        if (pos == AMSPanelPos::LEFT_PANEL) {
            if (m_left_road_length == len && m_pass_road_left_step == step && m_right_road_length == -1) { return; }
            m_left_road_length = len;
            m_right_road_length = -1;
            m_pass_road_left_step = step;
        }
        else {
            if (m_right_road_length == len && m_pass_road_right_step == step && m_left_road_length == -1) { return; }
            m_right_road_length = len;
            m_left_road_length = -1;
            m_pass_road_right_step = step;
        }
    }
    Refresh();
}

References Slic3r::GUI::LEFT_PANEL, m_left_road_length, m_nozzle_num, m_pass_road_left_step, m_pass_road_right_step, and m_right_road_length.

UpdateRight()

void Slic3r::GUI::AMSRoadDownPart::UpdateRight	(	int	nozzle_num,
		AMSRoadShowMode	mode )

{
    if (nozzle_num == m_nozzle_num && m_right_rode_mode == mode) { return; }
 
    this->m_right_rode_mode = mode;
    m_nozzle_num = nozzle_num;
    Refresh();
}

References m_nozzle_num, and m_right_rode_mode.

Member Data Documentation

m_left_road_length

int Slic3r::GUI::AMSRoadDownPart::m_left_road_length = {-1}

private

{-1};

Referenced by AMSRoadDownPart(), doRender(), and UpdatePassRoad().

m_left_rode_mode

AMSRoadShowMode Slic3r::GUI::AMSRoadDownPart::m_left_rode_mode = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR}

private

{AMSRoadShowMode::AMS_ROAD_MODE_FOUR};

Referenced by AMSRoadDownPart(), doRender(), SetShowMode(), and UpdateLeft().

m_nozzle_num

int Slic3r::GUI::AMSRoadDownPart::m_nozzle_num = {1}

private

{1};

Referenced by doRender(), UpdateLeft(), UpdatePassRoad(), and UpdateRight().

m_pass_road_left_step

AMSPassRoadSTEP Slic3r::GUI::AMSRoadDownPart::m_pass_road_left_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE}

private

{AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};

Referenced by doRender(), and UpdatePassRoad().

m_pass_road_right_step

AMSPassRoadSTEP Slic3r::GUI::AMSRoadDownPart::m_pass_road_right_step = {AMSPassRoadSTEP::AMS_ROAD_STEP_NONE}

private

{AMSPassRoadSTEP::AMS_ROAD_STEP_NONE};

Referenced by doRender(), and UpdatePassRoad().

m_right_road_length

int Slic3r::GUI::AMSRoadDownPart::m_right_road_length = {-1}

private

{-1};

Referenced by AMSRoadDownPart(), doRender(), and UpdatePassRoad().

m_right_rode_mode

AMSRoadShowMode Slic3r::GUI::AMSRoadDownPart::m_right_rode_mode = {AMSRoadShowMode::AMS_ROAD_MODE_FOUR}

private

{AMSRoadShowMode::AMS_ROAD_MODE_FOUR};

Referenced by AMSRoadDownPart(), doRender(), SetShowMode(), and UpdateRight().

m_road_color

std::map<int, wxColour> Slic3r::GUI::AMSRoadDownPart::m_road_color

private

Referenced by AMSRoadDownPart(), doRender(), and SetPassRoadColour().

m_selected

bool Slic3r::GUI::AMSRoadDownPart::m_selected = {false}

private

{false};

Referenced by AMSRoadDownPart().

---

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

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