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

Inheritance diagram for Slic3r::GUI::CloudTaskManagerPage:

Collaboration diagram for Slic3r::GUI::CloudTaskManagerPage:

Public Member Functions
	CloudTaskManagerPage (wxWindow *parent)
	~CloudTaskManagerPage ()
void	update_page ()
void	refresh_user_device (bool clear=false)
std::string	utc_time_to_date (std::string utc_time)
bool	Show (bool show)
void	update_page_number ()
void	start_timer ()
void	on_timer (wxTimerEvent &event)
void	pause_all (wxCommandEvent &evt)
void	resume_all (wxCommandEvent &evt)
void	stop_all (wxCommandEvent &evt)
void	enable_buttons (bool enable)
void	page_num_enter_evt ()
void	msw_rescale ()

Private Attributes
SortItem	m_sort
bool	device_name_big { true }
bool	device_state_big { true }
bool	device_send_time { true }
std::map< std::string, MultiTaskItem * >	m_task_items
wxPanel *	m_main_panel { nullptr }
wxBoxSizer *	page_sizer { nullptr }
wxBoxSizer *	m_sizer_task_list { nullptr }
wxBoxSizer *	m_main_sizer { nullptr }
wxScrolledWindow *	m_task_list { nullptr }
int	m_current_page { 0 }
int	m_total_page {0}
int	m_total_count { 0 }
int	m_count_page_item { 10 }
Button *	btn_last_page { nullptr }
Button *	btn_next_page { nullptr }
wxStaticText *	st_page_number { nullptr }
wxBoxSizer *	m_flipping_page_sizer { nullptr }
wxBoxSizer *	m_page_sizer { nullptr }
wxPanel *	m_flipping_panel { nullptr }
wxTimer *	m_flipping_timer { nullptr }
TextInput *	m_page_num_input { nullptr }
Button *	m_page_num_enter { nullptr }
wxPanel *	m_table_head_panel { nullptr }
wxBoxSizer *	m_table_head_sizer { nullptr }
CheckBox *	m_select_checkbox { nullptr }
Button *	m_task_name { nullptr }
Button *	m_printer_name { nullptr }
Button *	m_status { nullptr }
Button *	m_info { nullptr }
Button *	m_send_time { nullptr }
Button *	m_action { nullptr }
wxPanel *	m_ctrl_btn_panel { nullptr }
wxBoxSizer *	m_btn_sizer { nullptr }
Button *	btn_pause_all { nullptr }
Button *	btn_continue_all { nullptr }
Button *	btn_stop_all { nullptr }
wxStaticText *	m_sel_text { nullptr }
wxStaticText *	m_tip_text { nullptr }
wxStaticText *	m_loading_text { nullptr }

Detailed Description

Constructor & Destructor Documentation

◆ CloudTaskManagerPage()

Slic3r::GUI::CloudTaskManagerPage::CloudTaskManagerPage ( wxWindow * parent )

    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
{
#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__
    SetBackgroundColour(wxColour(0xEEEEEE));
    m_sort.set_role(SortItem::SR_SEND_TIME, true);
 
    SetBackgroundColour(wxColour(0xEEEEEE));
    m_main_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_main_panel->SetBackgroundColour(*wxWHITE);
    m_main_sizer = new wxBoxSizer(wxVERTICAL);
 
    StateColor head_bg(
        std::pair<wxColour, int>(TABLE_HEAD_PRESSED_COLOUR, StateColor::Pressed),
        std::pair<wxColour, int>(TABLE_HEAR_NORMAL_COLOUR, StateColor::Normal)
    );
 
    StateColor ctrl_bg(
        std::pair<wxColour, int>(CTRL_BUTTON_PRESSEN_COLOUR, StateColor::Pressed),
        std::pair<wxColour, int>(CTRL_BUTTON_NORMAL_COLOUR, StateColor::Normal)
    );
 
    m_table_head_panel = new wxPanel(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_table_head_panel->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_table_head_panel->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_table_head_panel->SetBackgroundColour(TABLE_HEAR_NORMAL_COLOUR);
    m_table_head_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_select_checkbox = new CheckBox(m_table_head_panel, wxID_ANY);
    m_select_checkbox->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRINTABLE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_select_checkbox->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRINTABLE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    //m_table_head_sizer->AddSpacer(FromDIP(TASK_LEFT_PADDING_LEFT));
    m_table_head_sizer->Add(m_select_checkbox, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_select_checkbox->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent& e) {
        if (m_select_checkbox->GetValue()) {
            for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
 
                if (it->second->state_cloud_task == 0) {
                    it->second->selected();
                }
            }
        }
        else {
            for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
                it->second->unselected();
            }
        }
        Refresh(false);
        e.Skip();
    });
 
 
 
    m_task_name = new Button(m_table_head_panel, _L("Task Name"), "", wxNO_BORDER, ICON_SINGLE_SIZE);
    m_task_name->SetBackgroundColor(TABLE_HEAR_NORMAL_COLOUR);
    m_task_name->SetFont(TABLE_HEAD_FONT);
    m_task_name->SetCornerRadius(0);
    m_task_name->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetCenter(false);
    m_table_head_sizer->Add(m_task_name, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_printer_name = new Button(m_table_head_panel, _L("Device Name"), "toolbar_double_directional_arrow", wxNO_BORDER, ICON_SINGLE_SIZE);
    m_printer_name->SetBackgroundColor(head_bg);
    m_printer_name->SetFont(TABLE_HEAD_FONT);
    m_printer_name->SetCornerRadius(0);
    m_printer_name->SetMinSize(wxSize(FromDIP(TASK_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->SetMaxSize(wxSize(FromDIP(TASK_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->SetCenter(false);
    m_printer_name->Bind(wxEVT_ENTER_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_HAND);
    });
    m_printer_name->Bind(wxEVT_LEAVE_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_ARROW);
    });
    m_printer_name->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& evt) {
        device_name_big = !device_name_big;
        this->m_sort.set_role(SortItem::SortRule::SR_DEV_NAME, device_name_big);
        this->refresh_user_device();
    });
    m_table_head_sizer->Add(m_printer_name, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_status = new Button(m_table_head_panel, _L("Task Status"), "toolbar_double_directional_arrow", wxNO_BORDER, ICON_SINGLE_SIZE);
    m_status->SetBackgroundColor(head_bg);
    m_status->SetFont(TABLE_HEAD_FONT);
    m_status->SetCornerRadius(0);
    m_status->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_STATE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_STATE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->SetCenter(false);
    m_status->Bind(wxEVT_ENTER_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_HAND);
    });
    m_status->Bind(wxEVT_LEAVE_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_ARROW);
    });
    m_status->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& evt) {
        device_state_big = !device_state_big;
        this->m_sort.set_role(SortItem::SortRule::SR_CLOUD_TASK_STATE, device_state_big);
        this->refresh_user_device();
    });
    m_table_head_sizer->Add(m_status, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_info = new Button(m_table_head_panel, _L("Info"), "", wxNO_BORDER, ICON_SINGLE_SIZE);
    m_info->SetBackgroundColor(TABLE_HEAR_NORMAL_COLOUR);
    m_info->SetFont(TABLE_HEAD_FONT);
    m_info->SetCornerRadius(0);
    m_info->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_info->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_info->SetCenter(false);
    m_table_head_sizer->Add(m_info, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_send_time = new Button(m_table_head_panel, _L("Sent Time"), "toolbar_double_directional_arrow", wxNO_BORDER, ICON_SINGLE_SIZE, false);
    m_send_time->SetBackgroundColor(head_bg);
    m_send_time->SetFont(TABLE_HEAD_FONT);
    m_send_time->SetCornerRadius(0);
    m_send_time->SetMinSize(wxSize(FromDIP(TASK_LEFT_SEND_TIME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_send_time->SetMaxSize(wxSize(FromDIP(TASK_LEFT_SEND_TIME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_send_time->SetCenter(false);
    m_send_time->Bind(wxEVT_ENTER_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_HAND);
    });
    m_send_time->Bind(wxEVT_LEAVE_WINDOW, [&](wxMouseEvent& evt) {
        SetCursor(wxCURSOR_ARROW);
    });
    m_send_time->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent& evt) {
        device_send_time = !device_send_time;
        this->m_sort.set_role(SortItem::SortRule::SR_SEND_TIME, device_send_time);
        this->refresh_user_device();
    });
    m_table_head_sizer->Add(m_send_time, 0, wxALIGN_CENTER_VERTICAL, 0);
 
    m_action = new Button(m_table_head_panel, _L("Actions"), "", wxNO_BORDER, ICON_SINGLE_SIZE, false);
    m_action->SetBackgroundColor(TABLE_HEAR_NORMAL_COLOUR);
    m_action->SetFont(TABLE_HEAD_FONT);
    m_action->SetCornerRadius(0);
    m_action->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetCenter(false);
    m_table_head_sizer->Add(m_action, 0, wxALIGN_CENTER_VERTICAL, 0);
    m_table_head_panel->SetSizer(m_table_head_sizer);
    m_table_head_panel->Layout();
 
    m_tip_text = new wxStaticText(m_main_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER);
    m_tip_text->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_tip_text->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_tip_text->SetLabel(_L("No historical tasks!"));
    m_tip_text->SetForegroundColour(wxColour(50, 58, 61));
    m_tip_text->SetFont(::Label::Head_24);
    m_tip_text->Wrap(-1);
 
    m_loading_text = new wxStaticText(m_main_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER);
    m_loading_text->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_loading_text->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_loading_text->SetLabel(_L("Loading..."));
    m_loading_text->SetForegroundColour(wxColour(50, 58, 61));
    m_loading_text->SetFont(::Label::Head_24);
    m_loading_text->Wrap(-1);
    m_loading_text->Show(false);
 
    m_task_list = new wxScrolledWindow(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_task_list->SetBackgroundColour(*wxWHITE);
    m_task_list->SetScrollRate(0, FromDIP(DEVICE_ITEM_MAX_HEIGHT));
    m_task_list->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_list->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), 10 * FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
 
    m_sizer_task_list = new wxBoxSizer(wxVERTICAL);
    m_task_list->SetSizer(m_sizer_task_list);
    m_task_list->Layout();
    m_task_list->Fit();
 
    m_main_sizer->AddSpacer(FromDIP(50));
    m_main_sizer->Add(m_table_head_panel, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_main_sizer->Add(m_tip_text, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(50));
    m_main_sizer->Add(m_loading_text, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(50));
    m_main_sizer->Add(m_task_list, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_main_sizer->AddSpacer(FromDIP(5));
 
    // add flipping page
    m_flipping_panel = new wxPanel(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_flipping_panel->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_flipping_panel->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_flipping_panel->SetBackgroundColour(*wxWHITE);
 
    m_flipping_page_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_page_sizer = new wxBoxSizer(wxVERTICAL);
    btn_last_page = new Button(m_flipping_panel, "", "go_last_plate", wxBORDER_NONE, FromDIP(20));
    btn_last_page->SetMinSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_last_page->SetMaxSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_last_page->SetBackgroundColor(head_bg);
    btn_last_page->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [&](auto& evt) {
        evt.Skip();
        if (m_current_page == 0)
            return;
        enable_buttons(false);
        start_timer();
        m_current_page--;
        if (m_current_page < 0)
            m_current_page = 0;
        refresh_user_device();
        update_page_number();
        /*m_sizer_task_list->Clear(false);
        m_loading_text->Show(true);
        Layout();*/
    });
    st_page_number = new wxStaticText(m_flipping_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize);
    btn_next_page = new Button(m_flipping_panel, "", "go_next_plate", wxBORDER_NONE, FromDIP(20));
    btn_next_page->SetMinSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_next_page->SetMaxSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_next_page->SetBackgroundColor(head_bg);
    btn_next_page->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [&](auto& evt) {
        evt.Skip();
        if (m_current_page == m_total_page - 1)
            return;
        enable_buttons(false);
        start_timer();
        m_current_page++;
        if (m_current_page > m_total_page - 1)
            m_current_page = m_total_page - 1;
        refresh_user_device();
        update_page_number();
        /*m_sizer_task_list->Clear(false);
        m_loading_text->Show(true);
        Layout();*/
    });
 
    m_page_num_input = new ::TextInput(m_flipping_panel, wxEmptyString, wxEmptyString, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(50), -1), wxTE_PROCESS_ENTER);
    StateColor input_bg(std::pair<wxColour, int>(wxColour("#F0F0F1"), StateColor::Disabled), std::pair<wxColour, int>(*wxWHITE, StateColor::Enabled));
    m_page_num_input->SetBackgroundColor(input_bg);
    m_page_num_input->GetTextCtrl()->SetValue("1");
    wxTextValidator validator(wxFILTER_DIGITS);
    m_page_num_input->GetTextCtrl()->SetValidator(validator);
    m_page_num_input->GetTextCtrl()->Bind(wxEVT_TEXT_ENTER, [&](wxCommandEvent& e) {
        page_num_enter_evt();
    });
 
    m_page_num_enter = new Button(m_flipping_panel, _L("Go"));
    m_page_num_enter->SetMinSize(wxSize(FromDIP(25), FromDIP(25)));
    m_page_num_enter->SetMaxSize(wxSize(FromDIP(25), FromDIP(25)));
    m_page_num_enter->SetBackgroundColor(ctrl_bg);
    m_page_num_enter->SetCornerRadius(FromDIP(5));
    m_page_num_enter->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [&](auto& evt) {
        page_num_enter_evt();
    });
 
    m_flipping_page_sizer->Add(0, 0, 1, wxEXPAND, 0);
    m_flipping_page_sizer->Add(btn_last_page, 0, wxALIGN_CENTER, 0);
    m_flipping_page_sizer->Add(st_page_number, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(5));
    m_flipping_page_sizer->Add(btn_next_page, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(5));
    m_flipping_page_sizer->Add(m_page_num_input, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(20));
    m_flipping_page_sizer->Add(m_page_num_enter, 0, wxLEFT | wxALIGN_CENTER_VERTICAL, FromDIP(5));
    m_flipping_page_sizer->Add(0, 0, 1, wxEXPAND, 0);
    m_page_sizer->Add(m_flipping_page_sizer, 0, wxALIGN_CENTER_HORIZONTAL, FromDIP(5));
    m_flipping_panel->SetSizer(m_page_sizer);
    m_flipping_panel->Layout();
    m_main_sizer->Add(m_flipping_panel, 0, wxALIGN_CENTER_HORIZONTAL, 0);
 
    m_ctrl_btn_panel = new wxPanel(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_ctrl_btn_panel->SetBackgroundColour(*wxWHITE);
    m_ctrl_btn_panel->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_ctrl_btn_panel->SetMaxSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), -1));
    m_btn_sizer = new wxBoxSizer(wxHORIZONTAL);
    btn_pause_all = new Button(m_ctrl_btn_panel, _L_CONTEXT("Pause", "Verb"));
    btn_pause_all->SetBackgroundColor(ctrl_bg);
    btn_pause_all->SetCornerRadius(FromDIP(5));
    btn_continue_all = new Button(m_ctrl_btn_panel, _L("Resume"));
    btn_continue_all->SetBackgroundColor(ctrl_bg);
    btn_continue_all->SetCornerRadius(FromDIP(5));
    btn_stop_all = new Button(m_ctrl_btn_panel, _L("Stop"));
    btn_stop_all->SetBackgroundColor(ctrl_bg);
    btn_stop_all->SetCornerRadius(FromDIP(5));
    m_sel_text = new wxStaticText(m_ctrl_btn_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize);
 
    btn_pause_all->Bind(wxEVT_BUTTON, &CloudTaskManagerPage::pause_all, this);
    btn_continue_all->Bind(wxEVT_BUTTON, &CloudTaskManagerPage::resume_all, this);
    btn_stop_all->Bind(wxEVT_BUTTON, &CloudTaskManagerPage::stop_all, this);
 
    m_btn_sizer->Add(m_sel_text, 0, wxLEFT, FromDIP(15));
    m_btn_sizer->Add(btn_pause_all, 0, wxLEFT, FromDIP(10));
    m_btn_sizer->Add(btn_continue_all, 0, wxLEFT, FromDIP(10));
    m_btn_sizer->Add(btn_stop_all, 0, wxLEFT, FromDIP(10));
    m_ctrl_btn_panel->SetSizer(m_btn_sizer);
    m_ctrl_btn_panel->Layout();
 
    m_main_sizer->AddSpacer(FromDIP(10));
    m_main_sizer->Add(m_ctrl_btn_panel, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_main_panel->SetSizer(m_main_sizer);
    m_main_panel->Layout();
 
    page_sizer = new wxBoxSizer(wxVERTICAL);
    page_sizer->Add(m_main_panel, 1, wxALL | wxEXPAND, FromDIP(10)); // ORCA match margin with other tabs
    Bind(wxEVT_TIMER, &CloudTaskManagerPage::on_timer, this);
 
    wxGetApp().UpdateDarkUIWin(this);
 
    SetSizer(page_sizer);
    Layout();
    Fit();
}

References _L, _L_CONTEXT, btn_continue_all, btn_last_page, btn_next_page, btn_pause_all, btn_stop_all, CLOUD_TASK_ITEM_MAX_WIDTH, CTRL_BUTTON_NORMAL_COLOUR, CTRL_BUTTON_PRESSEN_COLOUR, DEVICE_ITEM_MAX_HEIGHT, device_name_big, device_send_time, device_state_big, StateColor::Disabled, enable_buttons(), StateColor::Enabled, Label::Head_24, ICON_SINGLE_SIZE, m_action, m_btn_sizer, m_ctrl_btn_panel, m_current_page, m_flipping_page_sizer, m_flipping_panel, m_info, m_loading_text, m_main_panel, m_main_sizer, m_page_num_enter, m_page_num_input, m_page_sizer, m_printer_name, m_sel_text, m_select_checkbox, m_send_time, m_sizer_task_list, m_sort, m_status, m_table_head_panel, m_table_head_sizer, m_task_items, m_task_list, m_task_name, m_tip_text, m_total_page, StateColor::Normal, on_timer(), page_num_enter_evt(), page_sizer, pause_all(), StateColor::Pressed, refresh_user_device(), resume_all(), Slic3r::GUI::SortItem::SR_CLOUD_TASK_STATE, Slic3r::GUI::SortItem::SR_DEV_NAME, Slic3r::GUI::SortItem::SR_SEND_TIME, st_page_number, start_timer(), stop_all(), TABLE_HEAD_FONT, TABLE_HEAD_PRESSED_COLOUR, TABLE_HEAR_NORMAL_COLOUR, TASK_LEFT_DEV_NAME, TASK_LEFT_PRINTABLE, TASK_LEFT_PRO_INFO, TASK_LEFT_PRO_NAME, TASK_LEFT_PRO_STATE, TASK_LEFT_SEND_TIME, update_page_number(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Here is the call graph for this function:

◆ ~CloudTaskManagerPage()

Slic3r::GUI::CloudTaskManagerPage::~CloudTaskManagerPage ( )

{
    if (m_flipping_timer)
        m_flipping_timer->Stop();
    delete m_flipping_timer;
}

References m_flipping_timer.

Member Function Documentation

◆ enable_buttons()

void Slic3r::GUI::CloudTaskManagerPage::enable_buttons ( bool enable )

{
    btn_last_page->Enable(enable);
    btn_next_page->Enable(enable);
    btn_pause_all->Enable(enable);
    btn_continue_all->Enable(enable);
    btn_stop_all->Enable(enable);
}

References btn_continue_all, btn_last_page, btn_next_page, btn_pause_all, and btn_stop_all.

Referenced by CloudTaskManagerPage(), on_timer(), and page_num_enter_evt().

Here is the caller graph for this function:

◆ msw_rescale()

void Slic3r::GUI::CloudTaskManagerPage::msw_rescale ( )

{
    btn_last_page->Rescale();
    btn_last_page->SetMinSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_last_page->SetMaxSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_next_page->Rescale();
    btn_next_page->SetMinSize(wxSize(FromDIP(20), FromDIP(20)));
    btn_next_page->SetMaxSize(wxSize(FromDIP(20), FromDIP(20)));
    m_page_num_enter->Rescale();
    m_page_num_enter->SetMinSize(wxSize(FromDIP(25), FromDIP(25)));
    m_page_num_enter->SetMaxSize(wxSize(FromDIP(25), FromDIP(25)));
 
    m_select_checkbox->Rescale();
    m_select_checkbox->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRINTABLE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_select_checkbox->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRINTABLE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->Rescale();
    m_task_name->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->Rescale();
    m_printer_name->SetMinSize(wxSize(FromDIP(TASK_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->SetMaxSize(wxSize(FromDIP(TASK_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->Rescale();
    m_status->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_STATE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_STATE), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_info->Rescale();
    m_info->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_info->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_send_time->Rescale();
    m_send_time->SetMinSize(wxSize(FromDIP(TASK_LEFT_SEND_TIME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_send_time->SetMaxSize(wxSize(FromDIP(TASK_LEFT_SEND_TIME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->Rescale();
    m_action->SetMinSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetMaxSize(wxSize(FromDIP(TASK_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
 
    btn_pause_all->Rescale();
    btn_continue_all->Rescale();
    btn_stop_all->Rescale();
 
    for (auto it = m_task_items.begin(); it != m_task_items.end(); ++it) {
        it->second->Refresh();
    }
 
    Fit();
    Layout();
    Refresh();
}

References btn_continue_all, btn_last_page, btn_next_page, btn_pause_all, btn_stop_all, DEVICE_ITEM_MAX_HEIGHT, m_action, m_info, m_page_num_enter, m_printer_name, m_select_checkbox, m_send_time, m_status, m_task_items, m_task_name, TASK_LEFT_DEV_NAME, TASK_LEFT_PRINTABLE, TASK_LEFT_PRO_INFO, TASK_LEFT_PRO_NAME, TASK_LEFT_PRO_STATE, and TASK_LEFT_SEND_TIME.

◆ on_timer()

void Slic3r::GUI::CloudTaskManagerPage::on_timer ( wxTimerEvent & event )

{
    m_flipping_timer->Stop();
    enable_buttons(true);
    update_page_number();
}

References enable_buttons(), m_flipping_timer, and update_page_number().

Referenced by CloudTaskManagerPage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ page_num_enter_evt()

void Slic3r::GUI::CloudTaskManagerPage::page_num_enter_evt ( )

{
    enable_buttons(false);
    start_timer();
    auto value = m_page_num_input->GetTextCtrl()->GetValue();
    long page_num = 0;
    if (value.ToLong(&page_num)) {
        if (page_num > m_total_page)
            m_current_page = m_total_page - 1;
        else if (page_num < 1)
            m_current_page = 0;
        else
            m_current_page = page_num - 1;
    }
    refresh_user_device();
    update_page_number();
    /*m_sizer_task_list->Clear(false);
    m_loading_text->Show(true);
    Layout();*/
}

References enable_buttons(), m_current_page, m_page_num_input, m_total_page, refresh_user_device(), start_timer(), and update_page_number().

Referenced by CloudTaskManagerPage().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pause_all()

void Slic3r::GUI::CloudTaskManagerPage::pause_all ( wxCommandEvent & evt )

{
    for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
        if (it->second->m_button_pause->IsShown() && (it->second->get_state_selected()  == 1) && it->second->state_cloud_task == 0) {
            it->second->onPause();
        }
    }
}

References m_task_items.

Referenced by CloudTaskManagerPage().

Here is the caller graph for this function:

◆ refresh_user_device()

void Slic3r::GUI::CloudTaskManagerPage::refresh_user_device ( bool clear = false )

{
    m_sizer_task_list->Clear(false);
 
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) {
        for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
            wxWindow* child = it->second;
            child->Destroy();
        }
        m_flipping_panel->Show(false);
        m_ctrl_btn_panel->Show(false);
        return;
    }
 
    if (clear) return;
 
    std::vector<MultiTaskItem*> task_temps;
    std::vector<std::string> subscribe_list;
 
    auto all_machine = dev->get_my_cloud_machine_list();
    auto user_machine = std::map<std::string, MachineObject*>();
 
    //selected machine
    for (int i = 0; i < PICK_DEVICE_MAX; i++) {
        auto dev_id = wxGetApp().app_config->get("multi_devices", std::to_string(i));
 
        if (all_machine.count(dev_id) > 0) {
            user_machine[dev_id] = all_machine[dev_id];
        }
    }
 
    auto task_manager = wxGetApp().getTaskManager();
    if (task_manager) {
        auto m_task_obj_list = task_manager->get_task_list(m_current_page, m_count_page_item, m_total_count);
 
        for (auto it = m_task_obj_list.begin(); it != m_task_obj_list.end(); it++) {
 
            TaskStateInfo task_state_info = it->second;
            MachineObject* machine_obj  = nullptr;
 
            if (user_machine.count(task_state_info.params().dev_id)) {
                machine_obj = user_machine[task_state_info.params().dev_id];
            }
 
            MultiTaskItem* mtitem = new MultiTaskItem(m_task_list, machine_obj, 1);
            //mtitem->task_obj = task_state_info;
            mtitem->m_job_id = task_state_info.get_job_id();
            mtitem->m_project_name = wxString::FromUTF8(task_state_info.get_task_name());
            mtitem->m_dev_name = wxString::FromUTF8(task_state_info.get_device_name());
            mtitem->m_dev_id = task_state_info.params().dev_id;
 
            mtitem->m_send_time = utc_time_to_date(task_state_info.start_time);
 
            if (task_state_info.state() == TS_PRINTING) {
                mtitem->state_cloud_task = 0;
            }
            else if (task_state_info.state() == TS_PRINT_SUCCESS) {
                mtitem->state_cloud_task = 1;
            }
            else if (task_state_info.state() == TS_PRINT_FAILED) {
                mtitem->state_cloud_task = 2;
            }
 
            if (m_task_items.find(it->first) != m_task_items.end()) {
                MultiTaskItem* item = m_task_items[it->first];
                if (item->state_selected == 1 && mtitem->state_cloud_task == 0)
                    mtitem->state_selected = item->state_selected;
                item->Destroy();
            }
 
            m_task_items[it->first] = mtitem;
            mtitem->update_info();
            task_temps.push_back(mtitem);
 
            auto find_it = std::find(subscribe_list.begin(), subscribe_list.end(), mtitem->m_dev_id);
            if (find_it == subscribe_list.end()) {
                subscribe_list.push_back(mtitem->m_dev_id);
            }
        }
 
        dev->subscribe_device_list(subscribe_list);
 
        if (m_sort.rule == SortItem::SortRule::SR_None) {
            this->device_send_time = true;
            m_sort.set_role(SortItem::SortRule::SR_SEND_TIME, device_send_time);
        }
        std::sort(task_temps.begin(), task_temps.end(), m_sort.get_call_back());
 
        for (const auto& item : task_temps)
            m_sizer_task_list->Add(item, 0, wxALL | wxEXPAND, 0);
 
        // maintenance
        auto it = m_task_items.begin();
        while (it != m_task_items.end()) {
            if (m_task_obj_list.find(it->first) != m_task_obj_list.end()) {
                ++it;
            }
            else {
                it->second->Destroy();
                it = m_task_items.erase(it);
            }
        }
        m_sizer_task_list->Layout();
        int num = m_task_items.size() > 10 ? 10 : m_task_items.size();
        m_task_list->SetMinSize(wxSize(FromDIP(CLOUD_TASK_ITEM_MAX_WIDTH), num * FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
        m_task_list->Layout();
    }
 
    update_page_number();
 
    m_tip_text->Show(m_task_items.empty());
    m_flipping_panel->Show(m_total_page > 1);
    m_ctrl_btn_panel->Show(!m_task_items.empty());
    Layout();
}

References CLOUD_TASK_ITEM_MAX_WIDTH, Slic3r::PrintParams::dev_id, DEVICE_ITEM_MAX_HEIGHT, device_send_time, Slic3r::TaskStateInfo::get_device_name(), Slic3r::TaskStateInfo::get_job_id(), Slic3r::DeviceManager::get_my_cloud_machine_list(), Slic3r::TaskStateInfo::get_task_name(), m_count_page_item, m_ctrl_btn_panel, m_current_page, Slic3r::GUI::MultiTaskItem::m_dev_id, Slic3r::GUI::MultiTaskItem::m_dev_name, m_flipping_panel, Slic3r::GUI::MultiTaskItem::m_job_id, Slic3r::GUI::MultiTaskItem::m_project_name, Slic3r::GUI::DeviceItem::m_send_time, m_sizer_task_list, m_sort, m_task_items, m_task_list, m_tip_text, m_total_count, m_total_page, Slic3r::TaskStateInfo::params(), PICK_DEVICE_MAX, Slic3r::GUI::SortItem::SR_None, Slic3r::GUI::SortItem::SR_SEND_TIME, Slic3r::TaskStateInfo::start_time, Slic3r::TaskStateInfo::state(), Slic3r::GUI::DeviceItem::state_cloud_task, Slic3r::GUI::DeviceItem::state_selected, Slic3r::DeviceManager::subscribe_device_list(), Slic3r::TS_PRINT_FAILED, Slic3r::TS_PRINT_SUCCESS, Slic3r::TS_PRINTING, Slic3r::GUI::MultiTaskItem::update_info(), update_page_number(), and utc_time_to_date().

Referenced by CloudTaskManagerPage(), page_num_enter_evt(), and Show().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resume_all()

void Slic3r::GUI::CloudTaskManagerPage::resume_all ( wxCommandEvent & evt )

{
    for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
        if (it->second->m_button_resume->IsShown() && (it->second->get_state_selected()  == 1) && it->second->state_cloud_task == 0) {
            it->second->onResume();
        }
    }
}

References m_task_items.

Referenced by CloudTaskManagerPage().

Here is the caller graph for this function:

◆ Show()

bool Slic3r::GUI::CloudTaskManagerPage::Show ( bool show )

{
    if (show) {
        refresh_user_device();
    }
    else {
        Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
        if (dev) {
            dev->subscribe_device_list(std::vector<std::string>());
        }
    }
 
    return wxPanel::Show(show);
}

References refresh_user_device(), and Slic3r::DeviceManager::subscribe_device_list().

Here is the call graph for this function:

◆ start_timer()

void Slic3r::GUI::CloudTaskManagerPage::start_timer ( )

{
    if (m_flipping_timer) {
        m_flipping_timer->Stop();
    }
    else {
        m_flipping_timer = new wxTimer();
    }
 
    m_flipping_timer->SetOwner(this);
    m_flipping_timer->Start(1000);
    wxPostEvent(this, wxTimerEvent(*m_flipping_timer));
}

References m_flipping_timer.

Referenced by CloudTaskManagerPage(), and page_num_enter_evt().

Here is the caller graph for this function:

◆ stop_all()

void Slic3r::GUI::CloudTaskManagerPage::stop_all ( wxCommandEvent & evt )

{
    for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
        if (it->second->m_button_stop->IsShown() && (it->second->get_state_selected()  == 1) && it->second->state_cloud_task == 0) {
            it->second->onStop();
        }
    }
}

References m_task_items.

Referenced by CloudTaskManagerPage().

Here is the caller graph for this function:

◆ update_page()

void Slic3r::GUI::CloudTaskManagerPage::update_page ( )

{
    for (auto it = m_task_items.begin(); it != m_task_items.end(); it++) {
        it->second->sync_state();
        it->second->update_info();
    }
}

References m_task_items.

◆ update_page_number()

void Slic3r::GUI::CloudTaskManagerPage::update_page_number ( )

{
    double result = static_cast<double>(m_total_count) / m_count_page_item;
    m_total_page = std::ceil(result);
 
    wxString number = wxString(std::to_string(m_current_page + 1)) + " / " + wxString(std::to_string(m_total_page));
    st_page_number->SetLabel(number);
}

References m_count_page_item, m_current_page, m_total_count, m_total_page, and st_page_number.

Referenced by CloudTaskManagerPage(), on_timer(), page_num_enter_evt(), and refresh_user_device().

Here is the caller graph for this function:

◆ utc_time_to_date()

std::string Slic3r::GUI::CloudTaskManagerPage::utc_time_to_date ( std::string utc_time )

{
    /*std::tm timeInfo = {};
    std::istringstream iss(utc_time);
    iss >> std::get_time(&timeInfo, "%Y-%m-%dT%H:%M:%SZ");
 
    std::chrono::system_clock::time_point tp = std::chrono::system_clock::from_time_t(std::mktime(&timeInfo));
    std::time_t localTime = std::chrono::system_clock::to_time_t(tp);
    std::tm* localTimeInfo = std::localtime(&localTime);
 
    std::stringstream ss;
    ss << std::put_time(localTimeInfo, "%Y-%m-%d %H:%M:%S");
    return ss.str();*/
    std::string send_time;
 
 
    std::tm timeInfo = {};
    std::istringstream iss(utc_time);
    iss >> std::get_time(&timeInfo, "%Y-%m-%dT%H:%M:%SZ");
 
    std::chrono::system_clock::time_point tp = std::chrono::system_clock::from_time_t(std::mktime(&timeInfo));
    std::time_t utcTime = std::chrono::system_clock::to_time_t(tp);
 
 
    wxDateTime::TimeZone tz(wxDateTime::Local);
    long offset = tz.GetOffset();
 
 
    std::time_t localTime = utcTime + offset;
 
    std::tm* localTimeInfo = std::localtime(&localTime);
    std::stringstream ss;
    ss << std::put_time(localTimeInfo, "%Y-%m-%d %H:%M:%S");
    send_time =  ss.str();
 
 
    return send_time;
}