Slic3r::GUI::MultiTaskItem Class Reference

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

Inheritance diagram for Slic3r::GUI::MultiTaskItem:

Collaboration diagram for Slic3r::GUI::MultiTaskItem:

Public Member Functions
	MultiTaskItem (wxWindow *parent, MachineObject *obj, int type)
	~MultiTaskItem ()
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	DrawTextWithEllipsis (wxDC &dc, const wxString &text, int maxWidth, int left, int top=0)
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	update_info ()
void	onPause ()
void	onResume ()
void	onStop ()
void	onCancel ()
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
int	m_sending_percent {0}
int	m_task_type {0}
wxString	m_project_name
wxString	m_dev_name
std::string	m_dev_id
TaskStateInfo *	task_obj { nullptr }
std::string	m_job_id
Button *	m_button_resume { nullptr }
Button *	m_button_cancel { nullptr }
Button *	m_button_pause { nullptr }
Button *	m_button_stop { nullptr }
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

MultiTaskItem()

Slic3r::GUI::MultiTaskItem::MultiTaskItem	(	wxWindow *	parent,
		MachineObject *	obj,
		int	type )

    : DeviceItem(parent, obj),
    m_task_type(type)
{
    SetBackgroundColour(*wxWHITE);
    SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
 
    Bind(wxEVT_PAINT, &MultiTaskItem::paintEvent, this);
    Bind(wxEVT_ENTER_WINDOW, &MultiTaskItem::OnEnterWindow, this);
    Bind(wxEVT_LEAVE_WINDOW, &MultiTaskItem::OnLeaveWindow, this);
    Bind(wxEVT_LEFT_DOWN, &MultiTaskItem::OnLeftDown, this);
    Bind(wxEVT_MOTION, &MultiTaskItem::OnMove, this);
    Bind(EVT_MULTI_DEVICE_SELECTED, &MultiTaskItem::OnSelectedDevice, this);
 
    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);
 
    wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer* item_sizer = new wxBoxSizer(wxHORIZONTAL);
 
 
    auto m_btn_bg_enable = StateColor(
        std::pair<wxColour, int>(wxColour(0, 137, 123), StateColor::Pressed),
        std::pair<wxColour, int>(wxColour(38, 166, 154), StateColor::Hovered),
        std::pair<wxColour, int>(wxColour(0, 150, 136), StateColor::Normal)
    );
 
    m_button_resume = new Button(this, _L("Resume"));
    m_button_resume->SetBackgroundColor(m_btn_bg_enable);
    m_button_resume->SetBorderColor(m_btn_bg_enable);
    m_button_resume->SetFont(Label::Body_12);
    m_button_resume->SetTextColor(StateColor::darkModeColorFor("#FFFFFE"));
    m_button_resume->SetMinSize(wxSize(FromDIP(70), FromDIP(35)));
    m_button_resume->SetCornerRadius(6);
 
 
    StateColor clean_bg(std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Disabled), std::pair<wxColour, int>(wxColour(206, 206, 206), StateColor::Pressed),
        std::pair<wxColour, int>(wxColour(238, 238, 238), StateColor::Hovered), std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Enabled),
        std::pair<wxColour, int>(wxColour(255, 255, 255), StateColor::Normal));
    StateColor clean_bd(std::pair<wxColour, int>(wxColour(144, 144, 144), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
    StateColor clean_text(std::pair<wxColour, int>(wxColour(144, 144, 144), StateColor::Disabled), std::pair<wxColour, int>(wxColour(38, 46, 48), StateColor::Enabled));
 
    m_button_cancel = new Button(this, _L("Cancel"));
    m_button_cancel->SetBackgroundColor(clean_bg);
    m_button_cancel->SetBorderColor(clean_bd);
    m_button_cancel->SetTextColor(clean_text);
    m_button_cancel->SetFont(Label::Body_12);
    m_button_cancel->SetCornerRadius(6);
    m_button_cancel->SetMinSize(wxSize(FromDIP(70), FromDIP(35)));
 
    m_button_pause = new Button(this, _L_CONTEXT("Pause", "Verb"));
    m_button_pause->SetBackgroundColor(clean_bg);
    m_button_pause->SetBorderColor(clean_bd);
    m_button_pause->SetTextColor(clean_text);
    m_button_pause->SetFont(Label::Body_12);
    m_button_pause->SetCornerRadius(6);
    m_button_pause->SetMinSize(wxSize(FromDIP(70), FromDIP(35)));
 
    m_button_stop = new Button(this, _L("Stop"));
    m_button_stop->SetBackgroundColor(clean_bg);
    m_button_stop->SetBorderColor(clean_bd);
    m_button_stop->SetTextColor(clean_text);
    m_button_stop->SetFont(Label::Body_12);
    m_button_stop->SetCornerRadius(6);
    m_button_stop->SetMinSize(wxSize(FromDIP(70), FromDIP(35)));
 
 
    item_sizer->Add(0, 0, 1, wxEXPAND, 0);
    item_sizer->Add(m_button_cancel, 0, wxALIGN_CENTER, 0);
    item_sizer->Add(m_button_resume, 0, wxALIGN_CENTER, 0);
    item_sizer->Add(m_button_pause, 0, wxALIGN_CENTER, 0);
    item_sizer->Add(m_button_stop, 0, wxALIGN_CENTER, 0);
 
    m_button_cancel->Hide();
    m_button_pause->Hide();
    m_button_resume->Hide();
    m_button_stop->Hide();
 
    main_sizer->Add(item_sizer, 1, wxEXPAND, 0);
    SetSizer(main_sizer);
    Layout();
 
    m_button_cancel->Bind(wxEVT_BUTTON, [this](auto& e) {
        onCancel();
    });
 
    m_button_pause->Bind(wxEVT_BUTTON, [this](auto& e) {
        onPause();
    });
 
    m_button_resume->Bind(wxEVT_BUTTON, [this](auto& e) {
        onResume();
    });
 
    m_button_stop->Bind(wxEVT_BUTTON, [this](auto& e) {
        onStop();
    });
 
    wxGetApp().UpdateDarkUIWin(this);
}

References Slic3r::GUI::DeviceItem::DeviceItem(), _L, _L_CONTEXT, Label::Body_12, CLOUD_TASK_ITEM_MAX_WIDTH, StateColor::darkModeColorFor(), DEVICE_ITEM_MAX_HEIGHT, StateColor::Disabled, StateColor::Enabled, StateColor::Hovered, m_bitmap_check_disable, m_bitmap_check_off, m_bitmap_check_on, m_button_cancel, m_button_pause, m_button_resume, m_button_stop, m_task_type, StateColor::Normal, onCancel(), OnEnterWindow(), OnLeaveWindow(), OnLeftDown(), OnMove(), onPause(), onResume(), OnSelectedDevice(), onStop(), paintEvent(), and StateColor::Pressed.

Here is the call graph for this function:

~MultiTaskItem()

Slic3r::GUI::MultiTaskItem::~MultiTaskItem ( )

inline

{};

Member Function Documentation

doRender()

void Slic3r::GUI::MultiTaskItem::doRender

(

wxDC &

dc

)

{
    wxSize size = GetSize();
    dc.SetPen(wxPen(*wxBLACK));
 
    int left = FromDIP(TASK_LEFT_PADDING_LEFT);
 
 
    //checkbox
    if (m_task_type == 0) {
        if (state_local_task >= 2) {
            dc.DrawBitmap(m_bitmap_check_disable.bmp(), wxPoint(left, (size.y - m_bitmap_check_disable.GetBmpSize().y) / 2));
        }
        else {
            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));
            }
        }
    }
    else if(m_task_type == 1){
        if (state_cloud_task != 0) {
            dc.DrawBitmap(m_bitmap_check_disable.bmp(), wxPoint(left, (size.y - m_bitmap_check_disable.GetBmpSize().y) / 2));
        }
        else {
            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(TASK_LEFT_PRINTABLE);
 
    //project name
    DrawTextWithEllipsis(dc, m_project_name, FromDIP(TASK_LEFT_PRO_NAME), left);
    left += FromDIP(TASK_LEFT_PRO_NAME);
 
    //dev name
    DrawTextWithEllipsis(dc, m_dev_name, FromDIP(TASK_LEFT_DEV_NAME), left);
    left += FromDIP(TASK_LEFT_DEV_NAME);
 
    //local task state
    if (m_task_type == 0) {
        DrawTextWithEllipsis(dc, get_local_state_task(), FromDIP(TASK_LEFT_PRO_STATE), left);
    }
    else {
        DrawTextWithEllipsis(dc, get_cloud_state_task(), FromDIP(TASK_LEFT_PRO_STATE), left);
    }
 
    left += FromDIP(TASK_LEFT_PRO_STATE);
 
    //cloud task info
    if (m_task_type == 1) {
        if (get_obj()) {
            if (state_cloud_task == 0 && m_job_id == get_obj()->profile_id_) {
                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, 150, 136));
                    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(TASK_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(TASK_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(TASK_LEFT_PRO_INFO) * (static_cast<float>(obj_->subtask_->task_progress) / 100.0f), FromDIP(10), 2);
                    }
                    else {
                        DrawTextWithEllipsis(dc, obj_->get_curr_stage(), FromDIP(TASK_LEFT_PRO_INFO), left);
                    }
                }
                else {
                    dc.SetTextForeground(*wxBLACK);
                    DrawTextWithEllipsis(dc, get_state_device(), FromDIP(TASK_LEFT_PRO_INFO), left);
                }
            }
        }
    }
    else {
        if (state_local_task == 1) {
            wxString progress_info = wxString::Format("%d", m_sending_percent);
            DrawTextWithEllipsis(dc, progress_info + "% " , FromDIP(TASK_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(TASK_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(TASK_LEFT_PRO_INFO) * (static_cast<float>(m_sending_percent) / 100.0f), FromDIP(10), 2);
        }
        /*else {
            if () {
 
            }
            if (m_button_cancel->IsShown()) {
                m_button_cancel->Hide();
                Layout();
            }
        }*/
    }
    left += FromDIP(TASK_LEFT_PRO_INFO);
 
    //send time
    dc.SetFont(Label::Body_13);
    dc.SetTextForeground(*wxBLACK);
 
    if (!boost::algorithm::contains(m_send_time, "1970")) {
        DrawTextWithEllipsis(dc, m_send_time, FromDIP(TASK_LEFT_SEND_TIME), left);
    }
 
    left += FromDIP(TASK_LEFT_SEND_TIME);
 
    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, Label::Body_12, Label::Body_13, DEVICE_LEFT_PRO_INFO, DrawTextWithEllipsis(), Slic3r::GUI::DeviceItem::get_cloud_state_task(), get_left_time(), Slic3r::GUI::DeviceItem::get_local_state_task(), Slic3r::GUI::DeviceItem::get_obj(), Slic3r::GUI::DeviceItem::get_state_device(), m_bitmap_check_disable, m_bitmap_check_off, m_bitmap_check_on, m_dev_name, m_hover, m_job_id, m_project_name, Slic3r::GUI::DeviceItem::m_send_time, m_sending_percent, m_task_type, Slic3r::GUI::DeviceItem::obj_, Slic3r::GUI::DeviceItem::state_cloud_task, Slic3r::GUI::DeviceItem::state_device, Slic3r::GUI::DeviceItem::state_local_task, Slic3r::GUI::DeviceItem::state_selected, TASK_LEFT_DEV_NAME, TASK_LEFT_PADDING_LEFT, TASK_LEFT_PRINTABLE, TASK_LEFT_PRO_INFO, TASK_LEFT_PRO_NAME, TASK_LEFT_PRO_STATE, and TASK_LEFT_SEND_TIME.

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSetSize()

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

onCancel()

void Slic3r::GUI::MultiTaskItem::onCancel

(

)

{
    if (task_obj) {
        task_obj->cancel();
        if (!task_obj->get_job_id().empty()) {
            get_obj()->command_task_cancel(task_obj->get_job_id());
        }
    }
}

References Slic3r::MachineObject::command_task_cancel(), Slic3r::GUI::DeviceItem::get_obj(), and task_obj.

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

OnEnterWindow()

void Slic3r::GUI::MultiTaskItem::OnEnterWindow

(

wxMouseEvent &

evt

)

{
    m_hover = true;
    Refresh();
}

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

Referenced by MultiTaskItem().

Here is the caller graph for this function:

OnLeaveWindow()

void Slic3r::GUI::MultiTaskItem::OnLeaveWindow

(

wxMouseEvent &

evt

)

{
    m_hover = false;
    Refresh();
}

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

Referenced by MultiTaskItem().

Here is the caller graph for this function:

OnLeftDown()

void Slic3r::GUI::MultiTaskItem::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)) {
 
        if (m_task_type == 0 && state_local_task <= 1) {
            post_event(wxCommandEvent(EVT_MULTI_DEVICE_SELECTED));
        }
        else if (m_task_type == 1 && state_cloud_task == 0) {
            post_event(wxCommandEvent(EVT_MULTI_DEVICE_SELECTED));
        }
    }
}

References DEVICE_ITEM_MAX_HEIGHT, m_bitmap_check_disable, m_task_type, post_event(), Slic3r::GUI::DeviceItem::state_cloud_task, Slic3r::GUI::DeviceItem::state_local_task, and Slic3r::GUI::wxMouseEvent.

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

OnMove()

void Slic3r::GUI::MultiTaskItem::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 MultiTaskItem().

Here is the caller graph for this function:

onPause()

void Slic3r::GUI::MultiTaskItem::onPause

(

)

{
    if (get_obj() && !get_obj()->can_resume()) {
        BOOST_LOG_TRIVIAL(info) << "MultiTask: pause current print task dev_id =" << get_obj()->get_dev_id();
        get_obj()->command_task_pause();
        m_button_pause->Hide();
        m_button_resume->Show();
        Layout();
    }
}

References Slic3r::MachineObject::command_task_pause(), Slic3r::MachineObject::get_dev_id(), Slic3r::GUI::DeviceItem::get_obj(), m_button_pause, and m_button_resume.

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

onResume()

void Slic3r::GUI::MultiTaskItem::onResume

(

)

{
    if (get_obj() && get_obj()->can_resume()) {
        BOOST_LOG_TRIVIAL(info) << "MultiTask: resume current print task dev_id =" << get_obj()->get_dev_id();
        get_obj()->command_task_resume();
        m_button_pause->Show();
        m_button_resume->Hide();
        Layout();
    }
}

References Slic3r::MachineObject::command_task_resume(), Slic3r::MachineObject::get_dev_id(), Slic3r::GUI::DeviceItem::get_obj(), m_button_pause, and m_button_resume.

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSelectedDevice()

void Slic3r::GUI::MultiTaskItem::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();
}

References Slic3r::GUI::DeviceItem::state_selected.

Referenced by MultiTaskItem().

Here is the caller graph for this function:

onStop()

void Slic3r::GUI::MultiTaskItem::onStop

(

)

{
    if (get_obj()) {
        BOOST_LOG_TRIVIAL(info) << "MultiTask: abort current print task dev_id =" << get_obj()->get_dev_id();
        get_obj()->command_task_abort();
        m_button_pause->Hide();
        m_button_resume->Hide();
        m_button_stop->Hide();
        state_cloud_task = 2;
        Layout();
        Refresh();
    }
}

References Slic3r::MachineObject::command_task_abort(), Slic3r::MachineObject::get_dev_id(), Slic3r::GUI::DeviceItem::get_obj(), m_button_pause, m_button_resume, m_button_stop, and Slic3r::GUI::DeviceItem::state_cloud_task.

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

paintEvent()

void Slic3r::GUI::MultiTaskItem::paintEvent

(

wxPaintEvent &

evt

)

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

References render().

Referenced by MultiTaskItem().

Here is the call graph for this function:

Here is the caller graph for this function:

post_event()

void Slic3r::GUI::MultiTaskItem::post_event

(

wxCommandEvent &&

event

)

{
    event.SetEventObject(this);
    event.SetString(m_dev_id);
    event.SetInt(state_selected);
    wxPostEvent(this, event);
}

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

Referenced by OnLeftDown().

Here is the caller graph for this function:

render()

void Slic3r::GUI::MultiTaskItem::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_info()

void Slic3r::GUI::MultiTaskItem::update_info

(

)

{
    //local
    if (m_task_type == 0) {
        m_button_stop->Hide();
        m_button_pause->Hide();
        m_button_resume->Hide();
        if (state_local_task  == 0 || state_local_task == 1) {
            m_button_cancel->Show();
            Layout();
        }
        else {
            m_button_cancel->Hide();
            Layout();
        }
    }
    //cloud
    else if (m_task_type == 1 && get_obj() && (m_job_id == get_obj()->profile_id_)) {
        m_button_cancel->Hide();
 
        if (obj_ && obj_->is_in_printing() && state_cloud_task == 0 ) {
            if (obj_->can_abort()) {
                m_button_stop->Show();
            }
            else {
                m_button_stop->Hide();
            }
 
            if (obj_->can_pause()) {
                m_button_pause->Show();
            }
            else {
                m_button_pause->Hide();
            }
 
            if (obj_->can_resume()) {
                m_button_resume->Show();
            }
            else {
                m_button_resume->Hide();
            }
 
            Layout();
        }
        else {
            m_button_stop->Hide();
            m_button_pause->Hide();
            m_button_resume->Hide();
            Layout();
        }
    }
    else {
        m_button_cancel->Hide();
        m_button_stop->Hide();
        m_button_pause->Hide();
        m_button_resume->Hide();
        Layout();
    }
}

References Slic3r::GUI::DeviceItem::get_obj(), m_button_cancel, m_button_pause, m_button_resume, m_button_stop, m_job_id, m_task_type, Slic3r::GUI::DeviceItem::obj_, Slic3r::GUI::DeviceItem::state_cloud_task, and Slic3r::GUI::DeviceItem::state_local_task.

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

Here is the call graph for this function:

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::MultiTaskItem::m_bitmap_check_disable

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

m_bitmap_check_off

ScalableBitmap Slic3r::GUI::MultiTaskItem::m_bitmap_check_off

Referenced by MultiTaskItem(), and doRender().

m_bitmap_check_on

ScalableBitmap Slic3r::GUI::MultiTaskItem::m_bitmap_check_on

Referenced by MultiTaskItem(), and doRender().

m_button_cancel

Button* Slic3r::GUI::MultiTaskItem::m_button_cancel { nullptr }

{ nullptr };

Referenced by MultiTaskItem(), and update_info().

m_button_pause

Button* Slic3r::GUI::MultiTaskItem::m_button_pause { nullptr }

{ nullptr };

Referenced by MultiTaskItem(), onPause(), onResume(), onStop(), and update_info().

m_button_resume

Button* Slic3r::GUI::MultiTaskItem::m_button_resume { nullptr }

{ nullptr };

Referenced by MultiTaskItem(), onPause(), onResume(), onStop(), and update_info().

m_button_stop

Button* Slic3r::GUI::MultiTaskItem::m_button_stop { nullptr }

{ nullptr };

Referenced by MultiTaskItem(), onStop(), and update_info().

m_dev_id

std::string Slic3r::GUI::MultiTaskItem::m_dev_id

Referenced by post_event(), Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), and Slic3r::GUI::LocalTaskManagerPage::refresh_user_device().

m_dev_name

wxString Slic3r::GUI::MultiTaskItem::m_dev_name

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

m_hover

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

{ false };

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

m_job_id

std::string Slic3r::GUI::MultiTaskItem::m_job_id

Referenced by doRender(), Slic3r::GUI::CloudTaskManagerPage::refresh_user_device(), and update_info().

m_project_name

wxString Slic3r::GUI::MultiTaskItem::m_project_name

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

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().

m_sending_percent

int Slic3r::GUI::MultiTaskItem::m_sending_percent {0}

{0};

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

m_task_type

int Slic3r::GUI::MultiTaskItem::m_task_type {0}

{0}; //0-local 1-cloud

Referenced by MultiTaskItem(), doRender(), OnLeftDown(), and update_info().

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().

task_obj

TaskStateInfo* Slic3r::GUI::MultiTaskItem::task_obj { nullptr }

{ nullptr };

Referenced by onCancel(), and Slic3r::GUI::LocalTaskManagerPage::refresh_user_device().

---

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

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