Slic3r::GUI::SendToPrinterDialog Class Reference

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

Inheritance diagram for Slic3r::GUI::SendToPrinterDialog:

Collaboration diagram for Slic3r::GUI::SendToPrinterDialog:

Public Types

enum

{   SUCCESS = 0 , CONTINUE = 1 , ERROR_JSON = 2 , ERROR_PIPE = 3 ,   ERROR_CANCEL = 4 , ERROR_RES_BUSY = 5 , ERROR_TIME_OUT = 6 , FILE_NO_EXIST = 10 ,   FILE_NAME_INVALID = 11 , FILE_SIZE_ERR = 12 , FILE_OPEN_ERR = 13 , FILE_READ_WRITE_ERR = 14 ,   FILE_CHECK_ERR = 15 , FILE_TYPE_ERR = 16 , STORAGE_UNAVAILABLE = 17 , API_VERSION_UNSUPPORT = 18 ,   FILE_EXIST = 19 , STORAGE_SPACE_NOT_ENOUGH = 20 , FILE_CREATE_ERR = 21 , FILE_WRITE_ERR = 22 ,   MD5_COMPARE_ERR = 23 , FILE_RENAME_ERR = 24 , SEND_ERR = 25 }

Public Member Functions
	SendToPrinterDialog (Plater *plater=nullptr)
	~SendToPrinterDialog ()
bool	Show (bool show) override
bool	is_timeout ()
void	on_rename_click (wxCommandEvent &event)
void	on_rename_enter ()
void	stripWhiteSpace (std::string &str)
void	prepare_mode ()
void	sending_mode ()
void	reset_timeout ()
void	update_user_printer ()
void	update_show_status ()
void	prepare (int print_plate_idx)
void	check_focus (wxWindow *window)
void	check_fcous_state (wxWindow *window)
void	update_priner_status_msg (wxString msg, bool is_warning=false)
void	update_print_status_msg (wxString msg, bool is_warning=false, bool is_printer=true)
void	update_printer_combobox (wxCommandEvent &event)
void	on_cancel (wxCloseEvent &event)
void	on_ok (wxCommandEvent &event)
void	clear_ip_address_config (wxCommandEvent &e)
void	on_refresh (wxCommandEvent &event)
void	on_print_job_cancel (wxCommandEvent &evt)
void	set_default ()
void	on_timer (wxTimerEvent &event)
void	on_selection_changed (wxCommandEvent &event)
void	Enable_Refresh_Button (bool en)
void	show_status (PrintDialogStatus status, std::vector< wxString > params=std::vector< wxString >())
void	Enable_Send_Button (bool en)
void	on_dpi_changed (const wxRect &suggested_rect) override
void	update_user_machine_list ()
void	show_print_failed_info (bool show, int code=0, wxString description=wxEmptyString, wxString extra=wxEmptyString)
void	update_print_error_info (int code, std::string msg, std::string extra)
void	on_change_color_mode ()
void	update_storage_list (const std::vector< std::string > &storages)
std::string	get_storage_selected ()
wxString	format_text (wxString &m_msg)
std::vector< std::string >	sort_string (std::vector< std::string > strArray)
void	GetConnection ()
void	EndModal (int retCode) override
float	scale_factor () const
float	prev_scale_factor () const
void	set_scale_factor (float v)
void	set_prev_scale_factor (float v)
void	set_em_unit (int v)
bool	force_rescale () const
int	em_unit () const
const wxFont &	normal_font () const
void	enable_force_rescale ()
int	ShowModal ()

Protected Member Functions
virtual void	on_sys_color_changed ()

Private Types
enum	ConnectionStatus {   NOT_START , CONNECTING , CONNECTED , CONNECTION_FAILED ,   DISCONNECTED }

Private Member Functions
void	init_bind ()
void	init_timer ()
void	ResetConnectMethod ()
void	ResetTunnelAndJob ()
void	OnConnection (bool is_success, int error_code, std::string error_msg)
void	CreateMediaAbilityJob ()
void	CreateUploadFileJob (const std::string &path, const std::string &name)
void	ChangeConnectMethod ()
void	UploadFileProgressCallback (int progress)
void	UploadFileRessultCallback (int res, int resp_ec, std::string json_res, std::vector< std::byte > bin_res)
void	Reset ()
void	update_em_unit ()
bool	is_new_scale_factor () const
void	rescale (const wxRect &suggested_rect)

Private Attributes
int	m_print_plate_idx
int	m_print_error_code = 0
int	timeout_count = 0
int	m_connect_try_times = 0
bool	m_is_in_sending_mode { false }
bool	m_is_rename_mode { false }
bool	enable_prepare_mode { true }
bool	m_export_3mf_cancel { false }
bool	m_is_canceled { false }
bool	m_tcp_try_connect {true}
bool	m_tutk_try_connect {false}
bool	m_ftp_try_connect {false}
std::string	m_print_error_msg
std::string	m_print_error_extra
std::string	m_print_info
std::string	m_printer_last_select
std::string	m_device_select
wxString	m_current_project_name
TextInput *	m_rename_input { nullptr }
wxSimplebook *	m_rename_switch_panel { nullptr }
Plater *	m_plater { nullptr }
ThumbnailPanel *	m_thumbnailPanel { nullptr }
ComboBox *	m_comboBox_printer { nullptr }
Button *	m_rename_button { nullptr }
Button *	m_button_refresh { nullptr }
Button *	m_button_ensure { nullptr }
wxPanel *	m_scrollable_region
wxPanel *	m_line_schedule { nullptr }
wxPanel *	m_panel_sending { nullptr }
wxPanel *	m_panel_prepare { nullptr }
wxPanel *	m_panel_finish { nullptr }
wxPanel *	m_line_top { nullptr }
wxPanel *	m_panel_image { nullptr }
wxPanel *	m_rename_normal_panel { nullptr }
wxPanel *	m_line_materia { nullptr }
wxBoxSizer *	m_storage_sizer { nullptr }
wxPanel *	m_storage_panel { nullptr }
wxPanel *	m_connecting_panel {nullptr}
wxSimplebook *	m_simplebook { nullptr }
wxStaticText *	m_statictext_finish { nullptr }
wxStaticText *	m_statictext_printer_msg { nullptr }
wxStaticText *	m_connecting_printer_msg {nullptr}
wxStaticText *	m_stext_printer_title { nullptr }
wxStaticText *	m_rename_text { nullptr }
wxStaticText *	m_stext_time { nullptr }
wxStaticText *	m_stext_weight { nullptr }
Label *	m_st_txt_error_code { nullptr }
Label *	m_st_txt_error_desc { nullptr }
Label *	m_st_txt_extra_info { nullptr }
HyperLink *	m_link_network_state { nullptr }
StateColor	btn_bg_enable
wxBoxSizer *	rename_sizer_v { nullptr }
wxBoxSizer *	rename_sizer_h { nullptr }
wxBoxSizer *	sizer_thumbnail
wxBoxSizer *	m_sizer_scrollable_region
wxBoxSizer *	m_sizer_main
PrintDialogStatus	m_print_status { PrintStatusInit }
AnimaIcon *	m_animaicon {nullptr}
std::vector< wxString >	m_bedtype_list
std::map< std::string, ::CheckBox * >	m_checkbox_list
std::vector< MachineObject * >	m_list
wxColour	m_colour_def_color { wxColour(255, 255, 255) }
wxColour	m_colour_bold_color { wxColour(38, 46, 48) }
wxTimer *	m_refresh_timer { nullptr }
std::unique_ptr< wxTimer >	m_task_timer { nullptr }
std::unique_ptr< wxTimer >	m_url_timer {nullptr}
std::shared_ptr< BBLStatusBarSend >	m_status_bar
std::unique_ptr< Worker >	m_worker
wxScrolledWindow *	m_sw_print_failed_info {nullptr}
std::shared_ptr< int >	m_token = std::make_shared<int>(0)
std::vector< RadioBox * >	m_storage_radioBox
std::string	m_selected_storage
bool	m_if_has_sdcard
std::vector< std::string >	m_ability_list
ConnectionStatus	m_connection_status {ConnectionStatus::NOT_START}
std::unique_ptr< FileTransferTunnel >	m_filetransfer_tunnel
std::unique_ptr< FileTransferJob >	m_filetransfer_mediability_job
std::unique_ptr< FileTransferJob >	m_filetransfer_uploadfile_job
wxDateTime	m_last_refresh_time
float	m_scale_factor
int	m_em_unit
wxFont	m_normal_font
float	m_prev_scale_factor
bool	m_can_rescale
bool	m_force_rescale
int	m_new_font_point_size

Detailed Description

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
SUCCESS
CONTINUE
ERROR_JSON
ERROR_PIPE
ERROR_CANCEL
ERROR_RES_BUSY
ERROR_TIME_OUT
FILE_NO_EXIST
FILE_NAME_INVALID
FILE_SIZE_ERR
FILE_OPEN_ERR
FILE_READ_WRITE_ERR
FILE_CHECK_ERR
FILE_TYPE_ERR
STORAGE_UNAVAILABLE
API_VERSION_UNSUPPORT
FILE_EXIST
STORAGE_SPACE_NOT_ENOUGH
FILE_CREATE_ERR
FILE_WRITE_ERR
MD5_COMPARE_ERR
FILE_RENAME_ERR
SEND_ERR

         {
        SUCCESS                  = 0,
        CONTINUE                 = 1,
        ERROR_JSON               = 2,
        ERROR_PIPE               = 3,
        ERROR_CANCEL             = 4,
        ERROR_RES_BUSY           = 5,
        ERROR_TIME_OUT           = 6,
        FILE_NO_EXIST            = 10,
        FILE_NAME_INVALID        = 11,
        FILE_SIZE_ERR            = 12,
        FILE_OPEN_ERR            = 13,
        FILE_READ_WRITE_ERR      = 14,
        FILE_CHECK_ERR           = 15,
        FILE_TYPE_ERR            = 16,
        STORAGE_UNAVAILABLE      = 17,
        API_VERSION_UNSUPPORT    = 18,
        FILE_EXIST               = 19,
        STORAGE_SPACE_NOT_ENOUGH = 20,
        FILE_CREATE_ERR          = 21,
        FILE_WRITE_ERR           = 22,
        MD5_COMPARE_ERR          = 23,
        FILE_RENAME_ERR          = 24,
        SEND_ERR                 = 25,
};

ConnectionStatus

enum Slic3r::GUI::SendToPrinterDialog::ConnectionStatus

private

Enumerator
NOT_START
CONNECTING
CONNECTED
CONNECTION_FAILED
DISCONNECTED

{ NOT_START, CONNECTING, CONNECTED, CONNECTION_FAILED, DISCONNECTED };

Constructor & Destructor Documentation

SendToPrinterDialog()

Slic3r::GUI::SendToPrinterDialog::SendToPrinterDialog

(

Plater *

plater = nullptr

)

    : DPIDialog(static_cast<wxWindow *>(wxGetApp().mainframe), wxID_ANY, _L("Send to Printer storage"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
    , m_plater(plater), m_export_3mf_cancel(false)
{
#ifdef __WINDOWS__
    SetDoubleBuffered(true);
#endif //__WINDOWS__
 
    // bind
    Bind(wxEVT_CLOSE_WINDOW, &SendToPrinterDialog::on_cancel, this);
 
    // font
    SetFont(wxGetApp().normal_font());
 
    Freeze();
    SetBackgroundColour(m_colour_def_color);
 
    m_sizer_main = new wxBoxSizer(wxVERTICAL);
 
    m_sizer_main->SetMinSize(wxSize(0, -1));
    m_line_top = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1), wxTAB_TRAVERSAL);
    m_line_top->SetBackgroundColour(wxColour(166, 169, 170));
 
    m_scrollable_region       = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_sizer_scrollable_region = new wxBoxSizer(wxVERTICAL);
 
    m_panel_image = new wxPanel(m_scrollable_region, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_panel_image->SetBackgroundColour(m_colour_def_color);
 
    sizer_thumbnail = new wxBoxSizer(wxVERTICAL);
    m_thumbnailPanel = new ThumbnailPanel(m_panel_image);
    m_thumbnailPanel->SetSize(wxSize(FromDIP(256), FromDIP(256)));
    m_thumbnailPanel->SetMinSize(wxSize(FromDIP(256), FromDIP(256)));
    m_thumbnailPanel->SetMaxSize(wxSize(FromDIP(256), FromDIP(256)));
    sizer_thumbnail->Add(m_thumbnailPanel, 0, wxEXPAND, 0);
    m_panel_image->SetSizer(sizer_thumbnail);
    m_panel_image->Layout();
 
    wxBoxSizer *m_sizer_basic        = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *m_sizer_basic_weight = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *m_sizer_basic_time   = new wxBoxSizer(wxHORIZONTAL);
 
    auto timeimg = new wxStaticBitmap(m_scrollable_region, wxID_ANY, create_scaled_bitmap("print-time", this, 18), wxDefaultPosition, wxSize(FromDIP(18), FromDIP(18)), 0);
    m_sizer_basic_weight->Add(timeimg, 1, wxEXPAND | wxALL, FromDIP(5));
    m_stext_time = new wxStaticText(m_scrollable_region, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT);
    m_sizer_basic_weight->Add(m_stext_time, 0, wxALL, FromDIP(5));
    m_sizer_basic->Add(m_sizer_basic_weight, 0, wxALIGN_CENTER, 0);
    m_sizer_basic->Add(0, 0, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(30));
 
    auto weightimg = new wxStaticBitmap(m_scrollable_region, wxID_ANY, create_scaled_bitmap("print-weight", this, 18), wxDefaultPosition, wxSize(FromDIP(18), FromDIP(18)), 0);
    m_sizer_basic_time->Add(weightimg, 1, wxEXPAND | wxALL, FromDIP(5));
    m_stext_weight = new wxStaticText(m_scrollable_region, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
    m_sizer_basic_time->Add(m_stext_weight, 0, wxALL, FromDIP(5));
    m_sizer_basic->Add(m_sizer_basic_time, 0, wxALIGN_CENTER, 0);
 
    m_line_materia = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1), wxTAB_TRAVERSAL);
    m_line_materia->SetForegroundColour(wxColour(238, 238, 238));
    m_line_materia->SetBackgroundColour(wxColour(238, 238, 238));
 
    wxBoxSizer *m_sizer_printer = new wxBoxSizer(wxHORIZONTAL);
 
    m_stext_printer_title = new wxStaticText(this, wxID_ANY, _L("Printer"), wxDefaultPosition, wxSize(-1, -1), 0);
    m_stext_printer_title->SetFont(::Label::Head_14);
    m_stext_printer_title->Wrap(-1);
    m_stext_printer_title->SetForegroundColour(m_colour_bold_color);
    m_stext_printer_title->SetBackgroundColour(m_colour_def_color);
 
    m_sizer_printer->Add(m_stext_printer_title, 0, wxALL | wxLEFT, FromDIP(5));
    m_sizer_printer->Add(0, 0, 0, wxEXPAND | wxLEFT, FromDIP(12));
 
    m_comboBox_printer = new ::ComboBox(this, wxID_ANY, "", wxDefaultPosition, wxSize(FromDIP(250), -1), 0, nullptr, wxCB_READONLY);
    m_comboBox_printer->Bind(wxEVT_COMBOBOX, &SendToPrinterDialog::on_selection_changed, this);
 
    m_sizer_printer->Add(m_comboBox_printer, 1, wxEXPAND | wxRIGHT, FromDIP(5));
 
    m_button_refresh = new Button(this, _L("Refresh"));
    m_button_refresh->SetStyle(ButtonStyle::Confirm, ButtonType::Window);
    m_button_refresh->Bind(wxEVT_BUTTON, &SendToPrinterDialog::on_refresh, this);
 
    m_sizer_printer->Add(m_button_refresh, 0, wxALL | wxLEFT, FromDIP(5));
 
    /*select storage*/
    m_storage_panel = new wxPanel(this);
    m_storage_panel->SetBackgroundColour(*wxWHITE);
    m_storage_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_storage_panel->SetSizer(m_storage_sizer);
    m_storage_panel->Layout();
 
    // try to connect
    m_statictext_printer_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(400), -1), wxALIGN_CENTER_HORIZONTAL);
    m_statictext_printer_msg->SetFont(::Label::Body_13);
    m_statictext_printer_msg->SetForegroundColour(*wxBLACK);
    m_statictext_printer_msg->Hide();
 
    wxBoxSizer *m_sizer_connecting      = new wxBoxSizer(wxHORIZONTAL);
    m_connecting_panel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
 
    m_connecting_printer_msg = new wxStaticText(m_connecting_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER_HORIZONTAL);
    m_connecting_printer_msg->SetFont(::Label::Body_13);
    m_connecting_printer_msg->SetForegroundColour(*wxBLACK);
    m_connecting_printer_msg->SetLabel(_L("Try to connect"));
    /*m_connecting_printer_msg->Hide();*/
    m_connecting_printer_msg->Show();
 
    std::vector<std::string> list{"ams_rfid_1", "ams_rfid_2", "ams_rfid_3", "ams_rfid_4"};
    m_animaicon = new AnimaIcon(m_connecting_panel, wxID_ANY, list, "refresh_printer", 100);
    m_sizer_connecting->Add(m_connecting_printer_msg, 1, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(5));
    m_sizer_connecting->Add(m_animaicon, 0, wxALIGN_CENTER_VERTICAL);
 
    m_connecting_panel->SetSizer(m_sizer_connecting);
    m_connecting_panel->Layout();
    m_connecting_panel->Fit();
    m_connecting_panel->Hide();
 
    // line schedule
    m_line_schedule = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1));
    m_line_schedule->SetBackgroundColour(wxColour(238, 238, 238));
    m_simplebook   = new wxSimplebook(this, wxID_ANY, wxDefaultPosition, SELECT_MACHINE_DIALOG_SIMBOOK_SIZE, 0);
 
    // perpare mode
    m_panel_prepare = new wxPanel(m_simplebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_panel_prepare->SetBackgroundColour(m_colour_def_color);
    // m_panel_prepare->SetBackgroundColour(wxColour(135,206,250));
    wxBoxSizer *m_sizer_prepare = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer *m_sizer_pcont   = new wxBoxSizer(wxHORIZONTAL);
 
    m_sizer_prepare->Add(0, 0, 1, wxTOP, FromDIP(22));
    m_sizer_pcont->Add(0, 0, 1, wxEXPAND, 0);
    m_button_ensure = new Button(m_panel_prepare, _L("Send"));
    m_button_ensure->SetStyle(ButtonStyle::Confirm, ButtonType::Choice);
 
    m_button_ensure->Bind(wxEVT_BUTTON, &SendToPrinterDialog::on_ok, this);
    m_sizer_pcont->Add(m_button_ensure, 0, wxEXPAND | wxBOTTOM, FromDIP(10));
    m_sizer_prepare->Add(m_sizer_pcont, 0, wxEXPAND, 0);
    m_panel_prepare->SetSizer(m_sizer_prepare);
    m_panel_prepare->Layout();
    m_simplebook->AddPage(m_panel_prepare, wxEmptyString, true);
 
    // sending mode
    m_status_bar    = std::make_shared<BBLStatusBarSend>(m_simplebook);
    m_panel_sending = m_status_bar->get_panel();
    m_simplebook->AddPage(m_panel_sending, wxEmptyString, false);
    
    m_worker = std::make_unique<PlaterWorker<BoostThreadWorker>>(this, m_status_bar, "send_worker");
 
    // finish mode
    m_panel_finish = new wxPanel(m_simplebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_panel_finish->SetBackgroundColour(wxColour(135, 206, 250));
    wxBoxSizer *m_sizer_finish   = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *m_sizer_finish_v = new wxBoxSizer(wxVERTICAL);
    wxBoxSizer *m_sizer_finish_h = new wxBoxSizer(wxHORIZONTAL);
 
    auto imgsize      = FromDIP(25);
    auto completedimg = new wxStaticBitmap(m_panel_finish, wxID_ANY, create_scaled_bitmap("completed", m_panel_finish, 25), wxDefaultPosition, wxSize(imgsize, imgsize), 0);
    m_sizer_finish_h->Add(completedimg, 0, wxALIGN_CENTER | wxALL, FromDIP(5));
 
    m_statictext_finish = new wxStaticText(m_panel_finish, wxID_ANY, _L("Send complete"), wxDefaultPosition, wxDefaultSize, 0);
    m_statictext_finish->Wrap(-1);
    m_statictext_finish->SetForegroundColour(wxColour(0, 150, 136));
    m_sizer_finish_h->Add(m_statictext_finish, 0, wxALIGN_CENTER | wxALL, FromDIP(5));
 
    m_sizer_finish_v->Add(m_sizer_finish_h, 1, wxALIGN_CENTER, 0);
 
    m_sizer_finish->Add(m_sizer_finish_v, 1, wxALIGN_CENTER, 0);
 
    m_panel_finish->SetSizer(m_sizer_finish);
    m_panel_finish->Layout();
    m_sizer_finish->Fit(m_panel_finish);
    m_simplebook->AddPage(m_panel_finish, wxEmptyString, false);
 
    //show bind failed info
    m_sw_print_failed_info = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxSize(FromDIP(380), FromDIP(125)), wxVSCROLL);
    m_sw_print_failed_info->SetBackgroundColour(*wxWHITE);
    m_sw_print_failed_info->SetScrollRate(0, FromDIP(20));
    m_sw_print_failed_info->SetMinSize(wxSize(FromDIP(380), FromDIP(125)));
    m_sw_print_failed_info->SetMaxSize(wxSize(FromDIP(380), FromDIP(125)));
 
    wxBoxSizer* sizer_print_failed_info = new wxBoxSizer(wxVERTICAL);
    m_sw_print_failed_info->SetSizer(sizer_print_failed_info);
 
    wxBoxSizer* sizer_error_code = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* sizer_error_desc = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* sizer_extra_info = new wxBoxSizer(wxHORIZONTAL);
 
    auto st_title_error_code = new wxStaticText(m_sw_print_failed_info, wxID_ANY, _L("Error code"));
    auto st_title_error_code_doc = new wxStaticText(m_sw_print_failed_info, wxID_ANY, ": ");
    m_st_txt_error_code = new Label(m_sw_print_failed_info, wxEmptyString);
    st_title_error_code->SetForegroundColour(0x909090);
    st_title_error_code_doc->SetForegroundColour(0x909090);
    m_st_txt_error_code->SetForegroundColour(0x909090);
    st_title_error_code->SetFont(::Label::Body_13);
    st_title_error_code_doc->SetFont(::Label::Body_13);
    m_st_txt_error_code->SetFont(::Label::Body_13);
    st_title_error_code->SetMinSize(wxSize(FromDIP(74), -1));
    st_title_error_code->SetMaxSize(wxSize(FromDIP(74), -1));
    m_st_txt_error_code->SetMinSize(wxSize(FromDIP(260), -1));
    m_st_txt_error_code->SetMaxSize(wxSize(FromDIP(260), -1));
    sizer_error_code->Add(st_title_error_code, 0, wxALL, 0);
    sizer_error_code->Add(st_title_error_code_doc, 0, wxALL, 0);
    sizer_error_code->Add(m_st_txt_error_code, 0, wxALL, 0);
 
    auto st_title_error_desc = new wxStaticText(m_sw_print_failed_info, wxID_ANY, _L("Error desc"));
    auto st_title_error_desc_doc = new wxStaticText(m_sw_print_failed_info, wxID_ANY, ": ");
    m_st_txt_error_desc = new Label(m_sw_print_failed_info, wxEmptyString);
    st_title_error_desc->SetForegroundColour(0x909090);
    st_title_error_desc_doc->SetForegroundColour(0x909090);
    m_st_txt_error_desc->SetForegroundColour(0x909090);
    st_title_error_desc->SetFont(::Label::Body_13);
    st_title_error_desc_doc->SetFont(::Label::Body_13);
    m_st_txt_error_desc->SetFont(::Label::Body_13);
    st_title_error_desc->SetMinSize(wxSize(FromDIP(74), -1));
    st_title_error_desc->SetMaxSize(wxSize(FromDIP(74), -1));
    m_st_txt_error_desc->SetMinSize(wxSize(FromDIP(260), -1));
    m_st_txt_error_desc->SetMaxSize(wxSize(FromDIP(260), -1));
    sizer_error_desc->Add(st_title_error_desc, 0, wxALL, 0);
    sizer_error_desc->Add(st_title_error_desc_doc, 0, wxALL, 0);
    sizer_error_desc->Add(m_st_txt_error_desc, 0, wxALL, 0);
 
    auto st_title_extra_info = new wxStaticText(m_sw_print_failed_info, wxID_ANY, _L("Extra info"));
    auto st_title_extra_info_doc = new wxStaticText(m_sw_print_failed_info, wxID_ANY, ": ");
    m_st_txt_extra_info = new Label(m_sw_print_failed_info, wxEmptyString);
    st_title_extra_info->SetForegroundColour(0x909090);
    st_title_extra_info_doc->SetForegroundColour(0x909090);
    m_st_txt_extra_info->SetForegroundColour(0x909090);
    st_title_extra_info->SetFont(::Label::Body_13);
    st_title_extra_info_doc->SetFont(::Label::Body_13);
    m_st_txt_extra_info->SetFont(::Label::Body_13);
    st_title_extra_info->SetMinSize(wxSize(FromDIP(74), -1));
    st_title_extra_info->SetMaxSize(wxSize(FromDIP(74), -1));
    m_st_txt_extra_info->SetMinSize(wxSize(FromDIP(260), -1));
    m_st_txt_extra_info->SetMaxSize(wxSize(FromDIP(260), -1));
    sizer_extra_info->Add(st_title_extra_info, 0, wxALL, 0);
    sizer_extra_info->Add(st_title_extra_info_doc, 0, wxALL, 0);
    sizer_extra_info->Add(m_st_txt_extra_info, 0, wxALL, 0);
 
    // ORCA standardized HyperLink
    m_link_network_state = new HyperLink(m_sw_print_failed_info, _L("Check the status of current system services"), wxGetApp().link_to_network_check());
    m_link_network_state->SetFont(::Label::Body_12);
 
    sizer_print_failed_info->Add(m_link_network_state, 0, wxLEFT, 5);
    sizer_print_failed_info->Add(sizer_error_code, 0, wxLEFT, 5);
    sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
    sizer_print_failed_info->Add(sizer_error_desc, 0, wxLEFT, 5);
    sizer_print_failed_info->Add(0, 0, 0, wxTOP, FromDIP(3));
    sizer_print_failed_info->Add(sizer_extra_info, 0, wxLEFT, 5);
 
    // bind
    Bind(EVT_SHOW_ERROR_INFO_SEND, [this](auto& e) {
        show_print_failed_info(true);
    });
 
    // bind
    Bind(EVT_UPDATE_USER_MACHINE_LIST, &SendToPrinterDialog::update_printer_combobox, this);
    Bind(EVT_PRINT_JOB_CANCEL, &SendToPrinterDialog::on_print_job_cancel, this);
 
 
    m_sizer_scrollable_region->Add(m_panel_image, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_scrollable_region->Add(0, 0, 0, wxTOP, FromDIP(10));
    m_sizer_scrollable_region->Add(m_sizer_basic, 0, wxALIGN_CENTER_HORIZONTAL, 0);
  m_scrollable_region->SetSizer(m_sizer_scrollable_region);
  m_scrollable_region->Layout();
 
    //file name
    //rename normal
    m_rename_switch_panel = new wxSimplebook(this);
    m_rename_switch_panel->SetSize(wxSize(FromDIP(420), FromDIP(25)));
    m_rename_switch_panel->SetMinSize(wxSize(FromDIP(420), FromDIP(25)));
    m_rename_switch_panel->SetMaxSize(wxSize(FromDIP(420), FromDIP(25)));
 
    m_rename_normal_panel = new wxPanel(m_rename_switch_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_rename_normal_panel->SetBackgroundColour(*wxWHITE);
    rename_sizer_v = new wxBoxSizer(wxVERTICAL);
    rename_sizer_h = new wxBoxSizer(wxHORIZONTAL);
 
    m_rename_text = new wxStaticText(m_rename_normal_panel, wxID_ANY, wxT("MyLabel"), wxDefaultPosition, wxDefaultSize, wxST_ELLIPSIZE_END);
    m_rename_text->SetForegroundColour(*wxBLACK);
    m_rename_text->SetFont(::Label::Body_13);
    m_rename_text->SetMaxSize(wxSize(FromDIP(390), -1));
    m_rename_button = new Button(m_rename_normal_panel, "", "rename_edit", wxBORDER_NONE, FromDIP(13)); // ORCA Match edit icon and its size
    m_rename_button->SetBackgroundColor(*wxWHITE);
    m_rename_button->SetBackgroundColour(*wxWHITE);
 
    rename_sizer_h->Add(m_rename_text, 0, wxALIGN_CENTER, 0);
    rename_sizer_h->Add(m_rename_button, 0, wxALIGN_CENTER, 0);
    rename_sizer_v->Add(rename_sizer_h, 1, wxALIGN_CENTER, 0);
    m_rename_normal_panel->SetSizer(rename_sizer_v);
    m_rename_normal_panel->Layout();
    rename_sizer_v->Fit(m_rename_normal_panel);
 
    //rename edit
    auto m_rename_edit_panel = new wxPanel(m_rename_switch_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL);
    m_rename_edit_panel->SetBackgroundColour(*wxWHITE);
    auto rename_edit_sizer_v = new wxBoxSizer(wxVERTICAL);
 
    m_rename_input = new ::TextInput(m_rename_edit_panel, wxEmptyString, wxEmptyString, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
    m_rename_input->GetTextCtrl()->SetFont(::Label::Body_13);
    m_rename_input->SetSize(wxSize(FromDIP(380), FromDIP(24)));
    m_rename_input->SetMinSize(wxSize(FromDIP(380), FromDIP(24)));
    m_rename_input->SetMaxSize(wxSize(FromDIP(380), FromDIP(24)));
    m_rename_input->Bind(wxEVT_TEXT_ENTER, [this](auto& e) {on_rename_enter();});
    m_rename_input->Bind(wxEVT_KILL_FOCUS, [this](auto& e) {
        if (!m_rename_input->HasFocus() && !m_rename_text->HasFocus())
            on_rename_enter();
        else
            e.Skip(); });
    rename_edit_sizer_v->Add(m_rename_input, 1, wxALIGN_CENTER, 0);
 
 
    m_rename_edit_panel->SetSizer(rename_edit_sizer_v);
    m_rename_edit_panel->Layout();
    rename_edit_sizer_v->Fit(m_rename_edit_panel);
 
    m_rename_button->Bind(wxEVT_BUTTON, &SendToPrinterDialog::on_rename_click, this);
    m_rename_switch_panel->AddPage(m_rename_normal_panel, wxEmptyString, true);
    m_rename_switch_panel->AddPage(m_rename_edit_panel, wxEmptyString, false);
 
    Bind(wxEVT_CHAR_HOOK, [this](wxKeyEvent& e) {
        if (e.GetKeyCode() == WXK_ESCAPE) {
            if (m_rename_switch_panel->GetSelection() == 0) {
                e.Skip();
            }
            else {
                m_rename_switch_panel->SetSelection(0);
                m_rename_text->SetLabel(m_current_project_name);
                m_rename_normal_panel->Layout();
            }
        }
        else {
            e.Skip();
        }
        });
 
    m_panel_prepare->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
        check_fcous_state(this);
        e.Skip();
        });
 
    m_scrollable_region->Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
        check_fcous_state(this);
        e.Skip();
        });
 
    Bind(wxEVT_LEFT_DOWN, [this](auto& e) {
        check_fcous_state(this);
        e.Skip();
        });
 
    m_sizer_main->Add(m_line_top, 0, wxEXPAND, 0);
    m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(10));
    m_sizer_main->Add(m_scrollable_region, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(6));
    m_sizer_main->Add(m_rename_switch_panel, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(6));
    m_sizer_main->Add(m_line_materia, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(30));
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(12));
    m_sizer_main->Add(m_sizer_printer, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(30));
    m_sizer_main->Add(m_storage_panel, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP , FromDIP(8));
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(11));
    m_sizer_main->Add(m_statictext_printer_msg, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_main->Add(m_connecting_panel, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_main->Add(0, 1, 0, wxTOP, FromDIP(22));
    m_sizer_main->Add(m_line_schedule, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(30));
    m_sizer_main->Add(m_simplebook, 0, wxALIGN_CENTER_HORIZONTAL, 0);
    m_sizer_main->Add(m_sw_print_failed_info, 0, wxALIGN_CENTER, 0);
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(13));
 
     m_last_refresh_time = wxDateTime::Now();
    show_print_failed_info(false);
    SetSizer(m_sizer_main);
    Layout();
    Fit();
    Thaw();
 
    init_bind();
    init_timer();
    // CenterOnParent();
    Centre(wxBOTH);
    wxGetApp().UpdateDlgDarkUI(this);
}

References _L, Label::Body_12, Label::Body_13, check_fcous_state(), Choice, Confirm, create_scaled_bitmap(), Label::Head_14, init_bind(), init_timer(), m_animaicon, m_button_ensure, m_button_refresh, m_colour_bold_color, m_colour_def_color, m_comboBox_printer, m_connecting_panel, m_connecting_printer_msg, m_current_project_name, m_export_3mf_cancel, m_last_refresh_time, m_line_materia, m_line_schedule, m_line_top, m_link_network_state, m_panel_finish, m_panel_image, m_panel_prepare, m_panel_sending, m_plater, m_rename_button, m_rename_input, m_rename_normal_panel, m_rename_switch_panel, m_rename_text, m_scrollable_region, m_simplebook, m_sizer_main, m_sizer_scrollable_region, m_st_txt_error_code, m_st_txt_error_desc, m_st_txt_extra_info, m_statictext_finish, m_statictext_printer_msg, m_status_bar, m_stext_printer_title, m_stext_time, m_stext_weight, m_storage_panel, m_storage_sizer, m_sw_print_failed_info, m_thumbnailPanel, m_worker, Slic3r::GUI::DPIAware< wxDialog >::normal_font(), on_cancel(), on_ok(), on_print_job_cancel(), on_refresh(), on_rename_click(), on_rename_enter(), on_selection_changed(), Slic3r::GUI::plater(), rename_sizer_h, rename_sizer_v, SELECT_MACHINE_DIALOG_SIMBOOK_SIZE, show_print_failed_info(), sizer_thumbnail, update_printer_combobox(), Window, and wxStaticText.

Here is the call graph for this function:

~SendToPrinterDialog()

Slic3r::GUI::SendToPrinterDialog::~SendToPrinterDialog

(

)

{
    delete m_refresh_timer;
    if (m_task_timer && m_task_timer->IsRunning())
        m_task_timer->Stop();
    if (m_url_timer && m_url_timer->IsRunning())
         m_url_timer->Stop();
}

References ~SendToPrinterDialog(), m_refresh_timer, m_task_timer, and m_url_timer.

Referenced by ~SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

ChangeConnectMethod()

void Slic3r::GUI::SendToPrinterDialog::ChangeConnectMethod ( )

private

{
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
    MachineObject *obj = dev->get_my_machine(m_printer_last_select);
    if (!obj) return;
 
    bool is_lan = (obj->connection_type() == "lan");
 
    m_tcp_try_connect = false;
 
    if (is_lan) {
        m_ftp_try_connect  = true;
        m_tutk_try_connect = false;
    } else {
        if (m_connect_try_times == 0) {
            m_ftp_try_connect  = false;
            m_tutk_try_connect = true;
        } else {
            m_ftp_try_connect  = true;
            m_tutk_try_connect = false;
        }
    }
    m_connect_try_times++;
}

References ChangeConnectMethod(), Slic3r::MachineObject::connection_type(), Slic3r::DeviceManager::get_my_machine(), m_connect_try_times, m_ftp_try_connect, m_printer_last_select, m_tcp_try_connect, and m_tutk_try_connect.

Referenced by ChangeConnectMethod(), and OnConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

check_fcous_state()

void Slic3r::GUI::SendToPrinterDialog::check_fcous_state

(

wxWindow *

window

)

{
    check_focus(window);
    auto children = window->GetChildren();
    for (auto child : children) {
        check_fcous_state(child);
    }
}

References check_fcous_state(), and check_focus().

Referenced by SendToPrinterDialog(), and check_fcous_state().

Here is the call graph for this function:

Here is the caller graph for this function:

check_focus()

void Slic3r::GUI::SendToPrinterDialog::check_focus

(

wxWindow *

window

)

{
    if (window == m_rename_input || window == m_rename_input->GetTextCtrl()) {
        on_rename_enter();
    }
}

References m_rename_input, and on_rename_enter().

Referenced by check_fcous_state().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_ip_address_config()

void Slic3r::GUI::SendToPrinterDialog::clear_ip_address_config

(

wxCommandEvent &

e

)

{
    enable_prepare_mode = true;
    prepare_mode();
}

References enable_prepare_mode, and prepare_mode().

Referenced by init_bind().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateMediaAbilityJob()

void Slic3r::GUI::SendToPrinterDialog::CreateMediaAbilityJob ( )

private

{
    nlohmann::json media_ability = {{"cmd_type", 7}};
    try
    {
        m_filetransfer_mediability_job = std::make_unique<FileTransferJob>(module(), std::string(media_ability.dump()));
    }
    catch (const std::exception& e)
    {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
         show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
         return;
     }
     m_filetransfer_mediability_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) {
         //this pl
         CallAfter([this, res, resp_ec, json_res] {
             if (res == 0) // 0 is success
             {
                 show_status(PrintDialogStatus::PrintStatusReadingFinished);
                 try
                 {
                     auto media_set = nlohmann::json::parse(json_res);
                     for (const auto &it : media_set)
                         m_ability_list.push_back(it.get<std::string>());
 
                     BOOST_LOG_TRIVIAL(info) << "CreateMediaAbilityJob::" << "request mediaability success." << json_res;
                     if (m_if_has_sdcard == false && m_ability_list.size() == 1)
                     {
                         show_status(PrintDialogStatus::PrintStatusNoSdcard);
                         return;
                     }
                     else
                     {
                         update_storage_list(m_ability_list);
                     }
                 }
                 catch (const nlohmann::json::exception &e)
                 {
                    BOOST_LOG_TRIVIAL(error) << "CreateMediaAbilityJob::" << ": " << e.what();
                 }
                 catch (...)
                 {
                     BOOST_LOG_TRIVIAL(error) << "CreateMediaAbilityJob::" << ": " << "parse error!";
                 }
             }
             else
             {
                 BOOST_LOG_TRIVIAL(error) << "CreateMediaAbilityJob::" << ":request mediaability failed. res =" << res << "resp_ec is:" << resp_ec;
                 show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
                 update_print_status_msg(ParseErrorCode(resp_ec), false, true);
             }
         });
     });
     // Guard against a null transfer tunnel before dereferencing.
     if (m_filetransfer_tunnel) {
        m_filetransfer_mediability_job->start_on(*m_filetransfer_tunnel);
     } else {
        BOOST_LOG_TRIVIAL(info) << "CreateMediaAbilityJob: file transfer tunnel is null";
     }
}

References CreateMediaAbilityJob(), m_ability_list, m_filetransfer_mediability_job, m_filetransfer_tunnel, m_if_has_sdcard, Slic3r::module(), Slic3r::GUI::ParseErrorCode(), Slic3r::GUI::PrintStatusNoSdcard, Slic3r::GUI::PrintStatusPublicInitFailed, Slic3r::GUI::PrintStatusReadingFinished, show_status(), update_print_status_msg(), and update_storage_list().

Referenced by CreateMediaAbilityJob(), and OnConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateUploadFileJob()

void Slic3r::GUI::SendToPrinterDialog::CreateUploadFileJob ( const std::string & path, const std::string & name )

private

{
    nlohmann::json upload_params = {
        {"cmd_type", 5},
    };
    upload_params["dest_storage"] = m_selected_storage;
    upload_params["dest_name"] = name; // filenme no path
    upload_params["file_path"] = path;
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Begin CreateUploadFileJob";
    try
    {
        m_filetransfer_uploadfile_job = std::make_unique<FileTransferJob>(module(), std::string(upload_params.dump()));
    }
    catch (const std::exception& e)
    {
        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
        show_status(PrintDialogStatus::PrintStatusPublicUploadFiled);
        return;
    }
    m_filetransfer_uploadfile_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) { //
        CallAfter([this, res, resp_ec, json_res, bin_res] {
            UploadFileRessultCallback(res, resp_ec,json_res, bin_res);
        });
    });
 
    m_filetransfer_uploadfile_job->on_msg([this](int kind, std::string json_res) {
        CallAfter([this, kind, json_res] {
            if (kind == 0) {
                try
                {
                    auto js       = nlohmann::json::parse(json_res);
                    int  progress = js["progress"].get<int>();
                    UploadFileProgressCallback(progress);
                }
                catch (const nlohmann::json::exception& e)
                {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": " << e.what();
                }
                catch (...)
                {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ": " << "parse_json failed! ";
                }
            }
        });
    });
    // Guard against a null transfer tunnel before dereferencing.
    if (m_filetransfer_tunnel) {
        m_filetransfer_uploadfile_job->start_on(*m_filetransfer_tunnel);
    } else {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": file transfer tunnel is null";
    }
}

References CreateUploadFileJob(), m_filetransfer_tunnel, m_filetransfer_uploadfile_job, m_selected_storage, Slic3r::module(), Slic3r::GUI::PrintStatusPublicUploadFiled, show_status(), UploadFileProgressCallback(), and UploadFileRessultCallback().

Referenced by CreateUploadFileJob(), and on_ok().

Here is the call graph for this function:

Here is the caller graph for this function:

em_unit()

int Slic3r::GUI::DPIAware< wxDialog >::em_unit ( ) const

inlineinherited

{ return m_em_unit; }

Referenced by Slic3r::GUI::AuxiliaryDialog::AuxiliaryDialog(), Slic3r::GUI::CopyrightsDialog::CopyrightsDialog(), Slic3r::GUI::DesignTextDialog::DesignTextDialog(), Slic3r::GUI::EditGCodeDialog::EditGCodeDialog(), Slic3r::GUI::FileArchiveDialog::FileArchiveDialog(), Slic3r::GUI::MsgNoUpdates::MsgNoUpdates(), Slic3r::GUI::MsgUpdateForced::MsgUpdateForced(), Slic3r::GUI::OAuthDialog::OAuthDialog(), Slic3r::GUI::ParamsDialog::ParamsDialog(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::SettingsDialog::SettingsDialog(), anonymous_namespace{3DPrinterOS.cpp}::TokenAuthDialog::TokenAuthDialog(), anonymous_namespace{3DPrinterOS.cpp}::UploadOptionsDialog::UploadOptionsDialog(), Slic3r::GUI::PublishSettingsDialog::add_row_ui(), Slic3r::GUI::DiffPresetDialog::complete_dialog_creation(), Slic3r::GUI::DiffPresetDialog::create_edit_sizer(), Slic3r::GUI::DiffPresetDialog::create_presets_sizer(), Slic3r::GUI::DiffPresetDialog::create_tree(), Slic3r::GUI::ElegooPrintHostSendDialog::init(), Slic3r::GUI::FlashforgePrintHostSendDialog::init(), Slic3r::GUI::PrintHostSendDialog::init(), Slic3r::GUI::AboutDialog::on_dpi_changed(), Slic3r::GUI::AuxiliaryDialog::on_dpi_changed(), Slic3r::GUI::BedShapeDialog::on_dpi_changed(), Slic3r::GUI::ConfigWizard::on_dpi_changed(), Slic3r::GUI::CopyrightsDialog::on_dpi_changed(), Slic3r::GUI::DiffPresetDialog::on_dpi_changed(), Slic3r::GUI::EditGCodeDialog::on_dpi_changed(), Slic3r::GUI::FileArchiveDialog::on_dpi_changed(), Slic3r::GUI::OAuthDialog::on_dpi_changed(), Slic3r::GUI::ObjectTableDialog::on_dpi_changed(), Slic3r::GUI::ParamsDialog::on_dpi_changed(), Slic3r::GUI::PhysicalPrinterDialog::on_dpi_changed(), Slic3r::GUI::PrintHostQueueDialog::on_dpi_changed(), Slic3r::GUI::PurgeModeDialog::on_dpi_changed(), Slic3r::GUI::SavePresetDialog::on_dpi_changed(), Slic3r::GUI::SendSystemInfoDialog::on_dpi_changed(), Slic3r::GUI::SettingsDialog::on_dpi_changed(), and Slic3r::GUI::UnsavedChangesDialog::on_dpi_changed().

Here is the caller graph for this function:

enable_force_rescale()

void Slic3r::GUI::DPIAware< wxDialog >::enable_force_rescale ( )

inlineinherited

{ m_force_rescale = true; }

Enable_Refresh_Button()

void Slic3r::GUI::SendToPrinterDialog::Enable_Refresh_Button

(

bool

en

)

{
    if (!en) {
        if (m_button_refresh->IsEnabled()) {
            m_button_refresh->Disable(); // ORCA no need to set colors again
        }
    } else {
        if (!m_button_refresh->IsEnabled()) {
            m_button_refresh->Enable(); // ORCA no need to set colors again
        }
    }
}

References m_button_refresh.

Referenced by show_status().

Here is the caller graph for this function:

Enable_Send_Button()

void Slic3r::GUI::SendToPrinterDialog::Enable_Send_Button

(

bool

en

)

{
    if (!en) {
        if (m_button_ensure->IsEnabled()) {
            m_button_ensure->Disable();
            m_storage_panel->Hide();
        }
    } else {
        if (!m_button_ensure->IsEnabled()) {
            m_button_ensure->Enable();
            m_storage_panel->Show();
        }
    }
}

References m_button_ensure, and m_storage_panel.

Referenced by on_ok(), prepare_mode(), and show_status().

Here is the caller graph for this function:

EndModal()

void Slic3r::GUI::DPIDialog::EndModal ( int retCode )

inlineoverrideinherited

    {
        if (!dialogStack.empty() && dialogStack.front() != this) {
            // This is a bug in wxWidgets
            // when the dialog is not top modal dialog, EndModal() just hide dialog without quit 
            // the modal event loop. And the modal event loop blocks us from bottom widgets.
            // Solution: let user click it manually or close outside. FIXME
            BOOST_LOG_TRIVIAL(warning) << "DPIAware::EndModal Error: dialogStack is not empty, but top dialog is not this one. retCode=" << retCode;
            return;
        }
 
        return wxDialog::EndModal(retCode);
    }

References Slic3r::GUI::dialogStack.

Referenced by Slic3r::GUI::CloneDialog::CloneDialog(), Slic3r::GUI::ConfigWizard::ConfigWizard(), Slic3r::GUI::CreatePresetSuccessfulDialog::CreatePresetSuccessfulDialog(), Slic3r::GUI::DeleteConfirmDialog::DeleteConfirmDialog(), Slic3r::GUI::DesignVariableDialog::DesignVariableDialog(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotDialog::FlashforgeSlotDialog(), Slic3r::GUI::GuideFrame::GuideFrame(), Slic3r::GUI::InputIpAddressDialog::InputIpAddressDialog(), Slic3r::GUI::ManualNozzleCountDialog::ManualNozzleCountDialog(), Slic3r::GUI::MsgUpdateConfig::MsgUpdateConfig(), Slic3r::GUI::MsgUpdateForced::MsgUpdateForced(), Slic3r::GUI::MultiChoiceDialog::MultiChoiceDialog(), Slic3r::GUI::NetworkErrorDialog::NetworkErrorDialog(), Slic3r::GUI::NetworkPluginRestartDialog::NetworkPluginRestartDialog(), Slic3r::GUI::PartSkipConfirmDialog::PartSkipConfirmDialog(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::PlateNameEditDialog::PlateNameEditDialog(), Slic3r::GUI::PlateSettingsDialog::PlateSettingsDialog(), Slic3r::GUI::PublishSettingsDialog::PublishSettingsDialog(), Slic3r::GUI::SelectMachineDialog::SelectMachineDialog(), Slic3r::GUI::SendFailedConfirm::SendFailedConfirm(), Slic3r::GUI::SendSystemInfoDialog::SendSystemInfoDialog(), Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::SingleChoiceDialog::SingleChoiceDialog(), StepMeshDialog::StepMeshDialog(), Slic3r::GUI::SyncAmsInfoDialog::SyncAmsInfoDialog(), anonymous_namespace{3DPrinterOS.cpp}::TokenAuthDialog::TokenAuthDialog(), Slic3r::GUI::UpdatePluginDialog::UpdatePluginDialog(), Slic3r::GUI::UpdateVersionDialog::UpdateVersionDialog(), Slic3r::GUI::wgtDeviceNozzleRackUpgradeDlg::wgtDeviceNozzleRackUpgradeDlg(), Slic3r::GUI::SavePresetDialog::accept(), Slic3r::GUI::MsgDialog::add_button(), Slic3r::GUI::TipsDialog::add_button(), Slic3r::GUI::FilamentPickerDialog::BindEvents(), Slic3r::GUI::PluginPickerDialog::build_capability_ui(), Slic3r::GUI::BedShapeDialog::build_dialog(), Slic3r::GUI::PluginPickerDialog::build_ui(), Slic3r::GUI::UnsavedChangesDialog::close(), Slic3r::GUI::FileArchiveDialog::create_btn_sizer(), Slic3r::GUI::ColorDecomposeDialog::create_button_panel(), Slic3r::GUI::MixedFilamentDialog::create_button_panel(), Slic3r::GUI::CreateFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::CreatePresetForPrinterDialog::create_dialog_buttons(), Slic3r::GUI::EditFilamentPresetDialog::create_dialog_buttons(), Slic3r::GUI::ExportConfigsDialog::create_dialog_buttons(), Slic3r::GUI::PreferencesDialog::create_item_language_combobox(), Slic3r::GUI::PreferencesDialog::create_item_region_combobox(), Slic3r::GUI::PreferencesDialog::create_items(), Slic3r::GUI::CreatePrinterPresetDialog::create_page1_dialog_buttons(), Slic3r::GUI::CreatePrinterPresetDialog::create_page2_dialog_buttons(), Slic3r::GUI::ExportConfigsDialog::data_init(), Slic3r::GUI::WebDialog::destroy_silently(), Slic3r::GUI::EditFilamentPresetDialog::edit_preset(), Slic3r::GUI::ConnectPrinterDialog::end_modal(), Slic3r::GUI::PrintHostSendDialog::EndModal(), Slic3r::GUI::ColorPickerDialog::finish(), Slic3r::GUI::WebDialog::finish(), Slic3r::GUI::Newer3mfVersionDialog::get_btn_sizer(), Slic3r::GUI::ScoreDialog::get_button_sizer(), Slic3r::GUI::WebViewHostDialog::handle_common_script_command(), Slic3r::GUI::ExportPresetBundleDialog::InitExportData(), Slic3r::GUI::SelectMachineDialog::navigate_to_timelapse_page(), Slic3r::GUI::BindMachineDialog::on_bind_success(), Slic3r::GUI::ConnectPrinterDialog::on_button_confirm(), Slic3r::GUI::RecenterDialog::on_button_confirm(), Slic3r::GUI::BindMachineDialog::on_cancel(), Slic3r::GUI::EditCalibrationHistoryDialog::on_cancel(), Slic3r::GUI::InputIpAddressDialog::on_cancel(), Slic3r::GUI::NewCalibrationHistoryDialog::on_cancel(), Slic3r::GUI::OAuthDialog::on_cancel(), Slic3r::GUI::PingCodeBindDialog::on_cancel(), Slic3r::GUI::SelectMachineDialog::on_cancel(), Slic3r::GUI::SendToPrinterDialog::on_cancel(), Slic3r::GUI::SyncAmsInfoDialog::on_cancel(), Slic3r::GUI::UnBindMachineDialog::on_cancel(), Slic3r::GUI::WebDialog::on_close_window(), Slic3r::GUI::NetworkPluginDownloadDialog::on_dont_ask(), Slic3r::GUI::NetworkPluginDownloadDialog::on_download(), Slic3r::GUI::EditDevNameDialog::on_edit_name(), Slic3r::GUI::ConfirmBeforeSendDialog::on_hide(), Slic3r::GUI::PrivacyUpdateDialog::on_hide(), Slic3r::GUI::ShortcutCaptureDialog::on_key(), Slic3r::GUI::TextureImportDialog::on_ok_clicked(), Slic3r::GUI::FileArchiveDialog::on_open_button(), Slic3r::GUI::NetworkPluginDownloadDialog::on_remind_later(), Slic3r::GUI::ProjectDropDialog::on_select_cancel(), Slic3r::GUI::SavePresetDialog::on_select_cancel(), Slic3r::GUI::ProjectDropDialog::on_select_ok(), Slic3r::GUI::SendMultiMachinePage::on_send(), Slic3r::GUI::NetworkPluginDownloadDialog::on_skip(), Slic3r::GUI::TextureImportDialog::on_skip_clicked(), Slic3r::GUI::NetworkPluginDownloadDialog::on_skip_version(), Slic3r::GUI::Cornering_Test_Dlg::on_start(), Slic3r::GUI::FlowRateCalibrationDialog::on_start(), Slic3r::GUI::Input_Shaping_Damp_Test_Dlg::on_start(), Slic3r::GUI::Input_Shaping_Freq_Test_Dlg::on_start(), Slic3r::GUI::MaxVolumetricSpeed_Test_Dlg::on_start(), Slic3r::GUI::PA_Calibration_Dlg::on_start(), Slic3r::GUI::Retraction_Test_Dlg::on_start(), Slic3r::GUI::Temp_Calibration_Dlg::on_start(), Slic3r::GUI::VFA_Test_Dlg::on_start(), Slic3r::GUI::CalibrationDialog::on_start_calibration(), Slic3r::GUI::UnBindMachineDialog::on_unbind_printer(), Slic3r::GUI::PartSkipDialog::OnApplyDialog(), anonymous_namespace{3DPrinterOS.cpp}::TokenAuthDialog::OnCancel(), Slic3r::GUI::AboutDialog::onCloseDialog(), Slic3r::GUI::CopyrightsDialog::onCloseDialog(), Slic3r::GUI::MultiNozzleSyncDialog::OnRackStatusReadingFinished(), Slic3r::GUI::GuideFrame::OnScriptMessage(), Slic3r::GUI::InputIpAddressDialog::OnTimer(), Slic3r::GUI::KBShortcutsDialog::open_mouse_preferences(), Slic3r::GUI::TroubleshootDialog::PackAll(), Slic3r::GUI::TroubleshootDialog::RebuildSystemProfiles(), Slic3r::GUI::SpeedDialWebDialog::run_action(), Slic3r::GUI::OAuthDialog::Show(), Slic3r::GUI::MultiNozzleSyncDialog::UpdateButton(), and Slic3r::GUI::CreatePrinterPresetDialog::validate_input_valid().

force_rescale()

bool Slic3r::GUI::DPIAware< wxDialog >::force_rescale ( ) const

inlineinherited

{ return m_force_rescale; }

format_text()

wxString Slic3r::GUI::SendToPrinterDialog::format_text

(

wxString &

m_msg

)

{
 
  if (wxGetApp().app_config->get("language") != "zh_CN") { return m_msg; }
 
  wxString out_txt = m_msg;
  wxString count_txt = "";
  int      new_line_pos = 0;
 
  for (int i = 0; i < m_msg.length(); i++) {
    auto text_size = m_statictext_printer_msg->GetTextExtent(count_txt);
    if (text_size.x < (FromDIP(400))) {
      count_txt += m_msg[i];
    }
    else {
      out_txt.insert(i - 1, '\n');
      count_txt = "";
    }
  }
  return out_txt;
}

References m_statictext_printer_msg.

Referenced by update_priner_status_msg().

Here is the caller graph for this function:

get_storage_selected()

std::string Slic3r::GUI::SendToPrinterDialog::get_storage_selected

(

)

{
    if (!m_selected_storage.empty())
        return m_selected_storage;
 
    for (const auto& radio : m_storage_radioBox) {
        if (radio->GetValue()) {
            return radio->GetLabel().ToStdString();
        }
    }
    return "";
}

References m_selected_storage, and m_storage_radioBox.

GetConnection()

void Slic3r::GUI::SendToPrinterDialog::GetConnection

(

)

{
    DeviceManager *dm  = GUI::wxGetApp().getDeviceManager();
    MachineObject *obj = dm ? dm->get_selected_machine() : nullptr;
 
    if (!obj)
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : obj is empty";
    if (obj && !obj->get_file_remote())
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : remote_proto is not support";
    if (obj && obj->is_camera_busy_off())
    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : camera is busy";
 
    NetworkAgent* agent = wxGetApp().getAgent();
 
    if (m_url_timer && m_url_timer->IsRunning())
     {
         m_url_timer->Stop();
     }
 
     m_url_timer.reset(new wxTimer());
     m_url_timer->SetOwner(this);
     this->Bind(
         wxEVT_TIMER,
         [this](wxTimerEvent &e) {
             BOOST_LOG_TRIVIAL(info) << "Timer callback triggered!";
             m_connection_status = ConnectionStatus::CONNECTION_FAILED;
             m_ftp_try_connect   = true;
             if (m_filetransfer_tunnel)
             {
                 m_filetransfer_tunnel.reset();
                 m_filetransfer_tunnel = nullptr;
             }
 
         },
         m_url_timer->GetId());
     m_url_timer->StartOnce(8000);
 
    if (obj && agent)
    {
        std::string dev_ver = obj->get_ota_version();
        std::string dev_id = obj->get_dev_id();
 
        if (m_tcp_try_connect) {
            std::string devIP      = obj->get_dev_ip();
            std::string accessCode = obj->get_access_code();
            std::string url        = "bambu:///local/" + devIP + "?port=6000&user=" + "bblp" + "&passwd=" + accessCode;
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tcp, dev_id=" << dev_id
                                    << ", dev_ip=" << devIP << ", access_code_len=" << accessCode.size();
 
            try
            {
                m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
                m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg)
                {
                    CallAfter([this, is_success, err_code, error_msg]()
                    {
                        OnConnection(is_success, err_code, error_msg);
                    });
                });
                m_filetransfer_tunnel->start_connect();
            }
            catch (const std::exception& e)
            {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tcp FileTransferTunnel unavailable for dev_id=" <<
 dev_id
                                           << " dev_ip=" << devIP << ": " << e.what();
                if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
                m_filetransfer_tunnel.reset();
                m_connection_status = ConnectionStatus::CONNECTION_FAILED;
                show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
            }
        }
        else if (m_tutk_try_connect)
        {
            std::string protocols[] = {"", "\"tutk\"", "\"agora\"", "\"tutk\",\"agora\""};
            agent->get_camera_url(obj->get_dev_id() + "|" + dev_ver + "|" + protocols[1], [this, m = dev_id, v = agent->get_version(), dv = dev_ver](std::string url) {
                if (boost::algorithm::starts_with(url, "bambu:///")) {
                    url += "&device=" + m;
                    url += "&net_ver=" + v;
                    url += "&dev_ver=" + dv;
                    url += "&refresh_url=" + boost::lexical_cast<std::string>(&refresh_agora_url);
                    url += "&cli_id=" + wxGetApp().app_config->get("slicer_uuid");
                    url += "&cli_ver=" + std::string(SLIC3R_VERSION);
                }
 
                if (m_url_timer && m_url_timer->IsRunning())
                {
                    m_url_timer->Stop();
                }
 
                #if !BBL_RELEASE_TO_PUBLIC
                                BOOST_LOG_TRIVIAL(info) << "SendToPrinter::camera_url: " << hide_passwd(url, {"?uid=", "authkey=", "passwd="});
                #endif
 
 
                if (boost::algorithm::starts_with(url, "bambu:///"))
                {
                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tutk";
                    try
                    {
                        m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
                        m_filetransfer_tunnel->on_connection(
                            [this](bool is_success, int err_code, std::string error_msg)
                            {
                                CallAfter([this, is_success, err_code, error_msg]()
                                {
                                    OnConnection(is_success, err_code, error_msg);
                                });
                            });
                        m_filetransfer_tunnel->start_connect();
                    }
                    catch (const std::exception& e)
                    {
                        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tutk FileTransferTunnel unavailable: " << e.
what();
                        if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
                        m_filetransfer_tunnel.reset();
                        m_connection_status = ConnectionStatus::CONNECTION_FAILED;
                        show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
                    }
                }
                else
                {
                    std::string res = "";
                    if (!url.empty() && boost::ends_with(url, "]"))
                    {
                        size_t n = url.find_last_of('[');
                        if (n != std::string::npos)
                            res = url.substr(n + 1, url.length() - n - 2);
                    }
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : Tutk url error: ress = " << res;
                }
            }, wxGetApp().get_printer_cloud_provider());
        }
    }
}

References CONNECTION_FAILED, Slic3r::MachineObject::get_access_code(), Slic3r::NetworkAgent::get_camera_url(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_dev_ip(), Slic3r::MachineObject::get_file_remote(), Slic3r::MachineObject::get_ota_version(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::NetworkAgent::get_version(), Slic3r::GUI::hide_passwd(), Slic3r::MachineObject::is_camera_busy_off(), m_connection_status, m_filetransfer_tunnel, m_ftp_try_connect, m_tcp_try_connect, m_tutk_try_connect, m_url_timer, Slic3r::module(), OnConnection(), Slic3r::GUI::PrintStatusPublicInitFailed, and show_status().

Referenced by OnConnection(), and update_show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

init_bind()

void Slic3r::GUI::SendToPrinterDialog::init_bind ( )

private

{
    Bind(wxEVT_TIMER, &SendToPrinterDialog::on_timer, this);
    Bind(EVT_CLEAR_IPADDRESS, &SendToPrinterDialog::clear_ip_address_config, this);
}

References clear_ip_address_config(), and on_timer().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

init_timer()

void Slic3r::GUI::SendToPrinterDialog::init_timer ( )

private

{
    m_refresh_timer = new wxTimer();
    m_refresh_timer->SetOwner(this);
}

References m_refresh_timer.

Referenced by SendToPrinterDialog().

Here is the caller graph for this function:

is_new_scale_factor()

bool Slic3r::GUI::DPIAware< wxDialog >::is_new_scale_factor ( ) const

inlineprivateinherited

{ return fabs(m_scale_factor - m_prev_scale_factor) > 0.001; }

is_timeout()

bool Slic3r::GUI::SendToPrinterDialog::is_timeout

(

)

{
    if (timeout_count > 15 * 1000 / LIST_REFRESH_INTERVAL) {
        return true;
    }
    return false;
}

References LIST_REFRESH_INTERVAL, and timeout_count.

Referenced by update_show_status().

Here is the caller graph for this function:

normal_font()

const wxFont & Slic3r::GUI::DPIAware< wxDialog >::normal_font ( ) const

inlineinherited

{ return m_normal_font; }

Referenced by Slic3r::GUI::AboutDialog::AboutDialog(), Slic3r::GUI::ConfigWizard::ConfigWizard(), Slic3r::GUI::CopyrightsDialog::CopyrightsDialog(), Slic3r::GUI::EditGCodeDialog::EditGCodeDialog(), Slic3r::GUI::anonymous_namespace{PrintHostDialogs.cpp}::FlashforgeSlotDialog::FlashforgeSlotDialog(), Slic3r::GUI::KBShortcutsDialog::KBShortcutsDialog(), Slic3r::GUI::MsgDialog::MsgDialog(), Slic3r::GUI::OAuthDialog::OAuthDialog(), Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog(), Slic3r::GUI::SelectMachineDialog::SelectMachineDialog(), Slic3r::GUI::SendSystemInfoDialog::SendSystemInfoDialog(), Slic3r::GUI::SendToPrinterDialog::SendToPrinterDialog(), Slic3r::GUI::SettingsDialog::SettingsDialog(), Slic3r::GUI::ShortcutCaptureDialog::ShortcutCaptureDialog(), Slic3r::GUI::SyncAmsInfoDialog::SyncAmsInfoDialog(), anonymous_namespace{3DPrinterOS.cpp}::TokenAuthDialog::TokenAuthDialog(), Slic3r::GUI::TroubleshootDialog::TroubleshootDialog(), anonymous_namespace{3DPrinterOS.cpp}::UploadOptionsDialog::UploadOptionsDialog(), Slic3r::GUI::SavePresetDialog::build(), Slic3r::GUI::BedShapeDialog::build_dialog(), and Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings().

Here is the caller graph for this function:

on_cancel()

void Slic3r::GUI::SendToPrinterDialog::on_cancel

(

wxCloseEvent &

event

)

{
    m_worker->cancel_all();
 
    if (m_task_timer && m_task_timer->IsRunning()) {
        m_task_timer->Stop();
        m_task_timer.reset();
    }
 
    Reset();
    this->EndModal(wxID_CANCEL);
}

References Slic3r::GUI::DPIDialog::EndModal(), m_task_timer, m_worker, and Reset().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

on_change_color_mode()

void Slic3r::GUI::SendToPrinterDialog::on_change_color_mode ( )

inline

{ wxGetApp().UpdateDlgDarkUI(this); }

on_dpi_changed()

void Slic3r::GUI::SendToPrinterDialog::on_dpi_changed ( const wxRect & suggested_rect )

overridevirtual

Implements Slic3r::GUI::DPIAware< wxDialog >.

{
    m_button_refresh->Rescale(); // ORCA
    m_button_ensure->Rescale(); // ORCA
    m_status_bar->msw_rescale();
    Fit();
    Refresh();
}

References m_button_ensure, m_button_refresh, and m_status_bar.

on_ok()

void Slic3r::GUI::SendToPrinterDialog::on_ok

(

wxCommandEvent &

event

)

{
    BOOST_LOG_TRIVIAL(info) << "print_job: on_ok to send !";
    m_is_canceled = false;
    Enable_Send_Button(false);
    if (m_is_in_sending_mode)
        return;
 
    int result = 0;
    if (m_printer_last_select.empty()) {
        return;
    }
 
    DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    MachineObject *obj_ = dev->get_selected_machine();
 
    if (obj_ == nullptr) {
        m_printer_last_select = "";
        m_comboBox_printer->SetTextLabel("");
        return;
    }
    assert(obj_->get_dev_id() == m_printer_last_select);
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", print_job: for send task, current printer id =  " << m_printer_last_select << std::endl;
    show_status(PrintDialogStatus::PrintStatusSending);
 
    m_status_bar->reset();
    m_status_bar->set_prog_block();
    m_status_bar->set_cancel_callback_fina([this]() {
        BOOST_LOG_TRIVIAL(info) << "print_job: enter canceled";
        m_worker->cancel_all();
 
        if (m_task_timer && m_task_timer->IsRunning()) {
            m_task_timer->Stop();
            m_task_timer.reset();
        }
 
        if (m_filetransfer_uploadfile_job) {
            m_filetransfer_uploadfile_job->cancel();
            m_filetransfer_uploadfile_job.reset();
            m_filetransfer_uploadfile_job = nullptr;
        }
 
        m_is_canceled = true;
        wxCommandEvent* event = new wxCommandEvent(EVT_PRINT_JOB_CANCEL);
        wxQueueEvent(this, event);
    });
 
    if (m_is_canceled) {
        BOOST_LOG_TRIVIAL(info) << "send_job: m_is_canceled";
        //m_status_bar->set_status_text(task_canceled_text);
        return;
    }
 
    // enter sending mode
    sending_mode();
 
    if (wxGetApp().plater()->using_exported_file()) {
        m_plater->set_print_job_plate_idx(m_print_plate_idx);
        result = 0;
    }
     else {
         result = m_plater->send_gcode(m_print_plate_idx, [this](int export_stage, int current, int total, bool &cancel) {
             if (this->m_is_canceled) return;
             bool     cancelled = false;
             wxString msg       = _L("Preparing print job");
             m_status_bar->update_status(msg, cancelled, 10, true);
             m_export_3mf_cancel = cancel = cancelled;
         });
     }
 
    if (m_is_canceled || m_export_3mf_cancel) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": send progress 10";
        BOOST_LOG_TRIVIAL(info) << "send_job: m_export_3mf_cancel or m_is_canceled";
        //m_status_bar->set_status_text(task_canceled_text);
        return;
    }
 
    if (result < 0) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Abnormal print file data. Please slice again";
        wxString msg = _L("Abnormal print file data. Please slice again");
        m_status_bar->set_status_text(msg);
        return;
    }
 
    // export config 3mf if needed
    if(!wxGetApp().plater()->using_exported_file() && !obj_->is_lan_mode_printer()) {
            result = m_plater->export_config_3mf(m_print_plate_idx);
            if (result < 0) {
                BOOST_LOG_TRIVIAL(info) << "export_config_3mf failed, result = " << result;
                return;
            }
        }
 
 
    if (m_is_canceled || m_export_3mf_cancel) {
        BOOST_LOG_TRIVIAL(info) << "send_job: m_export_3mf_cancel or m_is_canceled";
        //m_status_bar->set_status_text(task_canceled_text);
        return;
    }
 
   /* std::string  file_name       = "";
  auto default_output_file    = wxGetApp().plater()->get_export_gcode_filename(".3mf");
    if (!default_output_file.empty()) {
    fs::path default_output_file_path = boost::filesystem::path(default_output_file.c_str());
    file_name = default_output_file_path.filename().string();
    }*/
 
    if (obj_->is_support_brtc && (m_tcp_try_connect || m_tutk_try_connect))
    {
        update_print_status_msg(wxEmptyString, false, false);
 
        PrintPrepareData print_data;
 
        m_plater->get_print_job_data(&print_data);
        std::string project_name = m_current_project_name.utf8_string() + ".gcode.3mf";
 
        std::string _3mf_path;
        if (wxGetApp().plater()->using_exported_file())
            _3mf_path = wxGetApp().plater()->get_3mf_filename();
        else
             _3mf_path = print_data._3mf_path.string();
 
        CreateUploadFileJob(_3mf_path, project_name);
 
        // time out
        if (m_task_timer && m_task_timer->IsRunning()) m_task_timer->Stop();
 
        m_task_timer.reset(new wxTimer());
        m_task_timer->SetOwner(this);
 
        this->Bind(wxEVT_TIMER, [this](auto e){
                show_status(PrintDialogStatus::PrintStatusPublicUploadFiled);
                m_filetransfer_uploadfile_job->cancel();
                update_print_status_msg(_L("Upload file timeout, please check if the firmware version supports it."), false, true);
        },m_task_timer->GetId());
        m_task_timer->StartOnce(timeout_period);
    }
    else
    {
        auto m_send_job           = std::make_unique<SendJob>(m_printer_last_select);
        m_send_job->m_dev_ip      = obj_->get_dev_ip();
        m_send_job->m_access_code = obj_->get_access_code();
 
 
        BOOST_LOG_TRIVIAL(info) << "send_job: use ftp send job";
 
 
#if !BBL_RELEASE_TO_PUBLIC
        m_send_job->m_local_use_ssl_for_ftp  = wxGetApp().app_config->get("enable_ssl_for_ftp") == "true" ? true : false;
        m_send_job->m_local_use_ssl = wxGetApp().app_config->get("enable_ssl_for_mqtt") == "true" ? true : false;
#else
        m_send_job->m_local_use_ssl_for_ftp  = obj_->local_use_ssl_for_ftp;
        m_send_job->m_local_use_ssl = obj_->local_use_ssl;
 
#endif
        m_send_job->connection_type     = obj_->connection_type();
        m_send_job->cloud_print_only    = true;
        m_send_job->sdcard_state = obj_->GetStorage()->get_sdcard_state();
        m_send_job->has_sdcard = wxGetApp().app_config->get("allow_abnormal_storage") == "true"
            ? (m_send_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL
               || m_send_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL)
            : m_send_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL;
        m_send_job->set_project_name(m_current_project_name.utf8_string());
 
        enable_prepare_mode = false;
 
        m_send_job->on_check_ip_address_fail([this, token = std::weak_ptr(m_token)](int result) {
             CallAfter([token, this] {
                if (token.expired()) { return; }
                SendFailedConfirm sfcDlg;
                auto res = sfcDlg.ShowModal();
                m_status_bar->cancel();
 
                if (res == wxYES) {
                    wxQueueEvent(m_button_ensure, new wxCommandEvent(wxEVT_BUTTON));
                } else if (res == wxAPPLY) {
                    wxCommandEvent *evt = new wxCommandEvent(EVT_CLEAR_IPADDRESS);
                    wxQueueEvent(this, evt);
                    wxGetApp().show_ip_address_enter_dialog();
                }
            });
        });
 
        if (obj_->is_lan_mode_printer()) {
            m_send_job->set_check_mode();
            m_send_job->check_and_continue();
        }
        replace_job(*m_worker, std::move(m_send_job));
    }
 
    BOOST_LOG_TRIVIAL(info) << "send_job: send print job";
}

References Slic3r::GUI::PrintPrepareData::_3mf_path, _L, Slic3r::MachineObject::connection_type(), CreateUploadFileJob(), enable_prepare_mode, Enable_Send_Button(), Slic3r::MachineObject::get_access_code(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_dev_ip(), Slic3r::DevStorage::get_sdcard_state(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::MachineObject::GetStorage(), Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::MachineObject::is_support_brtc, Slic3r::MachineObject::local_use_ssl, Slic3r::MachineObject::local_use_ssl_for_ftp, m_button_ensure, m_comboBox_printer, m_current_project_name, m_export_3mf_cancel, m_filetransfer_uploadfile_job, m_is_canceled, m_is_in_sending_mode, m_plater, m_print_plate_idx, m_printer_last_select, m_status_bar, m_task_timer, m_tcp_try_connect, m_token, m_tutk_try_connect, m_worker, Slic3r::GUI::plater(), Slic3r::GUI::PrintStatusPublicUploadFiled, Slic3r::GUI::PrintStatusSending, Slic3r::GUI::replace_job(), sending_mode(), show_status(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::timeout_period, and update_print_status_msg().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

on_print_job_cancel()

void Slic3r::GUI::SendToPrinterDialog::on_print_job_cancel

(

wxCommandEvent &

evt

)

{
    BOOST_LOG_TRIVIAL(info) << "print_job: canceled";
    show_status(PrintDialogStatus::PrintStatusSendingCanceled);
    // enter prepare mode
    prepare_mode();
}

References prepare_mode(), Slic3r::GUI::PrintStatusSendingCanceled, and show_status().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

on_refresh()

void Slic3r::GUI::SendToPrinterDialog::on_refresh

(

wxCommandEvent &

event

)

{
    wxDateTime now     = wxDateTime::Now();
    wxTimeSpan elapsed = now - m_last_refresh_time;
 
    if (elapsed.GetMilliseconds() < 500) return;
 
    m_last_refresh_time = now;
 
    BOOST_LOG_TRIVIAL(info) << "m_printer_last_select: on_refresh";
    show_status(PrintDialogStatus::PrintStatusRefreshingMachineList);
    update_user_machine_list();
}

References m_last_refresh_time, Slic3r::GUI::PrintStatusRefreshingMachineList, show_status(), and update_user_machine_list().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

on_rename_click()

void Slic3r::GUI::SendToPrinterDialog::on_rename_click

(

wxCommandEvent &

event

)

{
    m_is_rename_mode = true;
    m_rename_input->GetTextCtrl()->SetValue(m_current_project_name);
    m_rename_switch_panel->SetSelection(1);
    m_rename_input->GetTextCtrl()->SetFocus();
    m_rename_input->GetTextCtrl()->SetInsertionPointEnd();
}

References m_current_project_name, m_is_rename_mode, m_rename_input, and m_rename_switch_panel.

Referenced by SendToPrinterDialog().

Here is the caller graph for this function:

on_rename_enter()

void Slic3r::GUI::SendToPrinterDialog::on_rename_enter

(

)

{
    if (m_is_rename_mode == false) {
        return;
    }
    else {
        m_is_rename_mode = false;
    }
 
    auto     new_file_name = m_rename_input->GetTextCtrl()->GetValue();
 
    wxString temp;
    int      num = 0;
    for (auto t : new_file_name) {
        if (t == wxString::FromUTF8("\x20")) {
            num++;
            if (num == 1) temp += t;
        } else {
            num = 0;
            temp += t;
        }
    }
    new_file_name = temp;
 
    auto     m_valid_type = Valid;
    wxString info_line;
 
    const char* unusable_symbols = "<>[]:/\\|?*\"";
 
    const std::string unusable_suffix = PresetCollection::get_suffix_modified(); //"(modified)";
    for (size_t i = 0; i < std::strlen(unusable_symbols); i++) {
        if (new_file_name.find_first_of(unusable_symbols[i]) != std::string::npos) {
            info_line = _L("Name is invalid;") + "\n" + _L("illegal characters:") + " " + unusable_symbols;
            m_valid_type = NoValid;
            break;
        }
    }
 
    if (m_valid_type == Valid && new_file_name.find(unusable_suffix) != std::string::npos) {
        info_line = _L("Name is invalid;") + "\n" + _L("illegal suffix:") + "\n\t" + from_u8(PresetCollection::get_suffix_modified());
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && new_file_name.empty()) {
        info_line = _L("The name field is not allowed to be empty.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && new_file_name.find_first_of(' ') == 0) {
        info_line = _L("The name is not allowed to start with a space.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && new_file_name.find_last_of(' ') == new_file_name.length() - 1) {
        info_line = _L("The name is not allowed to end with a space.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && new_file_name.size() >= 100) {
        info_line    = _L("The name length exceeds the limit.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type != Valid) {
        MessageDialog msg_wingow(nullptr, info_line, "", wxICON_WARNING | wxOK);
        if (msg_wingow.ShowModal() == wxID_OK) {
            m_rename_switch_panel->SetSelection(0);
            m_rename_text->SetLabel(m_current_project_name);
            m_rename_normal_panel->Layout();
            return;
        }
    }
 
    m_current_project_name = new_file_name;
    m_rename_switch_panel->SetSelection(0);
    m_rename_text->SetLabel(m_current_project_name);
    m_rename_normal_panel->Layout();
}

References _L, Slic3r::GUI::from_u8(), Slic3r::PresetCollection::get_suffix_modified(), m_current_project_name, m_is_rename_mode, m_rename_input, m_rename_normal_panel, m_rename_switch_panel, m_rename_text, NoValid, Slic3r::GUI::DPIAware< P >::ShowModal(), and Valid.

Referenced by SendToPrinterDialog(), and check_focus().

Here is the call graph for this function:

Here is the caller graph for this function:

on_selection_changed()

void Slic3r::GUI::SendToPrinterDialog::on_selection_changed

(

wxCommandEvent &

event

)

{
    /* reset timeout and reading printer info */
    //m_status_bar->reset();
    timeout_count      = 0;
 
    auto selection = m_comboBox_printer->GetSelection();
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    Reset();
 
    MachineObject* obj = nullptr;
    for (int i = 0; i < m_list.size(); i++) {
        if (i == selection) {
            m_printer_last_select = m_list[i]->get_dev_id();
            obj = m_list[i];
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "for send task, current printer id =  " << m_printer_last_select << std::endl;
            break;
        }
    }
 
    if (obj && !obj->get_lan_mode_connection_state()) {
        obj->command_get_version();
        obj->command_request_push_all();
        if (!dev->get_selected_machine()) {
            dev->set_selected_machine(m_printer_last_select);
 
        }else if (dev->get_selected_machine()->get_dev_id() != m_printer_last_select) {
            update_storage_list(std::vector<std::string>());
            dev->set_selected_machine(m_printer_last_select);
        }
    }
    else {
        BOOST_LOG_TRIVIAL(error) << "on_selection_changed dev_id not found";
        return;
    }
 
    update_show_status();
}

References Slic3r::MachineObject::command_get_version(), Slic3r::MachineObject::command_request_push_all(), Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::get_lan_mode_connection_state(), Slic3r::DeviceManager::get_selected_machine(), m_comboBox_printer, m_list, m_printer_last_select, Reset(), Slic3r::DeviceManager::set_selected_machine(), timeout_count, update_show_status(), and update_storage_list().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

on_sys_color_changed()

virtual void Slic3r::GUI::DPIAware< wxDialog >::on_sys_color_changed ( )

inlineprotectedvirtualinherited

Reimplemented in PrintHostQueueDialog, Slic3r::GUI::ColorPickerDialog, Slic3r::GUI::ConfigWizard, Slic3r::GUI::DesignTextDialog, Slic3r::GUI::DiffPresetDialog, Slic3r::GUI::EditGCodeDialog, Slic3r::GUI::MultiMachinePickPage, Slic3r::GUI::ObjectTableDialog, Slic3r::GUI::PhysicalPrinterDialog, Slic3r::GUI::PrintHostQueueDialog, Slic3r::GUI::PublishSettingsDialog, Slic3r::GUI::SavePresetDialog, Slic3r::GUI::SendMultiMachinePage, and Slic3r::GUI::UnsavedChangesDialog.

{};

on_timer()

void Slic3r::GUI::SendToPrinterDialog::on_timer

(

wxTimerEvent &

event

)

{
    update_show_status();
}

References update_show_status().

Referenced by init_bind().

Here is the call graph for this function:

Here is the caller graph for this function:

OnConnection()

void Slic3r::GUI::SendToPrinterDialog::OnConnection ( bool is_success, int error_code, std::string error_msg )

private

                                                                                           {
    if (is_success)
    {
        if (m_url_timer && m_url_timer->IsRunning()) { m_url_timer->Stop(); }
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "Connect success";
        m_connection_status = ConnectionStatus::CONNECTED;
        CreateMediaAbilityJob();
    }
    else
    {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "Connect failed, error_code is:" << error_code << "error_msg is :" << error_msg;
        m_connection_status = ConnectionStatus::CONNECTION_FAILED;
        ChangeConnectMethod();
        if (!m_tcp_try_connect && !m_tutk_try_connect) {
             show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
             return;
        }
        m_filetransfer_tunnel.reset();
        m_filetransfer_tunnel = nullptr;
        GetConnection();
    }
}

References ChangeConnectMethod(), CONNECTED, CONNECTION_FAILED, CreateMediaAbilityJob(), GetConnection(), m_connection_status, m_filetransfer_tunnel, m_tcp_try_connect, m_tutk_try_connect, m_url_timer, OnConnection(), Slic3r::GUI::PrintStatusPublicInitFailed, and show_status().

Referenced by GetConnection(), and OnConnection().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare()

void Slic3r::GUI::SendToPrinterDialog::prepare

(

int

print_plate_idx

)

{
    m_print_plate_idx = print_plate_idx;
}

References m_print_plate_idx.

prepare_mode()

void Slic3r::GUI::SendToPrinterDialog::prepare_mode

(

)

{
    m_is_in_sending_mode = false;
    m_comboBox_printer->Enable();
    m_worker->wait_for_idle();
 
    if (wxIsBusy())
        wxEndBusyCursor();
    Enable_Send_Button(true);
    show_print_failed_info(false);
 
    m_status_bar->reset();
    if (m_simplebook->GetSelection() != 0) {
        m_simplebook->SetSelection(0);
    }
}

References Enable_Send_Button(), m_comboBox_printer, m_is_in_sending_mode, m_simplebook, m_status_bar, m_worker, and show_print_failed_info().

Referenced by clear_ip_address_config(), on_print_job_cancel(), set_default(), and show_status().

Here is the call graph for this function:

Here is the caller graph for this function:

prev_scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::prev_scale_factor ( ) const

inlineinherited

{ return m_prev_scale_factor; }

rescale()

void Slic3r::GUI::DPIAware< wxDialog >::rescale ( const wxRect & suggested_rect )

inlineprivateinherited

    {
        this->Freeze();
 
        m_force_rescale = false;
 
        // set normal application font as a current window font
        m_normal_font = this->GetFont();
 
        update_em_unit();
 
        // rescale missed controls sizes and images
        on_dpi_changed(suggested_rect);
 
        this->Layout();
        this->Thaw();
 
        // reset previous scale factor from current scale factor value
        m_prev_scale_factor = m_scale_factor;
    }

Reset()

void Slic3r::GUI::SendToPrinterDialog::Reset ( )

private

                                {
    if (m_url_timer && m_url_timer->IsRunning()) { m_url_timer->Stop(); }
    m_ability_list.clear();
    update_storage_list(std::vector<std::string>());
    m_device_select.clear();
    ResetConnectMethod();
    ResetTunnelAndJob();
 
}

References m_ability_list, m_device_select, m_url_timer, Reset(), ResetConnectMethod(), ResetTunnelAndJob(), and update_storage_list().

Referenced by on_cancel(), on_selection_changed(), Reset(), and Show().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_timeout()

void Slic3r::GUI::SendToPrinterDialog::reset_timeout

(

)

{
    timeout_count = 0;
}

References timeout_count.

Referenced by update_show_status().

Here is the caller graph for this function:

ResetConnectMethod()

void Slic3r::GUI::SendToPrinterDialog::ResetConnectMethod ( )

private

{
    m_tcp_try_connect   = true;
    m_ftp_try_connect   = false;
    m_tutk_try_connect  = false;
    m_connect_try_times = 0;
}

References m_connect_try_times, m_ftp_try_connect, m_tcp_try_connect, m_tutk_try_connect, and ResetConnectMethod().

Referenced by Reset(), and ResetConnectMethod().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetTunnelAndJob()

void Slic3r::GUI::SendToPrinterDialog::ResetTunnelAndJob ( )

private

{
    if (m_filetransfer_uploadfile_job)
    {
        m_filetransfer_uploadfile_job->cancel();
        m_filetransfer_uploadfile_job.reset();
        m_filetransfer_uploadfile_job = nullptr;
    }
    if (m_filetransfer_mediability_job)
    {
        m_filetransfer_mediability_job->cancel();
        m_filetransfer_mediability_job.reset();
        m_filetransfer_mediability_job = nullptr;
    }
    if (m_filetransfer_tunnel)
    {
        m_filetransfer_tunnel.reset();
        m_filetransfer_tunnel = nullptr;
    }
}

References m_filetransfer_mediability_job, m_filetransfer_tunnel, m_filetransfer_uploadfile_job, and ResetTunnelAndJob().

Referenced by Reset(), and ResetTunnelAndJob().

Here is the call graph for this function:

Here is the caller graph for this function:

scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::scale_factor ( ) const

inlineinherited

{ return m_scale_factor; }

sending_mode()

void Slic3r::GUI::SendToPrinterDialog::sending_mode

(

)

{
    m_is_in_sending_mode = true;
    m_comboBox_printer->Disable();
    if (m_simplebook->GetSelection() != 1){
        m_simplebook->SetSelection(1);
        Layout();
        Fit();
    }
}

References m_comboBox_printer, m_is_in_sending_mode, and m_simplebook.

Referenced by on_ok(), and show_status().

Here is the caller graph for this function:

set_default()

void Slic3r::GUI::SendToPrinterDialog::set_default

(

)

{
    //project name
    m_rename_switch_panel->SetSelection(0);
 
    wxString filename = m_plater->get_export_gcode_filename("", true, m_print_plate_idx == PLATE_ALL_IDX ? true : false);
 
    if (m_print_plate_idx == PLATE_ALL_IDX && filename.empty()) {
        filename = _L("Untitled");
    }
 
    if (filename.empty()) {
        filename = m_plater->get_export_gcode_filename("", true);
        if (filename.empty()) filename = _L("Untitled");
    }
 
    fs::path filename_path(filename.c_str());
    m_current_project_name = from_path(filename_path.filename());
 
    //unsupported character filter
    m_current_project_name = from_u8(filter_characters(m_current_project_name.ToUTF8().data(), "<>[]:/\\|?*\""));
 
    m_rename_text->SetLabelText(m_current_project_name);
    m_rename_normal_panel->Layout();
 
    enable_prepare_mode = true;
    prepare_mode();
 
    //clear combobox
    m_list.clear();
    m_comboBox_printer->Clear();
    m_printer_last_select = "";
    m_print_info = "";
    m_comboBox_printer->SetValue(wxEmptyString);
    m_comboBox_printer->Enable();
    // rset status bar
    m_status_bar->reset();
 
    NetworkAgent* agent = wxGetApp().getAgent();
    if (agent) {
        if (agent->is_user_login(wxGetApp().get_printer_cloud_provider())) {
            show_status(PrintDialogStatus::PrintStatusInit);
        }
    }
 
    // thumbmail
    //wxBitmap bitmap;
    ThumbnailData &data   = m_plater->get_partplate_list().get_curr_plate()->thumbnail_data;
    if (data.is_valid()) {
        wxImage image(data.width, data.height);
        image.InitAlpha();
        for (unsigned int r = 0; r < data.height; ++r) {
            unsigned int rr = (data.height - 1 - r) * data.width;
            for (unsigned int c = 0; c < data.width; ++c) {
                unsigned char *px = (unsigned char *) data.pixels.data() + 4 * (rr + c);
                image.SetRGB((int) c, (int) r, px[0], px[1], px[2]);
                image.SetAlpha((int) c, (int) r, px[3]);
            }
        }
        image  = image.Rescale(FromDIP(256), FromDIP(256));
        m_thumbnailPanel->set_thumbnail(image);
    } else {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " : thumbnail_data invalid." << "current plater: " << m_plater->get_partplate_list().get_curr_plate_index();
    }
 
    std::vector<std::string> materials;
    std::vector<std::string> display_materials;
    {
        auto preset_bundle = wxGetApp().preset_bundle;
        for (auto filament_name : preset_bundle->filament_presets) {
            for (auto iter = preset_bundle->filaments.lbegin(); iter != preset_bundle->filaments.end(); iter++) {
                if (filament_name.compare(iter->name) == 0) {
                    std::string display_filament_type;
                    std::string filament_type = iter->config.get_filament_type(display_filament_type);
                    display_materials.push_back(display_filament_type);
                    materials.push_back(filament_type);
                }
            }
        }
    }
 
    m_scrollable_region->Layout();
    m_scrollable_region->Fit();
    Layout();
    Fit();
 
 
    wxSize screenSize = wxGetDisplaySize();
    auto dialogSize = this->GetSize();
 
 
    // basic info
    auto       aprint_stats = m_plater->get_partplate_list().get_current_fff_print().print_statistics();
    wxString   time;
    PartPlate *plate = m_plater->get_partplate_list().get_curr_plate();
    if (plate) {
        if (plate->get_slice_result()) { time = wxString::Format("%s", short_time(get_time_dhms(plate->get_slice_result()->print_statistics.modes[0].time))); }
    }
 
    char weight[64];
    if (wxGetApp().app_config->get("use_inches") == "1") {
        ::sprintf(weight, "%.2f oz", aprint_stats.total_weight*0.035274); // ORCA remove spacing before text
    }else{
        ::sprintf(weight, "%.2f g", aprint_stats.total_weight); // ORCA remove spacing before text
    }
 
    m_stext_time->SetLabel(time);
    m_stext_weight->SetLabel(weight);
}

References _L, enable_prepare_mode, Slic3r::filament_type(), Slic3r::filter_characters(), Slic3r::GUI::from_path(), Slic3r::GUI::from_u8(), Slic3r::GUI::PartPlate::get_slice_result(), Slic3r::get_time_dhms(), Slic3r::ThumbnailData::height, Slic3r::NetworkAgent::is_user_login(), Slic3r::ThumbnailData::is_valid(), m_comboBox_printer, m_current_project_name, m_list, m_plater, m_print_info, m_print_plate_idx, m_printer_last_select, m_rename_normal_panel, m_rename_switch_panel, m_rename_text, m_scrollable_region, m_status_bar, m_stext_time, m_stext_weight, m_thumbnailPanel, Slic3r::PrintEstimatedStatistics::modes, Slic3r::ThumbnailData::pixels, PLATE_ALL_IDX, prepare_mode(), Slic3r::GCodeProcessorResult::print_statistics, Slic3r::GUI::PrintStatusInit, Slic3r::short_time(), show_status(), and Slic3r::ThumbnailData::width.

Referenced by Show().

Here is the call graph for this function:

Here is the caller graph for this function:

set_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::set_em_unit ( int v )

inlineinherited

{ m_em_unit = v; }

set_prev_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_prev_scale_factor ( float v )

inlineinherited

{ m_prev_scale_factor = v; }

set_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_scale_factor ( float v )

inlineinherited

{ m_scale_factor = v; }

Show()

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

override

{
    show_status(PrintDialogStatus::PrintStatusInit);
 
    // set default value when show this dialog
    if (show) {
        update_storage_list(std::vector<std::string>());
        set_default();
        update_user_machine_list();
        Reset();
        m_refresh_timer->Start(LIST_REFRESH_INTERVAL);
 
    } else {
        m_refresh_timer->Stop();
    }
 
    Layout();
    Fit();
    if (show) { CenterOnParent(); }
 
    return DPIDialog::Show(show);
}

References LIST_REFRESH_INTERVAL, m_refresh_timer, Slic3r::GUI::PrintStatusInit, Reset(), set_default(), show_status(), update_storage_list(), and update_user_machine_list().

Here is the call graph for this function:

show_print_failed_info()

void Slic3r::GUI::SendToPrinterDialog::show_print_failed_info	(	bool	show,
		int	code = 0,
		wxString	description = wxEmptyString,
		wxString	extra = wxEmptyString )

{
    if (show) {
        if (!m_sw_print_failed_info->IsShown()) {
            m_sw_print_failed_info->Show(true);
 
            m_st_txt_error_code->SetLabelText(wxString::Format("%d", m_print_error_code));
            m_st_txt_error_desc->SetLabelText( wxGetApp().filter_string(m_print_error_msg));
            m_st_txt_extra_info->SetLabelText( wxGetApp().filter_string(m_print_error_extra));
 
            m_st_txt_error_code->Wrap(FromDIP(260));
            m_st_txt_error_desc->Wrap(FromDIP(260));
            m_st_txt_extra_info->Wrap(FromDIP(260));
        }
        else {
            m_sw_print_failed_info->Show(false);
        }
        Layout();
        Fit();
    }
    else {
        if (!m_sw_print_failed_info->IsShown()) { return; }
        m_sw_print_failed_info->Show(false);
        m_st_txt_error_code->SetLabelText(wxEmptyString);
        m_st_txt_error_desc->SetLabelText(wxEmptyString);
        m_st_txt_extra_info->SetLabelText(wxEmptyString);
        Layout();
        Fit();
    }
}

References m_print_error_code, m_print_error_extra, m_print_error_msg, m_st_txt_error_code, m_st_txt_error_desc, m_st_txt_extra_info, and m_sw_print_failed_info.

Referenced by SendToPrinterDialog(), and prepare_mode().

Here is the caller graph for this function:

show_status()

void Slic3r::GUI::SendToPrinterDialog::show_status	(	PrintDialogStatus	status,
		std::vector< wxString >	params = std::vector<wxString>() )

{
    if (m_print_status != status)
        BOOST_LOG_TRIVIAL(info) << "select_machine_dialog: show_status = " << status;
    else
        return;
  m_print_status = status;
 
  // m_comboBox_printer
  if (status == PrintDialogStatus::PrintStatusRefreshingMachineList)
    m_comboBox_printer->Disable();
  else
    m_comboBox_printer->Enable();
 
 
    //connecting
    if(status == PrintDialogStatus::PrintStatusConnecting)
    {
        m_connecting_printer_msg->SetLabel(_L("Try to connect"));
        update_print_status_msg(wxEmptyString, true, true);
        m_connecting_panel->Show();
        m_animaicon->Play();
 
        Layout();
        Enable_Send_Button(false);
        Enable_Refresh_Button(false);
        return;
 
    } else if (status == PrintDialogStatus::PrintStatusReconnecting) {
        m_connecting_printer_msg->SetLabel(_L("Connection failed. Click the icon to retry"));
            update_print_status_msg(wxEmptyString, true, true);
            m_connecting_panel->Show();
            m_animaicon->Stop();
            m_animaicon->ShowEnabledIcon();
 
            Layout();
            Enable_Send_Button(false);
            Enable_Refresh_Button(true);
            return;
    }
    else {
        m_connecting_panel->Hide();
    }
 
 
  // m_panel_warn m_simplebook
  if (status == PrintDialogStatus::PrintStatusSending) {
    sending_mode();
  }
 
  // other
  if (status == PrintDialogStatus::PrintStatusInit) {
    update_print_status_msg(wxEmptyString, false, false);
    Enable_Send_Button(false);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusInvalidPrinter) {
    update_print_status_msg(wxEmptyString, true, true);
    Enable_Send_Button(false);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusConnectingServer) {
    wxString msg_text = _L("Connecting to server...");
    update_print_status_msg(msg_text, true, true);
    Enable_Send_Button(true);
    Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusReading) {
        wxString msg_text = _L("Synchronizing device information...");
        update_print_status_msg(msg_text, false, true);
        Enable_Send_Button(false);
        Enable_Refresh_Button(false);
    } else if (status == PrintDialogStatus::PrintStatusReadingFinished) {
    update_print_status_msg(wxEmptyString, false, true);
    Enable_Send_Button(true);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusReadingTimeout) {
    wxString msg_text = _L("Synchronizing device information timed out.");
    update_print_status_msg(msg_text, true, true);
    Enable_Send_Button(true);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusInUpgrading) {
    wxString msg_text = _L("Cannot send print tasks when an update is in progress");
    update_print_status_msg(msg_text, true, true);
    Enable_Send_Button(false);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter) {
        wxString msg_text = _L("The selected printer is incompatible with the chosen printer presets.");
        update_print_status_msg(msg_text, true, true);
        Enable_Send_Button(true);
        Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusRefreshingMachineList) {
    update_print_status_msg(wxEmptyString, false, true);
    Enable_Send_Button(false);
    Enable_Refresh_Button(false);
  } else if (status == PrintDialogStatus::PrintStatusSending) {
    Enable_Send_Button(false);
    Enable_Refresh_Button(false);
  } else if (status == PrintDialogStatus::PrintStatusSendingCanceled) {
    Enable_Send_Button(true);
    Enable_Refresh_Button(true);
  } else if (status == PrintDialogStatus::PrintStatusNoSdcard) {
    wxString msg_text = _L("Storage needs to be inserted before send to printer.");
    update_print_status_msg(msg_text, true, true);
    Enable_Send_Button(false);
    Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusNotOnTheSameLAN) {
        wxString msg_text = _L("The printer is required to be on the same LAN as Orca Slicer.");
        update_print_status_msg(msg_text, true, true);
        Enable_Send_Button(false);
        Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusNotSupportedSendToSDCard) {
        wxString msg_text = _L("The printer does not support sending to printer storage.");
        update_print_status_msg(msg_text, true, true);
        Enable_Send_Button(false);
        Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusPublicInitFailed) {
        wxString msg_text = _L(
            "Failed to initialize the printer file transfer. Please check the connection and try again.");
        update_print_status_msg(msg_text, true, true);
        Enable_Send_Button(false);
        Enable_Refresh_Button(true);
    } else if (status == PrintDialogStatus::PrintStatusPublicUploadFiled) {
        prepare_mode();
        Enable_Send_Button(true);
        Enable_Refresh_Button(true);
    }
    else {
    Enable_Send_Button(true);
    Enable_Refresh_Button(true);
    }
}

References _L, Enable_Refresh_Button(), Enable_Send_Button(), m_animaicon, m_comboBox_printer, m_connecting_panel, m_connecting_printer_msg, m_print_status, prepare_mode(), Slic3r::GUI::PrintStatusConnecting, Slic3r::GUI::PrintStatusConnectingServer, Slic3r::GUI::PrintStatusInit, Slic3r::GUI::PrintStatusInUpgrading, Slic3r::GUI::PrintStatusInvalidPrinter, Slic3r::GUI::PrintStatusNoSdcard, Slic3r::GUI::PrintStatusNotOnTheSameLAN, Slic3r::GUI::PrintStatusNotSupportedSendToSDCard, Slic3r::GUI::PrintStatusPublicInitFailed, Slic3r::GUI::PrintStatusPublicUploadFiled, Slic3r::GUI::PrintStatusReading, Slic3r::GUI::PrintStatusReadingFinished, Slic3r::GUI::PrintStatusReadingTimeout, Slic3r::GUI::PrintStatusReconnecting, Slic3r::GUI::PrintStatusRefreshingMachineList, Slic3r::GUI::PrintStatusSending, Slic3r::GUI::PrintStatusSendingCanceled, Slic3r::GUI::PrintStatusUnsupportedPrinter, sending_mode(), and update_print_status_msg().

Referenced by CreateMediaAbilityJob(), CreateUploadFileJob(), GetConnection(), on_ok(), on_print_job_cancel(), on_refresh(), OnConnection(), set_default(), Show(), update_printer_combobox(), update_show_status(), UploadFileProgressCallback(), and UploadFileRessultCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowModal()

int Slic3r::GUI::DPIAware< wxDialog >::ShowModal ( )

inlineinherited

    {
        dialogStack.push_front(this);
        int r = wxDialog::ShowModal();
        dialogStack.pop_front();
        return r;
    }

Referenced by Slic3r::GUI::EditFilamentPresetDialog::delete_preset(), Slic3r::GUI::SingleChoiceDialog::GetSingleChoiceIndex(), Slic3r::GUI::ConfirmBeforeSendDialog::on_show(), Slic3r::GUI::PrivacyUpdateDialog::on_show(), Slic3r::GUI::AMSMaterialsSetting::Popup(), Slic3r::GUI::ExtrusionCalibration::Popup(), Slic3r::GUI::ObjectTableDialog::Popup(), Slic3r::GUI::ConfigWizard::run(), Slic3r::GUI::GuideFrame::run(), Slic3r::GUI::MultiNozzleSyncDialog::ShowModal(), Slic3r::GUI::RichMessageDialog::ShowModal(), Slic3r::GUI::TextureImportDialog::ShowModal(), and Slic3r::GUI::UnsavedChangesDialog::ShowModal().

Here is the caller graph for this function:

sort_string()

std::vector< std::string > Slic3r::GUI::SendToPrinterDialog::sort_string

(

std::vector< std::string >

strArray

)

{
    std::vector<std::string> outputArray;
    std::sort(strArray.begin(), strArray.end());
    std::vector<std::string>::iterator st;
    for (st = strArray.begin(); st != strArray.end(); st++) { outputArray.push_back(*st); }
 
    return outputArray;
}

Referenced by update_user_printer().

Here is the caller graph for this function:

stripWhiteSpace()

void Slic3r::GUI::SendToPrinterDialog::stripWhiteSpace

(

std::string &

str

)

{
    if (str == "") { return; }
 
    std::string::iterator cur_it;
    cur_it = str.begin();
 
    while (cur_it != str.end()) {
        if ((*cur_it) == '\n' || (*cur_it) == ' ') {
            cur_it = str.erase(cur_it);
        }
        else {
            cur_it++;
        }
    }
}

Referenced by update_priner_status_msg().

Here is the caller graph for this function:

update_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::update_em_unit ( )

inlineprivateinherited

    {
        // Linux specific issue : get_dpi_for_window(this) still doesn't responce to the Display's scale in new wxWidgets(3.1.3).
        // So, calculate the m_em_unit value from the font size, as before
#if !defined(__WXGTK__)
        m_em_unit = std::max<size_t>(10, 10.0f * m_scale_factor);
#else
        // initialize default width_unit according to the width of the one symbol ("m") of the currently active font of this window.
        m_em_unit = std::max<size_t>(10, this->GetTextExtent("m").x - 1);
#endif // __WXGTK__
    }

update_priner_status_msg()

void Slic3r::GUI::SendToPrinterDialog::update_priner_status_msg	(	wxString	msg,
		bool	is_warning = false )

{
    auto colour = is_warning ? wxColour(0xFF, 0x6F, 0x00) : wxColour(0x6B, 0x6B, 0x6B);
    m_statictext_printer_msg->SetForegroundColour(colour);
 
    if (msg.empty()) {
        if (!m_statictext_printer_msg->GetLabel().empty()) {
            m_statictext_printer_msg->SetLabel(wxEmptyString);
            m_statictext_printer_msg->Hide();
            Layout();
            Fit();
        }
    } else {
        msg          = format_text(msg);
 
        auto str_new = msg.ToStdString();
        stripWhiteSpace(str_new);
 
        auto str_old = m_statictext_printer_msg->GetLabel().ToStdString();
        stripWhiteSpace(str_old);
 
        if (str_new != str_old) {
            if (m_statictext_printer_msg->GetLabel() != msg) {
                m_statictext_printer_msg->SetLabel(msg);
                const int wrap_width = FromDIP(400);
                m_statictext_printer_msg->Wrap(wrap_width);
                int line_count = 1;
                const wxString wrapped_label = m_statictext_printer_msg->GetLabel();
                for (size_t i = 0; i < wrapped_label.length(); ++i) {
                    if (wrapped_label[i] == '\n')
                        ++line_count;
                }
                wxCoord text_width = 0;
                wxCoord text_height = 0;
                m_statictext_printer_msg->GetTextExtent(msg, &text_width, &text_height);
                const int extent_line_count = text_width > 0 ?
                    std::max(1, (static_cast<int>(text_width) + wrap_width - 1) / wrap_width) : 1;
                line_count = std::max(line_count, extent_line_count);
                const int line_height = std::max(m_statictext_printer_msg->GetCharHeight(), static_cast<int>(text_height));
                const int min_height = std::max(m_statictext_printer_msg->GetBestSize().GetHeight(),
                                                line_count * line_height + FromDIP(2));
                m_statictext_printer_msg->SetMinSize(wxSize(wrap_width, min_height));
                m_statictext_printer_msg->SetMaxSize(wxDefaultSize);
                m_statictext_printer_msg->Show();
                Layout();
                Fit();
            }
        }
    }
}

References format_text(), m_statictext_printer_msg, and stripWhiteSpace().

Referenced by update_print_status_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

update_print_error_info()

void Slic3r::GUI::SendToPrinterDialog::update_print_error_info	(	int	code,
		std::string	msg,
		std::string	extra )

{
    m_print_error_code = code;
    m_print_error_msg = msg;
    m_print_error_extra = extra;
}

References m_print_error_code, m_print_error_extra, and m_print_error_msg.

update_print_status_msg()

void Slic3r::GUI::SendToPrinterDialog::update_print_status_msg	(	wxString	msg,
		bool	is_warning = false,
		bool	is_printer = true )

{
    if (is_printer_msg) {
        update_priner_status_msg(msg, is_warning);
    } else {
        update_priner_status_msg(wxEmptyString, false);
    }
}

References update_priner_status_msg().

Referenced by CreateMediaAbilityJob(), on_ok(), show_status(), update_show_status(), UploadFileProgressCallback(), and UploadFileRessultCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

update_printer_combobox()

void Slic3r::GUI::SendToPrinterDialog::update_printer_combobox

(

wxCommandEvent &

event

)

{
    show_status(PrintDialogStatus::PrintStatusInit);
    update_user_printer();
}

References Slic3r::GUI::PrintStatusInit, show_status(), and update_user_printer().

Referenced by SendToPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

update_show_status()

void Slic3r::GUI::SendToPrinterDialog::update_show_status

(

)

{
    NetworkAgent* agent = Slic3r::GUI::wxGetApp().getAgent();
    DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!agent) return;
    if (!dev) return;
    const std::string provider = wxGetApp().get_printer_cloud_provider();
    MachineObject* obj_ = dev->get_my_machine(m_printer_last_select);
 
    if (!obj_) {
        if (agent) {
            if (agent->is_user_login(provider)) {
                show_status(PrintDialogStatus::PrintStatusInvalidPrinter);
            }
        }
        return;
    }
 
    /* check cloud machine connections */
    if (!obj_->is_lan_mode_printer()) {
        if (!agent->is_server_connected(provider)) {
            show_status(PrintDialogStatus::PrintStatusConnectingServer);
            reset_timeout();
            return;
        }
    }
 
    if (!obj_->is_info_ready()) {
        if (is_timeout()) {
            show_status(PrintDialogStatus::PrintStatusReadingTimeout);
            return;
        }
        else {
            timeout_count++;
            show_status(PrintDialogStatus::PrintStatusReading);
            return;
        }
        return;
    }
 
    reset_timeout();
 
    // reading done
    if (wxGetApp().is_blocking_printing(obj_)) {
        show_status(PrintDialogStatus::PrintStatusUnsupportedPrinter);
        return;
    }
    else if (obj_->is_in_upgrading()) {
        show_status(PrintDialogStatus::PrintStatusInUpgrading);
        return;
    }
    else if (obj_->is_system_printing()) {
        show_status(PrintDialogStatus::PrintStatusInSystemPrinting);
        return;
    }
 
    // check sdcard when if lan mode printer
   /* if (obj_->is_lan_mode_printer()) {
    }*/
    if (!obj_->is_support_send_to_sdcard) {
        show_status(PrintDialogStatus::PrintStatusNotSupportedSendToSDCard);
        return;
    }
 
    if (!m_is_in_sending_mode)
    {
        if (obj_->is_support_brtc && !m_ftp_try_connect)
        {
            std::string dev_id = obj_->get_dev_ip();
            if (m_device_select != dev_id)
            {
                show_status(PrintDialogStatus::PrintStatusConnecting);
                m_device_select.swap(dev_id);
                if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD)
                    m_if_has_sdcard = false;
                else
                    m_if_has_sdcard = true;
 
                if (m_filetransfer_tunnel) {
                    m_filetransfer_tunnel.reset();
                    m_filetransfer_tunnel = nullptr;
                }
 
                GetConnection();
            }
        }
        else
        {
            if (obj_->is_support_brtc && !obj_->is_lan_mode_printer())
            {
                show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
                update_print_status_msg(_L("Connection timed out, please check your network."), true, true);
            }
            else
            {
                //use ftp
                if (obj_->GetStorage()->get_sdcard_state() == DevStorage::SdcardState::NO_SDCARD) {
                    show_status(PrintDialogStatus::PrintStatusNoSdcard);
                    return;
                }
 
                show_status(PrintDialogStatus::PrintStatusReadingFinished);
                return;
            }
        }
    }
}

References _L, Slic3r::MachineObject::get_dev_ip(), Slic3r::DeviceManager::get_my_machine(), Slic3r::DevStorage::get_sdcard_state(), GetConnection(), Slic3r::MachineObject::GetStorage(), Slic3r::MachineObject::is_in_upgrading(), Slic3r::MachineObject::is_info_ready(), Slic3r::MachineObject::is_lan_mode_printer(), Slic3r::NetworkAgent::is_server_connected(), Slic3r::MachineObject::is_support_brtc, Slic3r::MachineObject::is_support_send_to_sdcard, Slic3r::MachineObject::is_system_printing(), is_timeout(), Slic3r::NetworkAgent::is_user_login(), m_device_select, m_filetransfer_tunnel, m_ftp_try_connect, m_if_has_sdcard, m_is_in_sending_mode, m_printer_last_select, Slic3r::DevStorage::NO_SDCARD, Slic3r::GUI::PrintStatusConnecting, Slic3r::GUI::PrintStatusConnectingServer, Slic3r::GUI::PrintStatusInSystemPrinting, Slic3r::GUI::PrintStatusInUpgrading, Slic3r::GUI::PrintStatusInvalidPrinter, Slic3r::GUI::PrintStatusNoSdcard, Slic3r::GUI::PrintStatusNotSupportedSendToSDCard, Slic3r::GUI::PrintStatusPublicInitFailed, Slic3r::GUI::PrintStatusReading, Slic3r::GUI::PrintStatusReadingFinished, Slic3r::GUI::PrintStatusReadingTimeout, Slic3r::GUI::PrintStatusUnsupportedPrinter, reset_timeout(), show_status(), timeout_count, and update_print_status_msg().

Referenced by on_selection_changed(), and on_timer().

Here is the call graph for this function:

Here is the caller graph for this function:

update_storage_list()

void Slic3r::GUI::SendToPrinterDialog::update_storage_list

(

const std::vector< std::string > &

storages

)

{
    m_storage_sizer->Clear();
    m_storage_radioBox.clear();
    m_storage_panel->DestroyChildren();
 
    for (int i=0; i < storages.size(); i++) {
        RadioBox* radiobox = new RadioBox(m_storage_panel);
        Label    *storage_text = new Label(m_storage_panel);
 
        if (storages[i] == "emmc")
        {
            storage_text->SetLabel(_L("Internal Storage"));
            storage_text->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#000000")));
        }
        else
        {
            storage_text->SetLabel(_L("External Storage"));
            storage_text->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#000000")));
        }
 
 
        //radiobox->SetLabel(storages[i]);
        if (storages[i] != "emmc" && m_if_has_sdcard == false)
        {
            storage_text->SetLabel(_L("External Storage"));
            radiobox->Disable();
            storage_text->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#CECECE")));
        }
        else
        {
            radiobox->Enable();
        }
        radiobox->Bind(wxEVT_LEFT_DOWN, [this, radiobox, selectd_storage = storages[i]](auto& e) {
            for (const auto& radio : m_storage_radioBox) {
                radio->SetValue(false);
            }
            radiobox->SetValue(true);
            m_selected_storage = selectd_storage;
        });
 
        m_storage_sizer->Add(radiobox, 0, wxALIGN_CENTER, 0);
        m_storage_sizer->Add(0, 0, 0, wxEXPAND|wxLEFT, FromDIP(6));
        m_storage_sizer->Add(storage_text, 0, wxALIGN_CENTER,0);
        m_storage_sizer->AddSpacer(20);
        m_storage_radioBox.push_back(radiobox);
    }
 
    if (m_storage_radioBox.size() > 0) {
        m_storage_sizer->Add(0, 0, 0, wxEXPAND, FromDIP(6));
        auto radio = m_storage_radioBox.front();
        radio->SetValue(true);
        if (storages.size() > 0)
           m_selected_storage = storages[0];
    }
 
    m_storage_panel->Layout();
    m_storage_panel->Fit();
    Layout();
    Fit();
}

References _L, StateColor::darkModeColorFor(), Slic3r::GUI::RadioBox::Disable(), m_if_has_sdcard, m_selected_storage, m_storage_panel, m_storage_radioBox, m_storage_sizer, Label::SetLabel(), and Slic3r::GUI::RadioBox::SetValue().

Referenced by CreateMediaAbilityJob(), on_selection_changed(), Reset(), and Show().

Here is the call graph for this function:

Here is the caller graph for this function:

update_user_machine_list()

void Slic3r::GUI::SendToPrinterDialog::update_user_machine_list

(

)

{
    NetworkAgent* m_agent = wxGetApp().getAgent();
    const std::string provider = wxGetApp().get_printer_cloud_provider();
    if (m_agent && m_agent->is_user_login(provider)) {
        boost::thread get_print_info_thread = Slic3r::create_thread([this, token = std::weak_ptr<int>(m_token), provider] {
            NetworkAgent* agent = wxGetApp().getAgent();
            unsigned int http_code;
            std::string body;
            int result = agent->get_user_print_info(&http_code, &body, provider);
            CallAfter([token, this, result, body] {
                if (token.expired()) {return;}
                if (result == 0) {
                    m_print_info = body;
                }
                else {
                    m_print_info = "";
                }
                wxCommandEvent event(EVT_UPDATE_USER_MACHINE_LIST);
                event.SetEventObject(this);
                wxPostEvent(this, event);
            });
        });
    } else {
        wxCommandEvent event(EVT_UPDATE_USER_MACHINE_LIST);
        event.SetEventObject(this);
        wxPostEvent(this, event);
    }
}

References Slic3r::create_thread(), Slic3r::NetworkAgent::get_user_print_info(), Slic3r::NetworkAgent::is_user_login(), m_print_info, and m_token.

Referenced by on_refresh(), and Show().

Here is the call graph for this function:

Here is the caller graph for this function:

update_user_printer()

void Slic3r::GUI::SendToPrinterDialog::update_user_printer

(

)

{
    Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
    if (!dev) return;
 
    // update user print info
    if (!m_print_info.empty()) {
        dev->parse_user_print_info(m_print_info);
        m_print_info = "";
    }
 
    // clear machine list
    m_list.clear();
    m_comboBox_printer->Clear();
    std::vector<std::string>              machine_list;
    wxArrayString                         machine_list_name;
    std::map<std::string, MachineObject*> option_list;
 
    option_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
    // same machine only appear once
    for (auto it = option_list.begin(); it != option_list.end(); it++) {
        if (it->second && (it->second->is_online() || it->second->is_connected())) {
            machine_list.push_back(it->second->get_dev_name());
        }
    }
    machine_list = sort_string(machine_list);
    for (auto tt = machine_list.begin(); tt != machine_list.end(); tt++) {
        for (auto it = option_list.begin(); it != option_list.end(); it++) {
            if (it->second->get_dev_name() == *tt) {
                m_list.push_back(it->second);
                wxString dev_name_text = from_u8(it->second->get_dev_name());
                if (it->second->is_lan_mode_printer()) {
                    dev_name_text += _L("(LAN)");
                }
                machine_list_name.Add(dev_name_text);
                break;
            }
        }
    }
 
    m_comboBox_printer->Set(machine_list_name);
 
    MachineObject* obj = dev->get_selected_machine();
    if (!obj) {
        dev->load_last_machine();
        obj = dev->get_selected_machine();
    }
 
    if (obj) {
        m_printer_last_select = obj->get_dev_id();
    } else {
        m_printer_last_select = "";
    }
 
    if (m_list.size() > 0) {
        // select a default machine
        if (m_printer_last_select.empty()) {
            m_printer_last_select = m_list[0]->get_dev_id();
            m_comboBox_printer->SetSelection(0);
            wxCommandEvent event(wxEVT_COMBOBOX);
            event.SetEventObject(m_comboBox_printer);
            wxPostEvent(m_comboBox_printer, event);
        }
        for (auto i = 0; i < m_list.size(); i++) {
            if (m_list[i]->get_dev_id() == m_printer_last_select) {
                m_comboBox_printer->SetSelection(i);
                wxCommandEvent event(wxEVT_COMBOBOX);
                event.SetEventObject(m_comboBox_printer);
                wxPostEvent(m_comboBox_printer, event);
            }
        }
    }
    else {
        m_printer_last_select = "";
        m_comboBox_printer->SetValue(_L("No available printers"));
    }
 
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "for send task, current printer id =  " << m_printer_last_select << std::endl;
}

References _L, Slic3r::GUI::from_u8(), Slic3r::DeviceManager::get_current_printer_agent_id(), Slic3r::MachineObject::get_dev_id(), Slic3r::DeviceManager::get_my_machine_list(), Slic3r::DeviceManager::get_selected_machine(), Slic3r::DeviceManager::load_last_machine(), m_comboBox_printer, m_list, m_print_info, m_printer_last_select, Slic3r::DeviceManager::parse_user_print_info(), and sort_string().

Referenced by update_printer_combobox().

Here is the call graph for this function:

Here is the caller graph for this function:

UploadFileProgressCallback()

void Slic3r::GUI::SendToPrinterDialog::UploadFileProgressCallback ( int progress )

private

{
    bool     cancelled = false;
    wxString msg       = _L("Sending...");
    m_status_bar->update_status(msg, cancelled, 10 + std::floor(progress * 0.9), true);
 
    if (m_task_timer && m_task_timer->IsRunning()) m_task_timer->Stop();
 
    if (progress == 99) {
        m_task_timer.reset(new wxTimer());
        m_task_timer->SetOwner(this);
 
        this->Bind(
            wxEVT_TIMER,
            [this](auto e) {
                show_status(PrintDialogStatus::PrintStatusPublicUploadFiled);
                update_print_status_msg(
                    _L("File upload timed out. Please check if the firmware version supports this operation or verify if the printer is functioning properly."), false, true);
            },
            m_task_timer->GetId());
        m_task_timer->StartOnce(timeout_period);
    }
}

References _L, m_status_bar, m_task_timer, Slic3r::GUI::PrintStatusPublicUploadFiled, show_status(), Slic3r::GUI::timeout_period, update_print_status_msg(), and UploadFileProgressCallback().

Referenced by CreateUploadFileJob(), and UploadFileProgressCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

UploadFileRessultCallback()

void Slic3r::GUI::SendToPrinterDialog::UploadFileRessultCallback ( int res, int resp_ec, std::string json_res, std::vector< std::byte > bin_res )

private

{
        if (m_task_timer && m_task_timer->IsRunning()) m_task_timer->Stop();
 
        if (res == 0)
        {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":upload success to:" << m_selected_storage ;
            show_status(PrintDialogStatus::PrintStatusReadingFinished);
            wxCommandEvent *evt = new wxCommandEvent(m_plater->get_send_finished_event());
            evt->SetString(from_u8(m_current_project_name.utf8_string()));
            wxQueueEvent(m_plater, evt);
        }
        else {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << ":upload failed to:"<< m_selected_storage << "res:" << res << "resp_ec is:" << resp_ec;
            show_status(PrintDialogStatus::PrintStatusPublicUploadFiled)    ;
           // if (err_msg.IsEmpty()) err_msg = _L("Sending failed, please try again!"); // TODO error code
            if (ParseErrorCode(resp_ec) != "")
                update_print_status_msg(ParseErrorCode(resp_ec), false, true);
            else
                update_print_status_msg(_L("Sending failed, please try again!"), false, true);
            m_filetransfer_uploadfile_job.reset();
            m_filetransfer_uploadfile_job = nullptr;
        }
}

References _L, Slic3r::from_u8(), m_current_project_name, m_filetransfer_uploadfile_job, m_plater, m_selected_storage, m_task_timer, Slic3r::GUI::ParseErrorCode(), Slic3r::GUI::PrintStatusPublicUploadFiled, Slic3r::GUI::PrintStatusReadingFinished, show_status(), update_print_status_msg(), and UploadFileRessultCallback().

Referenced by CreateUploadFileJob(), and UploadFileRessultCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

btn_bg_enable

StateColor Slic3r::GUI::SendToPrinterDialog::btn_bg_enable

private

enable_prepare_mode

bool Slic3r::GUI::SendToPrinterDialog::enable_prepare_mode { true }

private

{ true };

Referenced by clear_ip_address_config(), on_ok(), and set_default().

m_ability_list

std::vector<std::string> Slic3r::GUI::SendToPrinterDialog::m_ability_list

private

Referenced by CreateMediaAbilityJob(), and Reset().

m_animaicon

AnimaIcon* Slic3r::GUI::SendToPrinterDialog::m_animaicon {nullptr}

private

{nullptr};

Referenced by SendToPrinterDialog(), and show_status().

m_bedtype_list

std::vector<wxString> Slic3r::GUI::SendToPrinterDialog::m_bedtype_list

private

m_button_ensure

Button* Slic3r::GUI::SendToPrinterDialog::m_button_ensure { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), Enable_Send_Button(), on_dpi_changed(), and on_ok().

m_button_refresh

Button* Slic3r::GUI::SendToPrinterDialog::m_button_refresh { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), Enable_Refresh_Button(), and on_dpi_changed().

m_can_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_can_rescale

privateinherited

{ true };

m_checkbox_list

std::map<std::string, ::CheckBox*> Slic3r::GUI::SendToPrinterDialog::m_checkbox_list

private

m_colour_bold_color

wxColour Slic3r::GUI::SendToPrinterDialog::m_colour_bold_color { wxColour(38, 46, 48) }

private

{ wxColour(38, 46, 48) };

Referenced by SendToPrinterDialog().

m_colour_def_color

wxColour Slic3r::GUI::SendToPrinterDialog::m_colour_def_color { wxColour(255, 255, 255) }

private

{ wxColour(255, 255, 255) };

Referenced by SendToPrinterDialog().

m_comboBox_printer

ComboBox* Slic3r::GUI::SendToPrinterDialog::m_comboBox_printer { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), on_ok(), on_selection_changed(), prepare_mode(), sending_mode(), set_default(), show_status(), and update_user_printer().

m_connect_try_times

int Slic3r::GUI::SendToPrinterDialog::m_connect_try_times = 0

private

Referenced by ChangeConnectMethod(), and ResetConnectMethod().

m_connecting_panel

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_connecting_panel {nullptr}

private

{nullptr};

Referenced by SendToPrinterDialog(), and show_status().

m_connecting_printer_msg

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_connecting_printer_msg {nullptr}

private

{nullptr};

Referenced by SendToPrinterDialog(), and show_status().

m_connection_status

ConnectionStatus Slic3r::GUI::SendToPrinterDialog::m_connection_status {ConnectionStatus::NOT_START}

private

{ConnectionStatus::NOT_START};

Referenced by GetConnection(), and OnConnection().

m_current_project_name

wxString Slic3r::GUI::SendToPrinterDialog::m_current_project_name

private

Referenced by SendToPrinterDialog(), on_ok(), on_rename_click(), on_rename_enter(), set_default(), and UploadFileRessultCallback().

m_device_select

std::string Slic3r::GUI::SendToPrinterDialog::m_device_select

private

Referenced by Reset(), and update_show_status().

m_em_unit

int Slic3r::GUI::DPIAware< wxDialog >::m_em_unit

privateinherited

m_export_3mf_cancel

bool Slic3r::GUI::SendToPrinterDialog::m_export_3mf_cancel { false }

private

{ false };

Referenced by SendToPrinterDialog(), and on_ok().

m_filetransfer_mediability_job

std::unique_ptr<FileTransferJob> Slic3r::GUI::SendToPrinterDialog::m_filetransfer_mediability_job

private

Referenced by CreateMediaAbilityJob(), and ResetTunnelAndJob().

m_filetransfer_tunnel

std::unique_ptr<FileTransferTunnel> Slic3r::GUI::SendToPrinterDialog::m_filetransfer_tunnel

private

Referenced by CreateMediaAbilityJob(), CreateUploadFileJob(), GetConnection(), OnConnection(), ResetTunnelAndJob(), and update_show_status().

m_filetransfer_uploadfile_job

std::unique_ptr<FileTransferJob> Slic3r::GUI::SendToPrinterDialog::m_filetransfer_uploadfile_job

private

Referenced by CreateUploadFileJob(), on_ok(), ResetTunnelAndJob(), and UploadFileRessultCallback().

m_force_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_force_rescale

privateinherited

{ false };

m_ftp_try_connect

bool Slic3r::GUI::SendToPrinterDialog::m_ftp_try_connect {false}

private

{false};

Referenced by ChangeConnectMethod(), GetConnection(), ResetConnectMethod(), and update_show_status().

m_if_has_sdcard

bool Slic3r::GUI::SendToPrinterDialog::m_if_has_sdcard

private

Referenced by CreateMediaAbilityJob(), update_show_status(), and update_storage_list().

m_is_canceled

bool Slic3r::GUI::SendToPrinterDialog::m_is_canceled { false }

private

{ false };

Referenced by on_ok().

m_is_in_sending_mode

bool Slic3r::GUI::SendToPrinterDialog::m_is_in_sending_mode { false }

private

{ false };

Referenced by on_ok(), prepare_mode(), sending_mode(), and update_show_status().

m_is_rename_mode

bool Slic3r::GUI::SendToPrinterDialog::m_is_rename_mode { false }

private

{ false };

Referenced by on_rename_click(), and on_rename_enter().

m_last_refresh_time

wxDateTime Slic3r::GUI::SendToPrinterDialog::m_last_refresh_time

private

Referenced by SendToPrinterDialog(), and on_refresh().

m_line_materia

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_line_materia { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_line_schedule

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_line_schedule { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_line_top

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_line_top { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_link_network_state

HyperLink* Slic3r::GUI::SendToPrinterDialog::m_link_network_state { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_list

std::vector<MachineObject*> Slic3r::GUI::SendToPrinterDialog::m_list

private

Referenced by on_selection_changed(), set_default(), and update_user_printer().

m_new_font_point_size

int Slic3r::GUI::DPIAware< wxDialog >::m_new_font_point_size

privateinherited

m_normal_font

wxFont Slic3r::GUI::DPIAware< wxDialog >::m_normal_font

privateinherited

m_panel_finish

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_panel_finish { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_panel_image

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_panel_image { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_panel_prepare

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_panel_prepare { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_panel_sending

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_panel_sending { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_plater

Plater* Slic3r::GUI::SendToPrinterDialog::m_plater { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), on_ok(), set_default(), and UploadFileRessultCallback().

m_prev_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_prev_scale_factor

privateinherited

m_print_error_code

int Slic3r::GUI::SendToPrinterDialog::m_print_error_code = 0

private

Referenced by show_print_failed_info(), and update_print_error_info().

m_print_error_extra

std::string Slic3r::GUI::SendToPrinterDialog::m_print_error_extra

private

Referenced by show_print_failed_info(), and update_print_error_info().

m_print_error_msg

std::string Slic3r::GUI::SendToPrinterDialog::m_print_error_msg

private

Referenced by show_print_failed_info(), and update_print_error_info().

m_print_info

std::string Slic3r::GUI::SendToPrinterDialog::m_print_info

private

Referenced by set_default(), update_user_machine_list(), and update_user_printer().

m_print_plate_idx

int Slic3r::GUI::SendToPrinterDialog::m_print_plate_idx

private

Referenced by on_ok(), prepare(), and set_default().

m_print_status

PrintDialogStatus Slic3r::GUI::SendToPrinterDialog::m_print_status { PrintStatusInit }

private

{ PrintStatusInit };

Referenced by show_status().

m_printer_last_select

std::string Slic3r::GUI::SendToPrinterDialog::m_printer_last_select

private

Referenced by ChangeConnectMethod(), on_ok(), on_selection_changed(), set_default(), update_show_status(), and update_user_printer().

m_refresh_timer

wxTimer* Slic3r::GUI::SendToPrinterDialog::m_refresh_timer { nullptr }

private

{ nullptr };

Referenced by ~SendToPrinterDialog(), init_timer(), and Show().

m_rename_button

Button* Slic3r::GUI::SendToPrinterDialog::m_rename_button { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_rename_input

TextInput* Slic3r::GUI::SendToPrinterDialog::m_rename_input { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), check_focus(), on_rename_click(), and on_rename_enter().

m_rename_normal_panel

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_rename_normal_panel { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), on_rename_enter(), and set_default().

m_rename_switch_panel

wxSimplebook* Slic3r::GUI::SendToPrinterDialog::m_rename_switch_panel { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), on_rename_click(), on_rename_enter(), and set_default().

m_rename_text

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_rename_text { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), on_rename_enter(), and set_default().

m_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_scale_factor

privateinherited

m_scrollable_region

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_scrollable_region

private

Referenced by SendToPrinterDialog(), and set_default().

m_selected_storage

std::string Slic3r::GUI::SendToPrinterDialog::m_selected_storage

private

Referenced by CreateUploadFileJob(), get_storage_selected(), update_storage_list(), and UploadFileRessultCallback().

m_simplebook

wxSimplebook* Slic3r::GUI::SendToPrinterDialog::m_simplebook { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), prepare_mode(), and sending_mode().

m_sizer_main

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::m_sizer_main

private

Referenced by SendToPrinterDialog().

m_sizer_scrollable_region

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::m_sizer_scrollable_region

private

Referenced by SendToPrinterDialog().

m_st_txt_error_code

Label* Slic3r::GUI::SendToPrinterDialog::m_st_txt_error_code { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and show_print_failed_info().

m_st_txt_error_desc

Label* Slic3r::GUI::SendToPrinterDialog::m_st_txt_error_desc { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and show_print_failed_info().

m_st_txt_extra_info

Label* Slic3r::GUI::SendToPrinterDialog::m_st_txt_extra_info { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and show_print_failed_info().

m_statictext_finish

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_statictext_finish { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_statictext_printer_msg

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_statictext_printer_msg { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), format_text(), and update_priner_status_msg().

m_status_bar

std::shared_ptr<BBLStatusBarSend> Slic3r::GUI::SendToPrinterDialog::m_status_bar

private

Referenced by SendToPrinterDialog(), on_dpi_changed(), on_ok(), prepare_mode(), set_default(), and UploadFileProgressCallback().

m_stext_printer_title

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_stext_printer_title { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

m_stext_time

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_stext_time { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and set_default().

m_stext_weight

wxStaticText* Slic3r::GUI::SendToPrinterDialog::m_stext_weight { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and set_default().

m_storage_panel

wxPanel* Slic3r::GUI::SendToPrinterDialog::m_storage_panel { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), Enable_Send_Button(), and update_storage_list().

m_storage_radioBox

std::vector<RadioBox *> Slic3r::GUI::SendToPrinterDialog::m_storage_radioBox

private

Referenced by get_storage_selected(), and update_storage_list().

m_storage_sizer

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::m_storage_sizer { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and update_storage_list().

m_sw_print_failed_info

wxScrolledWindow* Slic3r::GUI::SendToPrinterDialog::m_sw_print_failed_info {nullptr}

private

{nullptr};

Referenced by SendToPrinterDialog(), and show_print_failed_info().

m_task_timer

std::unique_ptr<wxTimer> Slic3r::GUI::SendToPrinterDialog::m_task_timer { nullptr }

private

{ nullptr };

Referenced by ~SendToPrinterDialog(), on_cancel(), on_ok(), UploadFileProgressCallback(), and UploadFileRessultCallback().

m_tcp_try_connect

bool Slic3r::GUI::SendToPrinterDialog::m_tcp_try_connect {true}

private

{true};

Referenced by ChangeConnectMethod(), GetConnection(), on_ok(), OnConnection(), and ResetConnectMethod().

m_thumbnailPanel

ThumbnailPanel* Slic3r::GUI::SendToPrinterDialog::m_thumbnailPanel { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog(), and set_default().

m_token

std::shared_ptr<int> Slic3r::GUI::SendToPrinterDialog::m_token = std::make_shared<int>(0)

private

Referenced by on_ok(), and update_user_machine_list().

m_tutk_try_connect

bool Slic3r::GUI::SendToPrinterDialog::m_tutk_try_connect {false}

private

{false};

Referenced by ChangeConnectMethod(), GetConnection(), on_ok(), OnConnection(), and ResetConnectMethod().

m_url_timer

std::unique_ptr<wxTimer> Slic3r::GUI::SendToPrinterDialog::m_url_timer {nullptr}

private

{nullptr};

Referenced by ~SendToPrinterDialog(), GetConnection(), OnConnection(), and Reset().

m_worker

std::unique_ptr<Worker> Slic3r::GUI::SendToPrinterDialog::m_worker

private

Referenced by SendToPrinterDialog(), on_cancel(), on_ok(), and prepare_mode().

rename_sizer_h

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::rename_sizer_h { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

rename_sizer_v

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::rename_sizer_v { nullptr }

private

{ nullptr };

Referenced by SendToPrinterDialog().

sizer_thumbnail

wxBoxSizer* Slic3r::GUI::SendToPrinterDialog::sizer_thumbnail

private

Referenced by SendToPrinterDialog().

timeout_count

int Slic3r::GUI::SendToPrinterDialog::timeout_count = 0

private

Referenced by is_timeout(), on_selection_changed(), reset_timeout(), and update_show_status().

---

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

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