Slic3r::GUI::DevicePickItem Class Reference

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

Inheritance diagram for Slic3r::GUI::DevicePickItem:

Collaboration diagram for Slic3r::GUI::DevicePickItem:

Public Member Functions
	DevicePickItem (wxWindow *parent, MachineObject *obj)
	~DevicePickItem ()
void	DrawTextWithEllipsis (wxDC &dc, const wxString &text, int maxWidth, int left, int top=0)
void	OnEnterWindow (wxMouseEvent &evt)
void	OnLeaveWindow (wxMouseEvent &evt)
void	OnSelectedDevice (wxCommandEvent &evt)
void	OnLeftDown (wxMouseEvent &evt)
void	OnMove (wxMouseEvent &evt)
void	paintEvent (wxPaintEvent &evt)
void	render (wxDC &dc)
void	doRender (wxDC &dc)
void	post_event (wxCommandEvent &&event)
virtual void	DoSetSize (int x, int y, int width, int height, int sizeFlags=wxSIZE_AUTO)
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

DevicePickItem()

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

    : DeviceItem(parent, obj)
{
    SetBackgroundColour(*wxWHITE);
    m_bitmap_check_disable = ScalableBitmap(this, "check_off_disabled", 18);
    m_bitmap_check_off = ScalableBitmap(this, "check_off_focused", 18);
    m_bitmap_check_on = ScalableBitmap(this, "check_on", 18);
 
 
    SetMinSize(wxSize(FromDIP(400), FromDIP(30)));
    SetMaxSize(wxSize(FromDIP(400), FromDIP(30)));
 
    Bind(wxEVT_PAINT, &DevicePickItem::paintEvent, this);
    Bind(wxEVT_ENTER_WINDOW, &DevicePickItem::OnEnterWindow, this);
    Bind(wxEVT_LEAVE_WINDOW, &DevicePickItem::OnLeaveWindow, this);
    Bind(wxEVT_LEFT_DOWN, &DevicePickItem::OnLeftDown, this);
    Bind(wxEVT_MOTION, &DevicePickItem::OnMove, this);
    Bind(EVT_MULTI_DEVICE_SELECTED, &DevicePickItem::OnSelectedDevice, this);
    wxGetApp().UpdateDarkUIWin(this);
}

References Slic3r::GUI::DeviceItem::DeviceItem(), m_bitmap_check_disable, m_bitmap_check_off, m_bitmap_check_on, OnEnterWindow(), OnLeaveWindow(), OnLeftDown(), OnMove(), OnSelectedDevice(), and paintEvent().

Here is the call graph for this function:

~DevicePickItem()

Slic3r::GUI::DevicePickItem::~DevicePickItem ( )

inline

{};

Member Function Documentation

doRender()

void Slic3r::GUI::DevicePickItem::doRender

(

wxDC &

dc

)

{
    wxSize size = GetSize();
    dc.SetPen(wxPen(*wxBLACK));
 
    int left = FromDIP(PICK_LEFT_PADDING_LEFT);
 
 
    //checkbox
    if (state_selected == 0) {
        dc.DrawBitmap(m_bitmap_check_off.bmp(), wxPoint(left, (size.y - m_bitmap_check_disable.GetBmpSize().y) / 2));
    }
    else if (state_selected == 1) {
        dc.DrawBitmap(m_bitmap_check_on.bmp(), wxPoint(left, (size.y - m_bitmap_check_disable.GetBmpSize().y) / 2));
    }
 
    left += FromDIP(PICK_LEFT_PRINTABLE);
 
    //dev names
    DrawTextWithEllipsis(dc, wxString::FromUTF8(get_obj()->get_dev_name()), FromDIP(PICK_LEFT_DEV_NAME), left);
    left += FromDIP(PICK_LEFT_DEV_NAME);
}

References DrawTextWithEllipsis(), Slic3r::GUI::DeviceItem::get_obj(), m_bitmap_check_disable, m_bitmap_check_off, m_bitmap_check_on, PICK_LEFT_DEV_NAME, PICK_LEFT_PADDING_LEFT, PICK_LEFT_PRINTABLE, and Slic3r::GUI::DeviceItem::state_selected.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSetSize()

void Slic3r::GUI::DevicePickItem::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::DevicePickItem::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_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::DevicePickItem::OnEnterWindow

(

wxMouseEvent &

evt

)

{
    m_hover = true;
    Refresh(false);
}

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

Referenced by DevicePickItem().

Here is the caller graph for this function:

OnLeaveWindow()

void Slic3r::GUI::DevicePickItem::OnLeaveWindow

(

wxMouseEvent &

evt

)

{
    m_hover = false;
    Refresh(false);
}

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

Referenced by DevicePickItem().

Here is the caller graph for this function:

OnLeftDown()

void Slic3r::GUI::DevicePickItem::OnLeftDown

(

wxMouseEvent &

evt

)

{
    int left = FromDIP(15);
    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 + m_bitmap_check_disable.GetBmpWidth()) &&
        mouse_pos.y > item.y &&
        mouse_pos.y < (item.y + DEVICE_ITEM_MAX_HEIGHT)) {
 
        post_event(wxCommandEvent(EVT_MULTI_DEVICE_SELECTED));
    }
}

References DEVICE_ITEM_MAX_HEIGHT, m_bitmap_check_disable, post_event(), and Slic3r::GUI::wxMouseEvent.

Referenced by DevicePickItem().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMove()

void Slic3r::GUI::DevicePickItem::OnMove

(

wxMouseEvent &

evt

)

{
    int left = FromDIP(15);
    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 + m_bitmap_check_disable.GetBmpWidth()) &&
        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, m_bitmap_check_disable, and Slic3r::GUI::wxMouseEvent.

Referenced by DevicePickItem().

Here is the caller graph for this function:

OnSelectedDevice()

void Slic3r::GUI::DevicePickItem::OnSelectedDevice

(

wxCommandEvent &

evt

)

{
    auto dev_id = evt.GetString();
    auto state = evt.GetInt();
    if (state == 0) {
        state_selected = 1;
    }
    else if (state == 1) {
        state_selected = 0;
    }
    Refresh(false);
    evt.Skip();
 
    post_event(wxCommandEvent(EVT_MULTI_DEVICE_SELECTED_FINHSH));
}

References post_event(), and Slic3r::GUI::DeviceItem::state_selected.

Referenced by DevicePickItem().

Here is the call graph for this function:

Here is the caller graph for this function:

paintEvent()

void Slic3r::GUI::DevicePickItem::paintEvent

(

wxPaintEvent &

evt

)

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

References render().

Referenced by DevicePickItem().

Here is the call graph for this function:

Here is the caller graph for this function:

post_event()

void Slic3r::GUI::DevicePickItem::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(), and OnSelectedDevice().

Here is the caller graph for this function:

render()

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

Referenced by DevicePickItem(), doRender(), OnLeftDown(), and OnMove().

m_bitmap_check_off

ScalableBitmap Slic3r::GUI::DevicePickItem::m_bitmap_check_off

Referenced by DevicePickItem(), and doRender().

m_bitmap_check_on

ScalableBitmap Slic3r::GUI::DevicePickItem::m_bitmap_check_on

Referenced by DevicePickItem(), and doRender().

m_hover

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

{ false };

Referenced by 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/MultiMachinePage.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MultiMachinePage.cpp