Slic3r::GUI::PhysicalPrinterDialog Class Reference

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

Inheritance diagram for Slic3r::GUI::PhysicalPrinterDialog:

Collaboration diagram for Slic3r::GUI::PhysicalPrinterDialog:

Public Types
enum	ValidationType { Valid , NoValid , Warning }

Public Member Functions
	PhysicalPrinterDialog (wxWindow *parent)
	~PhysicalPrinterDialog ()
void	update (bool printer_change=false)
void	update_host_type (bool printer_change)
void	update_preset_input ()
void	update_printhost_buttons ()
void	update_printers ()
void	update_ports ()
void	update_webui ()
void	EndModal (int retCode) override
float	scale_factor () const
float	prev_scale_factor () const
void	set_scale_factor (float v)
void	set_prev_scale_factor (float v)
void	set_em_unit (int v)
bool	force_rescale () const
int	em_unit () const
const wxFont &	normal_font () const
void	enable_force_rescale ()
int	ShowModal ()

Public Attributes
PresetCollection *	m_presets {nullptr}
ValidationType	m_valid_type
std::string	m_preset_name

Protected Member Functions
void	on_dpi_changed (const wxRect &suggested_rect) override
void	on_sys_color_changed () override
void	check_host_key_valid ()

Private Member Functions
void	build_printhost_settings (ConfigOptionsGroup *optgroup)
void	OnOK (wxEvent &event)
void	update_em_unit ()
bool	is_new_scale_factor () const
void	rescale (const wxRect &suggested_rect)

Private Attributes
DynamicPrintConfig *	m_config { nullptr }
ConfigOptionsGroup *	m_optgroup { nullptr }
Button *	m_printhost_browse_btn {nullptr}
Button *	m_printhost_test_btn {nullptr}
Button *	m_printhost_generate_creds_btn {nullptr}
Button *	m_printhost_logout_btn {nullptr}
Button *	m_printhost_cafile_browse_btn {nullptr}
Button *	m_printhost_port_browse_btn {nullptr}
RoundedRectangle *	m_input_area {nullptr}
wxStaticText *	m_valid_label {nullptr}
wxTextCtrl *	m_input_ctrl {nullptr}
Button *	btnOK {nullptr}
float	m_scale_factor
int	m_em_unit
wxFont	m_normal_font
float	m_prev_scale_factor
bool	m_can_rescale
bool	m_force_rescale
int	m_new_font_point_size

Detailed Description

Member Enumeration Documentation

ValidationType

enum Slic3r::GUI::PhysicalPrinterDialog::ValidationType

Enumerator
Valid
NoValid
Warning

    {
        Valid,
        NoValid,
        Warning
    };

Constructor & Destructor Documentation

PhysicalPrinterDialog()

Slic3r::GUI::PhysicalPrinterDialog::PhysicalPrinterDialog

(

wxWindow *

parent

)

                                                             :
    DPIDialog(parent, wxID_ANY, _L("Physical Printer"), wxDefaultPosition, wxSize(45 * wxGetApp().em_unit(), -1), wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
{
    SetFont(wxGetApp().normal_font());
    SetBackgroundColour(*wxWHITE);
 
    // input the preset name
    Tab *tab = wxGetApp().get_tab(Preset::TYPE_PRINTER);
    m_presets = tab->get_presets();
    const Preset &sel_preset  = m_presets->get_selected_preset();
    std::string suffix = _u8L_CONTEXT(L_CONTEXT("Copy", "PresetName"), "PresetName");
    std::string   preset_name = sel_preset.is_default ? _u8L("Untitled") : sel_preset.is_system ? (boost::format(("%1% - %2%")) % sel_preset.name % suffix).str() : sel_preset.name;
 
    auto input_sizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText *label_top = new wxStaticText(this, wxID_ANY, from_u8((boost::format(_utf8(L("Save %s as"))) % into_u8(tab->title())).str()));
    label_top->SetFont(::Label::Body_14);
    label_top->SetForegroundColour(wxColour(38,46,48));
 
    m_input_area = new RoundedRectangle(this, StateColor::darkModeColorFor(wxColour("#DBDBDB")), wxDefaultPosition, wxSize(-1,-1), 3, 1);
    m_input_area->SetMinSize(wxSize(FromDIP(360), FromDIP(32)));
 
    wxBoxSizer *input_sizer_h = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer *input_sizer_v  = new wxBoxSizer(wxVERTICAL);
 
    m_input_ctrl = new wxTextCtrl(m_input_area, -1, from_u8(preset_name), wxDefaultPosition, wxSize(wxSize(FromDIP(360), FromDIP(32)).x, -1), 0 | wxBORDER_NONE);
    m_input_ctrl->SetBackgroundColour(wxColour(255, 255, 255));
    m_input_ctrl->Bind(wxEVT_TEXT, [this](wxCommandEvent &) { update(); });
 
 
    input_sizer_v->Add(m_input_ctrl, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, 12);
    input_sizer_h->Add(input_sizer_v, 0, wxALIGN_CENTER, 0);
 
    m_input_area->SetSizer(input_sizer_h);
    m_input_area->Layout();
 
    m_valid_label = new wxStaticText(this, wxID_ANY, "");
    m_valid_label->SetForegroundColour(wxColor(255, 111, 0));
 
    input_sizer->Add(label_top, 0, wxEXPAND | wxLEFT, BORDER_W);
    input_sizer->Add(m_input_area, 0, wxEXPAND | wxTOP, BORDER_W);
    input_sizer->Add(m_valid_label, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, BORDER_W);
 
 
    m_config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
    m_optgroup = new ConfigOptionsGroup(this, _L("Print Host upload"), m_config);
    check_host_key_valid();
    build_printhost_settings(m_optgroup);
 
    auto dlg_btns = new DialogButtons(this, {"OK"});
 
    btnOK = dlg_btns->GetOK();
    btnOK->Bind(wxEVT_BUTTON, &PhysicalPrinterDialog::OnOK, this);
 
    wxBoxSizer* topSizer = new wxBoxSizer(wxVERTICAL);
 
    // topSizer->Add(label_top           , 0, wxEXPAND | wxLEFT | wxTOP | wxRIGHT, BORDER_W);
    topSizer->Add(input_sizer         , 0, wxEXPAND | wxALL, BORDER_W);
    topSizer->Add(m_optgroup->sizer   , 1, wxEXPAND | wxLEFT | wxTOP | wxRIGHT, BORDER_W);
    topSizer->Add(dlg_btns, 0, wxEXPAND);
 
    Bind(wxEVT_CLOSE_WINDOW, [this](auto& e) {this->EndModal(wxID_NO);});
 
    SetSizer(topSizer);
    topSizer->SetSizeHints(this);
    this->CenterOnParent();
    wxGetApp().UpdateDlgDarkUI(this);
}

References _L, _u8L, _u8L_CONTEXT, _utf8, Label::Body_14, BORDER_W, btnOK, build_printhost_settings(), check_host_key_valid(), StateColor::darkModeColorFor(), Slic3r::GUI::DPIAware< wxDialog >::em_unit(), Slic3r::GUI::DPIDialog::EndModal(), Slic3r::GUI::from_u8(), Slic3r::GUI::Tab::get_presets(), Slic3r::GUI::into_u8(), Slic3r::Preset::is_default, Slic3r::Preset::is_system, L, L_CONTEXT, m_config, m_input_area, m_input_ctrl, m_optgroup, m_presets, m_valid_label, Slic3r::Preset::name, Slic3r::GUI::DPIAware< wxDialog >::normal_font(), OnOK(), Slic3r::GUI::Tab::title(), Slic3r::Preset::TYPE_PRINTER, update(), and wxStaticText.

Here is the call graph for this function:

~PhysicalPrinterDialog()

Slic3r::GUI::PhysicalPrinterDialog::~PhysicalPrinterDialog

(

)

{
}

Member Function Documentation

build_printhost_settings()

void Slic3r::GUI::PhysicalPrinterDialog::build_printhost_settings ( ConfigOptionsGroup * optgroup )

private

{
    m_optgroup->m_on_change = [this](t_config_option_key opt_key, boost::any value) {
        if (opt_key == "host_type" || opt_key == "printhost_authorization_type")
            this->update();
        if (opt_key == "print_host")
            this->update_printhost_buttons();
        if (opt_key == "printhost_port")
            this->update_ports();
        if (opt_key == "bbl_use_print_host_webui")
            this->update_webui();
    };
 
    m_optgroup->append_single_option_line("host_type");
 
    auto create_sizer_with_btn = [](wxWindow* parent, Button** btn, const std::string& icon_name, const wxString& label) {
        *btn = new Button(parent, label);
        (*btn)->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
 
        auto sizer = new wxBoxSizer(wxHORIZONTAL);
        sizer->Add(*btn);
        return sizer;
    };
 
    auto printhost_browse = [=](wxWindow* parent)
    {
        auto sizer = create_sizer_with_btn(parent, &m_printhost_browse_btn, "printer_host_browser", _L("Browse") + " " + dots);
        m_printhost_browse_btn->Bind(wxEVT_BUTTON, [=](wxCommandEvent& e) {
            const auto host_type = m_config->opt_enum<PrintHostType>("host_type");
 
            // Creality K-series printers announce themselves via DNS-SD under a
            // per-device-unique service type _Creality-<MAC-hex>._udp, so the
            // standard fixed-service-name Bonjour browser does not find them.
            // Dispatch to the Creality-specific scanner instead.
            if (host_type == htCrealityPrint) {
                CrealityDiscoveryDialog dialog(this);
                if (dialog.ShowModal() == wxID_OK && !dialog.selected_ip().empty()) {
                    // set_value expects the value wrapped as wxString -- TextCtrl::set_value
                    // any_casts to wxString, so a raw std::string throws bad_any_cast.
                    wxString new_url = wxString::FromUTF8("http://" + dialog.selected_ip());
                    m_optgroup->set_value("print_host", new_url, true);
                    m_optgroup->get_field("print_host")->field_changed();
                }
                return;
            }
 
            if (host_type == htFlashforge) {
                wxBusyCursor                            wait;
                std::vector<FlashforgeDiscoveredPrinter> printers;
                wxString                               error_msg;
                if (!Flashforge::discover_printers(printers, error_msg)) {
                    show_error(this, error_msg);
                    return;
                }
 
                wxArrayString choices;
                for (const auto& printer : printers)
                    choices.Add(from_u8((boost::format("%1% (%2%) [%3%]") % printer.name % printer.ip_address % printer.serial_number).str()));
 
                wxSingleChoiceDialog dialog(this, _L("Select a Flashforge printer"), _L("Discovered Printers"), choices);
                if (dialog.ShowModal() == wxID_OK) {
                    const int idx = dialog.GetSelection();
                    if (idx >= 0 && idx < static_cast<int>(printers.size())) {
                        m_optgroup->set_value("print_host", from_u8(printers[idx].ip_address), true);
                        m_optgroup->set_value("flashforge_serial_number", from_u8(printers[idx].serial_number), true);
                        m_config->opt_string("print_host")                = printers[idx].ip_address;
                        m_config->opt_string("flashforge_serial_number") = printers[idx].serial_number;
                        update_printhost_buttons();
                    }
                }
                return;
            }
 
            BonjourDialog dialog(this, Preset::printer_technology(*m_config));
            if (dialog.show_and_lookup()) {
                m_optgroup->set_value("print_host", dialog.get_selected(), true);
                m_optgroup->get_field("print_host")->field_changed();
            }
        });
 
        return sizer;
    };
 
    auto print_host_test = [=](wxWindow* parent) {
        auto sizer = create_sizer_with_btn(parent, &m_printhost_test_btn, "printer_host_test", _L("Test"));
 
        m_printhost_test_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
            std::unique_ptr<PrintHost> host(PrintHost::get_print_host(m_config));
            if (!host) {
                const wxString text = _L("Could not get a valid Printer Host reference");
                show_error(this, text);
                return;
            }
 
            wxString msg;
            bool result;
            {
                // Show a wait cursor during the connection test, as it is blocking UI.
                wxBusyCursor wait;
                result = host->test(msg);
 
                if (!result && host->is_cloud()) {
                    if (const auto h = dynamic_cast<SimplyPrint*>(host.get()); h) {
                        OAuthDialog dlg(this, h->get_oauth_params());
                        dlg.ShowModal();
 
                        const auto& r = dlg.get_result();
                        result = r.success;
                        if (r.success) {
                            h->save_oauth_credential(r);
                        } else {
                            msg = r.error_message;
                        }
                    } else if (const auto h = dynamic_cast<C3DPrinterOS*>(host.get()); h) {
                        GUI::MessageDialog dlg(this, _L("Valid session not detected. Proceed with login to 3DPrinterOS?"), _L("Proceed"),
                                               wxICON_INFORMATION | wxYES | wxNO);
                        if (dlg.ShowModal() == wxID_YES) {
                            result = h->login(msg);
                        }
                    } else {
                        PrinterCloudAuthDialog dlg(this->GetParent(), host.get());
                        dlg.ShowModal();
                        
                        const auto api_key = dlg.GetApiKey();
                        m_config->opt_string("printhost_apikey") = api_key;
                        result       = !api_key.empty();
                    }
                }
            }
            if (result)
                show_info(this, host->get_test_ok_msg(), _L("Success!"));
            else
                show_error(this, host->get_test_failed_msg(msg));
 
            update();
            });
 
        return sizer;
    };
 
 
    auto ultimaker_generate_creds = [=](wxWindow* parent) {
        auto sizer = create_sizer_with_btn(parent, &m_printhost_generate_creds_btn, "ultimaker_generate_creds", _L("Generate API Key"));
 
        m_printhost_generate_creds_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
            std::unique_ptr<PrintHost> host(PrintHost::get_print_host(m_config));
            if (!host) {
                const wxString text = _L("Could not get a valid Printer Host reference");
                show_error(this, text);
                return;
            }
 
            wxString msg = "generate_auth_creds";
            bool result;
            {
                // Show a wait cursor during the connection test, as it is blocking UI.
                wxBusyCursor wait;
                // Send request to printer for api key and such
                result = host->test(msg); // using test with special input because I don't want to create the generate_auth_creds func for every printer
 
                // Prompt user to approve access on the machine.
                show_info(this, _L("API Key created. Go to the physical printer and hit \"authorize\" on the screen, then run \"Test\" again.") + "\n" + msg, _L("API Key created."));
                
                
            }
            if (result)
                show_info(this, host->get_test_ok_msg(), _L("Success!"));
            else
                show_error(this, host->get_test_failed_msg(msg));
 
            update();
            });
 
        return sizer;
    };
 
 
    auto print_host_logout = [&](wxWindow* parent) {
        auto sizer = create_sizer_with_btn(parent, &m_printhost_logout_btn, "", _L("Log Out"));
 
        m_printhost_logout_btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent& e) {
            std::unique_ptr<PrintHost> host(PrintHost::get_print_host(m_config));
            if (!host) {
                const wxString text = _L("Could not get a valid Printer Host reference");
                show_error(this, text);
                return;
            }
 
            wxString msg_text = _L("Are you sure to log out?");
            MessageDialog dialog(this, msg_text, "", wxICON_QUESTION | wxYES_NO);
 
            if (dialog.ShowModal() == wxID_YES) {
                host->log_out();
                update();
            }
        });
 
        return sizer;
    };
 
    auto print_host_printers = [this, create_sizer_with_btn](wxWindow* parent) {
        //add_scaled_button(parent, &m_printhost_port_browse_btn, "browse", _(L("Refresh Printers")), wxBU_LEFT | wxBU_EXACTFIT);
        auto sizer = create_sizer_with_btn(parent, &m_printhost_port_browse_btn, "monitor_signal_strong", _L("Refresh") + " " + dots);
        Button* btn = m_printhost_port_browse_btn;
        btn->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
        btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent e) { update_printers(); });
        return sizer;
    };
 
    // Set a wider width for a better alignment
    Option option = m_optgroup->get_option("print_host");
    option.opt.width = Field::def_width_wider();
    Line host_line = m_optgroup->create_single_option_line(option);
    host_line.append_widget(printhost_browse);
    host_line.append_widget(print_host_test);
    host_line.append_widget(ultimaker_generate_creds);
    host_line.append_widget(print_host_logout);
    m_optgroup->append_line(host_line);
 
    option = m_optgroup->get_option("print_host_webui");
    option.opt.width = Field::def_width_wider();
    m_optgroup->append_single_option_line(option);
 
    {
        // For bbl printers, we build a fake option to control whether the original device tab should be used
        ConfigOptionDef def;
        def.type     = coBool;
        def.width    = Field::def_width_wider();
        def.label    = L("View print host webui in Device tab");
        def.tooltip  = L("Replace the BambuLab's device tab with print host webui");
        def.set_default_value(new ConfigOptionBool(false));
 
        auto option = Option(def, "bbl_use_print_host_webui");
        m_optgroup->append_single_option_line(option);
    }
 
    m_optgroup->append_single_option_line("printhost_authorization_type");
 
    option = m_optgroup->get_option("printhost_apikey");
    option.opt.width = Field::def_width_wider();
    m_optgroup->append_single_option_line(option);
 
    option = m_optgroup->get_option("flashforge_serial_number");
    option.opt.width = Field::def_width_wider();
    m_optgroup->append_single_option_line(option);
 
    option = m_optgroup->get_option("printhost_port");
    option.opt.width = Field::def_width_wider();
    Line port_line = m_optgroup->create_single_option_line(option);
    port_line.append_widget(print_host_printers);
    m_optgroup->append_line(port_line);
 
    const auto ca_file_hint = _u8L("HTTPS CA file is optional. It is only needed if you use HTTPS with a self-signed certificate.");
 
    if (Http::ca_file_supported()) {
        option = m_optgroup->get_option("printhost_cafile");
        option.opt.width = Field::def_width_wider();
        Line cafile_line = m_optgroup->create_single_option_line(option);
 
        auto printhost_cafile_browse = [=](wxWindow* parent) {
            auto sizer = create_sizer_with_btn(parent, &m_printhost_cafile_browse_btn, "monitor_signal_strong", _L("Browse") + " " + dots);
            m_printhost_cafile_browse_btn->Bind(wxEVT_BUTTON, [this, m_optgroup](wxCommandEvent e) {
                static const auto filemasks = _L("Certificate files (*.crt, *.pem)|*.crt;*.pem|All files|*.*");
                wxFileDialog openFileDialog(this, _L("Open CA certificate file"), "", "", filemasks, wxFD_OPEN | wxFD_FILE_MUST_EXIST);
                if (openFileDialog.ShowModal() != wxID_CANCEL) {
                    m_optgroup->set_value("printhost_cafile", openFileDialog.GetPath(), true);
                    m_optgroup->get_field("printhost_cafile")->field_changed();
                }
                });
 
            return sizer;
        };
 
        cafile_line.append_widget(printhost_cafile_browse);
        m_optgroup->append_line(cafile_line);
 
        Line cafile_hint{ "", "" };
        cafile_hint.full_width = 1;
        cafile_hint.widget = [ca_file_hint](wxWindow* parent) {
            auto txt = new wxStaticText(parent, wxID_ANY, from_u8(ca_file_hint));
            auto sizer = new wxBoxSizer(wxHORIZONTAL);
            sizer->Add(txt);
            return sizer;
        };
        m_optgroup->append_line(cafile_hint);
    }
    else {
        
        Line line{ "", "" };
        line.full_width = 1;
 
        line.widget = [ca_file_hint](wxWindow* parent) {
            std::string info = _u8L("HTTPS CA File") + ":\n\t" +
                (boost::format(_u8L("On this system, %s uses HTTPS certificates from the system Certificate Store or Keychain.")) % SLIC3R_APP_NAME).str() +
                "\n\t" + _u8L("To use a custom CA file, please import your CA file into Certificate Store / Keychain.");
 
            //auto txt = new wxStaticText(parent, wxID_ANY, from_u8((boost::format("%1%\n\n\t%2%") % info % ca_file_hint).str()));
            auto txt = new wxStaticText(parent, wxID_ANY, from_u8((boost::format("%1%\n\t%2%") % info % ca_file_hint).str()));
            txt->SetFont(wxGetApp().normal_font());
            auto sizer = new wxBoxSizer(wxHORIZONTAL);
            sizer->Add(txt, 1, wxEXPAND);
            return sizer;
        };
        m_optgroup->append_line(line);
    }
 
    for (const std::string& opt_key : std::vector<std::string>{ "printhost_user", "printhost_password" }) {        
        option = m_optgroup->get_option(opt_key);
        option.opt.width = Field::def_width_wider();
        m_optgroup->append_single_option_line(option);
    }
 
#ifdef WIN32
    option = m_optgroup->get_option("printhost_ssl_ignore_revoke");
    option.opt.width = Field::def_width_wider();
    m_optgroup->append_single_option_line(option);
#endif
 
    m_optgroup->activate();
 
    Field* printhost_field = m_optgroup->get_field("print_host");
    if (printhost_field)
    {
        wxTextCtrl* temp = dynamic_cast<wxTextCtrl*>(printhost_field->getWindow());
        if (temp)
            temp->Bind(wxEVT_TEXT, ([printhost_field, temp](wxEvent& e)
            {
#ifndef __WXGTK__
                e.Skip();
                temp->GetToolTip()->Enable(true);
#endif // __WXGTK__
                // Remove all leading and trailing spaces from the input
                std::string trimed_str, str = trimed_str = temp->GetValue().ToStdString();
                boost::trim(trimed_str);
                if (trimed_str != str)
                    temp->SetValue(trimed_str);
 
                TextCtrl* field = dynamic_cast<TextCtrl*>(printhost_field);
                if (field)
                    field->propagate_value();
            }), temp->GetId());
    }
 
    // Always fill in the "printhost_port" combo box from the config and select it.
    {
        Choice* choice = dynamic_cast<Choice*>(m_optgroup->get_field("printhost_port"));
        choice->set_values(std::vector<std::string>{ m_config->opt_string("printhost_port") });
        choice->set_selection();
    }
 
    update();
}

References _L, _u8L, Slic3r::GUI::ConfigOptionsGroup::append_single_option_line(), Slic3r::GUI::Line::append_widget(), Slic3r::Http::ca_file_supported(), Slic3r::coBool, Slic3r::GUI::Field::def_width_wider(), Slic3r::Flashforge::discover_printers(), Slic3r::GUI::dots(), Slic3r::GUI::from_u8(), Slic3r::GUI::Line::full_width, Slic3r::PrintHost::get_print_host(), Slic3r::GUI::OAuthDialog::get_result(), Slic3r::BonjourDialog::get_selected(), Slic3r::GUI::PrinterCloudAuthDialog::GetApiKey(), Slic3r::GUI::Field::getWindow(), Slic3r::htCrealityPrint, Slic3r::htFlashforge, L, Slic3r::ConfigOptionDef::label, m_config, m_optgroup, m_printhost_browse_btn, m_printhost_cafile_browse_btn, m_printhost_generate_creds_btn, m_printhost_logout_btn, m_printhost_port_browse_btn, m_printhost_test_btn, Slic3r::GUI::DPIAware< wxDialog >::normal_font(), Slic3r::GUI::Option::opt, Parameter, Slic3r::Preset::printer_technology(), Slic3r::GUI::TextCtrl::propagate_value(), Regular, Slic3r::GUI::CrealityDiscoveryDialog::selected_ip(), Slic3r::ConfigOptionDef::set_default_value(), Slic3r::GUI::Choice::set_selection(), Slic3r::GUI::Choice::set_values(), Button::SetStyle(), Slic3r::BonjourDialog::show_and_lookup(), Slic3r::GUI::show_error(), Slic3r::GUI::show_info(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::OAuthResult::success, Slic3r::ConfigOptionDef::tooltip, Slic3r::ConfigOptionDef::type, update(), update_ports(), update_printers(), update_printhost_buttons(), update_webui(), Slic3r::GUI::Line::widget, Slic3r::ConfigOptionDef::width, and wxStaticText.

Referenced by PhysicalPrinterDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

check_host_key_valid()

void Slic3r::GUI::PhysicalPrinterDialog::check_host_key_valid ( )

protected

{
    std::vector<std::string> keys = {"print_host", "print_host_webui", "printhost_apikey", "flashforge_serial_number", "printhost_cafile", "printhost_user", "printhost_password", "printhost_port"};
    for (auto &key : keys) {
        auto it = m_config->option<ConfigOptionString>(key);
        if (!it) m_config->set_key_value(key, new ConfigOptionString(""));
    }
    return;
}

References Slic3r::ConfigOptionString, and m_config.

Referenced by PhysicalPrinterDialog().

Here is the caller graph for this function:

em_unit()

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

inlineinherited

{ return m_em_unit; }

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

Here is the caller graph for this function:

enable_force_rescale()

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

inlineinherited

{ m_force_rescale = true; }

EndModal()

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

inlineoverrideinherited

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

References Slic3r::GUI::dialogStack.

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

force_rescale()

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

inlineinherited

{ return m_force_rescale; }

is_new_scale_factor()

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

inlineprivateinherited

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

normal_font()

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

inlineinherited

{ return m_normal_font; }

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

Here is the caller graph for this function:

on_dpi_changed()

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

overrideprotectedvirtual

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

{
    const int& em = em_unit();
 
    m_printhost_browse_btn->Rescale();
    m_printhost_test_btn->Rescale();
    m_printhost_generate_creds_btn->Rescale();
    m_printhost_logout_btn->Rescale();
    if (m_printhost_cafile_browse_btn)
        m_printhost_cafile_browse_btn->Rescale();
 
    m_optgroup->msw_rescale();
 
    const wxSize& size = wxSize(45 * em, 35 * em);
    SetMinSize(size);
 
    Fit();
    Refresh();
}

References Slic3r::GUI::DPIAware< wxDialog >::em_unit(), m_optgroup, m_printhost_browse_btn, m_printhost_cafile_browse_btn, m_printhost_generate_creds_btn, m_printhost_logout_btn, and m_printhost_test_btn.

Here is the call graph for this function:

on_sys_color_changed()

void Slic3r::GUI::PhysicalPrinterDialog::on_sys_color_changed ( )

inlineoverrideprotectedvirtual

Reimplemented from Slic3r::GUI::DPIAware< wxDialog >.

{};

OnOK()

void Slic3r::GUI::PhysicalPrinterDialog::OnOK ( wxEvent & event )

private

{
    wxGetApp().get_tab(Preset::TYPE_PRINTER)->save_preset("", false, false, true, m_preset_name);
    event.Skip();
}

References m_preset_name, and Slic3r::Preset::TYPE_PRINTER.

Referenced by PhysicalPrinterDialog().

Here is the caller graph for this function:

prev_scale_factor()

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

inlineinherited

{ return m_prev_scale_factor; }

rescale()

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

inlineprivateinherited

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

scale_factor()

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

inlineinherited

{ return m_scale_factor; }

set_em_unit()

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

inlineinherited

{ m_em_unit = v; }

set_prev_scale_factor()

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

inlineinherited

{ m_prev_scale_factor = v; }

set_scale_factor()

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

inlineinherited

{ m_scale_factor = v; }

ShowModal()

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

inlineinherited

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

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

Here is the caller graph for this function:

update()

void Slic3r::GUI::PhysicalPrinterDialog::update

(

bool

printer_change = false

)

{
    m_optgroup->reload_config();
 
    const PrinterTechnology tech = Preset::printer_technology(*m_config);
    // Only offer the host type selection for FFF, for SLA it's always the SL1 printer (at the moment)
    bool supports_multiple_printers = false;
    if (tech == ptFFF) {
        update_host_type(printer_change);
        const auto opt = m_config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        m_optgroup->show_field("host_type");
 
        m_optgroup->enable_field("print_host");
        m_optgroup->show_field("print_host_webui");
        m_optgroup->hide_field("bbl_use_print_host_webui");
        m_optgroup->enable_field("printhost_cafile");
        m_optgroup->enable_field("printhost_ssl_ignore_revoke");
        if (m_printhost_cafile_browse_btn) { m_printhost_cafile_browse_btn->Enable(); }
 
        // hide pre-configured address, in case user switched to a different host type
        if (Field* printhost_field = m_optgroup->get_field("print_host"); printhost_field) {
            if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_field)->text_ctrl(); temp) {
                const auto current_host = temp->GetValue();
                if (current_host == L"https://connect.prusa3d.com" ||
                    current_host == L"https://app.obico.io" ||
                    current_host == "https://simplyprint.io" || current_host == "https://simplyprint.io/panel" || 
                    current_host == C3DPrinterOS::default_host()) {
                    temp->SetValue(wxString());
                    m_config->opt_string("print_host") = "";
                }
            }
        }
        if (opt->value == htPrusaLink) { // PrusaConnect does NOT allow http digest
            m_optgroup->show_field("printhost_authorization_type");
            AuthorizationType auth_type = m_config->option<ConfigOptionEnum<AuthorizationType>>("printhost_authorization_type")->value;
            m_optgroup->show_field("printhost_apikey", auth_type == AuthorizationType::atKeyPassword);
            for (const char* opt_key : { "printhost_user", "printhost_password" })
                m_optgroup->show_field(opt_key, auth_type == AuthorizationType::atUserPassword); 
        } else {
            m_optgroup->hide_field("printhost_authorization_type");
            m_optgroup->show_field("printhost_apikey", true);
            for (const std::string& opt_key : std::vector<std::string>{ "printhost_user", "printhost_password" })
                m_optgroup->hide_field(opt_key);
            supports_multiple_printers = opt->value == htRepetier || opt->value == htObico;
 
            if (opt->value == htPrusaConnect) { // automatically show default prusaconnect address
                if (Field* printhost_field = m_optgroup->get_field("print_host"); printhost_field) {
                    if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_field)->text_ctrl(); temp && temp->GetValue().IsEmpty()) {
                        temp->SetValue(L"https://connect.prusa3d.com");
                        m_config->opt_string("print_host") = "https://connect.prusa3d.com";
                    }
                }
            } else if (opt->value == htObico) { // automatically show default obico address
                if (Field* printhost_field = m_optgroup->get_field("print_host"); printhost_field) {
                    if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_field)->text_ctrl(); temp && temp->GetValue().IsEmpty()) {
                        temp->SetValue(L"https://app.obico.io");
                        m_config->opt_string("print_host") = "https://app.obico.io";
                    }
                }
            } else if (opt->value == htSimplyPrint)  {
                // Set the host url
                if (Field* printhost_field = m_optgroup->get_field("print_host"); printhost_field) {
                    printhost_field->disable();
                    if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_field)->text_ctrl(); temp && temp->GetValue().IsEmpty()) {
                        temp->SetValue("https://simplyprint.io/panel");
                    }
                    m_config->opt_string("print_host") = "https://simplyprint.io/panel";
                }
 
                const auto current_webui = m_config->opt_string("print_host_webui");
                if (!current_webui.empty()) {
                    if (Field* printhost_webui_field = m_optgroup->get_field("print_host_webui"); printhost_webui_field) {
                        if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_webui_field)->text_ctrl(); temp) {
                            temp->SetValue("https://simplyprint.io/panel");
                        }
                    }
                    m_config->opt_string("print_host_webui") = "https://simplyprint.io/panel";
                }
 
                // For bbl printers, show option to control the device tab
                if (wxGetApp().preset_bundle->is_bbl_vendor() || wxGetApp().app_config->get_bool("use_printer_agents")) {
                    m_optgroup->show_field("bbl_use_print_host_webui");
                    const bool use_print_host_webui = !current_webui.empty();
                    if (Field* printhost_webui_field = m_optgroup->get_field("bbl_use_print_host_webui"); printhost_webui_field) {
                        if (CheckBox* temp = dynamic_cast<CheckBox*>(printhost_webui_field); temp) {
                            temp->set_value(use_print_host_webui);
                        }
                    }
                }
 
                m_optgroup->hide_field("print_host_webui");
                m_optgroup->hide_field("printhost_apikey");
                m_optgroup->disable_field("printhost_cafile");
                m_optgroup->disable_field("printhost_ssl_ignore_revoke");
                if (m_printhost_cafile_browse_btn)
                    m_printhost_cafile_browse_btn->Disable();
            } else if (opt->value == ht3DPrinterOS) {
                if (Field* printhost_field = m_optgroup->get_field("print_host"); printhost_field) {
                    if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_field)->text_ctrl(); temp && temp->GetValue().IsEmpty()) {
                        temp->SetValue(C3DPrinterOS::default_host());
                        m_config->opt_string("print_host") = C3DPrinterOS::default_host();
                    }
                }
                m_optgroup->hide_field("print_host_webui");
                m_optgroup->hide_field("printhost_apikey");
            } 
        }
        
        if (opt->value == htFlashforge) {
            m_optgroup->show_field("printhost_apikey");
            m_optgroup->show_field("flashforge_serial_number");
            m_optgroup->hide_field("printhost_authorization_type");
        } else {
            m_optgroup->hide_field("flashforge_serial_number");
        }        
        
        if (opt->value == htUltiMaker) {
                m_optgroup->hide_field("printhost_apikey");
                m_optgroup->hide_field("printhost_authorization_type");
                m_optgroup->hide_field("bbl_use_print_host_webui");
                m_optgroup->hide_field("printhost_cafile");
                m_optgroup->show_field("printhost_user");
                m_optgroup->show_field("printhost_password");
                m_optgroup->enable_field("print_host");
                m_optgroup->show_field("print_host_webui");
                if (m_printhost_cafile_browse_btn) {
                    m_printhost_cafile_browse_btn->Disable();
                }
                if (m_printhost_generate_creds_btn) {
                    m_printhost_generate_creds_btn->Enable();
                }
            }
    }
    else {
        m_optgroup->set_value("host_type", int(PrintHostType::htOctoPrint), false);
        m_optgroup->hide_field("host_type");
        m_optgroup->hide_field("flashforge_serial_number");
 
        m_optgroup->show_field("printhost_authorization_type");
 
        AuthorizationType auth_type = m_config->option<ConfigOptionEnum<AuthorizationType>>("printhost_authorization_type")->value;
        m_optgroup->show_field("printhost_apikey", auth_type == AuthorizationType::atKeyPassword);
 
        for (const char *opt_key : { "printhost_user", "printhost_password" })
            m_optgroup->show_field(opt_key, auth_type == AuthorizationType::atUserPassword);
    }
 
    // The "Generate API Key" button is only meaningful for UltiMaker printers.
    if (m_printhost_generate_creds_btn)
        m_printhost_generate_creds_btn->Show(tech == ptFFF && m_config->opt_enum<PrintHostType>("host_type") == htUltiMaker);
 
    m_optgroup->show_field("printhost_port", supports_multiple_printers);
    m_printhost_port_browse_btn->Show(supports_multiple_printers);
 
    update_preset_input();
 
    update_printhost_buttons();
 
    this->SetSize(this->GetBestSize());
    this->Layout();
}

References Slic3r::atKeyPassword, Slic3r::atUserPassword, Slic3r::C3DPrinterOS::default_host(), Slic3r::ht3DPrinterOS, Slic3r::htFlashforge, Slic3r::htObico, Slic3r::htOctoPrint, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, Slic3r::htRepetier, Slic3r::htSimplyPrint, Slic3r::htUltiMaker, L, m_config, m_optgroup, m_printhost_cafile_browse_btn, m_printhost_generate_creds_btn, m_printhost_port_browse_btn, Slic3r::Preset::printer_technology(), Slic3r::ptFFF, update_host_type(), update_preset_input(), and update_printhost_buttons().

Referenced by PhysicalPrinterDialog(), and build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_em_unit()

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

inlineprivateinherited

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

update_host_type()

void Slic3r::GUI::PhysicalPrinterDialog::update_host_type

(

bool

printer_change

)

{
    if (m_config == nullptr)
        return;
    Field* ht = m_optgroup->get_field("host_type");
    wxArrayString types;
    int last_in_conf = m_config->option("host_type")->getInt(); //  this is real position in last choice
 
    // Append localized enum_labels
    assert(ht->m_opt.enum_labels.size() == ht->m_opt.enum_values.size());
    for (size_t i = 0; i < ht->m_opt.enum_labels.size(); ++ i) {
        wxString label = _(ht->m_opt.enum_labels[i]);
        types.Add(label);
    }
 
    Choice* choice = dynamic_cast<Choice*>(ht);
    choice->set_values(types);
    int index_in_choice = (printer_change ? std::clamp(last_in_conf - ((int)ht->m_opt.enum_values.size() - (int)types.size()), 0, (int)ht->m_opt.enum_values.size() - 1) : last_in_conf);
    choice->set_value(index_in_choice);
    if ("prusalink" == ht->m_opt.enum_values.at(index_in_choice))
        m_config->set_key_value("host_type", new ConfigOptionEnum<PrintHostType>(htPrusaLink));
    else if ("prusaconnect" == ht->m_opt.enum_values.at(index_in_choice))
        m_config->set_key_value("host_type", new ConfigOptionEnum<PrintHostType>(htPrusaConnect));
    else {
        int host_type = std::clamp(index_in_choice + ((int)ht->m_opt.enum_values.size() - (int)types.size()), 0, (int)ht->m_opt.enum_values.size() - 1);
        PrintHostType type = static_cast<PrintHostType>(host_type);
        m_config->set_key_value("host_type", new ConfigOptionEnum<PrintHostType>(type));
    }
}

References _, Slic3r::ConfigOptionDef::enum_labels, Slic3r::ConfigOptionDef::enum_values, Slic3r::htPrusaConnect, Slic3r::htPrusaLink, m_config, Slic3r::GUI::Field::m_opt, m_optgroup, Slic3r::GUI::Choice::set_value(), and Slic3r::GUI::Choice::set_values().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_ports()

void Slic3r::GUI::PhysicalPrinterDialog::update_ports

(

)

                                         {
    const PrinterTechnology tech = Preset::printer_technology(*m_config);
    if (tech == ptFFF) {
        const auto opt = m_config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        if (opt->value == htObico) {
            auto build_web_ui = [](DynamicPrintConfig* config) {
                auto host = config->opt_string("print_host");
                auto port = config->opt_string("printhost_port");
                auto api_key = config->opt_string("printhost_apikey");
                if (host.empty() || port.empty()) {
                    return std::string();
                }
                boost::regex  re("\\[(\\d+)\\]");
                boost::smatch match;
                if (!boost::regex_search(port, match, re))
                    return std::string();
                if (match.size() <= 1) {
                    return std::string();
                }
                boost::format urlFormat("%1%/printers/%2%/control");
                urlFormat % host % match[1];
                return urlFormat.str();
            };
            auto url = build_web_ui(m_config);
            if (Field* print_host_webui_field = m_optgroup->get_field("print_host_webui"); print_host_webui_field) {
                if (TextInput* temp_input = dynamic_cast<TextInput*>(print_host_webui_field->getWindow()); temp_input) {
                    if (wxTextCtrl* temp = temp_input->GetTextCtrl()) {
                        temp->SetValue(wxString(url));
                        m_config->opt_string("print_host_webui") = url;
                    }
                }
            }
        }
    }
}

References Slic3r::htObico, m_config, m_optgroup, Slic3r::Preset::printer_technology(), and Slic3r::ptFFF.

Referenced by build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_preset_input()

void Slic3r::GUI::PhysicalPrinterDialog::update_preset_input

(

)

                                                {
    m_preset_name = into_u8(m_input_ctrl->GetValue());
 
    m_valid_type = Valid;
    wxString info_line;
 
    const char *unusable_symbols = "<>[]:/\\|?*\"";
 
    const std::string unusable_suffix = PresetCollection::get_suffix_modified(); //"(modified)";
    for (size_t i = 0; i < std::strlen(unusable_symbols); i++) {
        if (m_preset_name.find_first_of(unusable_symbols[i]) != std::string::npos) {
            info_line    = _L("Name is invalid;") + "\n" + _L("illegal characters:") + " " + unusable_symbols;
            m_valid_type = NoValid;
            break;
        }
    }
 
 
    if (m_valid_type == Valid && m_preset_name.find(unusable_suffix) != std::string::npos) {
        info_line    = _L("Name is invalid;") + "\n" + _L("illegal suffix:") + "\n\t" + from_u8(PresetCollection::get_suffix_modified());
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid &&
        (m_preset_name == "Default Setting" || m_preset_name == PresetBundle::ORCA_DEFAULT_FILAMENT_PLACEHOLDER || m_preset_name == "Default Printer")) {
        info_line    = _L("Name is unavailable.");
        m_valid_type = NoValid;
    }
 
    const Preset *existing = m_presets->find_preset(m_preset_name, false);
    if (m_valid_type == Valid && existing && (existing->is_default || existing->is_system)) {
        info_line = _L("Overwriting a system profile is not allowed.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && existing && m_preset_name != m_presets->get_selected_preset_name()) {
        if (existing->is_compatible)
            info_line = from_u8((boost::format(_u8L("Preset \"%1%\" already exists.")) % m_preset_name).str());
        else
            info_line = from_u8((boost::format(_u8L("Preset \"%1%\" already exists and is incompatible with the current printer.")) % m_preset_name).str());
        info_line += "\n" + _L("Please note that saving will overwrite the current preset.");
        m_valid_type = Warning;
    }
 
    if (m_valid_type == Valid && m_preset_name.empty()) {
        info_line    = _L("The name field is not allowed to be empty.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && m_preset_name.find_first_of(' ') == 0) {
        info_line    = _L("The name is not allowed to start with a space.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && m_preset_name.find_last_of(' ') == m_preset_name.length() - 1) {
        info_line    = _L("The name is not allowed to end with a space.");
        m_valid_type = NoValid;
    }
 
    if (m_valid_type == Valid && m_presets->get_preset_name_by_alias(m_preset_name) != m_preset_name) {
        info_line    = _L("The name cannot be the same as a preset alias name.");
        m_valid_type = NoValid;
    }
 
    m_valid_label->SetLabel(info_line);
    m_input_area->Refresh();
    m_valid_label->Show(!info_line.IsEmpty());
 
    if (m_valid_type == NoValid) {
        if (btnOK)
            btnOK->Disable();
    }
    else {
        if (btnOK)
            btnOK->Enable();
    }
}

References _L, _u8L, btnOK, Slic3r::GUI::from_u8(), Slic3r::PresetCollection::get_suffix_modified(), Slic3r::GUI::into_u8(), Slic3r::Preset::is_compatible, Slic3r::Preset::is_default, Slic3r::Preset::is_system, m_input_area, m_input_ctrl, m_preset_name, m_presets, m_valid_label, m_valid_type, NoValid, Slic3r::PresetBundle::ORCA_DEFAULT_FILAMENT_PLACEHOLDER, Valid, and Warning.

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_printers()

void Slic3r::GUI::PhysicalPrinterDialog::update_printers

(

)

{
    wxBusyCursor wait;
 
    std::unique_ptr<PrintHost> host(PrintHost::get_print_host(m_config));
 
    wxArrayString printers;
    Field *rs = m_optgroup->get_field("printhost_port");
    try {
        if (! host->get_printers(printers))
            printers.clear();
    } catch (const HostNetworkError &err) {
        printers.clear();
        show_error(this, _L("Connection to printers connected via the print host failed.") + "\n\n" + from_u8(err.what()));
    }
    Choice *choice = dynamic_cast<Choice*>(rs);
    choice->set_values(printers);
    printers.empty() ? rs->disable() : rs->enable();
}

References _L, Slic3r::GUI::Field::disable(), Slic3r::GUI::Field::enable(), Slic3r::GUI::from_u8(), Slic3r::PrintHost::get_print_host(), m_config, m_optgroup, Slic3r::GUI::Choice::set_values(), and Slic3r::GUI::show_error().

Referenced by build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

update_printhost_buttons()

void Slic3r::GUI::PhysicalPrinterDialog::update_printhost_buttons

(

)

{
    std::unique_ptr<PrintHost> host(PrintHost::get_print_host(m_config));
    if (host) {
        m_printhost_test_btn->Enable(!m_config->opt_string("print_host").empty() && host->can_test());
        m_printhost_browse_btn->Show(host->has_auto_discovery());
        m_printhost_logout_btn->Show(host->is_logged_in());
        m_printhost_test_btn->SetLabel(host->is_cloud() ? _L("Login/Test") : _L("Test"));
    }
}

References _L, Slic3r::PrintHost::get_print_host(), m_config, m_printhost_browse_btn, m_printhost_logout_btn, and m_printhost_test_btn.

Referenced by build_printhost_settings(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_webui()

void Slic3r::GUI::PhysicalPrinterDialog::update_webui

(

)

{
    const PrinterTechnology tech = Preset::printer_technology(*m_config);
    if (tech == ptFFF) {
        const auto opt = m_config->option<ConfigOptionEnum<PrintHostType>>("host_type");
        if (opt->value == htSimplyPrint) {
            bool bbl_use_print_host_webui = false;
            if (Field* printhost_webui_field = m_optgroup->get_field("bbl_use_print_host_webui"); printhost_webui_field) {
                if (CheckBox* temp = dynamic_cast<CheckBox*>(printhost_webui_field); temp) {
                    bbl_use_print_host_webui = boost::any_cast<bool>(temp->get_value());
                }
            }
 
            const std::string v = bbl_use_print_host_webui ? "https://simplyprint.io/panel" : "";
            if (Field* printhost_webui_field = m_optgroup->get_field("print_host_webui"); printhost_webui_field) {
                if (wxTextCtrl* temp = dynamic_cast<TextCtrl*>(printhost_webui_field)->text_ctrl(); temp) {
                    temp->SetValue(v);
                }
            }
            m_config->opt_string("print_host_webui") = v;
        }
    }
}

References Slic3r::htSimplyPrint, m_config, m_optgroup, Slic3r::Preset::printer_technology(), and Slic3r::ptFFF.

Referenced by build_printhost_settings().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

btnOK

Button* Slic3r::GUI::PhysicalPrinterDialog::btnOK {nullptr}

private

{nullptr};

Referenced by PhysicalPrinterDialog(), and update_preset_input().

m_can_rescale

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

privateinherited

{ true };

m_config

DynamicPrintConfig* Slic3r::GUI::PhysicalPrinterDialog::m_config { nullptr }

private

{ nullptr };

Referenced by PhysicalPrinterDialog(), build_printhost_settings(), check_host_key_valid(), update(), update_host_type(), update_ports(), update_printers(), update_printhost_buttons(), and update_webui().

m_em_unit

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

privateinherited

m_force_rescale

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

privateinherited

{ false };

m_input_area

RoundedRectangle* Slic3r::GUI::PhysicalPrinterDialog::m_input_area {nullptr}

private

{nullptr};

Referenced by PhysicalPrinterDialog(), and update_preset_input().

m_input_ctrl

wxTextCtrl* Slic3r::GUI::PhysicalPrinterDialog::m_input_ctrl {nullptr}

private

{nullptr};

Referenced by PhysicalPrinterDialog(), and update_preset_input().

m_new_font_point_size

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

privateinherited

m_normal_font

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

privateinherited

m_optgroup

ConfigOptionsGroup* Slic3r::GUI::PhysicalPrinterDialog::m_optgroup { nullptr }

private

{ nullptr };

Referenced by PhysicalPrinterDialog(), build_printhost_settings(), on_dpi_changed(), update(), update_host_type(), update_ports(), update_printers(), and update_webui().

m_preset_name

std::string Slic3r::GUI::PhysicalPrinterDialog::m_preset_name

Referenced by OnOK(), and update_preset_input().

m_presets

PresetCollection* Slic3r::GUI::PhysicalPrinterDialog::m_presets {nullptr}

{nullptr};

Referenced by PhysicalPrinterDialog(), and update_preset_input().

m_prev_scale_factor

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

privateinherited

m_printhost_browse_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_browse_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), on_dpi_changed(), and update_printhost_buttons().

m_printhost_cafile_browse_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_cafile_browse_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), on_dpi_changed(), and update().

m_printhost_generate_creds_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_generate_creds_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), on_dpi_changed(), and update().

m_printhost_logout_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_logout_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), on_dpi_changed(), and update_printhost_buttons().

m_printhost_port_browse_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_port_browse_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), and update().

m_printhost_test_btn

Button* Slic3r::GUI::PhysicalPrinterDialog::m_printhost_test_btn {nullptr}

private

{nullptr};

Referenced by build_printhost_settings(), on_dpi_changed(), and update_printhost_buttons().

m_scale_factor

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

privateinherited

m_valid_label

wxStaticText* Slic3r::GUI::PhysicalPrinterDialog::m_valid_label {nullptr}

private

{nullptr};

Referenced by PhysicalPrinterDialog(), and update_preset_input().

m_valid_type

ValidationType Slic3r::GUI::PhysicalPrinterDialog::m_valid_type

Referenced by update_preset_input().

---

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

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