Slic3r::GUI::MultiMachineItem Class Reference

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

Inheritance diagram for Slic3r::GUI::MultiMachineItem:

Collaboration diagram for Slic3r::GUI::MultiMachineItem:

Public Member Functions
	MultiMachineItem (wxWindow *parent, MachineObject *obj)
	~MultiMachineItem ()
void	OnEnterWindow (wxMouseEvent &evt)
void	OnLeaveWindow (wxMouseEvent &evt)
void	OnLeftDown (wxMouseEvent &evt)
void	OnMove (wxMouseEvent &evt)
void	paintEvent (wxPaintEvent &evt)
void	render (wxDC &dc)
void	DrawTextWithEllipsis (wxDC &dc, const wxString &text, int maxWidth, int left, int top=0)
void	doRender (wxDC &dc)
void	post_event (wxCommandEvent &&event)
virtual void	DoSetSize (int x, int y, int width, int height, int sizeFlags=wxSIZE_AUTO)
wxString	get_left_time (int mc_left_time)
void	on_refresh (wxCommandEvent &evt)
void	sync_state ()
wxString	get_state_printable ()
int	get_state_printable () const
wxString	get_state_device ()
int	get_state_device () const
wxString	get_local_state_task ()
wxString	get_cloud_state_task ()
MachineObject *	get_obj () const
int	get_state_online () const
int	get_state_selected () const
int	get_state_enable_ams () const
int	get_state_local_task () const
int	get_state_cloud_task () const
std::string	get_state_dev_name () const
void	selected ()
void	unselected ()
void	update_item (const DeviceItem *item)

Public Attributes
bool	m_hover { false }
ScalableBitmap	m_bitmap_check_disable
ScalableBitmap	m_bitmap_check_off
ScalableBitmap	m_bitmap_check_on
MachineObject *	obj_ {nullptr}
int	state_online = { 0 }
std::string	state_dev_name
int	state_printable { 0 }
int	state_selected { 0 }
int	state_enable_ams { 0 }
int	state_device { 0 }
int	state_local_task { 0 }
int	state_cloud_task { 0 }
int	state_optional {0}
std::string	m_send_time

Detailed Description

Constructor & Destructor Documentation

MultiMachineItem()

Slic3r::GUI::MultiMachineItem::MultiMachineItem	(	wxWindow *	parent,
		MachineObject *	obj )

    : DeviceItem(parent, obj)
{
    SetBackgroundColour(*wxWHITE);
    SetMinSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    SetMaxSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
 
    Bind(wxEVT_PAINT, &MultiMachineItem::paintEvent, this);
    Bind(wxEVT_ENTER_WINDOW, &MultiMachineItem::OnEnterWindow, this);
    Bind(wxEVT_LEAVE_WINDOW, &MultiMachineItem::OnLeaveWindow, this);
    Bind(wxEVT_LEFT_DOWN, &MultiMachineItem::OnLeftDown, this);
    Bind(wxEVT_MOTION, &MultiMachineItem::OnMove, this);
    Bind(EVT_MULTI_DEVICE_VIEW, [obj](auto& e) {
        wxGetApp().mainframe->jump_to_monitor(obj->get_dev_id());
        MonitorPanel* monitor = MonitorPanel::if_built();
        if (monitor && monitor->get_status_panel()->get_media_play_ctrl()) {
            monitor->get_status_panel()->get_media_play_ctrl()->jump_to_play();
        }
    });
    wxGetApp().UpdateDarkUIWin(this);
}

References Slic3r::GUI::DeviceItem::DeviceItem(), DEVICE_ITEM_MAX_HEIGHT, DEVICE_ITEM_MAX_WIDTH, Slic3r::MachineObject::get_dev_id(), Slic3r::GUI::StatusBasePanel::get_media_play_ctrl(), Slic3r::GUI::MonitorPanel::get_status_panel(), Slic3r::GUI::LazyInstance< MonitorPanel >::if_built(), Slic3r::GUI::MediaPlayCtrl::jump_to_play(), OnEnterWindow(), OnLeaveWindow(), OnLeftDown(), OnMove(), and paintEvent().

Here is the call graph for this function:

~MultiMachineItem()

Slic3r::GUI::MultiMachineItem::~MultiMachineItem ( )

inline

{};

Member Function Documentation

doRender()

void Slic3r::GUI::MultiMachineItem::doRender

(

wxDC &

dc

)

{
    wxSize size = GetSize();
    dc.SetPen(wxPen(*wxBLACK));
 
    int left = FromDIP(DEVICE_LEFT_PADDING_LEFT);
 
    if (obj_) {
        //dev name
        wxString dev_name = wxString::FromUTF8(obj_->get_dev_name());
        if (!obj_->is_online()) {
            dev_name = dev_name + "(" + _L("Offline") + ")";
        }
        dc.SetFont(Label::Body_13);
        DrawTextWithEllipsis(dc, dev_name, FromDIP(DEVICE_LEFT_DEV_NAME), left);
        left += FromDIP(DEVICE_LEFT_DEV_NAME);
 
        //project name
        wxString project_name = _L("No task");
        if (obj_->is_in_printing()) {
            project_name = wxString::Format("%s", GUI::from_u8(obj_->subtask_name));
        }
        dc.SetFont(Label::Body_13);
        DrawTextWithEllipsis(dc, project_name, FromDIP(DEVICE_LEFT_PRO_NAME), left);
        left += FromDIP(DEVICE_LEFT_PRO_NAME);
 
        //state
        dc.SetFont(Label::Body_13);
        if (state_device == 0) {
            dc.SetTextForeground(*wxBLACK);
            DrawTextWithEllipsis(dc, get_state_device(), FromDIP(DEVICE_LEFT_PRO_INFO), left);
        }
        else if (state_device == 1) {
            dc.SetTextForeground(wxColour(0,174,66));
            DrawTextWithEllipsis(dc, get_state_device(), FromDIP(DEVICE_LEFT_PRO_INFO), left);
        }
        else if (state_device == 2)
        {
            dc.SetTextForeground(wxColour(208,27,27));
            DrawTextWithEllipsis(dc, get_state_device(), FromDIP(DEVICE_LEFT_PRO_INFO), left);
        }
        else if (state_device > 2 && state_device < 7) {
            dc.SetFont(Label::Body_12);
            dc.SetTextForeground(wxColour(0, 150, 136));
            if (obj_->get_curr_stage() == _L("Printing") && obj_->subtask_) {
                //wxString layer_info = wxString::Format(_L("Layer: %d/%d"), obj_->curr_layer, obj_->total_layers);
                wxString progress_info = wxString::Format("%d", obj_->subtask_->task_progress);
                wxString left_time = wxString::Format("%s", get_left_time(obj_->mc_left_time));
 
                DrawTextWithEllipsis(dc, progress_info + "%  |  " + left_time, FromDIP(DEVICE_LEFT_PRO_INFO), left, FromDIP(10));
 
 
                dc.SetPen(wxPen(wxColour(233,233,233)));
                dc.SetBrush(wxBrush(wxColour(233,233,233)));
                dc.DrawRoundedRectangle(left, FromDIP(30), FromDIP(DEVICE_LEFT_PRO_INFO), FromDIP(10), 2);
 
                dc.SetPen(wxPen(wxColour(0, 150, 136)));
                dc.SetBrush(wxBrush(wxColour(0, 150, 136)));
                dc.DrawRoundedRectangle(left, FromDIP(30), FromDIP(DEVICE_LEFT_PRO_INFO) * (static_cast<float>(obj_->subtask_->task_progress) / 100.0f), FromDIP(10), 2);
            }
            else {
                DrawTextWithEllipsis(dc, obj_->get_curr_stage(), FromDIP(DEVICE_LEFT_PRO_INFO), left);
            }
 
        }
        else {
            dc.SetTextForeground(*wxBLACK);
            DrawTextWithEllipsis(dc, get_state_device(), FromDIP(DEVICE_LEFT_PRO_INFO), left);
        }
 
        left += FromDIP(DEVICE_LEFT_PRO_INFO);
 
        //button
        dc.SetPen(wxPen(wxColour(38, 46, 48)));
        dc.SetBrush(wxBrush(wxColour(*wxWHITE)));
        dc.DrawRoundedRectangle(left, (size.y - FromDIP(38)) / 2, FromDIP(90), FromDIP(38), 6);
        dc.SetFont(Label::Body_14);
        dc.SetTextForeground(*wxBLACK);
        dc.DrawText(_L_CONTEXT("View", "Verb"),left + FromDIP(90) / 2 - dc.GetTextExtent(_L_CONTEXT("View", "Verb")).x / 2, (size.y -dc.GetTextExtent(_L_CONTEXT("View", "Verb")).y) / 2);
 
    }
 
    if (m_hover) {
        dc.SetPen(wxPen(wxColour(0, 150, 136)));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawRoundedRectangle(0, 0, size.x, size.y, 3);
    }
}

References _L, _L_CONTEXT, Label::Body_12, Label::Body_13, Label::Body_14, DEVICE_LEFT_DEV_NAME, DEVICE_LEFT_PADDING_LEFT, DEVICE_LEFT_PRO_INFO, DEVICE_LEFT_PRO_NAME, DrawTextWithEllipsis(), Slic3r::GUI::from_u8(), get_left_time(), Slic3r::GUI::DeviceItem::get_state_device(), m_hover, Slic3r::GUI::DeviceItem::obj_, and Slic3r::GUI::DeviceItem::state_device.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSetSize()

void Slic3r::GUI::MultiMachineItem::DoSetSize ( int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO )

virtual

{
    wxWindow::DoSetSize(x, y, width, height, sizeFlags);
}

DrawTextWithEllipsis()

void Slic3r::GUI::MultiMachineItem::DrawTextWithEllipsis	(	wxDC &	dc,
		const wxString &	text,
		int	maxWidth,
		int	left,
		int	top = 0 )

                                                                                                           {
    wxSize size = GetSize();
    wxFont font = dc.GetFont();
 
    wxSize textSize = dc.GetTextExtent(text);
    dc.SetTextForeground(StateColor::darkModeColorFor(wxColour(50, 58, 61)));
    int textWidth = textSize.GetWidth();
 
    if (textWidth > maxWidth) {
        wxString truncatedText = text;
        int ellipsisWidth = dc.GetTextExtent("...").GetWidth();
        int numChars = text.length();
 
        for (int i = numChars - 1; i >= 0; --i) {
            truncatedText = text.substr(0, i) + "...";
            int truncatedWidth = dc.GetTextExtent(truncatedText).GetWidth();
 
            if (truncatedWidth <= maxWidth - ellipsisWidth) {
                break;
            }
        }
 
        if (top == 0) {
            dc.DrawText(truncatedText, left, (size.y - textSize.y) / 2);
        }
        else {
            dc.DrawText(truncatedText, left, (size.y - textSize.y) / 2 - top);
        }
 
    }
    else {
        if (top == 0) {
            dc.DrawText(text, left, (size.y - textSize.y) / 2);
        }
        else {
            dc.DrawText(text, left, (size.y - textSize.y) / 2 - top);
        }
    }
}

References StateColor::darkModeColorFor().

Referenced by doRender().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cloud_state_task()

wxString Slic3r::GUI::DeviceItem::get_cloud_state_task ( )

inherited

{
    //0-printing 1-printing finish 2-printing failed
    std::vector<wxString> str_state_task;
    str_state_task.push_back(_L("Printing"));
    str_state_task.push_back(_L("Printing Finish"));
    str_state_task.push_back(_L("Printing Failed"));
 
    return str_state_task[state_cloud_task];
}

References _L, and state_cloud_task.

Referenced by Slic3r::GUI::MultiTaskItem::doRender().

Here is the caller graph for this function:

get_left_time()

wxString Slic3r::GUI::MultiMachineItem::get_left_time

(

int

mc_left_time

)

{
    // update gcode progress
    std::string left_time;
    wxString    left_time_text = _L("N/A");
 
    try {
        left_time = get_bbl_monitor_time_dhm(mc_left_time);
    }
    catch (...) {
        ;
    }
 
    if (!left_time.empty()) left_time_text = wxString::Format("-%s", left_time);
    return left_time_text;
}

References _L, and Slic3r::get_bbl_monitor_time_dhm().

Referenced by doRender().

Here is the call graph for this function:

Here is the caller graph for this function:

get_local_state_task()

wxString Slic3r::GUI::DeviceItem::get_local_state_task ( )

inherited

{
    //0-padding  1-sending 2-sending finish  3-sending cancel  4-sending failed 5-Removed
    std::vector<wxString> str_state_task;
    str_state_task.push_back(_L("Pending"));
    str_state_task.push_back(_L("Sending"));
    str_state_task.push_back(_L("Sending Finish"));
    str_state_task.push_back(_L("Sending Cancel"));
    str_state_task.push_back(_L("Sending Failed"));
    str_state_task.push_back(_L("Printing"));
    str_state_task.push_back(_L("Print Success"));
    str_state_task.push_back(_L("Print Failed"));
    str_state_task.push_back(_L("Removed"));
    str_state_task.push_back(_L("Idle"));   
    return str_state_task[state_local_task];
}

References _L, and state_local_task.

Referenced by Slic3r::GUI::MultiTaskItem::doRender().

Here is the caller graph for this function:

get_obj()

MachineObject * Slic3r::GUI::DeviceItem::get_obj ( ) const

inlineinherited

{ return obj_; }

References obj_.

Referenced by Slic3r::GUI::DevicePickItem::doRender(), Slic3r::GUI::MultiTaskItem::doRender(), Slic3r::GUI::SendDeviceItem::doRender(), Slic3r::GUI::MultiTaskItem::onCancel(), Slic3r::GUI::MultiTaskItem::onPause(), Slic3r::GUI::MultiTaskItem::onResume(), Slic3r::GUI::MultiTaskItem::onStop(), and Slic3r::GUI::MultiTaskItem::update_info().

Here is the caller graph for this function:

get_state_cloud_task()

int Slic3r::GUI::DeviceItem::get_state_cloud_task ( ) const

inlineinherited

{ return state_cloud_task; }

References state_cloud_task.

get_state_dev_name()

std::string Slic3r::GUI::DeviceItem::get_state_dev_name ( ) const

inlineinherited

{ return state_dev_name; }

References state_dev_name.

get_state_device() [1/2]

wxString Slic3r::GUI::DeviceItem::get_state_device ( )

inherited

{
    //0-idle 1-finish 2-running 3-pause 4-failed  5-prepare 
    std::vector<wxString> str_state_device;
    str_state_device.push_back(_L("Idle"));
    str_state_device.push_back(_L("Printing Finish"));
    str_state_device.push_back(_L("Printing Failed"));
    str_state_device.push_back(_L("Printing"));
    str_state_device.push_back(_L("Printing Pause"));
    str_state_device.push_back(_L_CONTEXT("Prepare", "Device status"));
    str_state_device.push_back(_L("Slicing"));
    str_state_device.push_back(_L("Syncing"));
 
    return str_state_device[state_device];
}

References _L, _L_CONTEXT, and state_device.

Referenced by Slic3r::GUI::MultiMachineItem::doRender(), and Slic3r::GUI::MultiTaskItem::doRender().

Here is the caller graph for this function:

get_state_device() [2/2]

int Slic3r::GUI::DeviceItem::get_state_device ( ) const

inlineinherited

{ return state_device; }

References state_device.

get_state_enable_ams()

int Slic3r::GUI::DeviceItem::get_state_enable_ams ( ) const

inlineinherited

{ return state_enable_ams; }

References state_enable_ams.

get_state_local_task()

int Slic3r::GUI::DeviceItem::get_state_local_task ( ) const

inlineinherited

{ return state_local_task; }

References state_local_task.

get_state_online()

int Slic3r::GUI::DeviceItem::get_state_online ( ) const

inlineinherited

{ return state_online; }

References state_online.

get_state_printable() [1/2]

wxString Slic3r::GUI::DeviceItem::get_state_printable ( )

inherited

{
    //0-idle 1-finish 2-printing 3-upgrading 4-preset incompatible  5-unknown
    std::vector<wxString> str_state_printable;
    str_state_printable.push_back(_L("Idle"));
    str_state_printable.push_back(_L("Idle"));
    str_state_printable.push_back(_L("Idle"));
    str_state_printable.push_back(_L("Printing"));
    str_state_printable.push_back(_L("Upgrading"));
    str_state_printable.push_back(_L("Incompatible"));
    str_state_printable.push_back(_L("Syncing"));
 
    return str_state_printable[state_printable];
}

References _L, and state_printable.

Referenced by Slic3r::GUI::SendDeviceItem::doRender().

Here is the caller graph for this function:

get_state_printable() [2/2]

int Slic3r::GUI::DeviceItem::get_state_printable ( ) const

inlineinherited

{ return state_printable; }

References state_printable.

get_state_selected()

int Slic3r::GUI::DeviceItem::get_state_selected ( ) const

inlineinherited

{ return state_selected; }

References state_selected.

on_refresh()

void Slic3r::GUI::DeviceItem::on_refresh ( wxCommandEvent & evt )

inherited

{
    Refresh();
}

Referenced by DeviceItem().

Here is the caller graph for this function:

OnEnterWindow()

void Slic3r::GUI::MultiMachineItem::OnEnterWindow

(

wxMouseEvent &

evt

)

{
    m_hover = true;
    Refresh();
}

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

Referenced by MultiMachineItem().

Here is the caller graph for this function:

OnLeaveWindow()

void Slic3r::GUI::MultiMachineItem::OnLeaveWindow

(

wxMouseEvent &

evt

)

{
    m_hover = false;
    Refresh();
}

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

Referenced by MultiMachineItem().

Here is the caller graph for this function:

OnLeftDown()

void Slic3r::GUI::MultiMachineItem::OnLeftDown

(

wxMouseEvent &

evt

)

{
    int left = FromDIP(DEVICE_LEFT_PADDING_LEFT +
        DEVICE_LEFT_DEV_NAME +
        DEVICE_LEFT_PRO_NAME +
        DEVICE_LEFT_PRO_INFO);
    auto mouse_pos = ClientToScreen(evt.GetPosition());
    auto item = this->ClientToScreen(wxPoint(0, 0));
 
    if (mouse_pos.x > (item.x + left) &&
        mouse_pos.x < (item.x + left + FromDIP(90)) &&
        mouse_pos.y > item.y &&
        mouse_pos.y < (item.y + DEVICE_ITEM_MAX_HEIGHT)) {
        post_event(wxCommandEvent(EVT_MULTI_DEVICE_VIEW));
    }
}

References DEVICE_ITEM_MAX_HEIGHT, DEVICE_LEFT_DEV_NAME, DEVICE_LEFT_PADDING_LEFT, DEVICE_LEFT_PRO_INFO, DEVICE_LEFT_PRO_NAME, post_event(), and Slic3r::GUI::wxMouseEvent.

Referenced by MultiMachineItem().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMove()

void Slic3r::GUI::MultiMachineItem::OnMove

(

wxMouseEvent &

evt

)

{
    int left = FromDIP(DEVICE_LEFT_PADDING_LEFT +
        DEVICE_LEFT_DEV_NAME +
        DEVICE_LEFT_PRO_NAME +
        DEVICE_LEFT_PRO_INFO);
 
    auto mouse_pos = ClientToScreen(evt.GetPosition());
    auto item = this->ClientToScreen(wxPoint(0, 0));
 
    if (mouse_pos.x > (item.x + left) &&
        mouse_pos.x < (item.x + left + FromDIP(90)) &&
        mouse_pos.y > item.y &&
        mouse_pos.y < (item.y + DEVICE_ITEM_MAX_HEIGHT)) {
        SetCursor(wxCURSOR_HAND);
    }
    else {
        SetCursor(wxCURSOR_ARROW);
    }
}

References DEVICE_ITEM_MAX_HEIGHT, DEVICE_LEFT_DEV_NAME, DEVICE_LEFT_PADDING_LEFT, DEVICE_LEFT_PRO_INFO, DEVICE_LEFT_PRO_NAME, and Slic3r::GUI::wxMouseEvent.

Referenced by MultiMachineItem().

Here is the caller graph for this function:

paintEvent()

void Slic3r::GUI::MultiMachineItem::paintEvent

(

wxPaintEvent &

evt

)

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

References render().

Referenced by MultiMachineItem().

Here is the call graph for this function:

Here is the caller graph for this function:

post_event()

void Slic3r::GUI::MultiMachineItem::post_event

(

wxCommandEvent &&

event

)

{
    event.SetEventObject(this);
    event.SetString(obj_->get_dev_id());
    event.SetInt(state_selected);
    wxPostEvent(this, event);
}

References Slic3r::GUI::DeviceItem::obj_, and Slic3r::GUI::DeviceItem::state_selected.

Referenced by OnLeftDown().

Here is the caller graph for this function:

render()

void Slic3r::GUI::MultiMachineItem::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:

selected()

void Slic3r::GUI::DeviceItem::selected ( )

inherited

{
    if (state_selected != 2) {
        state_selected = 1;
    }
}

References state_selected.

sync_state()

void Slic3r::GUI::DeviceItem::sync_state ( )

inherited

{
    if (obj_) {
        state_online = obj_->is_online();
        state_dev_name = obj_->get_dev_name();
 
        //printable
        if (obj_->print_status == "IDLE") {
            state_printable = 0;
        }
        else if (obj_->print_status == "FINISH") {
            state_printable = 1;
        }
        else if (obj_->print_status == "FAILED") {
            state_printable = 2;
        }
        else if (obj_->is_in_printing()) {
            state_printable = 3;
        }
        else {
            state_printable = 6;
        }
 
        if (wxGetApp().is_blocking_printing(obj_)) {
            state_printable = 5;
        }
 
        if (obj_->is_in_upgrading()) {
            state_printable = 4;
        }
 
        state_enable_ams = obj_->ams_exist_bits;
 
 
        //device
        if (obj_->print_status == "IDLE") {
            state_device = 0;
        }
        else if (obj_->print_status == "FINISH") {
            state_device = 1;
        }
        else if (obj_->print_status == "FAILED") {
            state_device = 2;
        }
        else if (obj_->print_status == "RUNNING") {
            state_device = 3;
        }
        else if (obj_->print_status == "PAUSE") {
            state_device = 4;
        }
        else if (obj_->print_status == "PREPARE") {
            state_device = 5;
        }
        else if (obj_->print_status == "SLICING") {
            state_device = 6;
        }
        else {
            state_device = 7;
        }
    }
}

References obj_, state_dev_name, state_device, state_enable_ams, state_online, and state_printable.

Referenced by DeviceItem().

Here is the caller graph for this function:

unselected()

void Slic3r::GUI::DeviceItem::unselected ( )

inherited

{
    if (state_selected != 2) {
        state_selected = 0;
    }
}

References state_selected.

Referenced by Slic3r::GUI::MultiMachinePickPage::refresh_user_device().

Here is the caller graph for this function:

update_item()

void Slic3r::GUI::DeviceItem::update_item ( const DeviceItem * item )

inherited

{
    // Except for the selected status, everything else is updated
    if (this == item)
        return;
    this->state_online = item->state_online;
    this->state_printable = item->state_printable;
    this->state_enable_ams = item->state_enable_ams;
    this->state_device = item->state_device;
    this->state_local_task = item->state_local_task;
}

References DeviceItem(), state_device, state_enable_ams, state_local_task, state_online, and state_printable.

Here is the call graph for this function:

Member Data Documentation

m_bitmap_check_disable

ScalableBitmap Slic3r::GUI::MultiMachineItem::m_bitmap_check_disable

m_bitmap_check_off

ScalableBitmap Slic3r::GUI::MultiMachineItem::m_bitmap_check_off

m_bitmap_check_on

ScalableBitmap Slic3r::GUI::MultiMachineItem::m_bitmap_check_on

m_hover

bool Slic3r::GUI::MultiMachineItem::m_hover { false }

{ false };

Referenced by doRender(), OnEnterWindow(), and OnLeaveWindow().

m_send_time

std::string Slic3r::GUI::DeviceItem::m_send_time

inherited

Referenced by Slic3r::GUI::SortItem::SortItem(), Slic3r::GUI::MultiTaskItem::doRender(), Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), and Slic3r::GUI::LocalTaskManagerPage::refresh_user_device().

obj_

MachineObject* Slic3r::GUI::DeviceItem::obj_ {nullptr}

inherited

{nullptr};

Referenced by DeviceItem(), Slic3r::GUI::MultiMachineItem::doRender(), Slic3r::GUI::MultiTaskItem::doRender(), Slic3r::GUI::SendDeviceItem::doRender(), get_obj(), Slic3r::GUI::DevicePickItem::post_event(), Slic3r::GUI::MultiMachineItem::post_event(), Slic3r::GUI::SendDeviceItem::post_event(), sync_state(), and Slic3r::GUI::MultiTaskItem::update_info().

state_cloud_task

int Slic3r::GUI::DeviceItem::state_cloud_task { 0 }

inherited

{ 0 };  //0-printing 1-printing finish 2-printing failed

Referenced by Slic3r::GUI::SortItem::SortItem(), Slic3r::GUI::MultiTaskItem::doRender(), get_cloud_state_task(), get_state_cloud_task(), Slic3r::GUI::MultiTaskItem::OnLeftDown(), Slic3r::GUI::MultiTaskItem::onStop(), Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), and Slic3r::GUI::MultiTaskItem::update_info().

state_dev_name

std::string Slic3r::GUI::DeviceItem::state_dev_name

inherited

Referenced by Slic3r::GUI::SortItem::SortItem(), get_state_dev_name(), and sync_state().

state_device

int Slic3r::GUI::DeviceItem::state_device { 0 }

inherited

{ 0 };   //0-idle 1-finish 2-failed 3-running 4-pause  5-prepare  6-slicing 7-removed

Referenced by Slic3r::GUI::SortItem::SortItem(), Slic3r::GUI::MultiMachineItem::doRender(), Slic3r::GUI::MultiTaskItem::doRender(), get_state_device(), get_state_device(), sync_state(), and update_item().

state_enable_ams

int Slic3r::GUI::DeviceItem::state_enable_ams { 0 }

inherited

{ 0 };//0-no ams 1-enabled ams 2-not enabled ams

Referenced by Slic3r::GUI::SortItem::SortItem(), get_state_enable_ams(), sync_state(), and update_item().

state_local_task

int Slic3r::GUI::DeviceItem::state_local_task { 0 }

inherited

{ 0 };  //0-padding  1-sending 2-sending finish  3-sending cancel  4-sending failed 5-TS_PRINT_SUCCESS 6- TS_PRINT_FAILED 7-TS_REMOVED 8-TS_IDLE

Referenced by Slic3r::GUI::SortItem::SortItem(), Slic3r::GUI::MultiTaskItem::doRender(), Slic3r::GUI::SendDeviceItem::doRender(), get_local_state_task(), get_state_local_task(), Slic3r::GUI::MultiTaskItem::OnLeftDown(), Slic3r::GUI::LocalTaskManagerPage::refresh_user_device(), Slic3r::GUI::MultiTaskItem::update_info(), and update_item().

state_online

int Slic3r::GUI::DeviceItem::state_online = { 0 }

inherited

{ 0 }; //0-Offline 1-Online

Referenced by Slic3r::GUI::SortItem::SortItem(), get_state_online(), sync_state(), and update_item().

state_optional

int Slic3r::GUI::DeviceItem::state_optional {0}

inherited

{0}; //0-Not optional 1-Optional

state_printable

int Slic3r::GUI::DeviceItem::state_printable { 0 }

inherited

{ 0 }; //0-idle 1-finish 2-failed 3-printing 4-upgrading 5-preset incompatible  6-unknown

Referenced by Slic3r::GUI::SortItem::SortItem(), Slic3r::GUI::SendDeviceItem::doRender(), get_state_printable(), get_state_printable(), Slic3r::GUI::SendDeviceItem::OnLeftDown(), Slic3r::GUI::SendMultiMachinePage::refresh_user_device(), sync_state(), and update_item().

state_selected

int Slic3r::GUI::DeviceItem::state_selected { 0 }

inherited

{ 0 };  //0-selected 1-unselected 2-un selectable

Referenced by Slic3r::GUI::DevicePickItem::doRender(), Slic3r::GUI::MultiTaskItem::doRender(), Slic3r::GUI::SendDeviceItem::doRender(), get_state_selected(), Slic3r::GUI::DevicePickItem::OnSelectedDevice(), Slic3r::GUI::MultiTaskItem::OnSelectedDevice(), Slic3r::GUI::SendDeviceItem::OnSelectedDevice(), Slic3r::GUI::DevicePickItem::post_event(), Slic3r::GUI::MultiMachineItem::post_event(), Slic3r::GUI::MultiTaskItem::post_event(), Slic3r::GUI::SendDeviceItem::post_event(), Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), Slic3r::GUI::LocalTaskManagerPage::refresh_user_device(), Slic3r::GUI::MultiMachinePickPage::refresh_user_device(), Slic3r::GUI::SendMultiMachinePage::refresh_user_device(), selected(), and unselected().

---

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

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