Slic3r::GUI::MultiMachineManagerPage Class Reference

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

Inheritance diagram for Slic3r::GUI::MultiMachineManagerPage:

Collaboration diagram for Slic3r::GUI::MultiMachineManagerPage:

Public Member Functions
	MultiMachineManagerPage (wxWindow *parent)
	~MultiMachineManagerPage ()
void	update_page ()
void	refresh_user_device (bool clear=false)
void	sync_state (MachineObject *obj_)
bool	Show (bool show)
std::vector< ObjState >	extractRange (const std::vector< ObjState > &source, int start, int end)
void	start_timer ()
void	update_page_number ()
void	on_timer (wxTimerEvent &event)
void	clear_page ()
void	page_num_enter_evt ()
void	msw_rescale ()

Private Attributes
std::vector< ObjState >	m_state_objs
std::vector< MultiMachineItem * >	m_device_items
SortItem	m_sort
bool	device_dev_name_big { true }
bool	device_state_big { true }
Button *	m_button_edit {nullptr}
wxBoxSizer *	page_sizer { nullptr }
wxPanel *	m_main_panel { nullptr }
wxBoxSizer *	m_main_sizer {nullptr}
wxBoxSizer *	m_sizer_machine_list {nullptr}
wxScrolledWindow *	m_machine_list { nullptr }
wxPanel *	m_table_head_panel { nullptr }
wxBoxSizer *	m_table_head_sizer { nullptr }
Button *	m_printer_name { nullptr }
Button *	m_task_name { nullptr }
Button *	m_status { nullptr }
Button *	m_action { nullptr }
wxStaticText *	m_tip_text { nullptr }
Button *	m_button_add { 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 }

Detailed Description

Constructor & Destructor Documentation

MultiMachineManagerPage()

Slic3r::GUI::MultiMachineManagerPage::MultiMachineManagerPage

(

wxWindow *

parent

)

    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
{
#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__
    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)
    );
 
    //edit prints
    auto sizer_button_printer = new wxBoxSizer(wxHORIZONTAL);
    sizer_button_printer->SetMinSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), -1));
    m_button_edit = new Button(m_main_panel, _L("Edit Printers"));
    m_button_edit->SetStyle(ButtonStyle::Confirm, ButtonType::Window);
 
    m_button_edit->Bind(wxEVT_BUTTON, [this](wxCommandEvent& evt) {
        MultiMachinePickPage dlg;
        dlg.ShowModal();
        refresh_user_device();
        evt.Skip();
    });
 
    sizer_button_printer->Add( 0, 0, 1, wxEXPAND, 5 );
    sizer_button_printer->Add(m_button_edit, 0, wxALIGN_CENTER, 0);
 
    m_table_head_panel = new wxPanel(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_table_head_panel->SetMinSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), -1));
    m_table_head_panel->SetMaxSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), -1));
    m_table_head_panel->SetBackgroundColour(TABLE_HEAR_NORMAL_COLOUR);
    m_table_head_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    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(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->SetMaxSize(wxSize(FromDIP(DEVICE_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_dev_name_big = !device_dev_name_big;
        auto sortcb = [this](ObjState s1, ObjState s2) {
            return device_dev_name_big ? s1.state_dev_name > s2.state_dev_name : s1.state_dev_name < s2.state_dev_name;
        };
        this->m_sort.set_role(sortcb, SortItem::SR_MACHINE_NAME, device_dev_name_big);
        this->refresh_user_device();
    });
 
 
    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(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetCenter(false);
 
 
 
    m_status = new Button(m_table_head_panel, _L("Device 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(DEVICE_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_PRO_INFO), 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;
        auto sortcb = [this](ObjState s1, ObjState s2) {
            return device_state_big ? s1.state_device > s2.state_device : s1.state_device < s2.state_device;
            };
        this->m_sort.set_role(sortcb, SortItem::SortRule::SR_MACHINE_STATE, device_state_big);
        this->refresh_user_device();
    });
 
 
    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(DEVICE_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetCenter(false);
 
 
    m_table_head_sizer->AddSpacer(FromDIP(DEVICE_LEFT_PADDING_LEFT));
    m_table_head_sizer->Add(m_printer_name, 0, wxALIGN_CENTER_VERTICAL, 0);
    m_table_head_sizer->Add(m_task_name, 0, wxALIGN_CENTER_VERTICAL, 0);
    m_table_head_sizer->Add(m_status, 0, wxALIGN_CENTER_VERTICAL, 0);
    m_table_head_sizer->Add(m_action, 0, wxLEFT, 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(DEVICE_ITEM_MAX_WIDTH), -1));
    m_tip_text->SetMaxSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), -1));
    m_tip_text->SetLabel(_L("Please select the devices you would like to manage here (up to 6 devices)"));
    m_tip_text->SetForegroundColour(wxColour(50, 58, 61));
    m_tip_text->SetFont(::Label::Head_20);
    m_tip_text->Wrap(-1);
 
    m_button_add = new Button(m_main_panel, _L("Add"));
    m_button_add->SetStyle(ButtonStyle::Confirm, ButtonType::Window);
 
    m_button_add->Bind(wxEVT_BUTTON, [this](wxCommandEvent& evt) {
        MultiMachinePickPage dlg;
        dlg.ShowModal();
        refresh_user_device();
        evt.Skip();
    });
 
    m_machine_list = new wxScrolledWindow(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_machine_list->SetBackgroundColour(*wxWHITE);
    m_machine_list->SetScrollRate(0, FromDIP(DEVICE_ITEM_MAX_HEIGHT));
    m_machine_list->SetMinSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), 10 * FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_machine_list->SetMaxSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), 10 * FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
 
    m_sizer_machine_list = new wxBoxSizer(wxVERTICAL);
    m_machine_list->SetSizer(m_sizer_machine_list);
    m_machine_list->Layout();
 
    // add flipping page
    StateColor ctrl_bg(
        std::pair<wxColour, int>(CTRL_BUTTON_PRESSEN_COLOUR, StateColor::Pressed),
        std::pair<wxColour, int>(CTRL_BUTTON_NORMAL_COLOUR, StateColor::Normal)
    );
 
    m_flipping_panel = new wxPanel(m_main_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize);
    m_flipping_panel->SetMinSize(wxSize(FromDIP(DEVICE_ITEM_MAX_WIDTH), -1));
    m_flipping_panel->SetMaxSize(wxSize(FromDIP(DEVICE_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", 0, 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_LEFT_DOWN, [&](wxMouseEvent& evt) {
        evt.Skip();
        if (m_current_page == 0)
            return;
        btn_last_page->Enable(false);
        btn_next_page->Enable(false);
        start_timer();
        m_current_page--;
        if (m_current_page < 0)
            m_current_page = 0;
        refresh_user_device();
        update_page_number();
    });
    st_page_number = new wxStaticText(m_flipping_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize);
    btn_next_page = new Button(m_flipping_panel, "", "go_next_plate", 0, 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_LEFT_DOWN, [&](wxMouseEvent& evt) {
        evt.Skip();
        if (m_current_page == m_total_page - 1)
            return;
        btn_last_page->Enable(false);
        btn_next_page->Enable(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_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();
    });
 
    // TRN Button that jumps to the page number typed next to it
    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_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->AddSpacer(FromDIP(16));
    m_main_sizer->Add(sizer_button_printer, 0, wxALIGN_CENTER_HORIZONTAL, 0);
     m_main_sizer->AddSpacer(FromDIP(5));
    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_button_add, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, FromDIP(16));
    m_main_sizer->Add(m_machine_list, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_main_sizer->Add(m_flipping_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
 
    SetSizer(page_sizer);
    Layout();
    Fit();
 
    Bind(wxEVT_TIMER, &MultiMachineManagerPage::on_timer, this);
}

References _L, btn_last_page, btn_next_page, Confirm, CTRL_BUTTON_NORMAL_COLOUR, CTRL_BUTTON_PRESSEN_COLOUR, device_dev_name_big, DEVICE_ITEM_MAX_HEIGHT, DEVICE_ITEM_MAX_WIDTH, DEVICE_LEFT_DEV_NAME, DEVICE_LEFT_PADDING_LEFT, DEVICE_LEFT_PRO_INFO, DEVICE_LEFT_PRO_NAME, device_state_big, StateColor::Disabled, StateColor::Enabled, Label::Head_20, ICON_SINGLE_SIZE, m_action, m_button_add, m_button_edit, m_current_page, m_flipping_page_sizer, m_flipping_panel, m_machine_list, m_main_panel, m_main_sizer, m_page_num_enter, m_page_num_input, m_page_sizer, m_printer_name, m_sizer_machine_list, m_sort, m_status, m_table_head_panel, m_table_head_sizer, m_task_name, m_tip_text, m_total_page, StateColor::Normal, on_timer(), page_num_enter_evt(), page_sizer, StateColor::Pressed, refresh_user_device(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::SortItem::SR_MACHINE_NAME, Slic3r::GUI::SortItem::SR_MACHINE_STATE, st_page_number, start_timer(), Slic3r::GUI::ObjState::state_dev_name, Slic3r::GUI::ObjState::state_device, TABLE_HEAD_FONT, TABLE_HEAD_PRESSED_COLOUR, TABLE_HEAR_NORMAL_COLOUR, update_page_number(), Window, Slic3r::GUI::wxMouseEvent, and wxStaticText.

Here is the call graph for this function:

~MultiMachineManagerPage()

Slic3r::GUI::MultiMachineManagerPage::~MultiMachineManagerPage ( )

inline

{};

Member Function Documentation

clear_page()

void Slic3r::GUI::MultiMachineManagerPage::clear_page

(

)

{
 
}

extractRange()

std::vector< ObjState > Slic3r::GUI::MultiMachineManagerPage::extractRange	(	const std::vector< ObjState > &	source,
		int	start,
		int	end )

                                                                                                               {
    std::vector<ObjState> result;
 
    if (start < 0 || start > end || source.size() <= 0) {
        return result;
    }
 
    if ( end >= source.size() ) {
        end = source.size();
    }
 
    auto startIter = source.begin() + start;
    auto endIter = source.begin() + end;
    result.assign(startIter, endIter);
    return result;
}

Referenced by refresh_user_device().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::MultiMachineManagerPage::msw_rescale

(

)

{
    m_printer_name->Rescale();
    m_printer_name->SetMinSize(wxSize(FromDIP(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_printer_name->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->Rescale();
    m_task_name->SetMinSize(wxSize(FromDIP(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_task_name->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_DEV_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->Rescale();
    m_status->SetMinSize(wxSize(FromDIP(DEVICE_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_status->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_PRO_INFO), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->Rescale();
    m_action->SetMinSize(wxSize(FromDIP(DEVICE_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_action->SetMaxSize(wxSize(FromDIP(DEVICE_LEFT_PRO_NAME), FromDIP(DEVICE_ITEM_MAX_HEIGHT)));
    m_button_add->Rescale();
    m_button_add->SetMinSize(wxSize(FromDIP(90), FromDIP(36)));
    m_button_add->SetMaxSize(wxSize(FromDIP(90), FromDIP(36)));
 
    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_button_edit->Rescale();
    m_button_edit->SetMinSize(wxSize(FromDIP(90), FromDIP(36)));
    m_button_edit->SetMaxSize(wxSize(FromDIP(90), FromDIP(36)));
 
 
    for (const auto& item : m_device_items) {
        item->Refresh();
    }
 
    Fit();
    Layout();
    Refresh();
}

References btn_last_page, btn_next_page, DEVICE_ITEM_MAX_HEIGHT, DEVICE_LEFT_DEV_NAME, DEVICE_LEFT_PRO_INFO, DEVICE_LEFT_PRO_NAME, m_action, m_button_add, m_button_edit, m_device_items, m_page_num_enter, m_printer_name, m_status, and m_task_name.

on_timer()

void Slic3r::GUI::MultiMachineManagerPage::on_timer

(

wxTimerEvent &

event

)

{
    m_flipping_timer->Stop();
    if (btn_last_page)
        btn_last_page->Enable(true);
    if (btn_next_page)
        btn_next_page->Enable(true);
}

References btn_last_page, btn_next_page, and m_flipping_timer.

Referenced by MultiMachineManagerPage().

Here is the caller graph for this function:

page_num_enter_evt()

void Slic3r::GUI::MultiMachineManagerPage::page_num_enter_evt

(

)

{
    btn_last_page->Enable(false);
    btn_next_page->Enable(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();
}

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

Referenced by MultiMachineManagerPage().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_user_device()

void Slic3r::GUI::MultiMachineManagerPage::refresh_user_device

(

bool

clear = false

)

{
    m_sizer_machine_list->Clear(true);
    m_device_items.clear();
 
    if(clear) return;
 
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    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];
        }
    }
 
 
    m_total_count = user_machine.size();
 
    m_state_objs.clear();
    for (auto it = user_machine.begin(); it != user_machine.end(); ++it) {
        sync_state(it->second);
    }
 
    //sort
    if (m_sort.rule != SortItem::SortRule::SR_None) {
        std::sort(m_state_objs.begin(), m_state_objs.end(), m_sort.get_machine_call_back());
    }
 
    double result = static_cast<double>(user_machine.size()) / m_count_page_item;
    m_total_page = std::ceil(result);
 
    std::vector<ObjState> sort_devices = extractRange(m_state_objs, m_current_page * m_count_page_item, (m_current_page + 1) * m_count_page_item - 1 );
    std::vector<std::string> subscribe_list;
 
    for (auto i = 0; i < sort_devices.size(); ++i) {
        auto dev_id = sort_devices[i].dev_id;
 
        auto machine = user_machine[dev_id];
 
        MultiMachineItem* di = new MultiMachineItem(m_machine_list, machine);
        m_device_items.push_back(di);
        m_sizer_machine_list->Add(m_device_items[i], 0, wxALL | wxEXPAND, 0);
 
        subscribe_list.push_back(dev_id);
    }
 
    dev->subscribe_device_list(subscribe_list);
 
    m_tip_text->Show(m_device_items.empty());
    m_button_add->Show(m_device_items.empty());
 
    update_page_number();
    m_flipping_panel->Show(m_total_page > 1);
    m_sizer_machine_list->Layout();
    Layout();
}

References extractRange(), Slic3r::DeviceManager::get_my_cloud_machine_list(), m_button_add, m_count_page_item, m_current_page, m_device_items, m_flipping_panel, m_machine_list, m_sizer_machine_list, m_sort, m_state_objs, m_tip_text, m_total_count, m_total_page, PICK_DEVICE_MAX, Slic3r::GUI::SortItem::SR_None, Slic3r::DeviceManager::subscribe_device_list(), sync_state(), and update_page_number().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Show()

bool Slic3r::GUI::MultiMachineManagerPage::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::MultiMachineManagerPage::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 MultiMachineManagerPage(), and page_num_enter_evt().

Here is the caller graph for this function:

sync_state()

void Slic3r::GUI::MultiMachineManagerPage::sync_state

(

MachineObject *

obj_

)

{
    ObjState state_obj;
 
    if (obj_) {
        state_obj.dev_id = obj_->get_dev_id();
        state_obj.state_dev_name = obj_->get_dev_name();
 
        if (obj_->print_status == "IDLE") {
            state_obj.state_device = 0;
        }
        else if (obj_->print_status == "FINISH") {
            state_obj.state_device = 1;
        }
        else if (obj_->print_status == "FAILED") {
            state_obj.state_device = 2;
        }
        else if (obj_->print_status == "RUNNING") {
            state_obj.state_device = 3;
        }
        else if (obj_->print_status == "PAUSE") {
            state_obj.state_device = 4;
        }
        else if (obj_->print_status == "PREPARE") {
            state_obj.state_device = 5;
        }
        else if (obj_->print_status == "SLICING") {
            state_obj.state_device = 6;
        }
        else {
            state_obj.state_device = 7;
        }
    }
    m_state_objs.push_back(state_obj);
}

References Slic3r::GUI::ObjState::dev_id, Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_dev_name(), m_state_objs, Slic3r::MachineObject::print_status, Slic3r::GUI::ObjState::state_dev_name, and Slic3r::GUI::ObjState::state_device.

Referenced by refresh_user_device().

Here is the call graph for this function:

Here is the caller graph for this function:

update_page()

void Slic3r::GUI::MultiMachineManagerPage::update_page

(

)

{
    for (int i = 0; i < m_device_items.size(); i++) {
        m_device_items[i]->sync_state();
        m_device_items[i]->Refresh();
    }
}

References m_device_items.

update_page_number()

void Slic3r::GUI::MultiMachineManagerPage::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 MultiMachineManagerPage(), page_num_enter_evt(), and refresh_user_device().

Here is the caller graph for this function:

Member Data Documentation

btn_last_page

Button* Slic3r::GUI::MultiMachineManagerPage::btn_last_page { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), msw_rescale(), on_timer(), and page_num_enter_evt().

btn_next_page

Button* Slic3r::GUI::MultiMachineManagerPage::btn_next_page { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), msw_rescale(), on_timer(), and page_num_enter_evt().

device_dev_name_big

bool Slic3r::GUI::MultiMachineManagerPage::device_dev_name_big { true }

private

{ true };

Referenced by MultiMachineManagerPage().

device_state_big

bool Slic3r::GUI::MultiMachineManagerPage::device_state_big { true }

private

{ true };

Referenced by MultiMachineManagerPage().

m_action

Button* Slic3r::GUI::MultiMachineManagerPage::m_action { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_button_add

Button* Slic3r::GUI::MultiMachineManagerPage::m_button_add { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), msw_rescale(), and refresh_user_device().

m_button_edit

Button* Slic3r::GUI::MultiMachineManagerPage::m_button_edit {nullptr}

private

{nullptr};

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_count_page_item

int Slic3r::GUI::MultiMachineManagerPage::m_count_page_item { 10 }

private

{ 10 };

Referenced by refresh_user_device(), and update_page_number().

m_current_page

int Slic3r::GUI::MultiMachineManagerPage::m_current_page { 0 }

private

{ 0 };

Referenced by MultiMachineManagerPage(), page_num_enter_evt(), refresh_user_device(), and update_page_number().

m_device_items

std::vector<MultiMachineItem*> Slic3r::GUI::MultiMachineManagerPage::m_device_items

private

Referenced by msw_rescale(), refresh_user_device(), and update_page().

m_flipping_page_sizer

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::m_flipping_page_sizer { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

m_flipping_panel

wxPanel* Slic3r::GUI::MultiMachineManagerPage::m_flipping_panel { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and refresh_user_device().

m_flipping_timer

wxTimer* Slic3r::GUI::MultiMachineManagerPage::m_flipping_timer { nullptr }

private

{ nullptr };

Referenced by on_timer(), and start_timer().

m_machine_list

wxScrolledWindow* Slic3r::GUI::MultiMachineManagerPage::m_machine_list { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and refresh_user_device().

m_main_panel

wxPanel* Slic3r::GUI::MultiMachineManagerPage::m_main_panel { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

m_main_sizer

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::m_main_sizer {nullptr}

private

{nullptr};

Referenced by MultiMachineManagerPage().

m_page_num_enter

Button* Slic3r::GUI::MultiMachineManagerPage::m_page_num_enter { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_page_num_input

TextInput* Slic3r::GUI::MultiMachineManagerPage::m_page_num_input { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and page_num_enter_evt().

m_page_sizer

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::m_page_sizer { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

m_printer_name

Button* Slic3r::GUI::MultiMachineManagerPage::m_printer_name { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_sizer_machine_list

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::m_sizer_machine_list {nullptr}

private

{nullptr};

Referenced by MultiMachineManagerPage(), and refresh_user_device().

m_sort

SortItem Slic3r::GUI::MultiMachineManagerPage::m_sort

private

Referenced by MultiMachineManagerPage(), and refresh_user_device().

m_state_objs

std::vector<ObjState> Slic3r::GUI::MultiMachineManagerPage::m_state_objs

private

Referenced by refresh_user_device(), and sync_state().

m_status

Button* Slic3r::GUI::MultiMachineManagerPage::m_status { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_table_head_panel

wxPanel* Slic3r::GUI::MultiMachineManagerPage::m_table_head_panel { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

m_table_head_sizer

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::m_table_head_sizer { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

m_task_name

Button* Slic3r::GUI::MultiMachineManagerPage::m_task_name { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and msw_rescale().

m_tip_text

wxStaticText* Slic3r::GUI::MultiMachineManagerPage::m_tip_text { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and refresh_user_device().

m_total_count

int Slic3r::GUI::MultiMachineManagerPage::m_total_count { 0 }

private

{ 0 };

Referenced by refresh_user_device(), and update_page_number().

m_total_page

int Slic3r::GUI::MultiMachineManagerPage::m_total_page { 0 }

private

{ 0 };

Referenced by MultiMachineManagerPage(), page_num_enter_evt(), refresh_user_device(), and update_page_number().

page_sizer

wxBoxSizer* Slic3r::GUI::MultiMachineManagerPage::page_sizer { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage().

st_page_number

wxStaticText* Slic3r::GUI::MultiMachineManagerPage::st_page_number { nullptr }

private

{ nullptr };

Referenced by MultiMachineManagerPage(), and update_page_number().

---

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

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