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

Inheritance diagram for Slic3r::GUI::SendJob:

Collaboration diagram for Slic3r::GUI::SendJob:

Public Types
enum	JobPrepareState { PREPARE_STATE_DEFAULT = 0 , PREPARE_STATE_MENU = 1 }

Public Member Functions
void	prepare ()
	SendJob (std::string dev_id="")
int	status_range () const
wxString	get_http_error_msg (unsigned int status, std::string body)
void	set_check_mode ()
void	check_and_continue ()
bool	is_finished ()
void	process (Ctl &ctl) override
void	on_success (std::function< void()> success)
void	on_check_ip_address_fail (std::function< void(int)> func)
void	on_check_ip_address_success (std::function< void()> func)
void	finalize (bool canceled, std::exception_ptr &) override
void	set_project_name (std::string name)

Public Attributes
std::string	m_project_name
std::string	m_dev_ip
std::string	m_access_code
std::string	task_bed_type
std::string	task_ams_mapping
std::string	connection_type
bool	m_local_use_ssl_for_ftp {true}
bool	m_local_use_ssl {true}
bool	cloud_print_only { false }
bool	has_sdcard { false }
bool	task_use_ams { true }
DevStorage::SdcardState	sdcard_state = DevStorage::SdcardState::NO_SDCARD
wxWindow *	m_parent {nullptr}

Private Attributes
PrintPrepareData	job_data
std::string	m_dev_id
bool	m_job_finished { false }
bool	m_lifecycle_started { false }
bool	m_lifecycle_finished { false }
int	m_print_job_completed_id = 0
bool	m_is_check_mode {false}
bool	m_check_and_continue {false}
std::function< void()>	m_success_fun {nullptr}
std::function< void(int)>	m_enter_ip_address_fun_fail {nullptr}
std::function< void()>	m_enter_ip_address_fun_success {nullptr}
Plater *	m_plater

Detailed Description

Member Enumeration Documentation

◆ JobPrepareState

enum Slic3r::GUI::Job::JobPrepareState

inherited

Enumerator
PREPARE_STATE_DEFAULT
PREPARE_STATE_MENU

                         {
        PREPARE_STATE_DEFAULT = 0,
        PREPARE_STATE_MENU = 1,
    };

Constructor & Destructor Documentation

◆ SendJob()

Slic3r::GUI::SendJob::SendJob ( std::string dev_id = "" )

: m_plater{wxGetApp().plater()},
    m_dev_id(dev_id)
{
    m_print_job_completed_id = m_plater->get_send_finished_event();
}

References m_dev_id, m_plater, m_print_job_completed_id, and Slic3r::GUI::plater().

Here is the call graph for this function:

Member Function Documentation

◆ check_and_continue()

void Slic3r::GUI::SendJob::check_and_continue ( )

inline

65{m_check_and_continue = true;};

Slic3r::GUI::SendJob::m_check_and_continue

bool m_check_and_continue

Definition SendJob.hpp:31

References m_check_and_continue.

◆ finalize()

void Slic3r::GUI::SendJob::finalize	(	bool	canceled,
		std::exception_ptr &	eptr )

overridevirtual

Reimplemented from Slic3r::GUI::Job.

{
    try {
        if (eptr)
            std::rethrow_exception(eptr);
        eptr = nullptr;
    } catch (...) {
        eptr = std::current_exception();
    }
 
    if (m_lifecycle_started && !m_lifecycle_finished) {
        LifecycleEventContext finish_ctx;
        finish_ctx.name = m_project_name;
        finish_ctx.device_id = m_dev_id;
        finish_ctx.source = "send_job";
        finish_ctx.code = canceled ? LifecycleEvtCode::Warn :
            (eptr ? LifecycleEvtCode::Error : (m_job_finished ? LifecycleEvtCode::Ok : LifecycleEvtCode::Error));
        finish_ctx.msg = canceled ? "cancelled" : (eptr ? "exception" :
            (m_job_finished ? "" : "failed"));
        fire_lifecycle_event(LifecycleEvent::SendJobFinished, finish_ctx);
        m_lifecycle_finished = true;
    }
 
    if (canceled || eptr)
        return;
}

References Slic3r::LifecycleEventContext::code, Slic3r::LifecycleEventContext::device_id, Slic3r::Error, Slic3r::fire_lifecycle_event(), m_dev_id, m_job_finished, m_lifecycle_finished, m_lifecycle_started, m_project_name, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Ok, Slic3r::SendJobFinished, Slic3r::LifecycleEventContext::source, and Slic3r::Warn.

Here is the call graph for this function:

◆ get_http_error_msg()

wxString Slic3r::GUI::SendJob::get_http_error_msg	(	unsigned int	status,
		std::string	body )

{
    int code = 0;
    std::string error;
    std::string message;
    wxString result;
    if (status >= 400 && status < 500)
        try {
        json j = json::parse(body);
        if (j.contains("code")) {
            if (!j["code"].is_null())
                code = j["code"].get<int>();
        }
        if (j.contains("error")) {
            if (!j["error"].is_null())
                error = j["error"].get<std::string>();
        }
        if (j.contains("message")) {
            if (!j["message"].is_null())
                message = j["message"].get<std::string>();
        }
    }
    catch (...) {
        ;
    }
    else if (status == 503) {
        return _L("Service Unavailable");
    }
    else {
        wxString unkown_text = _L("Unknown Error.");
        unkown_text += wxString::Format("status=%u, body=%s", status, body);
        return unkown_text;
    }
 
    BOOST_LOG_TRIVIAL(error) << "http_error: status=" << status << ", code=" << code << ", error=" << error;
 
    result = wxString::Format("code=%u, error=%s", code, from_u8(error));
    return result;
}

References _L, and Slic3r::GUI::from_u8().

Here is the call graph for this function:

◆ is_finished()

bool Slic3r::GUI::SendJob::is_finished ( )

inline

66{ return m_job_finished; }

References m_job_finished.

◆ on_check_ip_address_fail()

void Slic3r::GUI::SendJob::on_check_ip_address_fail ( std::function< void(int)> func )

{
    m_enter_ip_address_fun_fail = func;
}

References m_enter_ip_address_fun_fail.

◆ on_check_ip_address_success()

void Slic3r::GUI::SendJob::on_check_ip_address_success ( std::function< void()> func )

{
    m_enter_ip_address_fun_success = func;
}

References m_enter_ip_address_fun_success.

◆ on_success()

void Slic3r::GUI::SendJob::on_success ( std::function< void()> success )

{
  m_success_fun = success;
}

References m_success_fun.

◆ prepare()

void Slic3r::GUI::SendJob::prepare ( )

{
    m_plater->get_print_job_data(&job_data);
    std::string temp_file = Slic3r::resources_dir() + "/check_access_code.txt";
    auto check_access_code_path = temp_file.c_str();
    BOOST_LOG_TRIVIAL(trace) << "sned_job: check_access_code_path = " << check_access_code_path;
    job_data._temp_path = fs::path(check_access_code_path);
}

References job_data, m_plater, Slic3r::resources_dir(), and Slic3r::trace().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process()

void Slic3r::GUI::SendJob::process ( Ctl & ctl )

overridevirtual

Implements Slic3r::GUI::Job.

{
    PrintParams params;
    std::string msg;
    int curr_percent = 10;
    NetworkAgent* agent = wxGetApp().getAgent();
    AppConfig* config = wxGetApp().app_config;
    int result = -1;
    std::string http_body;
 
    if (this->connection_type == "lan") {
        msg = _u8L("Sending print job over LAN");
    }
    else {
        msg = _u8L("Sending print job through cloud service");
    }
 
    ctl.call_on_main_thread([this] { prepare(); }).wait();
    ctl.update_status(0, msg);
 
    // In check mode (InputIpAddressDialog / lan-mode send) verify the connection with a dummy
    // "verify_job" upload and fire the caller's success/fail callback; when not continuing, stop
    // here. Cloud sends skip this.
    if (m_is_check_mode) {
        PrintParams verify_params;
        verify_params.dev_ip           = m_dev_ip;
        verify_params.username         = agent->default_lan_username();
        verify_params.password         = m_access_code;
        verify_params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
        verify_params.use_ssl_for_mqtt = m_local_use_ssl;
        verify_params.dev_id           = m_dev_id;
        verify_params.project_name     = "verify_job";
        verify_params.filename         = job_data._temp_path.string();
        verify_params.connection_type  = this->connection_type;
 
        int verify_result = agent->start_send_gcode_to_sdcard(verify_params, nullptr, nullptr, nullptr);
        if (verify_result != 0) {
            BOOST_LOG_TRIVIAL(error) << "send_job: access code / ip verification failed, result = " << verify_result;
            if (m_enter_ip_address_fun_fail) m_enter_ip_address_fun_fail(verify_result);
            m_job_finished = true;
            return;
        } else if (!m_check_and_continue) {
            if (m_enter_ip_address_fun_success) m_enter_ip_address_fun_success();
            m_job_finished = true;
            return;
        }
    }
 
    LifecycleEventContext start_ctx;
    start_ctx.name = m_project_name;
    start_ctx.device_id = m_dev_id;
    start_ctx.source = "send_job";
    fire_lifecycle_event(LifecycleEvent::SendJobStarted, start_ctx);
    m_lifecycle_started = true;
 
    int total_plate_num = m_plater->get_partplate_list().get_plate_count();
 
    PartPlate* plate = m_plater->get_partplate_list().get_plate(job_data.plate_idx);
    if (plate == nullptr) {
        if (job_data.plate_idx == PLATE_ALL_IDX) {
            //all plate
            for (int index = 0; index < total_plate_num; index++)
            {
                PartPlate* plate_n = m_plater->get_partplate_list().get_plate(index);
                if (plate_n && plate_n->is_valid_gcode_file())
                {
                    plate = plate_n;
                    break;
                }
            }
        }
        else {
            plate = m_plater->get_partplate_list().get_curr_plate();
        }
        if (plate == nullptr) {
            BOOST_LOG_TRIVIAL(error) << "can not find plate with valid gcode file when sending to print, plate_index="<< job_data.plate_idx;
            ctl.update_status(curr_percent, check_gcode_failed_str);
            return;
        }
    }
 
    /* check gcode is valid */
    if (!plate->is_valid_gcode_file()) {
        ctl.update_status(curr_percent, check_gcode_failed_str);
        return;
    }
 
    if (ctl.was_canceled()) {
        ctl.update_status(curr_percent, printjob_cancel_str);
        return;
    }
 
    std::string project_name = wxGetApp().plater()->get_project_name().ToUTF8().data();
    int curr_plate_idx = 0;
    if (job_data.plate_idx >= 0)
        curr_plate_idx = job_data.plate_idx + 1;
    else if (job_data.plate_idx == PLATE_CURRENT_IDX)
        curr_plate_idx = m_plater->get_partplate_list().get_curr_plate_index() + 1;
 
    params.dev_id               = m_dev_id;
    params.project_name         = m_project_name + ".gcode.3mf";
    params.preset_name          = wxGetApp().preset_bundle->prints.get_selected_preset_name();
 
    if (wxGetApp().plater()->using_exported_file())
        params.filename = wxGetApp().plater()->get_3mf_filename();
    else
        params.filename = job_data._3mf_path.string();
 
 
    params.config_filename      = job_data._3mf_config_path.string();
 
    params.plate_index          = curr_plate_idx;
    params.ams_mapping          = this->task_ams_mapping;
    params.connection_type      = this->connection_type;
    params.task_use_ams         = this->task_use_ams;
 
    // local print access
    params.dev_ip = m_dev_ip;
    params.username = agent->default_lan_username();
    params.password = m_access_code;
    params.use_ssl_for_ftp = m_local_use_ssl_for_ftp;
    params.use_ssl_for_mqtt = m_local_use_ssl;
    std::string msg_text;
 
    const int StagePercentPoint[(int)PrintingStageFinished + 1] = {
        20,  // PrintingStageCreate
        30,  // PrintingStageUpload
        99,  // PrintingStageWaiting
        99,  // PrintingStageRecord
        99,  // PrintingStageSending
        100, // PrintingStageFinished
        100  // PrintingStageFinished
    };
 
    auto update_fn = [this, &ctl,
        &msg, &curr_percent, StagePercentPoint](int stage, int code, std::string info) {
                        if (stage == SendingPrintJobStage::PrintingStageCreate) {
                            if (this->connection_type == "lan") {
                                msg = _u8L("Sending G-code file over LAN");
                            } else {
                                msg = _u8L("Sending G-code file to SD card");
                            }
                        }
                        else if (stage == SendingPrintJobStage::PrintingStageUpload) {
                            if (code >= 0 && code <= 100 && !info.empty()) {
                  if (this->connection_type == "lan") {
                                    msg = _u8L("Sending G-code file over LAN");
                  }
                  else {
                                    msg = _u8L("Sending G-code file to SD card");
                  }
                                if (!info.empty()) {
                                    msg += format("(%s)", info);
                                }
                            }
                        }
            else if (stage == SendingPrintJobStage::PrintingStageFinished) {
                            msg = format(_u8L("Successfully sent. Close current page in %s s"), info);
            }
            else {
              if (this->connection_type == "lan") {
                                msg = _u8L("Sending G-code file over LAN");
              }
              else {
                                msg = _u8L("Sending G-code file over LAN");
              }
            }
 
                        // update current percnet
                        if (stage >= 0 && stage <= (int) PrintingStageFinished) {
                            curr_percent = StagePercentPoint[stage];
                            if ((stage == SendingPrintJobStage::PrintingStageUpload) &&
                                (code > 0 && code <= 100)) {
                                curr_percent = (StagePercentPoint[stage + 1] - StagePercentPoint[stage]) * code / 100 + StagePercentPoint[stage];
                            }
                        }
 
                        //get errors
                        if (code > 100 || code < 0 || stage == SendingPrintJobStage::PrintingStageERROR) {
                            if (code == BAMBU_NETWORK_ERR_PRINT_WR_FILE_OVER_SIZE || code == BAMBU_NETWORK_ERR_PRINT_SP_FILE_OVER_SIZE) {
                                m_plater->update_print_error_info(code, desc_file_too_large, info);
                            }
                            else if (code == BAMBU_NETWORK_ERR_PRINT_WR_FILE_NOT_EXIST || code == BAMBU_NETWORK_ERR_PRINT_SP_FILE_NOT_EXIST) {
                                m_plater->update_print_error_info(code, desc_fail_not_exist, info);
                            }
                            else if (code == BAMBU_NETWORK_ERR_PRINT_LP_UPLOAD_FTP_FAILED || code == BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED) {
                                m_plater->update_print_error_info(code, desc_upload_ftp_failed, info);
                            }
                            else {
                                m_plater->update_print_error_info(code, desc_network_error, info);
                            }
                        }
                        else {
                            ctl.update_status(curr_percent, msg);
                        }
                    };
 
    auto cancel_fn = [&ctl]() {
            return ctl.was_canceled();
        };
 
 
    if (params.connection_type != "lan") {
        if (params.dev_ip.empty())
            params.comments = "no_ip";
        else if (this->cloud_print_only)
            params.comments = "low_version";
        else if (!this->has_sdcard)
            params.comments = "no_sdcard";
        else if (params.password.empty())
            params.comments = "no_password";
 
        if (!params.password.empty()
            && !params.dev_ip.empty()
            && this->has_sdcard) {
            // try to send local with record
            BOOST_LOG_TRIVIAL(info) << "send_job: try to send gcode to printer";
            ctl.update_status(curr_percent, _u8L("Sending G-code file over LAN"));
            result = agent->start_send_gcode_to_sdcard(params, update_fn, cancel_fn, nullptr);
            if (result == BAMBU_NETWORK_ERR_FTP_UPLOAD_FAILED) {
                params.comments = "upload_failed";
            } else {
                params.comments = (boost::format("failed(%1%)") % result).str();
            }
            if (result < 0) {
                // try to send with cloud
                BOOST_LOG_TRIVIAL(info) << "send_job: try to send gcode file to printer";
                ctl.update_status(curr_percent, _u8L("Sending G-code file over LAN"));
            }
        } else {
            BOOST_LOG_TRIVIAL(info) << "send_job: try to send gcode file to printer";
            ctl.update_status(curr_percent, _u8L("Sending G-code file over LAN"));
        }
    } else {
          switch(this->sdcard_state) {
                case DevStorage::SdcardState::NO_SDCARD:
                    ctl.update_status(curr_percent, _u8L("Storage needs to be inserted before sending to printer."));
                    return;
                case DevStorage::SdcardState::HAS_SDCARD_ABNORMAL:
                    if(this->has_sdcard) {
                        // means the sdcard is abnormal but can be used option is enabled
                         ctl.update_status(curr_percent, _u8L("Sending G-code file over LAN, but the Storage in the printer is abnormal and print-issues may be caused by this."));
                         result = agent->start_send_gcode_to_sdcard(params, update_fn, cancel_fn, nullptr);
                        break;
                    }
                    ctl.update_status(curr_percent, _u8L("The Storage in the printer is abnormal. Please replace it with a normal Storage before sending to printer."));
                    return;
                case DevStorage::SdcardState::HAS_SDCARD_READONLY:
                    ctl.update_status(curr_percent, _u8L("The Storage in the printer is read-only. Please replace it with a normal Storage before sending to printer."));
                    return;
                case DevStorage::SdcardState::HAS_SDCARD_NORMAL:
                    ctl.update_status(curr_percent, _u8L("Sending G-code file over LAN"));
                    result = agent->start_send_gcode_to_sdcard(params, update_fn, cancel_fn, nullptr);       
                    break;
                default:
                    ctl.update_status(curr_percent, _u8L("Encountered an unknown error with the Storage status. Please try again."));
                    return;
            }
    }
 
    if (ctl.was_canceled()) {
        ctl.update_status(curr_percent, printjob_cancel_str);
        return;
    }
 
    if (result < 0) {
        curr_percent = -1;
 
        if (result == BAMBU_NETWORK_ERR_PRINT_WR_FILE_NOT_EXIST || result == BAMBU_NETWORK_ERR_PRINT_SP_FILE_NOT_EXIST) {
            msg_text = file_is_not_exists_str;
        }
        else if (result == BAMBU_NETWORK_ERR_PRINT_SP_FILE_OVER_SIZE || result == BAMBU_NETWORK_ERR_PRINT_WR_FILE_OVER_SIZE) {
            msg_text = file_over_size_str;
        }
        else if (result == BAMBU_NETWORK_ERR_PRINT_WR_CHECK_MD5_FAILED || result == BAMBU_NETWORK_ERR_PRINT_SP_CHECK_MD5_FAILED) {
            msg_text = failed_in_cloud_service_str;
        }
        else if (result == BAMBU_NETWORK_ERR_PRINT_WR_GET_NOTIFICATION_TIMEOUT || result == BAMBU_NETWORK_ERR_PRINT_SP_GET_NOTIFICATION_TIMEOUT) {
            msg_text = timeout_to_upload_str;
        }
        else if (result == BAMBU_NETWORK_ERR_PRINT_LP_UPLOAD_FTP_FAILED || result == BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED) {
            msg_text = upload_ftp_failed_str;
        }
        else if (result == BAMBU_NETWORK_ERR_CANCELED) {
            msg_text = print_canceled_str;
        }
        else {
            msg_text = send_print_failed_str;
        }
 
        if (result != BAMBU_NETWORK_ERR_CANCELED) {
            ctl.show_error_info(msg_text, 0, "", "");
        }
        BOOST_LOG_TRIVIAL(error) << "send_job: failed, result = " << result;
 
    }
    else {
        BOOST_LOG_TRIVIAL(error) << "send_job: send ok.";
        wxCommandEvent* evt = new wxCommandEvent(m_print_job_completed_id);
        evt->SetString(from_u8(params.project_name));
        wxQueueEvent(m_plater, evt);
        m_job_finished = true;
    }
}

Here is the call graph for this function:

◆ set_check_mode()

void Slic3r::GUI::SendJob::set_check_mode ( )

inline

64{m_is_check_mode = true;};

References m_is_check_mode.

◆ set_project_name()

void Slic3r::GUI::SendJob::set_project_name ( std::string name )

{
    m_project_name = name;
}

References m_project_name.

◆ status_range()

int Slic3r::GUI::SendJob::status_range ( ) const

inline

    {
        return 100;
    }

Member Data Documentation

◆ cloud_print_only

bool Slic3r::GUI::SendJob::cloud_print_only { false }

50{ false };

Referenced by process().

◆ connection_type

std::string Slic3r::GUI::SendJob::connection_type

Referenced by process().

◆ has_sdcard

bool Slic3r::GUI::SendJob::has_sdcard { false }

51{ false };

Referenced by process().

◆ job_data

PrintPrepareData Slic3r::GUI::SendJob::job_data

private

Referenced by prepare(), and process().

◆ m_access_code

std::string Slic3r::GUI::SendJob::m_access_code

Referenced by process().

◆ m_check_and_continue

bool Slic3r::GUI::SendJob::m_check_and_continue {false}

private

31{false};

Referenced by check_and_continue(), and process().

◆ m_dev_id

std::string Slic3r::GUI::SendJob::m_dev_id

private

Referenced by SendJob(), finalize(), and process().

◆ m_dev_ip

std::string Slic3r::GUI::SendJob::m_dev_ip

Referenced by process().

◆ m_enter_ip_address_fun_fail

std::function<void(int)> Slic3r::GUI::SendJob::m_enter_ip_address_fun_fail {nullptr}

private

33{nullptr};

Referenced by on_check_ip_address_fail(), and process().

◆ m_enter_ip_address_fun_success

std::function<void()> Slic3r::GUI::SendJob::m_enter_ip_address_fun_success {nullptr}

private

34{nullptr};

Referenced by on_check_ip_address_success(), and process().

◆ m_is_check_mode

bool Slic3r::GUI::SendJob::m_is_check_mode {false}

private

30{false};

Referenced by process(), and set_check_mode().

◆ m_job_finished

bool Slic3r::GUI::SendJob::m_job_finished { false }

private

26{ false };

Referenced by finalize(), is_finished(), and process().

◆ m_lifecycle_finished

bool Slic3r::GUI::SendJob::m_lifecycle_finished { false }

private

28{ false };

Referenced by finalize().

◆ m_lifecycle_started

bool Slic3r::GUI::SendJob::m_lifecycle_started { false }

private

27{ false };

Referenced by finalize(), and process().

◆ m_local_use_ssl

bool Slic3r::GUI::SendJob::m_local_use_ssl {true}

49{true};

Referenced by process().

◆ m_local_use_ssl_for_ftp

bool Slic3r::GUI::SendJob::m_local_use_ssl_for_ftp {true}

48{true};

Referenced by process().

◆ m_parent

wxWindow* Slic3r::GUI::SendJob::m_parent {nullptr}

56{nullptr};

◆ m_plater

Plater* Slic3r::GUI::SendJob::m_plater

private

Referenced by SendJob(), prepare(), and process().

◆ m_print_job_completed_id

int Slic3r::GUI::SendJob::m_print_job_completed_id = 0

private

Referenced by SendJob(), and process().

◆ m_project_name

std::string Slic3r::GUI::SendJob::m_project_name

Referenced by finalize(), process(), and set_project_name().

◆ m_success_fun

std::function<void()> Slic3r::GUI::SendJob::m_success_fun {nullptr}

private

32{nullptr};

Referenced by on_success().

◆ sdcard_state

DevStorage::SdcardState Slic3r::GUI::SendJob::sdcard_state = DevStorage::SdcardState::NO_SDCARD

Referenced by process().

◆ task_ams_mapping

std::string Slic3r::GUI::SendJob::task_ams_mapping

Referenced by process().

◆ task_bed_type

std::string Slic3r::GUI::SendJob::task_bed_type

◆ task_use_ams

bool Slic3r::GUI::SendJob::task_use_ams { true }

52{ true };

Referenced by process().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/SendJob.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/SendJob.cpp

	OrcaSlicer latest OrcaSlicer

Public Types

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ JobPrepareState

Constructor & Destructor Documentation

◆ SendJob()

Member Function Documentation

◆ check_and_continue()

◆ finalize()

◆ get_http_error_msg()

◆ is_finished()

◆ on_check_ip_address_fail()

◆ on_check_ip_address_success()

◆ on_success()

◆ prepare()

◆ process()

◆ set_check_mode()

◆ set_project_name()

◆ status_range()

Member Data Documentation

◆ cloud_print_only

◆ connection_type

◆ has_sdcard

◆ job_data

◆ m_access_code

◆ m_check_and_continue

◆ m_dev_id

◆ m_dev_ip

◆ m_enter_ip_address_fun_fail

◆ m_enter_ip_address_fun_success

◆ m_is_check_mode

◆ m_job_finished

◆ m_lifecycle_finished

◆ m_lifecycle_started

◆ m_local_use_ssl

◆ m_local_use_ssl_for_ftp

◆ m_parent

◆ m_plater

◆ m_print_job_completed_id

◆ m_project_name

◆ m_success_fun

◆ sdcard_state

◆ task_ams_mapping

◆ task_bed_type

◆ task_use_ams