Slic3r::GUI::PrintJob Class Reference

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

Inheritance diagram for Slic3r::GUI::PrintJob:

Collaboration diagram for Slic3r::GUI::PrintJob:

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

Public Member Functions
void	prepare ()
	PrintJob (std::string dev_id="")
void	set_print_config (std::string bed_type, bool bed_leveling, bool flow_cali, bool vabration_cali, bool record_timelapse, bool layer_inspect, bool ext_change_assist, int auto_bed_levelingt, int auto_flow_calit, int auto_offset_calit, int extruder_cali_manual_modet=-1)
int	status_range () const
bool	is_finished ()
void	set_print_job_finished_event (int event_id, wxString evt_data=wxEmptyString)
void	on_success (std::function< void()> success)
void	process (Ctl &ctl) override
void	finalize (bool canceled, std::exception_ptr &e) override
void	set_project_name (std::string name)
void	set_dst_name (std::string path)
void	on_check_ip_address_fail (std::function< void()> func)
void	on_check_ip_address_success (std::function< void()> func)
wxString	get_http_error_msg (unsigned int status, std::string body)
std::string	truncate_string (const std::string &str, size_t maxLength)
void	set_calibration_task (bool is_calibration)

Public Attributes
PrintPrepareData	job_data
PlateListData	plate_data
std::string	m_project_name
std::string	m_dev_ip
std::string	m_ftp_folder
std::string	m_access_code
std::string	task_bed_type
std::string	task_nozzle_mapping
std::string	task_ams_mapping
std::string	task_ams_mapping2
std::string	task_ams_mapping_info
std::string	task_nozzles_info
std::string	connection_type
std::string	m_print_type
std::string	m_dst_path
bool	m_is_calibration_task = false
int	m_print_from_sdc_plate_idx = 0
bool	m_local_use_ssl { true }
bool	m_local_use_ssl_for_ftp { true }
bool	task_bed_leveling
bool	task_flow_cali
bool	task_vibration_cali
bool	task_record_timelapse
bool	task_timelapse_use_internal { false }
bool	task_layer_inspect
bool	cloud_print_only { false }
bool	has_sdcard { false }
bool	could_emmc_print { false }
bool	task_use_ams { true }
DevStorage::SdcardState	sdcard_state = DevStorage::SdcardState::NO_SDCARD
bool	task_ext_change_assist { false }
int	auto_bed_leveling {0}
int	auto_flow_cali {0}
int	auto_offset_cali {0}
int	extruder_cali_manual_mode {-1}

Private Attributes
std::function< void()>	m_success_fun {nullptr}
std::string	m_dev_id
bool	m_job_finished { false }
bool	m_lifecycle_started { false }
bool	m_lifecycle_finished { false }
bool	m_lifecycle_success { false }
int	m_print_job_completed_id = 0
wxString	m_completed_evt_data
std::function< void()>	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

PrintJob()

Slic3r::GUI::PrintJob::PrintJob

(

std::string

dev_id = ""

)

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

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

Here is the call graph for this function:

Member Function Documentation

finalize()

void Slic3r::GUI::PrintJob::finalize ( bool canceled, std::exception_ptr & e )

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 = "print_job";
        finish_ctx.code = canceled ? LifecycleEvtCode::Warn :
            (eptr || !m_lifecycle_success ? LifecycleEvtCode::Error : LifecycleEvtCode::Ok);
        finish_ctx.msg = canceled ? "cancelled" : (eptr ? "exception" :
            (m_lifecycle_success ? "" : "failed"));
        fire_lifecycle_event(LifecycleEvent::PrintJobFinished, 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_lifecycle_finished, m_lifecycle_started, m_lifecycle_success, m_project_name, Slic3r::LifecycleEventContext::msg, Slic3r::LifecycleEventContext::name, Slic3r::Ok, Slic3r::PrintJobFinished, Slic3r::LifecycleEventContext::source, and Slic3r::Warn.

Here is the call graph for this function:

get_http_error_msg()

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

{
    try {
        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);
            BOOST_LOG_TRIVIAL(error) << "http_error: status=" << status << ", code=" << code << ", error=" << error;
            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;
    } catch(...) {
        ;
    }
    return wxEmptyString;
}

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

Here is the call graph for this function:

is_finished()

bool Slic3r::GUI::PrintJob::is_finished ( )

inline

{ return m_job_finished;  }

References m_job_finished.

on_check_ip_address_fail()

void Slic3r::GUI::PrintJob::on_check_ip_address_fail

(

std::function< void()>

func

)

{
    m_enter_ip_address_fun_fail = func;
}

References m_enter_ip_address_fun_fail.

on_check_ip_address_success()

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

(

std::function< void()>

success

)

{
    m_success_fun = success;
}

References m_success_fun.

prepare()

void Slic3r::GUI::PrintJob::prepare

(

)

{
    if (job_data.is_from_plater)
        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::PrintJob::process ( Ctl & ctl )

overridevirtual

Implements Slic3r::GUI::Job.

{
    /* display info */
    std::string msg;
    int curr_percent = 10;
    NetworkAgent* m_agent = wxGetApp().getAgent();
    AppConfig* config = wxGetApp().app_config;
 
    if (this->connection_type == "lan") {
        msg = _u8L("Sending print job over LAN");
    }
    else {
        msg = _u8L("Sending print job through cloud service");
    }
 
    ctl.update_status(0, msg);
    ctl.call_on_main_thread([this] { prepare(); }).wait();
 
    int result = -1;
    std::string http_body;
 
    const auto mark_lifecycle_started = [this]() {
        if (m_lifecycle_started)
            return;
 
        LifecycleEventContext start_ctx;
        start_ctx.name = m_project_name;
        start_ctx.device_id = m_dev_id;
        start_ctx.source = "print_job";
        fire_lifecycle_event(LifecycleEvent::PrintJobStarted, start_ctx);
        m_lifecycle_started = true;
    };
 
    int total_plate_num = plate_data.plate_count;
    if (!plate_data.is_valid) {
        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) {
            plate = m_plater->get_partplate_list().get_curr_plate();
            if (plate == nullptr) return;
        }
 
        /* check gcode is valid */
        if (!plate->is_valid_gcode_file() && m_print_type == "from_normal") {
            ctl.update_status(curr_percent, check_gcode_failed_str);
            return;
        }
 
        if (ctl.was_canceled()) {
            ctl.update_status(curr_percent, printjob_cancel_str);
            return;
        }
    }
 
    const std::string transport_project_name = truncate_string(m_project_name, 100);
    int curr_plate_idx = 0;
 
    if (m_print_type == "from_normal") {
        if (plate_data.is_valid)
            curr_plate_idx = plate_data.cur_plate_index;
        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;
        else if (job_data.plate_idx == PLATE_ALL_IDX)
            curr_plate_idx = m_plater->get_partplate_list().get_curr_plate_index() + 1;
        else
            curr_plate_idx = m_plater->get_partplate_list().get_curr_plate_index() + 1;
    }
    else if(m_print_type == "from_sdcard_view") {
        curr_plate_idx = m_print_from_sdc_plate_idx;
    }
 
    PartPlate* curr_plate = m_plater->get_partplate_list().get_curr_plate();
    if (curr_plate) {
        this->task_bed_type = bed_type_to_gcode_string(plate_data.is_valid ? plate_data.bed_type : curr_plate->get_bed_type(true));
    }
 
    PrintParams params;
 
    // local print access
    params.dev_ip = m_dev_ip;
    params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
    params.use_ssl_for_mqtt  = m_local_use_ssl;
    params.username = m_agent->default_lan_username();
    params.password = m_access_code;
 
    // check access code and ip address
    if (this->connection_type == "lan" && m_print_type == "from_normal") {
        bool emmc_ok = false;
        bool ftp_ok = false;
        if (could_emmc_print) {
            std::string devIP = m_dev_ip;
            std::string accessCode = m_access_code;
            std::string url = "bambu:///local/" + devIP + "?port=6000&user=" + "bblp" + "&passwd=" + accessCode;
            try {
                std::unique_ptr<FileTransferTunnel> tunnel = std::make_unique<FileTransferTunnel>(module(), url);
                emmc_ok = tunnel->sync_start_connect();
            } catch (const std::exception &e) {
                BOOST_LOG_TRIVIAL(warning) << "eMMC tunnel unavailable, falling back to FTP: " << e.what();
                emmc_ok = false;
            }
        }
        {
            params.dev_id = m_dev_id;
            params.project_name = "verify_job";
            params.filename = job_data._temp_path.string();
            params.connection_type = this->connection_type;
 
            result = m_agent->start_send_gcode_to_sdcard(params, nullptr, nullptr, nullptr);
 
            ftp_ok = result == 0;
        }
        if (!emmc_ok && !ftp_ok) {
            bool legacy_mode = BBLNetworkPlugin::instance().use_legacy_network();
            BOOST_LOG_TRIVIAL(error) << "LAN connection verification failed:"
                << " emmc_ok=" << emmc_ok
                << ", ftp_ok=" << ftp_ok
                << ", ftp_result=" << result
                << ", dev_ip=" << m_dev_ip
                << ", dev_id=" << m_dev_id
                << ", password_length=" << m_access_code.size()
                << ", legacy_mode=" << (legacy_mode ? "true" : "false");
            m_enter_ip_address_fun_fail();
            m_job_finished = true;
            return;
        }
 
        params.project_name = "";
        params.filename = "";
    }
 
    params.dev_id               = m_dev_id;
    params.ftp_folder           = m_ftp_folder;
    params.filename             = job_data._3mf_path.string();
    params.config_filename      = job_data._3mf_config_path.string();
    params.plate_index          = curr_plate_idx;
    params.task_bed_leveling    = this->task_bed_leveling;
    params.task_flow_cali       = this->task_flow_cali;
    params.task_vibration_cali  = this->task_vibration_cali;
    params.task_layer_inspect   = this->task_layer_inspect;
    params.task_record_timelapse= this->task_record_timelapse;
    params.task_timelapse_use_internal = this->task_timelapse_use_internal;
    params.nozzle_mapping       = this->task_nozzle_mapping;
    params.ams_mapping          = this->task_ams_mapping;
    params.ams_mapping2         = this->task_ams_mapping2;
    params.ams_mapping_info     = this->task_ams_mapping_info;
    params.nozzles_info         = this->task_nozzles_info;
    params.connection_type      = this->connection_type;
    params.task_use_ams         = this->task_use_ams;
    params.task_bed_type        = this->task_bed_type;
    params.print_type           = this->m_print_type;
    params.auto_bed_leveling    = this->auto_bed_leveling;
    params.auto_flow_cali       = this->auto_flow_cali;
    params.auto_offset_cali     = this->auto_offset_cali;
    params.extruder_cali_manual_mode = this->extruder_cali_manual_mode;
    params.task_ext_change_assist = this->task_ext_change_assist;
    // Allow disabling the eMMC print path via AppConfig. Plugin 02.03.00.62's
    // eMMC tunnel code hangs indefinitely at the upload phase with some
    // printers (e.g., Bambu H2D), so we default to disabled. Users with
    // working eMMC support can opt-in by setting disable_emmc_print = 0.
    bool disable_emmc = true;
    if (wxGetApp().app_config) {
        auto v = wxGetApp().app_config->get("disable_emmc_print");
        if (v == "0" || v == "false")
            disable_emmc = false;
    }
    params.try_emmc_print         = this->could_emmc_print && !disable_emmc;
 
    if (m_print_type == "from_sdcard_view") {
        params.dst_file = m_dst_path;
    }
 
    if (wxGetApp().model().model_info && wxGetApp().model().model_info.get()) {
        ModelInfo* model_info = wxGetApp().model().model_info.get();
        auto origin_profile_id = model_info->metadata_items.find(BBL_DESIGNER_PROFILE_ID_TAG);
        if (origin_profile_id != model_info->metadata_items.end()) {
            try {
                params.origin_profile_id    = std::stoi(origin_profile_id->second.c_str());
            }
            catch(...) {}
        }
        auto origin_model_id = model_info->metadata_items.find(BBL_DESIGNER_MODEL_ID_TAG);
        if (origin_model_id != model_info->metadata_items.end()) {
            try {
                params.origin_model_id = origin_model_id->second;
            }
            catch(...) {}
        }
 
        auto profile_name = model_info->metadata_items.find(BBL_DESIGNER_PROFILE_TITLE_TAG);
        if (profile_name != model_info->metadata_items.end()) {
            try {
                params.preset_name = profile_name->second;
            }
            catch (...) {}
        }
 
         if (m_print_type != "from_sdcard_view") {
            auto model_name = model_info->metadata_items.find(BBL_DESIGNER_MODEL_TITLE_TAG);
            if (model_name != model_info->metadata_items.end()) {
                try {
                    std::string mall_model_name = model_name->second;
                    std::replace(mall_model_name.begin(), mall_model_name.end(), ' ', '_');
                    const char *unusable_symbols = "<>[]:/\\|?*\" ";
                    for (const char *symbol = unusable_symbols; *symbol != '\0'; ++symbol) { std::replace(mall_model_name.begin(), mall_model_name.end(), *symbol, '_'); }
 
                    std::regex pattern("_+");
                    params.project_name = std::regex_replace(mall_model_name, pattern, "_");
                    params.project_name = truncate_string(params.project_name, 100);
                } catch (...) {}
            }
        }
    }
 
    params.stl_design_id = 0;
    if (!wxGetApp().model().stl_design_id.empty()) {
 
        auto country_code = wxGetApp().app_config->get_country_code();
        bool match_code = false;
 
        if (wxGetApp().model().stl_design_country == "DEV" && (country_code == "ENV_CN_DEV" || country_code == "NEW_ENV_DEV_HOST")) {
            match_code = true;
        }
 
        if (wxGetApp().model().stl_design_country == "QA" && (country_code == "ENV_CN_QA" || country_code == "NEW_ENV_QAT_HOST")) {
            match_code = true;
        }
 
        if (wxGetApp().model().stl_design_country == "CN_PRE" && (country_code == "ENV_CN_PRE" || country_code == "NEW_ENV_PRE_HOST")) {
            match_code = true;
        }
 
        if (wxGetApp().model().stl_design_country == "US_PRE" && country_code == "ENV_US_PRE") {
            match_code = true;
        }
 
        if (country_code == wxGetApp().model().stl_design_country) {
            match_code = true;
        }
 
        if (match_code) {
            int stl_design_id = 0;
            try {
                stl_design_id = std::stoi(wxGetApp().model().stl_design_id);
            }
            catch (const std::exception&) {
                stl_design_id = 0;
            }
            params.stl_design_id = stl_design_id;
        }
    }
 
    if (params.preset_name.empty() && m_print_type == "from_normal") { params.preset_name = wxString::Format("%s_plate_%d", transport_project_name, curr_plate_idx).ToStdString(); }
    if (params.project_name.empty()) {params.project_name = transport_project_name;}
 
    if (m_is_calibration_task) {
        params.project_name = transport_project_name;
        params.origin_model_id = "";
    }
 
    wxString error_text;
    std::string msg_text;
 
 
    const int StagePercentPoint[(int)PrintingStageFinished + 1] = {
        20,     // PrintingStageCreate
        30,     // PrintingStageUpload
        70,     // PrintingStageWaiting
        75,     // PrintingStageRecord
        97,     // PrintingStageSending
        100,    // PrintingStageFinished
        100     // PrintingStageFinished
    };
 
    bool is_try_lan_mode = false;
    bool is_try_lan_mode_failed = false;
 
    auto update_fn = [this, &ctl,
        &is_try_lan_mode,
        &is_try_lan_mode_failed,
        &msg,
        &curr_percent,
        StagePercentPoint
    ](int stage, int code, std::string info) {
 
                        if (stage == SendingPrintJobStage::PrintingStageCreate && !is_try_lan_mode_failed) {
                            if (this->connection_type == "lan") {
                                msg = _u8L("Sending print job over LAN");
                            } else {
                                msg = _u8L("Sending print job through cloud service");
                            }
                        }
                        else if (stage == SendingPrintJobStage::PrintingStageUpload && !is_try_lan_mode_failed) {
                            if (code >= 0 && code <= 100 && !info.empty()) {
                                if (this->connection_type == "lan") {
                                    msg = _u8L("Sending print job over LAN");
                                } else {
                                    msg = _u8L("Sending print job through cloud service");
                                }
                                msg += format("(%s)", info);
                            }
                        }
                        else if (stage == SendingPrintJobStage::PrintingStageWaiting) {
                            if (this->connection_type == "lan") {
                                msg = _u8L("Sending print job over LAN");
                            } else {
                                msg = _u8L("Sending print job through cloud service");
                            }
                        }
                        else  if (stage == SendingPrintJobStage::PrintingStageRecord && !is_try_lan_mode) {
                            msg = _u8L("Sending print configuration");
                        }
                        else if (stage == SendingPrintJobStage::PrintingStageSending && !is_try_lan_mode) {
                            if (this->connection_type == "lan") {
                                msg = _u8L("Sending print job over LAN");
                            } else {
                                msg = _u8L("Sending print job through cloud service");
                            }
                        }
                        else if (stage == SendingPrintJobStage::PrintingStageFinished) {
                            msg = format(_u8L("Successfully sent. Will automatically jump to the device page in %ss"), info);
                            if (m_print_job_completed_id == wxGetApp().plater()->get_send_calibration_finished_event()) {
                                msg = format(_u8L("Successfully sent. Will automatically jump to the next page in %ss"), info);
                            }
                            ctl.clear_percent();
                        } else {
                            if (this->connection_type == "lan") {
                                msg = _u8L("Sending print job over LAN");
                            } else {
                                msg = _u8L("Sending print job through cloud service");
                            }
                        }
 
                        // update current percnet
                        if (stage >= 0 && stage <= (int) PrintingStageFinished) {
                            curr_percent = StagePercentPoint[stage];
                            if ((stage == SendingPrintJobStage::PrintingStageUpload
                                || stage == SendingPrintJobStage::PrintingStageRecord)
                                && (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();
        };
 
 
    DeviceManager* dev = wxGetApp().getDeviceManager();
    MachineObject* obj = dev->get_selected_machine();
 
    auto wait_fn = [&ctl, &obj](int state, std::string job_info) {
            BOOST_LOG_TRIVIAL(info) << "print_job: get_job_info = " << job_info;
 
            if (!obj->is_support_wait_sending_finish) {
                return true;
            }
 
            std::string curr_job_id;
            json job_info_j;
            try {
                std::ignore = job_info_j.parse(job_info);
                if (job_info_j.contains("job_id")) {
                    curr_job_id = DevJsonValParser::get_longlong_val(job_info_j["job_id"]);
                }
                BOOST_LOG_TRIVIAL(trace) << "print_job: curr_obj_id=" << curr_job_id;
 
            } catch(...) {
                ;
            }
 
            if (obj) {
                int time_out = 0;
                while (time_out < PRINT_JOB_SENDING_TIMEOUT) {
                    BOOST_LOG_TRIVIAL(trace) << "print_job: obj job_id = " << obj->job_id_;
                    if (!obj->job_id_.empty() && obj->job_id_.compare(curr_job_id) == 0) {
                        BOOST_LOG_TRIVIAL(info) << "print_job: got job_id = " << obj->job_id_ << ", time_out=" << time_out;
                        return true;
                    }
                    if (obj->is_in_printing_status(obj->print_status)) {
                        BOOST_LOG_TRIVIAL(info) << "print_job: printer has enter printing status, s = " << obj->print_status;
                        return true;
                    }
                    // Break the wait-for-print-start loop on user cancel.
                    if (ctl.was_canceled()) {
                        BOOST_LOG_TRIVIAL(info) << "print_job: user cancel the job " << obj->job_id_;
                        return true;
                    }
                    time_out++;
                    boost::this_thread::sleep_for(boost::chrono::milliseconds(1000));
                }
                //this->update_status(curr_percent, _L("Print task sending times out."));
                //m_plater->update_print_error_info(BAMBU_NETWORK_ERR_TIMEOUT, wait_sending_finish.ToStdString(), desc_wait_sending_finish.ToStdString());
                BOOST_LOG_TRIVIAL(info) << "print_job: timeout, cancel the job" << obj->job_id_;
                /* handle tiemout */
                //obj->command_task_cancel(curr_job_id);
                //return false;
                return true;
            }
            BOOST_LOG_TRIVIAL(info) << "print_job: obj is null";
            return true;
    };
 
    if (m_print_type == "from_sdcard_view") {
        BOOST_LOG_TRIVIAL(info) << "print_job: try to send with cloud, model is sdcard view";
        ctl.update_status(curr_percent, _u8L("Sending print job through cloud service"));
        mark_lifecycle_started();
        result = m_agent->start_sdcard_print(params, update_fn, cancel_fn);
    } else 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";
 
 
        //use ftp only
        if (!wxGetApp().app_config->get("lan_mode_only").empty() && wxGetApp().app_config->get("lan_mode_only") == "1") {
 
            if (params.password.empty() || params.dev_ip.empty()) {
                error_text = wxString::Format(_L("Access code:%s IP address:%s"), params.password, params.dev_ip);
                result = BAMBU_NETWORK_ERR_FTP_UPLOAD_FAILED;
            }
            else {
                BOOST_LOG_TRIVIAL(info) << "print_job: use ftp send print only";
                ctl.update_status(curr_percent, _u8L("Sending print job over LAN"));
                is_try_lan_mode = true;
                mark_lifecycle_started();
                result = m_agent->start_local_print_with_record(params, update_fn, cancel_fn, wait_fn);
                if (result < 0) {
                    error_text = wxString::Format(_L("Access code:%s IP address:%s"), params.password, params.dev_ip);
                    // try to send with cloud
                    BOOST_LOG_TRIVIAL(warning) << "print_job: use ftp send print failed";
                }
            }
        }
        else {
            if (!this->cloud_print_only
                && !params.password.empty()
                && !params.dev_ip.empty()
                && this->has_sdcard) {
                // try to send local with record
                BOOST_LOG_TRIVIAL(info) << "print_job: try to start local print with record";
                ctl.update_status(curr_percent, _u8L("Sending print job over LAN"));
                mark_lifecycle_started();
                result = m_agent->start_local_print_with_record(params, update_fn, cancel_fn, wait_fn);
                if (result == 0) {
                    params.comments = "";
                }
                else if (result == BAMBU_NETWORK_ERR_PRINT_WR_UPLOAD_FTP_FAILED) {
                    params.comments = "upload_failed";
                }
                else {
                    params.comments = (boost::format("failed(%1%)") % result).str();
                }
                if (result < 0) {
                    is_try_lan_mode_failed = true;
                    // try to send with cloud
                    BOOST_LOG_TRIVIAL(warning) << "print_job: try to send with cloud";
                    ctl.update_status(curr_percent, _u8L("Sending print job through cloud service"));
                    // Started was already emitted before the local attempt.
                    result = m_agent->start_print(params, update_fn, cancel_fn, wait_fn);
                }
            }
            else {
                BOOST_LOG_TRIVIAL(info) << "print_job: send with cloud";
                ctl.update_status(curr_percent, _u8L("Sending print job through cloud service"));
                mark_lifecycle_started();
                result = m_agent->start_print(params, update_fn, cancel_fn, wait_fn);
            }
        }
    } else {
        if (this->could_emmc_print) {
            ctl.update_status(curr_percent, _u8L("Sending print job over LAN"));
            mark_lifecycle_started();
            result = m_agent->start_local_print(params, update_fn, cancel_fn);
        } else {
            switch(this->sdcard_state) {
                case DevStorage::SdcardState::NO_SDCARD:
                    ctl.update_status(curr_percent, _u8L("A Storage needs to be inserted before printing via LAN."));
                    return;
                case DevStorage::SdcardState::HAS_SDCARD_ABNORMAL:
                    if(this->has_sdcard) {
                        // means the storage is abnormal but can be used option is enabled
                        ctl.update_status(curr_percent, _u8L("Sending print job over LAN, but the Storage in the printer is abnormal and print-issues may be caused by this."));
                        mark_lifecycle_started();
                        result = m_agent->start_local_print(params, update_fn, cancel_fn);
                        break;
                    }
                    ctl.update_status(curr_percent, _u8L("The Storage in the printer is abnormal. Please replace it with a normal Storage before sending print job 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 print job to printer."));
                    return;
                case DevStorage::SdcardState::HAS_SDCARD_NORMAL:
                    ctl.update_status(curr_percent, _u8L("Sending print job over LAN"));
                    mark_lifecycle_started();
                    result = m_agent->start_local_print(params, update_fn, cancel_fn);
                    break;
                default:
                    ctl.update_status(curr_percent, _u8L("Encountered an unknown error with the Storage status. Please try again."));
                    return;
            }
        }
    }
 
    if (result < 0) {
        curr_percent = -1;
 
        // The printer is still fetching its encryption flag (a transient state), so ask the
        // user to retry rather than showing a generic error.
        if (result == BAMBU_NETOWRK_ERR_PRINT_SP_ENC_FLAG_NOT_READY) {
            msg_text = _u8L("Retrieving printer information, please try again later.");
        } else 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;
            ctl.update_status(0, msg_text);
        } else {
            msg_text = send_print_failed_str;
        }
 
        if (result != BAMBU_NETWORK_ERR_CANCELED) {
            ctl.show_error_info(msg_text, 0, "", "");
        }
 
        BOOST_LOG_TRIVIAL(error) << "print_job: failed, result = " << result;
    } else {
        // wait for printer mqtt ready the same job id
 
        BOOST_LOG_TRIVIAL(error) << "print_job: send ok.";
        wxCommandEvent* evt = new wxCommandEvent(m_print_job_completed_id);
        if (!m_completed_evt_data.empty())
            evt->SetString(m_completed_evt_data);
        else
            evt->SetString(m_dev_id);
        if (m_print_job_completed_id == wxGetApp().plater()->get_send_calibration_finished_event()) {
            int sel = wxGetApp().mainframe->get_calibration_curr_tab();
            if (sel >= 0) {
                evt->SetInt(sel);
            }
        }
        wxQueueEvent(m_plater, evt);
        m_job_finished = true;
        m_lifecycle_success = true;
    }
}

References _L, _u8L, Slic3r::PrintParams::ams_mapping, Slic3r::PrintParams::ams_mapping2, Slic3r::PrintParams::ams_mapping_info, auto_bed_leveling, Slic3r::PrintParams::auto_bed_leveling, auto_flow_cali, Slic3r::PrintParams::auto_flow_cali, auto_offset_cali, Slic3r::PrintParams::auto_offset_cali, BAMBU_NETOWRK_ERR_PRINT_SP_ENC_FLAG_NOT_READY, BAMBU_NETWORK_ERR_CANCELED, BAMBU_NETWORK_ERR_FTP_UPLOAD_FAILED, BAMBU_NETWORK_ERR_PRINT_LP_UPLOAD_FTP_FAILED, BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED, BAMBU_NETWORK_ERR_PRINT_SP_CHECK_MD5_FAILED, BAMBU_NETWORK_ERR_PRINT_SP_FILE_NOT_EXIST, BAMBU_NETWORK_ERR_PRINT_SP_FILE_OVER_SIZE, BAMBU_NETWORK_ERR_PRINT_SP_GET_NOTIFICATION_TIMEOUT, BAMBU_NETWORK_ERR_PRINT_WR_CHECK_MD5_FAILED, BAMBU_NETWORK_ERR_PRINT_WR_FILE_NOT_EXIST, BAMBU_NETWORK_ERR_PRINT_WR_FILE_OVER_SIZE, BAMBU_NETWORK_ERR_PRINT_WR_GET_NOTIFICATION_TIMEOUT, BAMBU_NETWORK_ERR_PRINT_WR_UPLOAD_FTP_FAILED, BBL_DESIGNER_MODEL_ID_TAG, BBL_DESIGNER_MODEL_TITLE_TAG, BBL_DESIGNER_PROFILE_ID_TAG, BBL_DESIGNER_PROFILE_TITLE_TAG, Slic3r::bed_type_to_gcode_string(), Slic3r::GUI::Job::Ctl::call_on_main_thread(), Slic3r::GUI::check_gcode_failed_str, Slic3r::GUI::Job::Ctl::clear_percent(), cloud_print_only, Slic3r::PrintParams::comments, Slic3r::PrintParams::config_filename, connection_type, Slic3r::PrintParams::connection_type, could_emmc_print, Slic3r::NetworkAgent::default_lan_username(), Slic3r::GUI::desc_fail_not_exist, Slic3r::GUI::desc_file_too_large, Slic3r::GUI::desc_network_error, Slic3r::GUI::desc_upload_ftp_failed, Slic3r::PrintParams::dev_id, Slic3r::PrintParams::dev_ip, Slic3r::LifecycleEventContext::device_id, Slic3r::PrintParams::dst_file, extruder_cali_manual_mode, Slic3r::PrintParams::extruder_cali_manual_mode, Slic3r::GUI::failed_in_cloud_service_str, Slic3r::GUI::file_is_not_exists_str, Slic3r::GUI::file_over_size_str, Slic3r::PrintParams::filename, Slic3r::fire_lifecycle_event(), Slic3r::GUI::format(), Slic3r::PrintParams::ftp_folder, Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::DevJsonValParser::get_longlong_val(), Slic3r::DeviceManager::get_selected_machine(), has_sdcard, Slic3r::DevStorage::HAS_SDCARD_ABNORMAL, Slic3r::DevStorage::HAS_SDCARD_NORMAL, Slic3r::DevStorage::HAS_SDCARD_READONLY, Slic3r::BBLNetworkPlugin::instance(), Slic3r::MachineObject::is_in_printing_status(), Slic3r::MachineObject::is_support_wait_sending_finish, Slic3r::GUI::PartPlate::is_valid_gcode_file(), job_data, Slic3r::MachineObject::job_id_, m_access_code, m_completed_evt_data, m_dev_id, m_dev_ip, m_dst_path, m_enter_ip_address_fun_fail, m_ftp_folder, m_is_calibration_task, m_job_finished, m_lifecycle_started, m_lifecycle_success, m_local_use_ssl, m_local_use_ssl_for_ftp, m_plater, m_print_from_sdc_plate_idx, m_print_job_completed_id, m_print_type, m_project_name, Slic3r::ModelInfo::metadata_items, Slic3r::module(), Slic3r::LifecycleEventContext::name, Slic3r::DevStorage::NO_SDCARD, Slic3r::PrintParams::nozzle_mapping, Slic3r::PrintParams::nozzles_info, Slic3r::PrintParams::origin_model_id, Slic3r::PrintParams::origin_profile_id, Slic3r::PrintParams::password, PLATE_ALL_IDX, PLATE_CURRENT_IDX, plate_data, Slic3r::PrintParams::plate_index, Slic3r::GUI::plater(), prepare(), Slic3r::PrintParams::preset_name, Slic3r::GUI::print_canceled_str, PRINT_JOB_SENDING_TIMEOUT, Slic3r::MachineObject::print_status, Slic3r::PrintParams::print_type, Slic3r::PrintingStageCreate, Slic3r::PrintingStageERROR, Slic3r::PrintingStageFinished, Slic3r::PrintingStageRecord, Slic3r::PrintingStageSending, Slic3r::PrintingStageUpload, Slic3r::PrintingStageWaiting, Slic3r::GUI::printjob_cancel_str, Slic3r::PrintJobStarted, Slic3r::PrintParams::project_name, sdcard_state, Slic3r::GUI::send_print_failed_str, Slic3r::GUI::Job::Ctl::show_error_info(), Slic3r::LifecycleEventContext::source, Slic3r::NetworkAgent::start_local_print(), Slic3r::NetworkAgent::start_local_print_with_record(), Slic3r::NetworkAgent::start_print(), Slic3r::NetworkAgent::start_sdcard_print(), Slic3r::NetworkAgent::start_send_gcode_to_sdcard(), Slic3r::PrintParams::stl_design_id, task_ams_mapping, task_ams_mapping2, task_ams_mapping_info, task_bed_leveling, Slic3r::PrintParams::task_bed_leveling, task_bed_type, Slic3r::PrintParams::task_bed_type, task_ext_change_assist, Slic3r::PrintParams::task_ext_change_assist, task_flow_cali, Slic3r::PrintParams::task_flow_cali, task_layer_inspect, Slic3r::PrintParams::task_layer_inspect, task_nozzle_mapping, task_nozzles_info, task_record_timelapse, Slic3r::PrintParams::task_record_timelapse, task_timelapse_use_internal, Slic3r::PrintParams::task_timelapse_use_internal, task_use_ams, Slic3r::PrintParams::task_use_ams, task_vibration_cali, Slic3r::PrintParams::task_vibration_cali, Slic3r::GUI::time_out, Slic3r::GUI::timeout_to_upload_str, Slic3r::trace(), truncate_string(), Slic3r::PrintParams::try_emmc_print, Slic3r::GUI::Job::Ctl::update_status(), Slic3r::GUI::upload_ftp_failed_str, Slic3r::BBLNetworkPlugin::use_legacy_network(), Slic3r::PrintParams::use_ssl_for_ftp, Slic3r::PrintParams::use_ssl_for_mqtt, Slic3r::PrintParams::username, and Slic3r::GUI::Job::Ctl::was_canceled().

Here is the call graph for this function:

set_calibration_task()

void Slic3r::GUI::PrintJob::set_calibration_task

(

bool

is_calibration

)

{
    m_is_calibration_task = is_calibration;
}

References m_is_calibration_task.

set_dst_name()

void Slic3r::GUI::PrintJob::set_dst_name

(

std::string

path

)

{
    m_dst_path = path;
}

References m_dst_path.

set_print_config()

void Slic3r::GUI::PrintJob::set_print_config ( std::string bed_type, bool bed_leveling, bool flow_cali, bool vabration_cali, bool record_timelapse, bool layer_inspect, bool ext_change_assist, int auto_bed_levelingt, int auto_flow_calit, int auto_offset_calit, int extruder_cali_manual_modet = -1 )

inline

    {
        task_bed_type       = bed_type;
        task_bed_leveling   = bed_leveling;
        task_flow_cali      = flow_cali;
        task_vibration_cali = vabration_cali;
        task_record_timelapse = record_timelapse;
        task_layer_inspect    = layer_inspect;
        task_ext_change_assist = ext_change_assist;
 
        auto_bed_leveling = auto_bed_levelingt;
        auto_flow_cali = auto_flow_calit;
        auto_offset_cali = auto_offset_calit;
        extruder_cali_manual_mode = extruder_cali_manual_modet;
 
    }

References auto_bed_leveling, auto_flow_cali, auto_offset_cali, extruder_cali_manual_mode, task_bed_leveling, task_bed_type, task_ext_change_assist, task_flow_cali, task_layer_inspect, task_record_timelapse, and task_vibration_cali.

set_print_job_finished_event()

void Slic3r::GUI::PrintJob::set_print_job_finished_event ( int event_id, wxString evt_data = wxEmptyString )

inline

                                                                                       {
        m_print_job_completed_id = event_id;
        m_completed_evt_data = evt_data;
    }

References m_completed_evt_data, and m_print_job_completed_id.

set_project_name()

void Slic3r::GUI::PrintJob::set_project_name

(

std::string

name

)

{
    m_project_name = name;
}

References m_project_name.

status_range()

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

inline

    {
        return 100;
    }

truncate_string()

std::string Slic3r::GUI::PrintJob::truncate_string	(	const std::string &	str,
		size_t	maxLength )

{
    if (str.length() <= maxLength)
    {
        return str;
    }
 
    wxString local_str = wxString::FromUTF8(str);
    wxString truncatedStr;
 
    for (auto i = 1; i < local_str.Length(); i++) {
        wxString tagStr = local_str.Mid(0, i);
        if (tagStr.ToUTF8().length() >= maxLength) {
            truncatedStr = local_str.Mid(0, i - 1);
            break;
        }
    }
    return truncatedStr.utf8_string();
}

Referenced by process().

Here is the caller graph for this function:

Member Data Documentation

auto_bed_leveling

int Slic3r::GUI::PrintJob::auto_bed_leveling {0}

{0};

Referenced by process(), and set_print_config().

auto_flow_cali

int Slic3r::GUI::PrintJob::auto_flow_cali {0}

{0};

Referenced by process(), and set_print_config().

auto_offset_cali

int Slic3r::GUI::PrintJob::auto_offset_cali {0}

{0};

Referenced by process(), and set_print_config().

cloud_print_only

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

{ false };

Referenced by process().

connection_type

std::string Slic3r::GUI::PrintJob::connection_type

Referenced by process().

could_emmc_print

bool Slic3r::GUI::PrintJob::could_emmc_print { false }

{ false };

Referenced by process().

extruder_cali_manual_mode

int Slic3r::GUI::PrintJob::extruder_cali_manual_mode {-1}

{-1};

Referenced by process(), and set_print_config().

has_sdcard

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

{ false };

Referenced by process().

job_data

PrintPrepareData Slic3r::GUI::PrintJob::job_data

Referenced by prepare(), and process().

m_access_code

std::string Slic3r::GUI::PrintJob::m_access_code

Referenced by process().

m_completed_evt_data

wxString Slic3r::GUI::PrintJob::m_completed_evt_data

private

Referenced by process(), and set_print_job_finished_event().

m_dev_id

std::string Slic3r::GUI::PrintJob::m_dev_id

private

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

m_dev_ip

std::string Slic3r::GUI::PrintJob::m_dev_ip

Referenced by process().

m_dst_path

std::string Slic3r::GUI::PrintJob::m_dst_path

Referenced by process(), and set_dst_name().

m_enter_ip_address_fun_fail

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

private

{ nullptr };

Referenced by on_check_ip_address_fail(), and process().

m_enter_ip_address_fun_success

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

private

{ nullptr };

Referenced by on_check_ip_address_success().

m_ftp_folder

std::string Slic3r::GUI::PrintJob::m_ftp_folder

Referenced by process().

m_is_calibration_task

bool Slic3r::GUI::PrintJob::m_is_calibration_task = false

Referenced by PrintJob(), process(), and set_calibration_task().

m_job_finished

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

private

{ false };

Referenced by is_finished(), and process().

m_lifecycle_finished

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

private

{ false };

Referenced by finalize().

m_lifecycle_started

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

private

{ false };

Referenced by finalize(), and process().

m_lifecycle_success

bool Slic3r::GUI::PrintJob::m_lifecycle_success { false }

private

{ false };

Referenced by finalize(), and process().

m_local_use_ssl

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

{ true };

Referenced by process().

m_local_use_ssl_for_ftp

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

{ true };

Referenced by process().

m_plater

Plater* Slic3r::GUI::PrintJob::m_plater

private

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

m_print_from_sdc_plate_idx

int Slic3r::GUI::PrintJob::m_print_from_sdc_plate_idx = 0

Referenced by process().

m_print_job_completed_id

int Slic3r::GUI::PrintJob::m_print_job_completed_id = 0

private

Referenced by PrintJob(), process(), and set_print_job_finished_event().

m_print_type

std::string Slic3r::GUI::PrintJob::m_print_type

Referenced by process().

m_project_name

std::string Slic3r::GUI::PrintJob::m_project_name

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

m_success_fun

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

private

{nullptr};

Referenced by on_success().

plate_data

PlateListData Slic3r::GUI::PrintJob::plate_data

Referenced by process().

sdcard_state

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

Referenced by process().

task_ams_mapping

std::string Slic3r::GUI::PrintJob::task_ams_mapping

Referenced by process().

task_ams_mapping2

std::string Slic3r::GUI::PrintJob::task_ams_mapping2

Referenced by process().

task_ams_mapping_info

std::string Slic3r::GUI::PrintJob::task_ams_mapping_info

Referenced by process().

task_bed_leveling

bool Slic3r::GUI::PrintJob::task_bed_leveling

Referenced by process(), and set_print_config().

task_bed_type

std::string Slic3r::GUI::PrintJob::task_bed_type

Referenced by process(), and set_print_config().

task_ext_change_assist

bool Slic3r::GUI::PrintJob::task_ext_change_assist { false }

{ false };

Referenced by process(), and set_print_config().

task_flow_cali

bool Slic3r::GUI::PrintJob::task_flow_cali

Referenced by process(), and set_print_config().

task_layer_inspect

bool Slic3r::GUI::PrintJob::task_layer_inspect

Referenced by process(), and set_print_config().

task_nozzle_mapping

std::string Slic3r::GUI::PrintJob::task_nozzle_mapping

Referenced by process().

task_nozzles_info

std::string Slic3r::GUI::PrintJob::task_nozzles_info

Referenced by process().

task_record_timelapse

bool Slic3r::GUI::PrintJob::task_record_timelapse

Referenced by process(), and set_print_config().

task_timelapse_use_internal

bool Slic3r::GUI::PrintJob::task_timelapse_use_internal { false }

{ false };

Referenced by process().

task_use_ams

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

{ true };

Referenced by process().

task_vibration_cali

bool Slic3r::GUI::PrintJob::task_vibration_cali

Referenced by process(), and set_print_config().

---

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

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