Slic3r::CrealityPrint Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CrealityPrint.hpp>

Inheritance diagram for Slic3r::CrealityPrint:

Collaboration diagram for Slic3r::CrealityPrint:

Classes
struct	WsSettings

Public Types
typedef Http::ProgressFn	ProgressFn
typedef std::function< void(wxString)>	ErrorFn
typedef std::function< void(wxString, wxString)>	InfoFn

Public Member Functions
	CrealityPrint (DynamicPrintConfig *config)
	~CrealityPrint () override=default
const char *	get_name () const override
virtual bool	can_test () const override
std::string	get_host () const override
bool	has_auto_discovery () const override
wxString	get_test_ok_msg () const override
wxString	get_test_failed_msg (wxString &msg) const override
virtual bool	test (wxString &curl_msg) const override
PrintHostPostUploadActions	get_post_upload_actions () const override
bool	upload (PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn) const override
bool	supports_multi_color_print () const
std::string	query_boxes_info () const
std::string	model_name () const
virtual bool	supports_multiple_printers () const
virtual std::string	get_sn () const
virtual bool	get_groups (wxArrayString &) const
virtual bool	get_printers (wxArrayString &) const
virtual bool	get_storage (wxArrayString &, wxArrayString &) const
virtual bool	is_cloud () const
virtual bool	is_logged_in () const
virtual void	log_out () const
virtual bool	get_login_url (wxString &auth_url) const

Static Public Member Functions
static bool	model_supports_multi_color (const std::string &model)
static std::string	model_display_name (const std::string &model)
static PrintHost *	get_print_host (DynamicPrintConfig *config)
static std::string	get_print_host_webui (DynamicPrintConfig *config)
static int	get_err_code_from_body (const std::string &body)

Protected Member Functions
virtual void	set_auth (Http &http) const
virtual wxString	format_error (const std::string &body, const std::string &error, unsigned status) const

Static Protected Member Functions
static wxString	timed_out_message ()

Protected Attributes
struct Slic3r::CrealityPrint::WsSettings	ws_settings

Private Member Functions
std::string	make_url (const std::string &path) const
bool	start_print (wxString &msg, const std::string &filename, const std::map< std::string, std::string > &extended_info) const
std::string	safe_filename (const std::string &filename) const
void	query_model () const

Private Attributes
std::string	m_host
std::string	m_port
std::string	m_apikey
std::string	m_cafile
std::string	m_web_ui
bool	m_ssl_revoke_best_effort
std::string	m_model

Detailed Description

---

Class Documentation

Slic3r::CrealityPrint::WsSettings

struct Slic3r::CrealityPrint::WsSettings

Collaboration diagram for Slic3r::CrealityPrint::WsSettings:

Class Members
milliseconds	close {std::chrono::seconds(3)}
milliseconds	connect {std::chrono::seconds(5)}
string	port {"9999"}
milliseconds	reply {std::chrono::seconds(10)}

Member Typedef Documentation

ErrorFn

typedef std::function<void(wxString )> Slic3r::PrintHost::ErrorFn

inherited

InfoFn

typedef std::function<void(wxString , wxString )> Slic3r::PrintHost::InfoFn

inherited

ProgressFn

typedef Http::ProgressFn Slic3r::PrintHost::ProgressFn

inherited

Constructor & Destructor Documentation

CrealityPrint()

Slic3r::CrealityPrint::CrealityPrint

(

DynamicPrintConfig *

config

)

                                                       : 
    m_host(config->opt_string("print_host")), 
    m_web_ui(config->opt_string("print_host_webui")),
    m_cafile(config->opt_string("printhost_cafile")),
    m_port(config->opt_string("printhost_port")),
    m_apikey(config->opt_string("printhost_apikey")),
    m_ssl_revoke_best_effort(config->opt_bool("printhost_ssl_ignore_revoke"))
{}

References m_apikey, m_cafile, m_host, m_port, m_ssl_revoke_best_effort, and m_web_ui.

~CrealityPrint()

Slic3r::CrealityPrint::~CrealityPrint ( )

overridedefault

Member Function Documentation

can_test()

virtual bool Slic3r::CrealityPrint::can_test ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; };

format_error()

wxString Slic3r::PrintHost::format_error ( const std::string & body, const std::string & error, unsigned status ) const

protectedvirtualinherited

{
    if (status != 0) {
        const std::string reason = moonraker_error_reason(body);
        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
        return wxString::Format("HTTP %u: %s", status, wxbody);
    } else {
        if (error.find("curl:Timeout was reached") != std::string::npos) {
            return timed_out_message();
        }else if(error.find("curl:Couldn't resolve host name")!= std::string::npos){
            return _L("The Hostname/IP/URL could not be parsed, please check it and try again.");
        } else if (error.find("Connection was reset") != std::string::npos){
            return _L("File/data transfer interrupted. Please check the printer and network, then try it again.");
        }
        else {
            return wxString::FromUTF8(error.data());
        }
    }
}

References _L, and timed_out_message().

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::SimplyPrint::do_chunk_upload(), Slic3r::SimplyPrint::do_temp_upload(), Slic3r::ElegooLink::elegoo_cc2_test(), Slic3r::ElegooLink::elegoo_test(), Slic3r::PrusaLink::post_inner(), Slic3r::PrusaLink::put_inner(), Slic3r::Flashforge::request_local_api_json(), Slic3r::Duet::start_print(), Slic3r::Moonraker::start_print(), Slic3r::UltiMaker::start_print(), Slic3r::AstroBox::test(), Slic3r::CrealityPrint::test(), Slic3r::ESP3D::test(), Slic3r::FlashAir::test(), Slic3r::Moonraker::test(), Slic3r::Obico::test(), Slic3r::OctoPrint::test(), Slic3r::PrusaLink::test(), Slic3r::Repetier::test(), Slic3r::UltiMaker::test(), Slic3r::PrusaLink::test_with_method_check(), Slic3r::AstroBox::upload(), Slic3r::C3DPrinterOS::upload(), Slic3r::CrealityPrint::upload(), Slic3r::Duet::upload(), Slic3r::ESP3D::upload(), Slic3r::FlashAir::upload(), Slic3r::MKS::upload(), Slic3r::Moonraker::upload(), Slic3r::Obico::upload(), Slic3r::Repetier::upload(), Slic3r::UltiMaker::upload(), Slic3r::OctoPrint::upload_inner_with_host(), Slic3r::Flashforge::upload_local_api(), Slic3r::ElegooLink::uploadPart(), and Slic3r::ElegooLink::uploadPartCC2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_err_code_from_body()

int Slic3r::PrintHost::get_err_code_from_body ( const std::string & body )

staticinherited

{
    boost::property_tree::ptree root;
    std::istringstream iss(body);
    try {
        boost::property_tree::read_json(iss, root);
    } catch (const std::exception &ex) {
        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
        return -1;
    }
 
    return root.get<int>("err", 0);
}

Referenced by Slic3r::Duet::connect(), Slic3r::UltiMaker::connect(), Slic3r::Duet::upload(), Slic3r::MKS::upload(), and Slic3r::UltiMaker::upload().

Here is the caller graph for this function:

get_groups()

virtual bool Slic3r::PrintHost::get_groups ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

get_host()

std::string Slic3r::CrealityPrint::get_host ( ) const

overridevirtual

Implements Slic3r::PrintHost.

                                        {
    return m_host;
}

References m_host.

get_login_url()

virtual bool Slic3r::PrintHost::get_login_url ( wxString & auth_url ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico.

{ return false; }

Referenced by Slic3r::GUI::PrinterCloudAuthDialog::PrinterCloudAuthDialog().

Here is the caller graph for this function:

get_name()

const char * Slic3r::CrealityPrint::get_name ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return "Creality Print"; }

Referenced by test(), and upload().

Here is the caller graph for this function:

get_post_upload_actions()

PrintHostPostUploadActions Slic3r::CrealityPrint::get_post_upload_actions ( ) const

overridevirtual

Implements Slic3r::PrintHost.

                                                                        {
    return PrintHostPostUploadAction::StartPrint; 
}

References Slic3r::StartPrint.

get_print_host()

PrintHost * Slic3r::PrintHost::get_print_host ( DynamicPrintConfig * config )

staticinherited

{
    PrinterTechnology tech = ptFFF;
 
    {
        const auto opt = config->option<ConfigOptionEnum<PrinterTechnology>>("printer_technology");
        if (opt != nullptr) {
            tech = opt->value;
        }
    }
 
    if (tech == ptFFF) {
        const auto opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        const auto host_type = opt != nullptr ? opt->value : htOctoPrint;
 
        switch (host_type) {
            case htOctoPrint: return new OctoPrint(config);
            case htDuet:      return new Duet(config);
            case htUltiMaker: return new UltiMaker(config);
            case htFlashAir:  return new FlashAir(config);
            case htAstroBox:  return new AstroBox(config);
            case htRepetier:  return new Repetier(config);
            case htPrusaLink: return new PrusaLink(config);
            case htPrusaConnect: return new PrusaConnect(config);
            case htMKS:       return new MKS(config);
            case htESP3D:       return new ESP3D(config);
            case htCrealityPrint:    return new CrealityPrint(config);
            case htObico:     return new Obico(config);
            case htFlashforge: return new Flashforge(config);
            case htSimplyPrint: return new SimplyPrint(config);
            case htElegooLink: return new ElegooLink(config);
            case ht3DPrinterOS: return new C3DPrinterOS(config);
            case htMoonraker: return new Moonraker(config);
            default:          return nullptr;
        }
    } else {
        return new SL1Host(config);
    }
}

References Slic3r::ht3DPrinterOS, Slic3r::htAstroBox, Slic3r::htCrealityPrint, Slic3r::htDuet, Slic3r::htElegooLink, Slic3r::htESP3D, Slic3r::htFlashAir, Slic3r::htFlashforge, Slic3r::htMKS, Slic3r::htMoonraker, Slic3r::htObico, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::htSimplyPrint, Slic3r::htUltiMaker, Slic3r::ConfigBase::option(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_get_sn_request(), Slic3r::GUI::anonymous_namespace{PrinterWebViewHandler.cpp}::ElegooPrinterWebViewHandler::handle_upload_request(), Slic3r::GUI::PhysicalPrinterDialog::update_printers(), and Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

get_print_host_webui()

std::string Slic3r::PrintHost::get_print_host_webui ( DynamicPrintConfig * config )

staticinherited

{
    if (config == nullptr)
        return {};
 
    std::string webui_url;
    const auto* host_type_opt = config->option<ConfigOptionEnum<PrintHostType>>("host_type");
    const auto  host_type     = host_type_opt != nullptr ? host_type_opt->value : htOctoPrint;
 
    switch (host_type) {
    case htElegooLink: {
        webui_url = ElegooLink::get_print_host_webui(config);
        break;
    }
    default: break;
    }
 
    if (webui_url.empty()) {
        webui_url = config->opt_string("print_host_webui");
        if (webui_url.empty())
            webui_url = config->opt_string("print_host");
        if (webui_url.empty())
            return webui_url;
    }
 
    const bool has_http_scheme = boost::algorithm::istarts_with(webui_url, "http");
    const bool has_file_scheme = boost::algorithm::istarts_with(webui_url, "file:");
 
    if (!has_http_scheme && !has_file_scheme)
        webui_url = "http://" + webui_url;
 
    return webui_url;
}

References Slic3r::ElegooLink::get_print_host_webui(), Slic3r::htElegooLink, Slic3r::htOctoPrint, Slic3r::DynamicConfig::opt_string(), Slic3r::ConfigBase::option(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by Slic3r::GUI::MainFrame::load_printer_url(), Slic3r::GUI::Plater::priv::on_tab_selection_changing(), and Slic3r::GUI::Sidebar::update_all_preset_comboboxes().

Here is the call graph for this function:

Here is the caller graph for this function:

get_printers()

virtual bool Slic3r::PrintHost::get_printers ( wxArrayString & ) const

inlinevirtualinherited

Reimplemented in Slic3r::Obico, and Slic3r::Repetier.

{ return false; }

get_sn()

virtual std::string Slic3r::PrintHost::get_sn ( ) const

inlinevirtualinherited

Get the serial number for connecting to the printer. For Elegoo CC2, the device details connection to the printer requires the serial number. Other print hosts do not need to implement this interface, and it returns an empty string by default.

Reimplemented in Slic3r::ElegooLink.

{ return ""; }

get_storage()

virtual bool Slic3r::PrintHost::get_storage ( wxArrayString & , wxArrayString &  ) const

inlinevirtualinherited

Reimplemented in Slic3r::Moonraker, Slic3r::PrusaConnect, and Slic3r::PrusaLink.

{ return false; }

get_test_failed_msg()

wxString Slic3r::CrealityPrint::get_test_failed_msg ( wxString & msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{
    return GUI::format_wxstr("%s: %s", _L("Could not connect to CrealityPrint"), msg.Truncate(256));
}

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

Here is the call graph for this function:

get_test_ok_msg()

wxString Slic3r::CrealityPrint::get_test_ok_msg ( ) const

overridevirtual

Implements Slic3r::PrintHost.

{ return _(L("Connected to CrealityPrint successfully!")); }

References _, and L.

has_auto_discovery()

bool Slic3r::CrealityPrint::has_auto_discovery ( ) const

inlineoverridevirtual

Implements Slic3r::PrintHost.

{ return true; }

is_cloud()

virtual bool Slic3r::PrintHost::is_cloud ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, Slic3r::Obico, and Slic3r::SimplyPrint.

{ return false; }

is_logged_in()

virtual bool Slic3r::PrintHost::is_logged_in ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{ return false; }

log_out()

virtual void Slic3r::PrintHost::log_out ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::C3DPrinterOS, and Slic3r::SimplyPrint.

{}

make_url()

std::string Slic3r::CrealityPrint::make_url ( const std::string & path ) const

private

{
    if (m_host.find("http://") == 0 || m_host.find("https://") == 0) {
        if (m_host.back() == '/') {
            return (boost::format("%1%%2%") % m_host % path).str();
        } else {
            return (boost::format("%1%/%2%") % m_host % path).str();
        }
    } else {
        return (boost::format("http://%1%/%2%") % m_host % path).str();
    }
}

References m_host.

Referenced by test(), and upload().

Here is the caller graph for this function:

model_display_name()

std::string Slic3r::CrealityPrint::model_display_name ( const std::string & model )

static

{
    auto& names = cfs_capable_models();
    auto it = names.find(model);
    return it != names.end() ? it->second : std::string{};
}

References Slic3r::cfs_capable_models().

Referenced by model_name(), and Slic3r::anonymous_namespace{CrealityHostDiscovery.cpp}::model_name_for().

Here is the call graph for this function:

Here is the caller graph for this function:

model_name()

std::string Slic3r::CrealityPrint::model_name

(

)

const

{
    query_model();
    if (m_model.empty())
        return "unreachable";
    std::string name = model_display_name(m_model);
    return !name.empty() ? name : "unknown (" + m_model + ")";
}

References m_model, model_display_name(), and query_model().

Referenced by Slic3r::CrealityPrintAgent::fetch_filament_info().

Here is the call graph for this function:

Here is the caller graph for this function:

model_supports_multi_color()

bool Slic3r::CrealityPrint::model_supports_multi_color ( const std::string & model )

static

{
    return cfs_capable_models().count(model) > 0;
}

References Slic3r::cfs_capable_models().

Referenced by Slic3r::anonymous_namespace{CrealityHostDiscovery.cpp}::is_cfs_capable(), and supports_multi_color_print().

Here is the call graph for this function:

Here is the caller graph for this function:

query_boxes_info()

std::string Slic3r::CrealityPrint::query_boxes_info

(

)

const

{
    try {
        net::io_context ioc;
        websocket::stream<beast::tcp_stream> ws{ioc};
        ws_connect(ioc, ws, m_host, ws_settings.port, ws_settings.connect);
 
        beast::get_lowest_layer(ws).expires_after(ws_settings.reply);
        json boxs_query = {{"method", "get"}, {"params", {{"boxsInfo", 1}}}};
        std::string result = ws_send_and_read(ioc, ws, boxs_query, "boxsInfo");
 
        ws_close(ioc, ws, ws_settings.close);
        return result;
    } catch (std::exception const& e) {
        BOOST_LOG_TRIVIAL(error) << "CrealityPrint: Failed to query boxsInfo: " << e.what();
        return {};
    }
}

References m_host, Slic3r::ws_close(), Slic3r::ws_connect(), Slic3r::ws_send_and_read(), and ws_settings.

Referenced by Slic3r::CrealityPrintAgent::fetch_filament_info().

Here is the call graph for this function:

Here is the caller graph for this function:

query_model()

void Slic3r::CrealityPrint::query_model ( ) const

private

{
    if (!m_model.empty())
        return;
 
    wxString msg;
    test(msg);
}

References m_model, and test().

Referenced by model_name(), and supports_multi_color_print().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_filename()

std::string Slic3r::CrealityPrint::safe_filename ( const std::string & filename ) const

private

{
    std::string safe_filename = filename;
    std::replace(safe_filename.begin(), safe_filename.end(), ' ', '_');
 
    return safe_filename;
}

References safe_filename().

Referenced by safe_filename(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

set_auth()

void Slic3r::CrealityPrint::set_auth ( Http & http ) const

protectedvirtual

{
    http.header("Authorization", "Bearer " + m_apikey);
    if (!m_cafile.empty()) {
        http.ca_file(m_cafile);
    }
}

References Slic3r::http, m_apikey, and m_cafile.

Referenced by test(), and upload().

Here is the caller graph for this function:

start_print()

bool Slic3r::CrealityPrint::start_print ( wxString & msg, const std::string & filename, const std::map< std::string, std::string > & extended_info ) const

private

{
    try {
        const std::string data_root = is_k1_family(m_model) ? "/usr/data" : "/mnt/UDISK";
        const std::string gcode_path = data_root + "/printer_data/gcodes/" + filename;
 
        net::io_context ioc;
        websocket::stream<beast::tcp_stream> ws{ioc};
        ws_connect(ioc, ws, m_host, ws_settings.port, ws_settings.connect);
 
        // Runs before the reply deadline starts, since it can query the printer over HTTP.
        const bool multi_color = supports_multi_color_print();
        beast::get_lowest_layer(ws).expires_after(ws_settings.reply);
        if (multi_color) {
            // Build colorMatch list from the mapping provided by the dialog
            bool use_spool_holder = false;
            json color_list = json::array();
            for (int i = 0; ; i++) {
                auto it = extended_info.find("colorMatch_" + std::to_string(i));
                if (it == extended_info.end())
                    break;
                // Value format: "toolId\ttype\tcolor\tboxId\tmaterialId"
                auto val = it->second;
                std::vector<std::string> parts;
                std::istringstream iss(val);
                std::string part;
                while (std::getline(iss, part, '\t'))
                    parts.push_back(part);
                if (parts.size() >= 5) {
                    int box_id = std::stoi(parts[3]);
                    if (box_id == 0)
                        use_spool_holder = true;
                    color_list.push_back({
                        {"id", parts[0]},
                        {"type", parts[1]},
                        {"color", parts[2]},
                        {"boxId", box_id},
                        {"materialId", std::stoi(parts[4])}
                    });
                }
            }
 
            int enable_self_test = 0;
            {
                auto it = extended_info.find("enableSelfTest");
                if (it != extended_info.end())
                    enable_self_test = std::stoi(it->second);
            }
 
            if (use_spool_holder) {
                json cmd = {
                    {"method", "set"},
                    {"params", {
                        {"opGcodeFile", "printprt:" + gcode_path},
                        {"enableSelfTest", enable_self_test}
                    }}
                };
                ws_send(ioc, ws, cmd);
            } else {
                json color_match = {
                    {"method", "set"},
                    {"params", {
                        {"colorMatch", {
                            {"path", gcode_path},
                            {"list", color_list}
                        }}
                    }}
                };
                ws_send(ioc, ws, color_match);
 
                json multi_color_print = {
                    {"method", "set"},
                    {"params", {
                        {"multiColorPrint", {
                            {"gcode", gcode_path},
                            {"enableSelfTest", enable_self_test}
                        }}
                    }}
                };
                ws_send(ioc, ws, multi_color_print);
            }
        } else {
            json cmd = {
                {"method", "set"},
                {"params", {
                    {"opGcodeFile", "printprt:" + gcode_path}
                }}
            };
            ws_send(ioc, ws, cmd);
 
            // K1-family firmware closes the WebSocket right after accepting the
            // start command, so a blocking read here surfaces a benign
            // "End of file [asio.misc:2]" even though the print already started
            // (ws_send() delivers the command). Read best-effort, ignore errors.
            beast::flat_buffer buffer;
            ws_read(ioc, ws, buffer);
        }
 
        ws_close(ioc, ws, ws_settings.close);
        return true;
    } catch(std::exception const& e) {
        BOOST_LOG_TRIVIAL(error) << "CrealityPrint: Error starting print: " << e.what();
        // Shows a websocket error without Boost's source location, and a timeout the same way as an HTTP one
        if (const auto* system_error = dynamic_cast<const beast::system_error*>(&e))
            msg = system_error->code() == beast::error::timeout ? timed_out_message() : wxString::FromUTF8(system_error->code().message());
        else
            msg = wxString::FromUTF8(e.what());
        return false;
    }
}

References Slic3r::is_k1_family(), m_host, m_model, supports_multi_color_print(), Slic3r::PrintHost::timed_out_message(), Slic3r::ws_close(), Slic3r::ws_connect(), Slic3r::ws_read(), Slic3r::ws_send(), and ws_settings.

Referenced by upload().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multi_color_print()

bool Slic3r::CrealityPrint::supports_multi_color_print

(

)

const

{
    query_model();
    return model_supports_multi_color(m_model);
}

References m_model, model_supports_multi_color(), and query_model().

Referenced by Slic3r::CrealityPrintAgent::fetch_filament_info(), start_print(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

supports_multiple_printers()

virtual bool Slic3r::PrintHost::supports_multiple_printers ( ) const

inlinevirtualinherited

Reimplemented in Slic3r::Repetier.

{ return false; }

test()

bool Slic3r::CrealityPrint::test ( wxString & curl_msg ) const

overridevirtual

Implements Slic3r::PrintHost.

{ 
    bool res = true;
    const char* name = get_name();
    auto url = make_url("info");
 
    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Get version at: %2%") % name % url;
    // Here we do not have to add custom "Host" header - the url contains host filled by user and libCurl will set the header by itself.
    auto http = Http::get(std::move(url));
    set_auth(http);
    http.timeout_max(5)
        .on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error getting version: %2%, HTTP %3%, body: `%4%`") % name % error % status %
                                            body;
            res = false;
            msg = format_error(body, error, status);
        })
        .on_complete([&, this](std::string body, unsigned) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: Got version: %2%") % name % body;
            try {
                auto info = json::parse(body);
                if (info.contains("model")) {
                    m_model = info["model"].get<std::string>();
                    BOOST_LOG_TRIVIAL(info) << boost::format("%1%: Detected model: %2%") % name % m_model;
                }
            } catch (const json::exception& e) {
                BOOST_LOG_TRIVIAL(warning) << boost::format("%1%: Failed to parse /info response: %2%") % name % e.what();
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
        .on_ip_resolve([&](std::string address) {
            // Workaround for Windows 10/11 mDNS resolve issue, where two mDNS resolves in succession fail.
            // Remember resolved address to be reused at successive REST API call.
            msg = GUI::from_u8(address);
        })
#endif // WIN32
        .perform_sync();
 
    return res;
}

References Slic3r::PrintHost::format_error(), Slic3r::GUI::from_u8(), Slic3r::Http::get(), get_name(), Slic3r::http, m_model, m_ssl_revoke_best_effort, make_url(), and set_auth().

Referenced by query_model(), and upload().

Here is the call graph for this function:

Here is the caller graph for this function:

timed_out_message()

wxString Slic3r::PrintHost::timed_out_message ( )

staticprotectedinherited

{
    return _L("Connection timed out. Please check if the printer and computer network are functioning properly, and confirm that they are on the same network.");
}

References _L.

Referenced by format_error(), and Slic3r::CrealityPrint::start_print().

Here is the caller graph for this function:

upload()

bool Slic3r::CrealityPrint::upload ( PrintHostUpload upload_data, ProgressFn prorgess_fn, ErrorFn error_fn, InfoFn info_fn ) const

overridevirtual

Implements Slic3r::PrintHost.

{   
    const char* name = get_name();
    const auto upload_filename = upload_data.upload_path.filename();
    const auto upload_parent_path = upload_data.upload_path.parent_path();
    wxString test_msg;
    if (!test(test_msg)) {
        error_fn(std::move(test_msg));
        return false;
    }
 
    bool res = true;
    const auto safe_upload_filename = safe_filename(upload_filename.string());
    // Only encode the URL path segment; keep the multipart filename and start-print path as the stored filename.
    auto url = make_url("upload/" + Http::url_encode(safe_upload_filename));
 
    auto  http = Http::post(url); // std::move(url));
    set_auth(http);
    if (!supports_multi_color_print())
        http.form_add("path", upload_parent_path.string());
    http.form_add_file("file", upload_data.source_path.string(), safe_upload_filename)
 
        .on_complete([&](std::string body, unsigned status) {
            BOOST_LOG_TRIVIAL(debug) << boost::format("%1%: File uploaded: HTTP %2%: %3%") % name % status % body;
 
            if (upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
                wxString errormsg;
                if (!start_print(errormsg, safe_upload_filename, upload_data.extended_info)) {
                    error_fn(std::move(errormsg));
                    res = false;
                }
            }
        })
        .on_error([&](std::string body, std::string error, unsigned status) {
            BOOST_LOG_TRIVIAL(error) << boost::format("%1%: Error uploading file to %2%: %3%, HTTP %4%, body: `%5%`") % name % url % error %
                                            status % body;
            error_fn(format_error(body, error, status));
            res = false;
        })
        .on_progress([&](Http::Progress progress, bool& cancel) {
            prorgess_fn(std::move(progress), cancel);
            if (cancel) {
                // Upload was canceled
                BOOST_LOG_TRIVIAL(info) << name << ": Upload canceled";
                res = false;
            }
        })
#ifdef WIN32
        .ssl_revoke_best_effort(m_ssl_revoke_best_effort)
#endif
        .perform_sync();
    return res;
}

References Slic3r::PrintHostUpload::extended_info, Slic3r::PrintHost::format_error(), get_name(), Slic3r::http, m_ssl_revoke_best_effort, make_url(), Slic3r::Http::post(), Slic3r::PrintHostUpload::post_action, safe_filename(), set_auth(), Slic3r::PrintHostUpload::source_path, start_print(), Slic3r::StartPrint, supports_multi_color_print(), test(), Slic3r::PrintHostUpload::upload_path, and Slic3r::Http::url_encode().

Here is the call graph for this function:

Member Data Documentation

m_apikey

std::string Slic3r::CrealityPrint::m_apikey

private

Referenced by CrealityPrint(), and set_auth().

m_cafile

std::string Slic3r::CrealityPrint::m_cafile

private

Referenced by CrealityPrint(), and set_auth().

m_host

std::string Slic3r::CrealityPrint::m_host

private

Referenced by CrealityPrint(), get_host(), make_url(), query_boxes_info(), and start_print().

m_model

std::string Slic3r::CrealityPrint::m_model

mutableprivate

Referenced by model_name(), query_model(), start_print(), supports_multi_color_print(), and test().

m_port

std::string Slic3r::CrealityPrint::m_port

private

Referenced by CrealityPrint().

m_ssl_revoke_best_effort

bool Slic3r::CrealityPrint::m_ssl_revoke_best_effort

private

Referenced by CrealityPrint(), test(), and upload().

m_web_ui

std::string Slic3r::CrealityPrint::m_web_ui

private

Referenced by CrealityPrint().

ws_settings

struct Slic3r::CrealityPrint::WsSettings Slic3r::CrealityPrint::ws_settings

protected

Referenced by query_boxes_info(), and start_print().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CrealityPrint.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/CrealityPrint.cpp