Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceTab/wgtDeviceNozzleRackUpdate.h>

Inheritance diagram for Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate:

Collaboration diagram for Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate:

Public Member Functions
	wgtDeviceNozzleRackHotendUpdate (wxWindow *parent, const wxString &idx_text)
void	UpdateColourStyle (const wxColour &clr)
int	GetExtruderNozzleId () const
void	SetExtruderNozzleId (int ext_nozzle_id)
void	UpdateExtruderNozzleInfo (const std::shared_ptr< DevNozzleRack > rack)
void	SetRackNozzleId (int rack_nozzle_id)
int	GetRackNozzleId () const
void	UpdateRackNozzleInfo (const std::shared_ptr< DevNozzleRack > rack)
void	Rescale ()
bool	Create (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0)
void	SetCornerRadius (double radius)
void	SetBorderWidth (int width)
void	SetTopMargin (int margin)
void	SetBorderColor (StateColor const &color)
void	SetBorderColorNormal (wxColor const &color)
void	SetBorderStyle (wxPenStyle style)
void	SetBackgroundColor (StateColor const &color)
void	SetBackgroundColorNormal (wxColor const &color)
void	SetBackgroundColor2 (StateColor const &color)
void	ShowBadge (bool show)

Static Public Member Functions
static wxColor	GetParentBackgroundColor (wxWindow *parent)

Protected Member Functions
void	eraseEvent (wxEraseEvent &evt)
void	sizeEvent (wxSizeEvent &evt)
void	paintEvent (wxPaintEvent &evt)
void	render (wxDC &dc)
virtual void	doRender (wxDC &dc)

Protected Attributes
double	radius
int	border_width = 1
int	top_margin = 0
wxPenStyle	border_style = wxPENSTYLE_SOLID
StateHandler	state_handler
StateColor	border_color
StateColor	background_color
StateColor	background_color2
ScalableBitmap	badge

Private Types
enum	NozzleStatus : int {   NOZZLE_STATUS_DC = -1 , NOZZLE_STATUS_EMPTY , NOZZLE_STATUS_NORMAL , NOZZLE_STATUS_ABNORMAL ,   NOZZLE_STATUS_UNKNOWN }

Private Member Functions
void	CreateGui ()
void	UpdateInfo (const DevNozzle &nozzle)
void	OnBitmapHoverEnter (wxMouseEvent &event)
void	OnBitmapHoverLeave (wxMouseEvent &event)
void	OnStatusIconClick (wxMouseEvent &event)
void	updateNozzleImage (const DevNozzle &nozzle)

Private Attributes
int	m_ext_nozzle_id = -1
int	m_rack_nozzle_id = -1
bool	findNozzleImage = false
NozzleStatus	m_nozzle_status = NOZZLE_STATUS_DC
std::weak_ptr< DevNozzleRack >	m_nozzle_rack
std::vector< std::vector< ScalableBitmap * > >	nozzle_hs
std::vector< std::vector< ScalableBitmap * > >	nozzle_hh
ScalableBitmap *	m_nozzle_image = nullptr
ScalableBitmap *	m_nozzle_empty_image = nullptr
ScalableBitmap *	m_scaled_nozzle_image = nullptr
ScalableBitmap *	m_scaled_nozzle_empty_image = nullptr
ScalableBitmap *	m_refresh_icon = nullptr
AnimaIcon *	m_refreshing_icon = nullptr
ScalableBitmap *	m_error_icon = nullptr
Label *	m_idx_label
wxStaticBitmap *	m_icon_bitmap { nullptr }
wxStaticBitmap *	m_status_bitmap { nullptr }
Label *	m_material_label { nullptr }
StaticBox *	m_colour_box { nullptr }
wxFrame *	m_hoverFrame { nullptr }
Label *	m_status_label { nullptr }
Label *	m_used_time { nullptr }
Label *	m_diameter_label
Label *	m_flowtype_label
Label *	m_type_label
Label *	m_sn_label
Label *	m_version_label
Label *	m_version_new_label

Detailed Description

Member Enumeration Documentation

NozzleStatus

enum Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::NozzleStatus : int

private

Enumerator
NOZZLE_STATUS_DC
NOZZLE_STATUS_EMPTY
NOZZLE_STATUS_NORMAL
NOZZLE_STATUS_ABNORMAL
NOZZLE_STATUS_UNKNOWN

    {
        NOZZLE_STATUS_DC = -1,
        NOZZLE_STATUS_EMPTY,
        NOZZLE_STATUS_NORMAL,
        NOZZLE_STATUS_ABNORMAL,
        NOZZLE_STATUS_UNKNOWN,
    };

Constructor & Destructor Documentation

wgtDeviceNozzleRackHotendUpdate()

Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::wgtDeviceNozzleRackHotendUpdate	(	wxWindow *	parent,
		const wxString &	idx_text )

    : StaticBox(parent, wxID_ANY)
{
    CreateGui();
 
    m_idx_label->SetLabel(idx_text);
}

References StaticBox::StaticBox(), CreateGui(), and m_idx_label.

Here is the call graph for this function:

Member Function Documentation

Create()

bool StaticBox::Create ( wxWindow * parent, wxWindowID id = wxID_ANY, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0 )

inherited

{
    if (style & wxBORDER_NONE)
        border_width = 0;
    wxWindow::Create(parent, id, pos, size, style);
    state_handler.attach({&border_color, &background_color, &background_color2});
    state_handler.update_binds();
    SetBackgroundColour(GetParentBackgroundColor(parent));
    return true;
}

References background_color, background_color2, border_color, border_width, GetParentBackgroundColor(), state_handler, and style.

Referenced by FanSwitchButton::FanSwitchButton(), ImageSwitchButton::ImageSwitchButton(), ModeSwitchButton::ModeSwitchButton(), StaticBox(), Button::Create(), SpinInput::Create(), TabButton::Create(), TempInput::Create(), and TextInput::Create().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateGui()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::CreateGui ( )

private

{
    SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    SetBorderColor(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    SetCornerRadius(0);
 
    //load nozzle hs image
    for (int i = 1; i <= 4; i++)
    {
        auto normalImage = new ScalableBitmap(this, "Nozzle_HS_01_0" + std::to_string(i * 2), 46);
        auto bigImage = new ScalableBitmap(this, "Big_Nozzle_HS_01_0" + std::to_string(i * 2), 216);
        nozzle_hs.push_back({normalImage, bigImage});
    }
    for (int i = 2; i <= 4; i++)
    {
        auto normalImage = new ScalableBitmap(this, "Nozzle_HH_01_0" + std::to_string(i * 2), 46);
        auto bigImage = new ScalableBitmap(this, "Big_Nozzle_HH_01_0" + std::to_string(i * 2), 216);
        nozzle_hh.push_back({normalImage, bigImage});
    }
 
    auto* content_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Index
    m_idx_label = new Label(this);
    m_idx_label->SetFont(Label::Head_14);
    m_idx_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    content_sizer->Add(m_idx_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(25));
 
    // Icon
    wxPanel* imagePanel = new wxPanel(this);
    imagePanel->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    imagePanel->SetMaxSize(WX_DIP_SIZE(46, -1));
    imagePanel->SetMinSize(WX_DIP_SIZE(46, -1));
    imagePanel->SetSize(wxSize(FromDIP(46), FromDIP(-1)));
    wxBoxSizer* panelSizer = new wxBoxSizer(wxVERTICAL);
    imagePanel->SetSizer(panelSizer);
 
    m_nozzle_empty_image = new ScalableBitmap(imagePanel, "dev_rack_nozzle_empty", 46);
    m_icon_bitmap = new wxStaticBitmap(imagePanel, wxID_ANY, m_nozzle_empty_image->bmp());
    panelSizer->Add(m_icon_bitmap, 0, wxALIGN_CENTER);
    content_sizer->Add(imagePanel, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(25));
    m_icon_bitmap->Bind(wxEVT_ENTER_WINDOW, &wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverEnter, this);
    m_icon_bitmap->Bind(wxEVT_LEAVE_WINDOW, &wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverLeave, this);
 
    // Diameter/type (vertical)
    wxPanel* type_panel = new wxPanel(this);
    type_panel->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    auto* main_type_sizer = new wxBoxSizer(wxVERTICAL);
    auto* type_sizer_row_1 = new wxBoxSizer(wxHORIZONTAL);
    auto* type_sizer_row_2 = new wxBoxSizer(wxHORIZONTAL);
 
    m_material_label = new Label(type_panel);
    m_material_label->SetFont(Label::Body_12);
    m_material_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    m_colour_box = new StaticBox(type_panel);
    m_colour_box->SetMaxSize(WX_DIP_SIZE(16, 16));
    m_colour_box->SetMinSize(WX_DIP_SIZE(16, 16));
    m_colour_box->SetCornerRadius(FromDIP(2));
    m_colour_box->SetSize(wxSize(FromDIP(16), FromDIP(16)));
    // m_colour_box->SetBackgroundColour(*wxRED);
 
    // type_sizer_row_1->AddStretchSpacer();
    type_sizer_row_1->Add(m_colour_box, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
    type_sizer_row_1->AddStretchSpacer(1);
    type_sizer_row_1->Add(m_material_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
    // type_sizer_row_1->AddStretchSpacer();
 
    m_diameter_label = new Label(type_panel);
    m_diameter_label->SetFont(Label::Body_12);
    m_diameter_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    m_flowtype_label = new Label(type_panel);
    m_flowtype_label->SetFont(Label::Body_12);
    m_flowtype_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    m_type_label = new Label(type_panel);
    m_type_label->SetFont(Label::Body_12);
    m_type_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    type_sizer_row_2->Add(m_diameter_label, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT );
    type_sizer_row_2->Add(m_flowtype_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
    type_sizer_row_2->Add(m_type_label, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
 
    main_type_sizer->Add(type_sizer_row_1, 0, wxALIGN_LEFT);
    main_type_sizer->Add(type_sizer_row_2, 1, wxALIGN_LEFT | wxEXPAND | wxTOP, FromDIP(4));
    type_panel->SetSizer(main_type_sizer);
    type_panel->SetMaxSize(WX_DIP_SIZE(160, 40));
    type_panel->SetMinSize(WX_DIP_SIZE(160, 40));
    type_panel->SetSize(WX_DIP_SIZE(160, 40));
 
    content_sizer->Add(type_panel, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(12));
 
    // SN and version (vertical)
    wxPanel* info_panel = new wxPanel(this);
    info_panel->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    auto* info_sizer = new wxBoxSizer(wxVERTICAL);
    m_sn_label = new Label(info_panel);
    m_sn_label->SetFont(Label::Body_12);
    m_sn_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    auto* version_h_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_version_label = new Label(info_panel);
    m_version_label->SetFont(Label::Body_12);
    m_version_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    m_version_new_label = new Label(info_panel);
    m_version_new_label->SetFont(Label::Body_12);
    m_version_new_label->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    m_version_new_label->SetForegroundColour(wxColour(0, 168, 84)); // Green
 
    version_h_sizer->Add(m_version_label, 0, wxALIGN_CENTER_VERTICAL);
    version_h_sizer->Add(m_version_new_label, 0, wxALIGN_CENTER_VERTICAL);
    info_sizer->Add(m_sn_label, 0, wxALIGN_LEFT);
    info_sizer->Add(version_h_sizer, 0, wxALIGN_LEFT | wxTOP, FromDIP(4));
    info_panel->SetSizer(info_sizer);
    info_panel->SetMaxSize(WX_DIP_SIZE(183, 40));
    info_panel->SetMinSize(WX_DIP_SIZE(183, 40));
    info_panel->SetSize(WX_DIP_SIZE(183, 40));
 
    //Used Time
    m_used_time = new Label(this);
    m_used_time->SetFont(Label::Body_12);
    m_used_time->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
 
    m_refresh_icon = new ScalableBitmap(this, "refresh_printer", 12);
    // m_in_refreh_icon = new ScalableBitmap(this, "refresh_nozzle", 12);
    m_error_icon = new ScalableBitmap(this, "error", 14);
    m_status_bitmap = new wxStaticBitmap(this, wxID_ANY, m_refresh_icon->bmp());
    m_status_bitmap->Bind(wxEVT_LEFT_UP, &wgtDeviceNozzleRackHotendUpdate::OnStatusIconClick, this);
 
    std::vector<std::string> list{"refresh_nozzle_1", "refresh_nozzle_2", "refresh_nozzle_3", "refresh_nozzle_4"};
    // Orca: AnimaIcon has no per-instance size argument (it fixes the size internally), so none is passed.
    m_refreshing_icon = new AnimaIcon(this, wxID_ANY, list, "refresh_nozzle", 100);
    m_refreshing_icon->Show(false);
 
 
    m_status_label = new Label(this);
    m_status_label->SetFont(Label::Body_12);
    // m_status_label->SetForegroundColour(wxColour("#00AE42"));
 
    content_sizer->Add(info_panel, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(20));
    content_sizer->Add(m_used_time, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(20));
    content_sizer->Add(m_status_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(20));
    content_sizer->Add(m_status_bitmap, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
    content_sizer->Add(m_refreshing_icon, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(2));
    content_sizer->AddSpacer(FromDIP(25));
 
    auto* main_sizer = new wxBoxSizer(wxHORIZONTAL);
    main_sizer->Add(content_sizer, 0, wxEXPAND | wxTOP | wxBOTTOM, FromDIP(10));
 
    SetSizer(main_sizer);
    Layout();
}

References StaticBox::StaticBox(), Label::Body_12, Label::Head_14, m_colour_box, m_diameter_label, m_error_icon, m_flowtype_label, m_icon_bitmap, m_idx_label, m_material_label, m_nozzle_empty_image, m_refresh_icon, m_refreshing_icon, m_sn_label, m_status_bitmap, m_status_label, m_type_label, m_used_time, m_version_label, m_version_new_label, nozzle_hh, nozzle_hs, OnBitmapHoverEnter(), OnBitmapHoverLeave(), OnStatusIconClick(), StaticBox::SetBorderColor(), StaticBox::SetCornerRadius(), WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG, and WX_DIP_SIZE.

Referenced by wgtDeviceNozzleRackHotendUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

doRender()

void StaticBox::doRender ( wxDC & dc )

protectedvirtualinherited

Reimplemented in FilamentStepIndicator, ModeSwitchButton, StepCtrl, StepIndicator, and TabCtrl.

{
    wxSize size = GetSize();
    int states = state_handler.states();
    if (background_color2.count() == 0) {
        if ((border_width && border_color.count() > 0) || background_color.count() > 0) {
            int topM = top_margin > 0 ? top_margin : 0;
            wxRect rc(0, topM, size.x, size.y - topM);
            if (border_width && border_color.count() > 0) {
                const double scale = dc.GetContentScaleFactor();
 
                // Snap rect edges to physical pixel boundaries so the 1px pen doesn't straddle a pixel boundary
                auto snap = [&](int logical) -> int {
                    return (int)(ceil(logical * scale) / scale);
                };
 
                int deflate = snap(border_width / 2.0);  // at 175%: snap(0.5) = snap→1/1.75 ≈ 1
                rc.x      += deflate;
                rc.y      += deflate;
                rc.width  -= deflate * 2;
                rc.height -= deflate * 2;
                dc.SetPen(wxPen(border_color.colorForStates(states), border_width, border_style));
            } else {
                dc.SetPen(wxPen(background_color.colorForStates(states)));
            }
            if (background_color.count() > 0)
                dc.SetBrush(wxBrush(background_color.colorForStates(states)));
            else
                dc.SetBrush(wxBrush(GetBackgroundColour()));
            if (radius == 0) {
                dc.DrawRectangle(rc);
            }
            else {
                dc.DrawRoundedRectangle(rc, radius - border_width);
            }
        }
    }
    else {
        wxColor start = background_color.colorForStates(states);
        wxColor stop = background_color2.colorForStates(states);
        int r = start.Red(), g = start.Green(), b = start.Blue();
        int dr = (int) stop.Red() - r, dg = (int) stop.Green() - g, db = (int) stop.Blue() - b;
        int lr = 0, lg = 0, lb = 0;
        for (int y = 0; y < size.y; ++y) {
            dc.SetPen(wxPen(wxColor(r, g, b)));
            dc.DrawLine(0, y, size.x, y);
            lr += dr; while (lr >= size.y) { ++r, lr -= size.y; } while (lr <= -size.y) { --r, lr += size.y; }
            lg += dg; while (lg >= size.y) { ++g, lg -= size.y; } while (lg <= -size.y) { --g, lg += size.y; }
            lb += db; while (lb >= size.y) { ++b, lb -= size.y; } while (lb <= -size.y) { --b, lb += size.y; }
        }
    }
 
    if (badge.bmp().IsOk()) {
        auto s = badge.bmp().GetScaledSize();
        dc.DrawBitmap(badge.bmp(), size.x - s.x, top_margin > 0 ? top_margin : 0);
    }
}

References background_color, background_color2, badge, border_color, border_style, border_width, radius, scale(), state_handler, and top_margin.

Referenced by FilamentStepIndicator::doRender(), StepCtrl::doRender(), StepIndicator::doRender(), and render().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseEvent()

void StaticBox::eraseEvent ( wxEraseEvent & evt )

protectedinherited

{
    // for transparent background, but not work
#ifdef __WXMSW__
    wxDC *dc = evt.GetDC();
    wxSize size = GetSize();
    wxClientDC dc2(GetParent());
    dc->Blit({0, 0}, size, &dc2, GetPosition());
#endif
}

GetExtruderNozzleId()

int Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::GetExtruderNozzleId ( ) const

inline

{ return m_ext_nozzle_id; }

References m_ext_nozzle_id.

GetParentBackgroundColor()

wxColor StaticBox::GetParentBackgroundColor ( wxWindow * parent )

staticinherited

{
    if (auto box = dynamic_cast<StaticBox*>(parent)) {
        if (box->background_color.count() > 0) {
            if (box->background_color2.count() == 0)
                return box->background_color.defaultColor();
            auto s = box->background_color.defaultColor();
            auto e = box->background_color2.defaultColor();
            int r = (s.Red() + e.Red()) / 2;
            int g = (s.Green() + e.Green()) / 2;
            int b = (s.Blue() + e.Blue()) / 2;
            return wxColor(r, g, b);
        }
    }
    if (parent)
        return parent->GetBackgroundColour();
    return *wxWHITE;
}

References StaticBox().

Referenced by Label::Label(), ModeSwitchButton::ModeSwitchButton(), ScalableButton::ScalableButton(), SwitchButton::SwitchButton(), Create(), and SwitchButton::Rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

GetRackNozzleId()

int Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::GetRackNozzleId ( ) const

inline

{ return m_rack_nozzle_id; }

References m_rack_nozzle_id.

OnBitmapHoverEnter()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverEnter ( wxMouseEvent & event )

private

{
    int scaledW = FromDIP(240);
    int scaledH = FromDIP(240);
 
    ScalableBitmap* scaledBmp{nullptr};
    if (m_nozzle_status == NOZZLE_STATUS_EMPTY || m_nozzle_status == NOZZLE_STATUS_UNKNOWN || !findNozzleImage)
    {
        if (!m_scaled_nozzle_empty_image) {m_scaled_nozzle_empty_image = new ScalableBitmap(this, "dev_rack_nozzle_empty", 216);}
 
        scaledBmp = m_scaled_nozzle_empty_image;
    }
    else
    {
        scaledBmp = m_scaled_nozzle_image;
    }
 
    m_hoverFrame = new wxFrame(nullptr, wxID_ANY, "", 
                                wxDefaultPosition, wxDefaultSize, 
                                wxFRAME_NO_TASKBAR | wxBORDER_NONE | wxTRANSPARENT_WINDOW);
    m_hoverFrame->SetBackgroundColour(WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG);
    m_hoverFrame->SetSize(scaledW, scaledH);
    wxBoxSizer* frameSizer = new wxBoxSizer(wxVERTICAL);
    m_hoverFrame->SetSizer(frameSizer);
 
    wxStaticBitmap* hoverBmp = new wxStaticBitmap(m_hoverFrame, wxID_ANY, scaledBmp->bmp());
    frameSizer->Add(hoverBmp, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP | wxBOTTOM, FromDIP(12));
 
    wxPoint mousePos = wxGetMousePosition();
    m_hoverFrame->SetPosition(wxPoint(mousePos.x + 10, mousePos.y));
    m_hoverFrame->Layout();
    m_hoverFrame->Show(true);
 
    event.Skip();
}

References ScalableBitmap::bmp(), findNozzleImage, m_hoverFrame, m_nozzle_status, m_scaled_nozzle_empty_image, m_scaled_nozzle_image, NOZZLE_STATUS_EMPTY, NOZZLE_STATUS_UNKNOWN, WGT_DEVICE_NOZZLE_RACK_HOTEND_UPDATE_DEFAULT_BG, and Slic3r::GUI::wxMouseEvent.

Referenced by CreateGui().

Here is the call graph for this function:

Here is the caller graph for this function:

OnBitmapHoverLeave()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnBitmapHoverLeave ( wxMouseEvent & event )

private

{
    if (m_hoverFrame)
    {
        m_hoverFrame->Destroy();
        m_hoverFrame = nullptr;
    }
    event.Skip();
}

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

Referenced by CreateGui().

Here is the caller graph for this function:

OnStatusIconClick()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::OnStatusIconClick ( wxMouseEvent & event )

private

{
    if (m_status_label->GetLabel() == _L("Refresh"))
    {
        m_status_label->SetForegroundColour(wxColour("#A3A3A3"));
        m_status_label->SetLabel(_L("Refreshing"));
        m_status_bitmap->Show(false);
        // m_status_bitmap->Refresh();
        if(!m_refreshing_icon->IsPlaying()) 
        {
            m_refreshing_icon->Play();
            m_refreshing_icon->Show();
        }
        if (auto shared = m_nozzle_rack.lock())
        {
            shared->CrtlRackReadNozzle(m_rack_nozzle_id);
        }
        Layout();
    }
 
    if (m_status_label->GetLabel() == _L("Error") /*&& m_nozzle_status == NOZZLE_STATUS_ABNORMAL*/)
    {
        if (auto shared = m_nozzle_rack.lock())
        {
            MessageDialog dlg(nullptr, _L("Hotend status abnormal, unavailable at present. Please upgrade the firmware"
            " and try again."), _L("Update"), wxICON_WARNING);
            dlg.AddButton(wxID_CANCEL, _L("Cancel"), false);
            dlg.AddButton(wxID_OK,_L("Jump to the upgrade page"), true);
 
            if (dlg.ShowModal() == wxID_OK) 
            {
                if (MonitorPanel* monitor = MonitorPanel::if_built())
                    monitor->jump_to_Upgrade();
 
                wxCommandEvent evt(wxEVT_NOZZLE_JUMP_UPGRADE, GetId());
                evt.SetEventObject(this);
                wxWindow* target = GetParent();
                if (target) 
                {
                    target = target->GetParent();
                    if (target) 
                    {
                        wxPostEvent(target, evt);
                    }
                }
            };
        }
    }
}

References _L, Slic3r::GUI::MsgDialog::AddButton(), Slic3r::GUI::LazyInstance< MonitorPanel >::if_built(), m_nozzle_rack, m_rack_nozzle_id, m_refreshing_icon, m_status_bitmap, m_status_label, Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::wxMouseEvent.

Referenced by CreateGui().

Here is the call graph for this function:

Here is the caller graph for this function:

paintEvent()

void StaticBox::paintEvent ( wxPaintEvent & evt )

protectedinherited

{
    // depending on your system you may need to look at double-buffered dcs
    wxPaintDC dc(this);
    render(dc);
}

References render().

Here is the call graph for this function:

render()

void StaticBox::render ( wxDC & dc )

protectedinherited

{
#ifdef __WXMSW__
    if (radius == 0) {
        doRender(dc);
        return;
    }
 
  wxSize size = GetSize();
    if (size.x <= 0 || size.y <= 0)
        return;
    wxMemoryDC memdc(&dc);
    if (!memdc.IsOk()) {
        doRender(dc);
        return;
    }
    wxBitmap bmp(size.x, size.y);
    memdc.SelectObject(bmp);
    //memdc.Blit({0, 0}, size, &dc, {0, 0});
    memdc.SetBackground(wxBrush(GetBackgroundColour()));
    memdc.Clear();
    {
        wxGCDC dc2(memdc);
        doRender(dc2);
    }
 
    memdc.SelectObject(wxNullBitmap);
  dc.DrawBitmap(bmp, 0, 0);
#else
    doRender(dc);
#endif
}

References doRender(), and radius.

Referenced by paintEvent(), Button::render(), FanSwitchButton::render(), ImageSwitchButton::render(), SpinInput::render(), TabButton::render(), TempInput::render(), and TextInput::render().

Here is the call graph for this function:

Here is the caller graph for this function:

Rescale()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::Rescale

(

)

{
    // update images
    if (m_nozzle_image) { m_nozzle_image->msw_rescale(); }
    if (m_nozzle_empty_image) { m_nozzle_empty_image->msw_rescale(); }
    if (m_nozzle_status == NOZZLE_STATUS_EMPTY && m_nozzle_empty_image)
    {
        m_icon_bitmap->SetBitmap(m_nozzle_empty_image->bmp());
    }
    else if (m_nozzle_image != nullptr)
    {
        m_icon_bitmap->SetBitmap(m_nozzle_image->bmp());
    }
    m_icon_bitmap->Refresh();
}

References m_icon_bitmap, m_nozzle_empty_image, m_nozzle_image, m_nozzle_status, and NOZZLE_STATUS_EMPTY.

SetBackgroundColor()

void StaticBox::SetBackgroundColor ( StateColor const & color )

inherited

{
    background_color = color;
    state_handler.update_binds();
    Refresh();
}

References background_color, and state_handler.

Referenced by Slic3r::GUI::CaliPageButton::CaliPageButton(), TabCtrl::AppendItem(), MultiSwitchButton::AppendOption(), Slic3r::GUI::KBShortcutsDialog::create_page(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::CreateGui(), Slic3r::GUI::wgtDeviceNozzleRackArea::CreateNozzleBox(), Slic3r::GUI::DeviceErrorDialog::init_button(), ButtonsListCtrl::InsertPage(), TabButtonsListCtrl::InsertPage(), ButtonsListCtrl::OnPaint(), TabButtonsListCtrl::OnPaint(), Slic3r::GUI::s_set_bg_style(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::SetDisable(), Button::SetStyle(), and Slic3r::GUI::style_sidebar_icon_btn().

Here is the caller graph for this function:

SetBackgroundColor2()

void StaticBox::SetBackgroundColor2 ( StateColor const & color )

inherited

{
    background_color2 = color;
    state_handler.update_binds();
    Refresh();
}

References background_color2, and state_handler.

SetBackgroundColorNormal()

void StaticBox::SetBackgroundColorNormal ( wxColor const & color )

inherited

{
    background_color.setColorForStates(color, 0);
    Refresh();
}

References background_color.

Referenced by Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), and Slic3r::GUI::HotEndTable::CreateNozzleBox().

Here is the caller graph for this function:

SetBorderColor()

void StaticBox::SetBorderColor ( StateColor const & color )

inherited

{
    if (border_color != color) {
        border_color = color;
        state_handler.update_binds();
        Refresh();
    }
}

References border_color, and state_handler.

Referenced by Slic3r::GUI::CaliPageButton::CaliPageButton(), Slic3r::GUI::ExtruderGroup::ExtruderGroup(), TabCtrl::TabCtrl(), Slic3r::GUI::wgtDeviceNozzleRackTitle::wgtDeviceNozzleRackTitle(), MultiSwitchButton::AppendOption(), Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::CreateGui(), Slic3r::GUI::wgtDeviceNozzleRackArea::CreateNozzleBox(), Slic3r::GUI::DeviceErrorDialog::init_button(), Slic3r::GUI::s_set_bg_style(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::SetSelected(), Button::SetStyle(), and Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::UpdateColourStyle().

Here is the caller graph for this function:

SetBorderColorNormal()

void StaticBox::SetBorderColorNormal ( wxColor const & color )

inherited

{
    border_color.setColorForStates(color, 0);
    Refresh();
}

References border_color.

Referenced by Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), and Slic3r::GUI::HotEndTable::CreateNozzleBox().

Here is the caller graph for this function:

SetBorderStyle()

void StaticBox::SetBorderStyle ( wxPenStyle style )

inherited

{
    border_style = style;
    Refresh();
}

References border_style, and style.

SetBorderWidth()

void StaticBox::SetBorderWidth ( int width )

inherited

{
    border_width = width;
    Refresh();
}

References border_width.

Referenced by MultiSwitchButton::MultiSwitchButton(), Slic3r::GUI::KBShortcutsDialog::create_page(), and Button::SetStyle().

Here is the caller graph for this function:

SetCornerRadius()

void StaticBox::SetCornerRadius ( double radius )

inherited

{
    this->radius = radius;
    Refresh();
}

References radius.

Referenced by Slic3r::GUI::CaliPageButton::CaliPageButton(), Slic3r::GUI::ExtruderGroup::ExtruderGroup(), MultiSwitchButton::MultiSwitchButton(), Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::wgtDeviceNozzleRackTitle::wgtDeviceNozzleRackTitle(), TabCtrl::AppendItem(), MultiSwitchButton::AppendOption(), Slic3r::GUI::KBShortcutsDialog::create_page(), Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::CreateGui(), Slic3r::GUI::wgtDeviceNozzleRackNozzleItem::CreateGui(), Slic3r::GUI::HotEndTable::CreateNozzleBox(), Slic3r::GUI::wgtDeviceNozzleRackArea::CreateNozzleBox(), Slic3r::GUI::DeviceErrorDialog::init_button(), ButtonsListCtrl::InsertPage(), TabButtonsListCtrl::InsertPage(), Slic3r::GUI::CaliPageButton::msw_rescale(), ModeSwitchButton::Rescale(), MultiSwitchButton::SetButtonCornerRadius(), Button::SetStyle(), and Slic3r::GUI::style_sidebar_icon_btn().

Here is the caller graph for this function:

SetExtruderNozzleId()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::SetExtruderNozzleId ( int ext_nozzle_id )

inline

{ m_ext_nozzle_id = ext_nozzle_id; }

References m_ext_nozzle_id.

SetRackNozzleId()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::SetRackNozzleId ( int rack_nozzle_id )

inline

{ m_rack_nozzle_id = rack_nozzle_id; }

References m_rack_nozzle_id.

SetTopMargin()

void StaticBox::SetTopMargin ( int margin )

inherited

{
    this->top_margin = margin;
    Refresh();
}

References top_margin.

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

Here is the caller graph for this function:

ShowBadge()

void StaticBox::ShowBadge ( bool show )

inherited

{
    if (show && badge.name() != "badge") {
        badge = ScalableBitmap(this, "badge", 18);
        Refresh();
    } else if (!show && !badge.name().empty()) {
        badge = ScalableBitmap {};
        Refresh();
    }
}

References badge.

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

Here is the caller graph for this function:

sizeEvent()

void StaticBox::sizeEvent ( wxSizeEvent & evt )

protectedinherited

{
    Refresh();
    evt.Skip();
}

UpdateColourStyle()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::UpdateColourStyle

(

const wxColour &

clr

)

{
    SetBackgroundColour(clr);
    SetBorderColor(clr);
 
    // BFS: Update all children background color
    auto children = GetChildren();
    while (!children.IsEmpty())
    {
        auto win = children.front();
        children.pop_front();
        win->SetBackgroundColour(clr);
 
        for (auto child : win->GetChildren())
        {
            children.push_back(child);
        }
    }
}

References StaticBox::SetBorderColor().

Here is the call graph for this function:

UpdateExtruderNozzleInfo()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::UpdateExtruderNozzleInfo

(

const std::shared_ptr< DevNozzleRack >

rack

)

{
    m_nozzle_rack = rack;
    if (rack)
    {
        DevNozzleSystem* nozzle_system = rack->GetNozzleSystem();
        if (nozzle_system)
        {
            UpdateInfo(nozzle_system->GetExtNozzle(m_ext_nozzle_id));
        }
    }
}

References Slic3r::DevNozzleSystem::GetExtNozzle(), m_ext_nozzle_id, m_nozzle_rack, and UpdateInfo().

Here is the call graph for this function:

UpdateInfo()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::UpdateInfo ( const DevNozzle & nozzle )

private

{
    /*update nozzle possition and background*/
    if (auto share = m_nozzle_rack.lock())
    {
        // if (share->GetReadingCount() > 0 && m_status_label->IsShown())
        if (share->GetReadingCount() > 0 && m_status_label->IsShown() && m_status_label->GetLabel() == _L("Refreshing"))
        {
            m_refreshing_icon->Play();
            m_refreshing_icon->Show();
            m_nozzle_status = NOZZLE_STATUS_DC;
            return;
        }
        else
        {
            m_refreshing_icon->Stop();
            m_refreshing_icon->Show(false);
        }
    }
 
    wxString filamentDisplayName{};
    for (auto iter = GUI::wxGetApp().preset_bundle->filaments.begin(); iter != GUI::wxGetApp().preset_bundle->filaments.end(); ++iter) 
    {
        const Preset& filament_preset = *iter;
        // const auto& config = filament_preset.config;
        if (filament_preset.filament_id == nozzle.GetFilamentId()) 
        {
            filamentDisplayName = wxString(filament_preset.alias);
        }
    }
 
    if (nozzle.IsEmpty() && m_nozzle_status != NOZZLE_STATUS_EMPTY)
    {
        m_nozzle_status = NOZZLE_STATUS_EMPTY;
 
        m_material_label->Show(false);
        m_colour_box->Show(false);
 
        m_diameter_label->Show(false);
        m_flowtype_label->Show(false);
        m_type_label->SetLabel(_L("Empty"));
        m_type_label->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));
 
        m_sn_label->Show(false);
        m_version_label->Show(false);
        m_version_new_label->Show(false);
 
        updateNozzleImage(nozzle);
 
        m_used_time->Show(false);
        m_status_label->Show(false);
        m_status_bitmap->Show(false);
 
    }
    else if (nozzle.IsNormal() && m_nozzle_status != NOZZLE_STATUS_NORMAL)
    {
        m_nozzle_status = NOZZLE_STATUS_NORMAL;
 
        m_material_label->SetLabel(filamentDisplayName);
        m_colour_box->SetBackgroundColour(wxColour("#" + nozzle.GetFilamentColor()));
        m_colour_box->SetBorderColor(wxColour("#" + nozzle.GetFilamentColor()));
        m_material_label->Show(true);
        m_colour_box->Show(true);
 
        m_diameter_label->Show(true);
        m_flowtype_label->Show(true);
        m_diameter_label->SetLabel(nozzle.GetNozzleDiameterStr());
        m_flowtype_label->SetLabel(nozzle.GetNozzleFlowTypeStr());
        m_type_label->SetLabel(nozzle.GetNozzleTypeStr());
        m_type_label->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));
 
        m_sn_label->Show(true);
        m_version_label->Show(true);
 
        updateNozzleImage(nozzle);
 
        m_used_time->Show(true);
        m_status_label->Show(false);
        m_status_bitmap->Show(false);
    }
    else if (nozzle.IsAbnormal() && m_nozzle_status != NOZZLE_STATUS_ABNORMAL)
    {
        m_nozzle_status = NOZZLE_STATUS_ABNORMAL;
 
        m_material_label->SetLabel(filamentDisplayName);
        m_colour_box->SetBackgroundColour(wxColour("#" + nozzle.GetFilamentColor()));
        m_colour_box->SetBorderColor(wxColour("#" + nozzle.GetFilamentColor()));
        m_material_label->Show(true);
        m_colour_box->Show(true);
 
        m_diameter_label->Show(true);
        m_flowtype_label->Show(true);
        m_diameter_label->SetLabel(nozzle.GetNozzleDiameterStr());
        m_flowtype_label->SetLabel(nozzle.GetNozzleFlowTypeStr());
        m_type_label->SetLabel(nozzle.GetNozzleTypeStr());
        m_type_label->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));
 
        updateNozzleImage(nozzle);
 
        m_status_label->Show(true);
        m_status_bitmap->Show(true);
        m_status_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#E14747")));
        m_status_label->SetLabel(_L("Error"));
        m_status_bitmap->SetBitmap(m_error_icon->bmp());
        m_status_bitmap->Refresh();
    }
    else if (nozzle.IsUnknown()  && m_nozzle_status != NOZZLE_STATUS_UNKNOWN)
    {
        m_nozzle_status = NOZZLE_STATUS_UNKNOWN;
 
        m_colour_box->Show(false);
        m_material_label->SetLabel(wxString("--"));
        m_material_label->Show(true);
 
        m_diameter_label->Show(false);
        m_flowtype_label->Show(false);
        m_type_label->SetLabel(_L("Unknown"));
        m_type_label->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));
 
        m_sn_label->Show(true);
        m_version_label->Show(true);
 
        updateNozzleImage(nozzle);
 
        m_used_time->Show(true);
        m_status_label->Show(true);
        m_status_bitmap->Show(true);
        m_status_label->SetForegroundColour(wxColour("#009688")); // Orca: accent green
        m_status_label->SetLabel(_L("Refresh"));
        m_status_bitmap->SetBitmap(m_refresh_icon->bmp());
        m_status_bitmap->Refresh();
    }
 
    // Update firmware info
    const DevFirmwareVersionInfo& firmware = nozzle.GetFirmwareInfo();
    if (nozzle.IsUnknown())
    {
        m_sn_label->SetLabel(wxString::Format("%s: --", _L("SN")));
        m_version_label->SetLabel(wxString::Format("%s: --", _L("Version")));
        m_version_new_label->Show(false);
    }
    if (nozzle.IsNormal() || nozzle.IsAbnormal())
    {
        if (firmware.isValid())
        {
            m_sn_label->SetLabel(wxString::Format("%s: %s", _L("SN"), firmware.sn));
 
            if (!firmware.sw_new_ver.empty() && firmware.sw_new_ver != firmware.sw_ver)
            {
                m_version_label->SetLabel(wxString::Format("%s: %s > ", _L("Version"), firmware.sw_ver));
                m_version_new_label->SetLabel(wxString::Format("%s", firmware.sw_new_ver));
                m_version_new_label->Show(true);
            }
            else
            {
                m_version_label->SetLabel(wxString::Format("%s:%s", _L("Version"), firmware.sw_ver));
                m_version_new_label->Show(false);
            }
        }
        else
        {
            m_sn_label->SetLabel(wxString::Format("%s: --", _L("SN")));
            m_version_label->SetLabel(wxString::Format("%s: --", _L("Version")));
            m_version_new_label->Show(false);
        }
    }
 
    if (!nozzle.IsEmpty())
    {
        if (nozzle.IsUnknown())
        {
            m_used_time->SetLabel(wxString::Format(_L("Used Time: %s"), "--h"));
        }
        else
        {
            // Update used time
            int usedSeconds = nozzle.GetNozzlePrintTime();
            if (usedSeconds < 60)
            {
                m_used_time->SetLabel(wxString::Format(_L("Used Time: %s"), "0 h"));
            }
            else
            {
                int printTime = (usedSeconds >= 3600 ? usedSeconds / 3600 : usedSeconds / 60);
                std::string printTimeStr = (usedSeconds >= 3600 ? std::to_string(printTime) + " h" : std::to_string(printTime) + " min");
                m_used_time->SetLabel(wxString::Format(_L("Used Time: %s"), printTimeStr.c_str()));
            }
        }
 
    }
}

References _L, Slic3r::Preset::alias, StateColor::darkModeColorFor(), Slic3r::Preset::filament_id, Slic3r::DevNozzle::GetFilamentColor(), Slic3r::DevNozzle::GetFilamentId(), Slic3r::DevNozzle::GetFirmwareInfo(), Slic3r::DevNozzle::GetNozzleDiameterStr(), Slic3r::DevNozzle::GetNozzleFlowTypeStr(), Slic3r::DevNozzle::GetNozzlePrintTime(), Slic3r::DevNozzle::GetNozzleTypeStr(), Slic3r::DevNozzle::IsAbnormal(), Slic3r::DevNozzle::IsEmpty(), Slic3r::DevNozzle::IsNormal(), Slic3r::DevNozzle::IsUnknown(), Slic3r::DevFirmwareVersionInfo::isValid(), m_colour_box, m_diameter_label, m_error_icon, m_flowtype_label, m_material_label, m_nozzle_rack, m_nozzle_status, m_refresh_icon, m_refreshing_icon, m_sn_label, m_status_bitmap, m_status_label, m_type_label, m_used_time, m_version_label, m_version_new_label, NOZZLE_STATUS_ABNORMAL, NOZZLE_STATUS_DC, NOZZLE_STATUS_EMPTY, NOZZLE_STATUS_NORMAL, NOZZLE_STATUS_UNKNOWN, Slic3r::DevFirmwareVersionInfo::sn, Slic3r::DevFirmwareVersionInfo::sw_new_ver, Slic3r::DevFirmwareVersionInfo::sw_ver, and updateNozzleImage().

Referenced by UpdateExtruderNozzleInfo(), and UpdateRackNozzleInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

updateNozzleImage()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::updateNozzleImage ( const DevNozzle & nozzle )

private

{
    if (m_nozzle_status == NOZZLE_STATUS_UNKNOWN || m_nozzle_status == NOZZLE_STATUS_EMPTY)
    {
        if (!m_nozzle_empty_image) {m_nozzle_empty_image = new ScalableBitmap(this, "dev_rack_nozzle_empty", 46);}
        m_icon_bitmap->SetBitmap(m_nozzle_empty_image->bmp());
        m_icon_bitmap->Refresh();
        return;
    }
    findNozzleImage = false;
    int index = -1;
    switch (nozzle.GetNozzleDiameterType()) {
        case NOZZLE_DIAMETER_0_2: index = 0; break;
        case NOZZLE_DIAMETER_0_4: index = 1; break;
        case NOZZLE_DIAMETER_0_6: index = 2; break;
        case NOZZLE_DIAMETER_0_8: index = 3; break;
        default:                  index = -1; break;
    }
    NozzleType nozzleType = nozzle.GetNozzleType();
    if (nozzleType == ntHardenedSteel || nozzleType == ntStainlessSteel)
    {
        if (nozzle.GetNozzleFlowType() == H_FLOW && index >= 1)
        {
            m_nozzle_image = nozzle_hh[index - 1][0];
            m_icon_bitmap->SetBitmap(m_nozzle_image->bmp());
            m_scaled_nozzle_image = nozzle_hh[index - 1][1];
            findNozzleImage = true;
        }
        else if (nozzle.GetNozzleFlowType() == S_FLOW && index >= 0)
        {
            m_nozzle_image = nozzle_hs[index][0];
            m_icon_bitmap->SetBitmap(m_nozzle_image->bmp());
            m_scaled_nozzle_image = nozzle_hs[index][1];
            findNozzleImage = true;
        }
    }
    if (!findNozzleImage)
    {
        if (!m_nozzle_empty_image) {m_nozzle_empty_image = new ScalableBitmap(this, "dev_rack_nozzle_empty", 46);}
        m_icon_bitmap->SetBitmap(m_nozzle_empty_image->bmp());
    }
    m_icon_bitmap->Refresh();
}

References findNozzleImage, Slic3r::DevNozzle::GetNozzleDiameterType(), Slic3r::DevNozzle::GetNozzleFlowType(), Slic3r::DevNozzle::GetNozzleType(), Slic3r::H_FLOW, m_icon_bitmap, m_nozzle_empty_image, m_nozzle_image, m_nozzle_status, m_scaled_nozzle_image, Slic3r::NOZZLE_DIAMETER_0_2, Slic3r::NOZZLE_DIAMETER_0_4, Slic3r::NOZZLE_DIAMETER_0_6, Slic3r::NOZZLE_DIAMETER_0_8, nozzle_hh, nozzle_hs, NOZZLE_STATUS_EMPTY, NOZZLE_STATUS_UNKNOWN, Slic3r::ntHardenedSteel, Slic3r::ntStainlessSteel, and Slic3r::S_FLOW.

Referenced by UpdateInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateRackNozzleInfo()

void Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::UpdateRackNozzleInfo

(

const std::shared_ptr< DevNozzleRack >

rack

)

{
    m_nozzle_rack = rack;
    if (rack)
    {
        UpdateInfo(rack->GetNozzle(m_rack_nozzle_id));
    }
}

References m_nozzle_rack, m_rack_nozzle_id, and UpdateInfo().

Here is the call graph for this function:

Member Data Documentation

background_color

StateColor StaticBox::background_color

protectedinherited

Referenced by Button::Button(), FanSwitchButton::FanSwitchButton(), ImageSwitchButton::ImageSwitchButton(), ModeSwitchButton::ModeSwitchButton(), TabButton::TabButton(), Create(), ModeSwitchButton::doRender(), doRender(), SetBackgroundColor(), SetBackgroundColorNormal(), and TabButton::SetBGColor().

background_color2

StateColor StaticBox::background_color2

protectedinherited

Referenced by Create(), doRender(), and SetBackgroundColor2().

badge

ScalableBitmap StaticBox::badge

protectedinherited

Referenced by doRender(), and ShowBadge().

border_color

StateColor StaticBox::border_color

protectedinherited

Referenced by FanSwitchButton::FanSwitchButton(), ImageSwitchButton::ImageSwitchButton(), ModeSwitchButton::ModeSwitchButton(), StaticBox(), StepCtrlBase::StepCtrlBase(), Create(), ModeSwitchButton::doRender(), doRender(), TabCtrl::doRender(), SetBorderColor(), SetBorderColorNormal(), and Button::SetStyle().

border_style

wxPenStyle StaticBox::border_style = wxPENSTYLE_SOLID

protectedinherited

Referenced by doRender(), and SetBorderStyle().

border_width

int StaticBox::border_width = 1

protectedinherited

Referenced by FilamentStepIndicator::FilamentStepIndicator(), StepCtrl::StepCtrl(), StepIndicator::StepIndicator(), TabCtrl::TabCtrl(), Create(), doRender(), TabCtrl::doRender(), and SetBorderWidth().

findNozzleImage

bool Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::findNozzleImage = false

private

Referenced by OnBitmapHoverEnter(), and updateNozzleImage().

m_colour_box

StaticBox* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_colour_box { nullptr }

private

{ nullptr };

Referenced by CreateGui(), and UpdateInfo().

m_diameter_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_diameter_label

private

Referenced by CreateGui(), and UpdateInfo().

m_error_icon

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_error_icon = nullptr

private

Referenced by CreateGui(), and UpdateInfo().

m_ext_nozzle_id

int Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_ext_nozzle_id = -1

private

Referenced by GetExtruderNozzleId(), SetExtruderNozzleId(), and UpdateExtruderNozzleInfo().

m_flowtype_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_flowtype_label

private

Referenced by CreateGui(), and UpdateInfo().

m_hoverFrame

wxFrame* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_hoverFrame { nullptr }

private

{ nullptr };

Referenced by OnBitmapHoverEnter(), and OnBitmapHoverLeave().

m_icon_bitmap

wxStaticBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_icon_bitmap { nullptr }

private

{ nullptr };

Referenced by CreateGui(), Rescale(), and updateNozzleImage().

m_idx_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_idx_label

private

Referenced by wgtDeviceNozzleRackHotendUpdate(), and CreateGui().

m_material_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_material_label { nullptr }

private

{ nullptr };

Referenced by CreateGui(), and UpdateInfo().

m_nozzle_empty_image

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_nozzle_empty_image = nullptr

private

Referenced by CreateGui(), Rescale(), and updateNozzleImage().

m_nozzle_image

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_nozzle_image = nullptr

private

Referenced by Rescale(), and updateNozzleImage().

m_nozzle_rack

std::weak_ptr<DevNozzleRack> Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_nozzle_rack

private

Referenced by OnStatusIconClick(), UpdateExtruderNozzleInfo(), UpdateInfo(), and UpdateRackNozzleInfo().

m_nozzle_status

NozzleStatus Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_nozzle_status = NOZZLE_STATUS_DC

private

Referenced by OnBitmapHoverEnter(), Rescale(), UpdateInfo(), and updateNozzleImage().

m_rack_nozzle_id

int Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_rack_nozzle_id = -1

private

Referenced by GetRackNozzleId(), OnStatusIconClick(), SetRackNozzleId(), and UpdateRackNozzleInfo().

m_refresh_icon

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_refresh_icon = nullptr

private

Referenced by CreateGui(), and UpdateInfo().

m_refreshing_icon

AnimaIcon* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_refreshing_icon = nullptr

private

Referenced by CreateGui(), OnStatusIconClick(), and UpdateInfo().

m_scaled_nozzle_empty_image

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_scaled_nozzle_empty_image = nullptr

private

Referenced by OnBitmapHoverEnter().

m_scaled_nozzle_image

ScalableBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_scaled_nozzle_image = nullptr

private

Referenced by OnBitmapHoverEnter(), and updateNozzleImage().

m_sn_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_sn_label

private

Referenced by CreateGui(), and UpdateInfo().

m_status_bitmap

wxStaticBitmap* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_status_bitmap { nullptr }

private

{ nullptr };

Referenced by CreateGui(), OnStatusIconClick(), and UpdateInfo().

m_status_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_status_label { nullptr }

private

{ nullptr };

Referenced by CreateGui(), OnStatusIconClick(), and UpdateInfo().

m_type_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_type_label

private

Referenced by CreateGui(), and UpdateInfo().

m_used_time

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_used_time { nullptr }

private

{ nullptr };

Referenced by CreateGui(), and UpdateInfo().

m_version_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_version_label

private

Referenced by CreateGui(), and UpdateInfo().

m_version_new_label

Label* Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::m_version_new_label

private

Referenced by CreateGui(), and UpdateInfo().

nozzle_hh

std::vector<std::vector<ScalableBitmap*> > Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::nozzle_hh

private

Referenced by CreateGui(), and updateNozzleImage().

nozzle_hs

std::vector<std::vector<ScalableBitmap*> > Slic3r::GUI::wgtDeviceNozzleRackHotendUpdate::nozzle_hs

private

Referenced by CreateGui(), and updateNozzleImage().

radius

double StaticBox::radius

protectedinherited

Referenced by FanSwitchButton::FanSwitchButton(), ImageSwitchButton::ImageSwitchButton(), StaticBox(), StepCtrlBase::StepCtrlBase(), TabCtrl::TabCtrl(), doRender(), TabCtrl::doRender(), render(), MultiSwitchButton::SetButtonCornerRadius(), and SetCornerRadius().

state_handler

StateHandler StaticBox::state_handler

protectedinherited

Referenced by ModeSwitchButton::ModeSwitchButton(), StaticBox(), Button::Create(), Create(), TabButton::Create(), FilamentStepIndicator::doRender(), ModeSwitchButton::doRender(), doRender(), StepCtrl::doRender(), StepIndicator::doRender(), TabCtrl::doRender(), Button::GetValue(), Button::render(), FanSwitchButton::render(), ImageSwitchButton::render(), TabButton::render(), SetBackgroundColor(), SetBackgroundColor2(), TabButton::SetBGColor(), SetBorderColor(), TabButton::SetBorderColor(), Button::SetTextColor(), FanSwitchButton::SetTextColor(), ImageSwitchButton::SetTextColor(), TabButton::SetTextColor(), and Button::SetValue().

top_margin

int StaticBox::top_margin = 0

protectedinherited

Referenced by doRender(), and SetTopMargin().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceTab/wgtDeviceNozzleRackUpdate.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/DeviceTab/wgtDeviceNozzleRackUpdate.cpp