Slic3r::GUI::ExportConfigsDialog Class Reference

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

Inheritance diagram for Slic3r::GUI::ExportConfigsDialog:

Collaboration diagram for Slic3r::GUI::ExportConfigsDialog:

Classes
struct	ExportType

Public Member Functions
	ExportConfigsDialog (wxWindow *parent)
	~ExportConfigsDialog ()
void	EndModal (int retCode) override
float	scale_factor () const
float	prev_scale_factor () const
void	set_scale_factor (float v)
void	set_prev_scale_factor (float v)
void	set_em_unit (int v)
bool	force_rescale () const
int	em_unit () const
const wxFont &	normal_font () const
void	enable_force_rescale ()
int	ShowModal ()

Protected Types
enum	ExportCase {   INITIALIZE_FAIL = 0 , ADD_FILE_FAIL , ADD_BUNDLE_STRUCTURE_FAIL , FINALIZE_FAIL ,   OPEN_ZIP_WRITTEN_FILE , EXPORT_CANCEL , EXPORT_SUCCESS , CASE_COUNT }

Protected Member Functions
virtual void	on_sys_color_changed ()

Private Member Functions
void	data_init ()
void	select_curr_radiobox (std::vector< std::pair< RadioBox *, wxString > > &radiobox_list, int btn_idx)
void	update_include_bed_assets_enabled ()
void	on_dpi_changed (const wxRect &suggested_rect) override
void	show_export_result (const ExportCase &export_case)
bool	has_check_box_selected ()
bool	earse_preset_fields_for_safe (Preset *preset)
std::string	initial_file_path (const wxString &path, const std::string &sub_file_path)
std::string	initial_file_name (const wxString &path, const std::string file_name)
wxBoxSizer *	create_export_config_item (wxWindow *parent)
wxWindow *	create_dialog_buttons (wxWindow *parent)
wxBoxSizer *	create_select_printer (wxWindow *parent)
wxBoxSizer *	create_radio_item (wxString title, wxWindow *parent, wxString tooltip, std::vector< std::pair< RadioBox *, wxString > > &radiobox_list)
int	initial_zip_archive (mz_zip_archive &zip_archive, const std::string &file_path)
ExportCase	save_zip_archive_to_file (mz_zip_archive &zip_archive)
ExportCase	save_presets_to_zip (const std::string &export_file, const std::vector< std::pair< std::string, std::string > > &config_paths)
ExportCase	archive_preset_bundle_to_file (const wxString &path, bool include_bed_assets)
ExportCase	archive_filament_bundle_to_file (const wxString &path)
ExportCase	archive_printer_preset_to_file (const wxString &path)
ExportCase	archive_filament_preset_to_file (const wxString &path)
ExportCase	archive_process_preset_to_file (const wxString &path)
void	update_em_unit ()
bool	is_new_scale_factor () const
void	rescale (const wxRect &suggested_rect)

Private Attributes
std::vector< std::pair< RadioBox *, wxString > >	m_export_type_btns
std::vector< std::pair<::CheckBox *, Preset * > >	m_preset
std::vector< std::pair<::CheckBox *, std::string > >	m_printer_name
std::unordered_map< std::string, Preset * >	m_printer_presets
std::unordered_map< std::string, std::vector< Preset * > >	m_filament_presets
std::unordered_map< std::string, std::vector< Preset * > >	m_process_presets
std::unordered_map< std::string, std::vector< std::pair< std::string, Preset * > > >	m_filament_name_to_presets
ExportType	m_exprot_type
wxBoxSizer *	m_main_sizer = nullptr
wxScrolledWindow *	m_scrolled_preset_window = nullptr
wxGridSizer *	m_preset_sizer = nullptr
wxPanel *	m_presets_window = nullptr
wxStaticText *	m_serial_text = nullptr
::CheckBox *	m_include_bed_assets = nullptr
wxStaticText *	m_include_bed_assets_label = 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

---

Class Documentation

Slic3r::GUI::ExportConfigsDialog::ExportType

struct Slic3r::GUI::ExportConfigsDialog::ExportType

Class Members
wxString	filament_bundle
wxString	filament_preset
wxString	preset_bundle
wxString	printer_preset
wxString	process_preset

Member Enumeration Documentation

ExportCase

enum Slic3r::GUI::ExportConfigsDialog::ExportCase

protected

Enumerator
INITIALIZE_FAIL
ADD_FILE_FAIL
ADD_BUNDLE_STRUCTURE_FAIL
FINALIZE_FAIL
OPEN_ZIP_WRITTEN_FILE
EXPORT_CANCEL
EXPORT_SUCCESS
CASE_COUNT

                    {
        INITIALIZE_FAIL = 0,
        ADD_FILE_FAIL,
        ADD_BUNDLE_STRUCTURE_FAIL,
        FINALIZE_FAIL,
        OPEN_ZIP_WRITTEN_FILE,
        EXPORT_CANCEL,
        EXPORT_SUCCESS,
        CASE_COUNT,
    };

Constructor & Destructor Documentation

ExportConfigsDialog()

Slic3r::GUI::ExportConfigsDialog::ExportConfigsDialog

(

wxWindow *

parent

)

    : DPIDialog(parent ? parent : nullptr, wxID_ANY, _L("Export Preset Bundle"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
{
    m_exprot_type.preset_bundle   = _L("Printer config bundle(.orca_printer)");
    m_exprot_type.filament_bundle = _L("Filament bundle(.orca_filament)");
    m_exprot_type.printer_preset  = _L("Printer presets(.zip)");
    m_exprot_type.filament_preset = _L("Filament presets(.zip)");
    m_exprot_type.process_preset  = _L("Process presets(.zip)");
 
    this->SetBackgroundColour(*wxWHITE);
    this->SetSize(wxSize(FromDIP(600), FromDIP(600)));
 
    m_main_sizer = new wxBoxSizer(wxVERTICAL);
    // top line
    auto m_line_top = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1), wxTAB_TRAVERSAL);
    m_line_top->SetBackgroundColour(wxColour(0xA6, 0xa9, 0xAA));
    m_main_sizer->Add(m_line_top, 0, wxEXPAND, 0);
    m_main_sizer->Add(0, 0, 0, wxTOP, FromDIP(5));
 
    m_main_sizer->Add(create_export_config_item(this), 0, wxEXPAND | wxALL, FromDIP(5));
    m_main_sizer->Add(create_select_printer(this), 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, FromDIP(5));
    m_main_sizer->Add(create_dialog_buttons(this), 0, wxEXPAND);
 
    data_init();
 
    this->SetSizer(m_main_sizer);
 
    this->Layout();
    this->Fit();
 
    wxGetApp().UpdateDlgDarkUI(this);
 
}

References _L, create_dialog_buttons(), create_export_config_item(), create_select_printer(), data_init(), m_exprot_type, and m_main_sizer.

Here is the call graph for this function:

~ExportConfigsDialog()

Slic3r::GUI::ExportConfigsDialog::~ExportConfigsDialog

(

)

{
    for (std::pair<std::string, Preset *> printer_preset : m_printer_presets) {
        Preset *preset = printer_preset.second;
        if (preset) {
            delete preset;
            preset = nullptr;
        }
    }
    for (std::pair<std::string, std::vector<Preset *>> filament_presets : m_filament_presets) {
        for (Preset* preset : filament_presets.second) {
            if (preset) {
                delete preset;
                preset = nullptr;
            }
        }
    }
    for (std::pair<std::string, std::vector<Preset *>> filament_presets : m_process_presets) {
        for (Preset *preset : filament_presets.second) {
            if (preset) {
                delete preset;
                preset = nullptr;
            }
        }
    }
    for (std::pair<std::string, std::vector<std::pair<std::string, Preset *>>> filament_preset : m_filament_name_to_presets) {
        for (std::pair<std::string, Preset*> printer_name_preset : filament_preset.second) {
            Preset *preset = printer_name_preset.second;
            if (preset) {
                delete preset;
                preset = nullptr;
            }
        }
    }
 
    // Delete the Temp folder
    boost::filesystem::path temp_folder(data_dir() + "/" + PRESET_USER_DIR + "/" + "Temp");
    if (boost::filesystem::exists(temp_folder)) boost::filesystem::remove_all(temp_folder);
}

References Slic3r::data_dir(), m_filament_name_to_presets, m_filament_presets, m_printer_presets, m_process_presets, and PRESET_USER_DIR.

Here is the call graph for this function:

Member Function Documentation

archive_filament_bundle_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::archive_filament_bundle_to_file ( const wxString & path )

private

{
    std::string export_path = initial_file_path(path, "");
    if (export_path.empty() || "initial_failed" == export_path) return ExportCase::EXPORT_CANCEL;
    BOOST_LOG_TRIVIAL(info) << "Export filament preset bundle";
 
    for (std::pair<::CheckBox *, std::string> checkbox_filament_name : m_printer_name) {
        if (checkbox_filament_name.first->GetValue()) {
            std::string filament_name = checkbox_filament_name.second;
 
            json          bundle_structure;
            NetworkAgent *agent = wxGetApp().getAgent();
            std::string   clock = get_curr_timestmp();
            if (agent) {
                bundle_structure["version"]   = agent->get_version();
                bundle_structure["bundle_id"] = agent->get_user_id() + "_" + filament_name + "_" + clock;
            } else {
                bundle_structure["version"]   = "";
                bundle_structure["bundle_id"] = "offline_" + filament_name + "_" + clock;
            }
            bundle_structure["bundle_type"] = "filament config bundle";
            bundle_structure["filament_name"] = filament_name;
            std::unordered_map<std::string, json> vendor_structure;
 
            mz_zip_archive zip_archive;
            mz_bool        status = initial_zip_archive(zip_archive, export_path + "/" + filament_name + ".orca_filament");
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << "Failed to initialize ZIP archive";
                return ExportCase::INITIALIZE_FAIL;
            }
 
            std::unordered_map<std::string, std::vector<std::pair<std::string, Preset *>>>::iterator iter = m_filament_name_to_presets.find(filament_name);
            if (m_filament_name_to_presets.end() == iter) {
                BOOST_LOG_TRIVIAL(info) << "Filament name do not find, filament name:" << filament_name;
                continue;
            }
            std::set<std::pair<std::string, std::string>> vendor_to_filament_name;
            for (std::pair<std::string, Preset *> printer_name_to_preset : iter->second) {
                std::string printer_vendor = printer_name_to_preset.first;
                if (printer_vendor.empty()) continue;
                Preset *    filament_preset = printer_name_to_preset.second;
                if (vendor_to_filament_name.find(std::make_pair(printer_vendor, filament_preset->name)) != vendor_to_filament_name.end()) continue;
                vendor_to_filament_name.insert(std::make_pair(printer_vendor, filament_preset->name));
                std::string preset_path     = boost::filesystem::path(filament_preset->file).make_preferred().string();
                if (preset_path.empty()) {
                    BOOST_LOG_TRIVIAL(info) << "Export printer preset: " << filament_preset->name << " skip because of the preset file path is empty.";
                    continue;
                }
                // Add a file to the ZIP file
                std::string file_name = printer_vendor + "/" + filament_preset->name + ".json";
                status                = mz_zip_writer_add_file(&zip_archive, file_name.c_str(), encode_path(preset_path.c_str()).c_str(), NULL, 0, MZ_DEFAULT_COMPRESSION);
                // status = mz_zip_writer_add_mem(&zip_archive, ("printer/" + printer_preset->name + ".json").c_str(), json_contents, strlen(json_contents), MZ_DEFAULT_COMPRESSION);
                if (MZ_FALSE == status) {
                    BOOST_LOG_TRIVIAL(info) << filament_preset->name << " Failed to add file to ZIP archive";
                    mz_zip_writer_end(&zip_archive);
                    return ExportCase::ADD_FILE_FAIL;
                }
                std::unordered_map<std::string, json>::iterator iter = vendor_structure.find(printer_vendor);
                if (vendor_structure.end() == iter) {
                    json j = json::array();
                    j.push_back(file_name);
                    vendor_structure[printer_vendor] = j;
                } else {
                    iter->second.push_back(file_name);
                }
                BOOST_LOG_TRIVIAL(info) << "Filament preset json add successful: " << filament_preset->name;
            }
 
            for (const auto& vendor_name_to_json : vendor_structure) {
                json j;
                std::string printer_vendor = vendor_name_to_json.first;
                j["vendor"]                = printer_vendor;
                j["filament_path"]         = vendor_name_to_json.second;
                bundle_structure["printer_vendor"].push_back(j);
            }
 
            std::string bundle_structure_str = bundle_structure.dump();
            status = mz_zip_writer_add_mem(&zip_archive, BUNDLE_STRUCTURE_JSON_NAME, bundle_structure_str.data(), bundle_structure_str.size(), MZ_DEFAULT_COMPRESSION);
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << " Failed to add file: " << BUNDLE_STRUCTURE_JSON_NAME;
                mz_zip_writer_end(&zip_archive);
                return ExportCase::ADD_BUNDLE_STRUCTURE_FAIL;
            }
            BOOST_LOG_TRIVIAL(info) << " Success to add file: " << BUNDLE_STRUCTURE_JSON_NAME;
 
            // Complete writing of ZIP file
            ExportCase save_result = save_zip_archive_to_file(zip_archive);
            if (ExportCase::CASE_COUNT != save_result) return save_result;
        }
    }
    BOOST_LOG_TRIVIAL(info) << "ZIP archive created successfully";
 
    return ExportCase::EXPORT_SUCCESS;
}

References ADD_BUNDLE_STRUCTURE_FAIL, ADD_FILE_FAIL, BUNDLE_STRUCTURE_JSON_NAME, CASE_COUNT, Slic3r::encode_path(), EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::Preset::file, Slic3r::GUI::get_curr_timestmp(), Slic3r::NetworkAgent::get_user_id(), Slic3r::NetworkAgent::get_version(), initial_file_path(), initial_zip_archive(), INITIALIZE_FAIL, m_filament_name_to_presets, m_printer_name, Slic3r::Preset::name, and save_zip_archive_to_file().

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

archive_filament_preset_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::archive_filament_preset_to_file ( const wxString & path )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "start exprot filament presets";
    std::string export_file = "Filament presets.zip";
    export_file             = initial_file_name(path, export_file);
    if (export_file.empty() || "initial_failed" == export_file) return ExportCase::EXPORT_CANCEL;
 
    std::vector<std::pair<std::string, std::string>> config_paths;
 
    std::set<std::string> filament_presets;
    for (std::pair<::CheckBox *, std::string> checkbox_preset : m_printer_name) {
        if (checkbox_preset.first->GetValue()) {
            std::string filament_name = checkbox_preset.second;
 
            std::unordered_map<std::string, std::vector<std::pair<std::string, Preset *>>>::iterator iter = m_filament_name_to_presets.find(filament_name);
            if (m_filament_name_to_presets.end() == iter) {
                BOOST_LOG_TRIVIAL(info) << "Filament name do not find, filament name:" << filament_name;
                continue;
            }
            for (std::pair<std::string, Preset*> printer_name_preset : iter->second) {
                Preset *    filament_preset = printer_name_preset.second;
                if (filament_presets.find(filament_preset->name) != filament_presets.end()) continue;
                filament_presets.insert(filament_preset->name);
                std::string preset_path     = boost::filesystem::path(filament_preset->file).make_preferred().string();
                if (preset_path.empty()) {
                    BOOST_LOG_TRIVIAL(info) << "Export filament preset: " << filament_preset->name << " skip because of the filament file path is empty.";
                    continue;
                }
 
                std::string preset_name = filament_preset->name + ".json";
                config_paths.push_back(std::make_pair(preset_name, preset_path));
            }
        }
    }
 
    ExportCase save_result = save_presets_to_zip(export_file, config_paths);
    if (ExportCase::CASE_COUNT != save_result) return save_result;
 
    BOOST_LOG_TRIVIAL(info) << "ZIP archive created successfully";
 
    return ExportCase::EXPORT_SUCCESS;
}

References CASE_COUNT, EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::Preset::file, initial_file_name(), m_filament_name_to_presets, m_printer_name, Slic3r::Preset::name, and save_presets_to_zip().

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

archive_preset_bundle_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::archive_preset_bundle_to_file ( const wxString & path, bool include_bed_assets )

private

{
    std::string export_path = initial_file_path(path, "");
    if (export_path.empty() || "initial_failed" == export_path) return ExportCase::EXPORT_CANCEL;
    BOOST_LOG_TRIVIAL(info) << "Export printer preset bundle";
 
    for (std::pair<::CheckBox *, Preset *> checkbox_preset : m_preset) {
        if (checkbox_preset.first->GetValue()) {
            Preset *printer_preset = checkbox_preset.second;
            std::string printer_preset_name_ = printer_preset->name;
 
            json          bundle_structure;
            NetworkAgent *agent = wxGetApp().getAgent();
            std::string   clock = get_curr_timestmp();
            if (agent) {
                bundle_structure["version"]   = agent->get_version();
                bundle_structure["bundle_id"] = agent->get_user_id() + "_" + printer_preset_name_ + "_" + clock;
            } else {
                bundle_structure["version"]   = "";
                bundle_structure["bundle_id"] = "offline_" + printer_preset_name_ + "_" + clock;
            }
            bundle_structure["bundle_type"] = "printer config bundle";
            bundle_structure["printer_preset_name"] = printer_preset_name_;
            json printer_config   = json::array();
            json filament_configs = json::array();
            json process_configs  = json::array();
 
            mz_zip_archive zip_archive;
            mz_bool        status = initial_zip_archive(zip_archive, export_path + "/" + printer_preset->name + ".orca_printer");
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << "Failed to initialize ZIP archive";
                return ExportCase::INITIALIZE_FAIL;
            }
 
            boost::filesystem::path printer_file_path      = boost::filesystem::path(printer_preset->file);
            std::string             preset_path       = printer_file_path.make_preferred().string();
            if (preset_path.empty()) {
                BOOST_LOG_TRIVIAL(info) << "Export printer preset: " << printer_preset->name << " skip because of the preset file path is empty.";
                continue;
            }
 
            // Add a file to the ZIP file
            std::string printer_config_file_name = "printer/" + printer_file_path.filename().string();
            status = mz_zip_writer_add_file(&zip_archive, printer_config_file_name.c_str(), encode_path(preset_path.c_str()).c_str(), NULL, 0, MZ_DEFAULT_COMPRESSION);
            //status = mz_zip_writer_add_mem(&zip_archive, ("printer/" + printer_preset->name + ".json").c_str(), json_contents, strlen(json_contents), MZ_DEFAULT_COMPRESSION);
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << printer_preset->name << " Failed to add file to ZIP archive";
                mz_zip_writer_end(&zip_archive);
                return ExportCase::ADD_FILE_FAIL;
            }
            printer_config.push_back(printer_config_file_name);
            BOOST_LOG_TRIVIAL(info) << "Printer preset json add successful: " << printer_preset->name;
 
            const std::string printer_preset_name = printer_preset->name;
            std::unordered_map<std::string, std::vector<Preset *>>::iterator iter = m_filament_presets.find(printer_preset_name);
            if (m_filament_presets.end() != iter) {
                for (Preset *preset : iter->second) {
                    boost::filesystem::path filament_file_path   = boost::filesystem::path(preset->file);
                    std::string             filament_preset_path = filament_file_path.make_preferred().string();
                    if (filament_preset_path.empty()) {
                        BOOST_LOG_TRIVIAL(info) << "Export filament preset: " << preset->name << " skip because of the preset file path is empty.";
                        continue;
                    }
 
                    std::string filament_config_file_name = "filament/" + filament_file_path.filename().string();
                    status = mz_zip_writer_add_file(&zip_archive, filament_config_file_name.c_str(), encode_path(filament_preset_path.c_str()).c_str(), NULL, 0, MZ_DEFAULT_COMPRESSION);
                    if (MZ_FALSE == status) {
                        BOOST_LOG_TRIVIAL(info) << preset->name << " Failed to add file to ZIP archive";
                        mz_zip_writer_end(&zip_archive);
                        return ExportCase::ADD_FILE_FAIL;
                    }
                    filament_configs.push_back(filament_config_file_name);
                    BOOST_LOG_TRIVIAL(info) << "Filament preset json add successful.";
                }
            }
 
            iter = m_process_presets.find(printer_preset_name);
            if (m_process_presets.end() != iter) {
                for (Preset *preset : iter->second) {
                    boost::filesystem::path process_file_path   = boost::filesystem::path(preset->file);
                    std::string             process_preset_path = process_file_path.make_preferred().string();
                    if (process_preset_path.empty()) {
                        BOOST_LOG_TRIVIAL(info) << "Export process preset: " << preset->name << " skip because of the preset file path is empty.";
                        continue;
                    }
 
                    std::string process_config_file_name = "process/" + process_file_path.filename().string();
                    status = mz_zip_writer_add_file(&zip_archive, process_config_file_name.c_str(), encode_path(process_preset_path.c_str()).c_str(), NULL, 0, MZ_DEFAULT_COMPRESSION);
                    if (MZ_FALSE == status) {
                        BOOST_LOG_TRIVIAL(info) << preset->name << " Failed to add file to ZIP archive";
                        mz_zip_writer_end(&zip_archive);
                        return ExportCase::ADD_FILE_FAIL;
                    }
                    process_configs.push_back(process_config_file_name);
                    BOOST_LOG_TRIVIAL(info) << "Process preset json add successful: ";
                }
            }
 
            bundle_structure["printer_config"]  = printer_config;
            bundle_structure["filament_config"] = filament_configs;
            bundle_structure["process_config"]  = process_configs;
 
            if (include_bed_assets &&
                !append_printer_bed_assets(zip_archive, printer_preset->config, bundle_structure, printer_config_file_name, 0)) {
                mz_zip_writer_end(&zip_archive);
                return ExportCase::ADD_FILE_FAIL;
            }
 
            std::string bundle_structure_str = bundle_structure.dump();
            status = mz_zip_writer_add_mem(&zip_archive, BUNDLE_STRUCTURE_JSON_NAME, bundle_structure_str.data(), bundle_structure_str.size(), MZ_DEFAULT_COMPRESSION);
            if (MZ_FALSE == status) {
                BOOST_LOG_TRIVIAL(info) << " Failed to add file: " << BUNDLE_STRUCTURE_JSON_NAME;
                mz_zip_writer_end(&zip_archive);
                return ExportCase::ADD_BUNDLE_STRUCTURE_FAIL;
            }
            BOOST_LOG_TRIVIAL(info) << " Success to add file: " << BUNDLE_STRUCTURE_JSON_NAME;
 
            ExportCase save_result = save_zip_archive_to_file(zip_archive);
            if (ExportCase::CASE_COUNT != save_result) return save_result;
        }
    }
    BOOST_LOG_TRIVIAL(info) << "ZIP archive created successfully";
 
    return ExportCase::EXPORT_SUCCESS;
}

References ADD_BUNDLE_STRUCTURE_FAIL, ADD_FILE_FAIL, Slic3r::append_printer_bed_assets(), BUNDLE_STRUCTURE_JSON_NAME, CASE_COUNT, Slic3r::Preset::config, Slic3r::encode_path(), EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::Preset::file, Slic3r::GUI::get_curr_timestmp(), Slic3r::NetworkAgent::get_user_id(), Slic3r::NetworkAgent::get_version(), initial_file_path(), initial_zip_archive(), INITIALIZE_FAIL, m_filament_presets, m_preset, m_process_presets, Slic3r::Preset::name, Slic3r::GUI::printer_config(), and save_zip_archive_to_file().

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

archive_printer_preset_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::archive_printer_preset_to_file ( const wxString & path )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "start exprot printer presets";
    std::string export_file = "Printer presets.zip";
    export_file             = initial_file_name(path, export_file);
    if (export_file.empty() || "initial_failed" == export_file) return ExportCase::EXPORT_CANCEL;
 
    std::vector<std::pair<std::string, std::string>> config_paths;
 
    for (std::pair<::CheckBox *, Preset *> checkbox_preset : m_preset) {
        if (checkbox_preset.first->GetValue()) {
            Preset *    printer_preset = checkbox_preset.second;
            std::string preset_path    = boost::filesystem::path(printer_preset->file).make_preferred().string();
            if (preset_path.empty()) {
                BOOST_LOG_TRIVIAL(info) << "Export printer preset: " << printer_preset->name << " skip because of the preset file path is empty.";
                continue;
            }
            std::string preset_name = printer_preset->name + ".json";
            config_paths.push_back(std::make_pair(preset_name, preset_path));
        }
    }
 
    ExportCase save_result = save_presets_to_zip(export_file, config_paths);
    if (ExportCase::CASE_COUNT != save_result) return save_result;
 
    BOOST_LOG_TRIVIAL(info) << "ZIP archive created successfully";
 
    return ExportCase::EXPORT_SUCCESS;
 
}

References CASE_COUNT, EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::Preset::file, initial_file_name(), m_preset, Slic3r::Preset::name, and save_presets_to_zip().

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

archive_process_preset_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::archive_process_preset_to_file ( const wxString & path )

private

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "start exprot process presets";
    std::string export_file = "Process presets.zip";
    export_file             = initial_file_name(path, export_file);
    if (export_file.empty() || "initial_failed" == export_file) return ExportCase::EXPORT_CANCEL;
 
    std::vector<std::pair<std::string, std::string>> config_paths;
 
    std::set<std::string> process_presets;
    for (std::pair<::CheckBox *, std::string> checkbox_preset : m_printer_name) {
        if (checkbox_preset.first->GetValue()) {
            std::string printer_name = checkbox_preset.second;
            std::unordered_map<std::string, std::vector<Preset *>>::iterator iter = m_process_presets.find(printer_name);
            if (m_process_presets.end() != iter) {
                for (Preset *process_preset : iter->second) {
                    if (process_presets.find(process_preset->name) != process_presets.end()) continue;
                    process_presets.insert(process_preset->name);
                    std::string preset_path = boost::filesystem::path(process_preset->file).make_preferred().string();
                    if (preset_path.empty()) {
                        BOOST_LOG_TRIVIAL(info) << "Export process preset: " << process_preset->name << " skip because of the preset file path is empty.";
                        continue;
                    }
 
                    std::string preset_name = process_preset->name + ".json";
                    config_paths.push_back(std::make_pair(preset_name, preset_path));
                }
            }
        }
    }
 
    ExportCase save_result = save_presets_to_zip(export_file, config_paths);
    if (ExportCase::CASE_COUNT != save_result) return save_result;
 
    BOOST_LOG_TRIVIAL(info) << "ZIP archive created successfully";
 
    return ExportCase::EXPORT_SUCCESS;
}

References CASE_COUNT, EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::Preset::file, initial_file_name(), m_printer_name, m_process_presets, Slic3r::Preset::name, and save_presets_to_zip().

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

create_dialog_buttons()

wxWindow * Slic3r::GUI::ExportConfigsDialog::create_dialog_buttons ( wxWindow * parent )

private

{
    auto dlg_btns = new DialogButtons(parent, {"OK", "Cancel"});
    dlg_btns->GetOK()->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) {
        if (!has_check_box_selected()) {
            MessageDialog dlg(this, _L("Please select at least one printer or filament."), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"),
                              wxOK | wxCENTRE);
            dlg.ShowModal();
            return;
        }
 
        wxDirDialog dlg(this, _L("Choose a directory"), "", wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
        wxString    path;
        if (dlg.ShowModal() == wxID_OK) path = dlg.GetPath();
        ExportCase export_case = ExportCase::EXPORT_CANCEL;
        if (!path.IsEmpty()) {
            wxGetApp().app_config->update_config_dir(into_u8(path));
            wxGetApp().app_config->save();
            const wxString curr_radio_type = get_curr_radio_type(m_export_type_btns);
 
            if (curr_radio_type == m_exprot_type.preset_bundle) {
                export_case = archive_preset_bundle_to_file(path, m_include_bed_assets->GetValue());
            } else if (curr_radio_type == m_exprot_type.filament_bundle) {
                export_case = archive_filament_bundle_to_file(path);
            } else if (curr_radio_type == m_exprot_type.printer_preset) {
                export_case = archive_printer_preset_to_file(path);
            } else if (curr_radio_type == m_exprot_type.filament_preset) {
                export_case = archive_filament_preset_to_file(path);
            } else if (curr_radio_type == m_exprot_type.process_preset) {
                export_case = archive_process_preset_to_file(path);
            }
        } else {
            return;
        }
        show_export_result(export_case);
        if (ExportCase::EXPORT_SUCCESS != export_case) return;
 
        EndModal(wxID_OK);
        });
 
    dlg_btns->GetCANCEL()->Bind(wxEVT_BUTTON, [this](wxCommandEvent &e) { EndModal(wxID_CANCEL); });
 
    return dlg_btns;
}

References _L, archive_filament_bundle_to_file(), archive_filament_preset_to_file(), archive_preset_bundle_to_file(), archive_printer_preset_to_file(), archive_process_preset_to_file(), Slic3r::GUI::DPIDialog::EndModal(), EXPORT_CANCEL, EXPORT_SUCCESS, Slic3r::GUI::get_curr_radio_type(), Slic3r::GUI::DialogButtons::GetOK(), has_check_box_selected(), Slic3r::GUI::into_u8(), m_export_type_btns, m_exprot_type, m_include_bed_assets, show_export_result(), Slic3r::GUI::DPIAware< P >::ShowModal(), and SLIC3R_APP_FULL_NAME.

Referenced by ExportConfigsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

create_export_config_item()

wxBoxSizer * Slic3r::GUI::ExportConfigsDialog::create_export_config_item ( wxWindow * parent )

private

{
    wxBoxSizer *horizontal_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBoxSizer *  optionSizer        = new wxBoxSizer(wxVERTICAL);
    wxStaticText *static_serial_text = new wxStaticText(parent, wxID_ANY, _L("Presets"), wxDefaultPosition, wxDefaultSize);
    optionSizer->Add(static_serial_text, 0, wxEXPAND | wxALL, 0);
    optionSizer->SetMinSize(OPTION_SIZE);
    horizontal_sizer->Add(optionSizer, 0, wxEXPAND | wxALL, FromDIP(10));
 
    wxBoxSizer *radioBoxSizer = new wxBoxSizer(wxVERTICAL);
 
    radioBoxSizer->Add(create_radio_item(m_exprot_type.preset_bundle, parent, wxEmptyString, m_export_type_btns), 0, wxEXPAND | wxALL, 0);
    radioBoxSizer->Add(0, 0, 0, wxTOP, FromDIP(6));
    wxStaticText *static_export_printer_preset_bundle_text = new wxStaticText(parent, wxID_ANY, _L("Printer and all the filament and process presets that belongs to the printer.\n"
                                                                                                   "Can be shared with others."), wxDefaultPosition, wxDefaultSize);
    static_export_printer_preset_bundle_text->SetFont(Label::Body_12);
    static_export_printer_preset_bundle_text->SetForegroundColour(wxColour("#6B6B6B"));
    radioBoxSizer->Add(static_export_printer_preset_bundle_text, 0, wxEXPAND | wxLEFT, FromDIP(22));
    wxBoxSizer *include_bed_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_include_bed_assets = new ::CheckBox(parent);
    m_include_bed_assets->SetValue(true);
    include_bed_sizer->Add(m_include_bed_assets, 0, wxALIGN_CENTER_VERTICAL, 0);
    m_include_bed_assets_label = new wxStaticText(parent, wxID_ANY, _L("Include custom bed texture and model"));
    m_include_bed_assets_label->SetFont(Label::Body_12);
    m_include_bed_assets_label->SetForegroundColour(wxColour("#6B6B6B"));
    include_bed_sizer->Add(m_include_bed_assets_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(5));
    radioBoxSizer->Add(0, 0, 0, wxTOP, FromDIP(6));
    radioBoxSizer->Add(include_bed_sizer, 0, wxEXPAND | wxLEFT, FromDIP(22));
    update_include_bed_assets_enabled();
    radioBoxSizer->Add(create_radio_item(m_exprot_type.filament_bundle, parent, wxEmptyString, m_export_type_btns), 0, wxEXPAND | wxTOP, FromDIP(10));
    wxStaticText *static_export_filament_preset_bundle_text = new wxStaticText(parent, wxID_ANY, _L("User's filament preset set.\nCan be shared with others."),
                                                                                                    wxDefaultPosition, wxDefaultSize);
    static_export_filament_preset_bundle_text->SetFont(Label::Body_12);
    static_export_filament_preset_bundle_text->SetForegroundColour(wxColour("#6B6B6B"));
    radioBoxSizer->Add(static_export_filament_preset_bundle_text, 0, wxEXPAND | wxLEFT, FromDIP(22));
    radioBoxSizer->Add(create_radio_item(m_exprot_type.printer_preset, parent, wxEmptyString, m_export_type_btns), 0, wxEXPAND | wxTOP, FromDIP(10));
    radioBoxSizer->Add(create_radio_item(m_exprot_type.filament_preset, parent, wxEmptyString, m_export_type_btns), 0, wxEXPAND | wxTOP, FromDIP(10));
    radioBoxSizer->Add(create_radio_item(m_exprot_type.process_preset, parent, wxEmptyString, m_export_type_btns), 0, wxEXPAND | wxTOP, FromDIP(10));
    horizontal_sizer->Add(radioBoxSizer, 0, wxEXPAND | wxALL, FromDIP(10));
 
    return horizontal_sizer;
}

References _L, Label::Body_12, create_radio_item(), m_export_type_btns, m_exprot_type, m_include_bed_assets, m_include_bed_assets_label, OPTION_SIZE, update_include_bed_assets_enabled(), and wxStaticText.

Referenced by ExportConfigsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

create_radio_item()

wxBoxSizer * Slic3r::GUI::ExportConfigsDialog::create_radio_item ( wxString title, wxWindow * parent, wxString tooltip, std::vector< std::pair< RadioBox *, wxString > > & radiobox_list )

private

{
    wxBoxSizer *horizontal_sizer = new wxBoxSizer(wxHORIZONTAL);
    RadioBox *  radiobox         = new RadioBox(parent);
    horizontal_sizer->Add(radiobox, 0, wxEXPAND | wxALL, 0);
    horizontal_sizer->Add(0, 0, 0, wxEXPAND | wxLEFT, FromDIP(5));
    radiobox_list.push_back(std::make_pair(radiobox, title));
    int btn_idx = radiobox_list.size() - 1;
    radiobox->Bind(wxEVT_LEFT_DOWN, [this, &radiobox_list, btn_idx](wxMouseEvent &e) {
        select_curr_radiobox(radiobox_list, btn_idx);
        });
 
    wxStaticText *text = new wxStaticText(parent, wxID_ANY, title, wxDefaultPosition, wxDefaultSize);
    text->Bind(wxEVT_LEFT_DOWN, [this, &radiobox_list, btn_idx](wxMouseEvent &e) {
        select_curr_radiobox(radiobox_list, btn_idx);
        });
    horizontal_sizer->Add(text, 0, wxEXPAND | wxLEFT, 0);
 
    radiobox->SetToolTip(tooltip);
    text->SetToolTip(tooltip);
    return horizontal_sizer;
}

References select_curr_radiobox(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Referenced by create_export_config_item().

Here is the call graph for this function:

Here is the caller graph for this function:

create_select_printer()

wxBoxSizer * Slic3r::GUI::ExportConfigsDialog::create_select_printer ( wxWindow * parent )

private

{
    wxBoxSizer *horizontal_sizer = new wxBoxSizer(wxVERTICAL);
 
    wxBoxSizer *  optionSizer        = new wxBoxSizer(wxVERTICAL);
    m_serial_text           = new wxStaticText(parent, wxID_ANY, _L("Please select a preset type you want to export"), wxDefaultPosition, wxDefaultSize);
    optionSizer->Add(m_serial_text, 0, wxEXPAND | wxALL, 0);
    optionSizer->SetMinSize(OPTION_SIZE);
    horizontal_sizer->Add(optionSizer, 0, wxEXPAND | wxALL, FromDIP(10));
    m_scrolled_preset_window = new wxScrolledWindow(parent);
    m_scrolled_preset_window->SetScrollRate(5, FromDIP(20));
    m_scrolled_preset_window->SetBackgroundColour(*wxWHITE);
    m_scrolled_preset_window->SetMaxSize(wxSize(FromDIP(660), FromDIP(400)));
    m_scrolled_preset_window->SetSize(wxSize(FromDIP(660), FromDIP(400)));
    wxBoxSizer *scrolled_window = new wxBoxSizer(wxHORIZONTAL);
 
    m_presets_window = new wxPanel(m_scrolled_preset_window, wxID_ANY);
    m_presets_window->SetBackgroundColour(*wxWHITE);
    wxBoxSizer *select_printer_sizer  = new wxBoxSizer(wxVERTICAL);
 
    m_preset_sizer = new wxGridSizer(3, FromDIP(5), FromDIP(5));
    select_printer_sizer->Add(m_preset_sizer, 0, wxEXPAND, FromDIP(5));
    m_presets_window->SetSizer(select_printer_sizer);
    scrolled_window->Add(m_presets_window, 0, wxEXPAND, 0);
    m_scrolled_preset_window->SetSizerAndFit(scrolled_window);
 
    horizontal_sizer->Add(m_scrolled_preset_window, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(10));
 
    return horizontal_sizer;
}

References _L, m_preset_sizer, m_presets_window, m_scrolled_preset_window, m_serial_text, OPTION_SIZE, and wxStaticText.

Referenced by ExportConfigsDialog().

Here is the caller graph for this function:

data_init()

void Slic3r::GUI::ExportConfigsDialog::data_init ( )

private

{
    // Delete the Temp folder
    boost::filesystem::path folder(data_dir() + "/" + PRESET_USER_DIR + "/" + "Temp");
    if (boost::filesystem::exists(folder)) boost::filesystem::remove_all(folder);
 
    boost::system::error_code ec;
    boost::filesystem::path user_folder(data_dir() + "/" + PRESET_USER_DIR);
    bool                      temp_folder_exist = true;
    if (!boost::filesystem::exists(user_folder)) {
        if (!boost::filesystem::create_directories(user_folder, ec)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << user_folder << " "<<ec.message();
            temp_folder_exist = false;
        }
    }
    boost::filesystem::path temp_folder(user_folder / "Temp");
    if (!boost::filesystem::exists(temp_folder)) {
        if (!boost::filesystem::create_directories(temp_folder, ec)) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " create directory failed: " << temp_folder << " " << ec.message();
            temp_folder_exist = false;
        }
    }
    if (!temp_folder_exist) {
        MessageDialog dlg(this, _L("Failed to create temporary folder, please try Export Configs again."), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxYES_NO | wxYES_DEFAULT | wxCENTRE);
        dlg.ShowModal();
        EndModal(wxCANCEL);
    }
 
    PresetBundle preset_bundle(*wxGetApp().preset_bundle);
 
    const std::deque<Preset> & printer_presets = preset_bundle.printers.get_presets();
    for (const Preset &printer_preset : printer_presets) {
 
        std::string preset_name        = printer_preset.name;
        if (!printer_preset.is_visible || printer_preset.is_default || printer_preset.is_project_embedded) continue;
        if (preset_bundle.printers.select_preset_by_name(preset_name, true)) {
            preset_bundle.update_compatible(PresetSelectCompatibleType::Always);
 
            const std::deque<Preset> &filament_presets = preset_bundle.filaments.get_presets();
            for (const Preset &filament_preset : filament_presets) {
                if (!filament_preset.is_user()) continue;
                if (filament_preset.is_compatible) {
                    Preset *new_filament_preset = new Preset(filament_preset);
                    m_filament_presets[preset_name].push_back(new_filament_preset);
                }
            }
 
            const std::deque<Preset> &process_presets = preset_bundle.prints.get_presets();
            for (const Preset &process_preset : process_presets) {
                if (!process_preset.is_user()) continue;
                if (process_preset.is_compatible) {
                    Preset *new_prpcess_preset = new Preset(process_preset);
                    m_process_presets[preset_name].push_back(new_prpcess_preset);
                }
            }
 
            Preset *new_printer_preset     = new Preset(printer_preset);
            earse_preset_fields_for_safe(new_printer_preset);
            m_printer_presets[preset_name] = new_printer_preset;
        }
    }
    const std::deque<Preset> &filament_presets = preset_bundle.filaments.get_presets();
    for (const Preset &filament_preset : filament_presets) {
        if (!filament_preset.can_overwrite()) continue;
        Preset *new_filament_preset = new Preset(filament_preset);
        const Preset *base_filament_preset = preset_bundle.filaments.get_preset_base(*new_filament_preset);
 
        if (base_filament_preset == nullptr) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to find base preset";
            continue;
        }
        std::string filament_preset_name = base_filament_preset->name;
        std::string machine_name         = get_machine_name(filament_preset_name);
        m_filament_name_to_presets[get_filament_name(filament_preset_name)].push_back(std::make_pair(get_vendor_name(machine_name), new_filament_preset));
    }
}

References _L, Slic3r::Always, Slic3r::data_dir(), earse_preset_fields_for_safe(), Slic3r::GUI::DPIDialog::EndModal(), Slic3r::PresetBundle::filaments, Slic3r::GUI::get_filament_name(), Slic3r::GUI::get_machine_name(), Slic3r::PresetCollection::get_preset_base(), Slic3r::PresetCollection::get_presets(), Slic3r::GUI::get_vendor_name(), m_filament_name_to_presets, m_filament_presets, m_printer_presets, m_process_presets, Slic3r::Preset::name, Slic3r::Preset, PRESET_USER_DIR, Slic3r::PresetBundle::printers, Slic3r::PresetBundle::prints, Slic3r::PresetCollection::select_preset_by_name(), Slic3r::GUI::DPIAware< P >::ShowModal(), SLIC3R_APP_FULL_NAME, and Slic3r::PresetBundle::update_compatible().

Referenced by ExportConfigsDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

earse_preset_fields_for_safe()

bool Slic3r::GUI::ExportConfigsDialog::earse_preset_fields_for_safe ( Preset * preset )

private

{
    if (preset->type != Preset::Type::TYPE_PRINTER) return true;
 
    boost::filesystem::path file_path(data_dir() + "/" + PRESET_USER_DIR + "/" + "Temp" + "/" + (preset->name + ".json"));
    preset->file = file_path.make_preferred().string();
 
    DynamicPrintConfig &config = preset->config;
    config.erase("print_host");
    config.erase("print_host_webui");
    config.erase("printhost_apikey");
    config.erase("printhost_cafile");
    config.erase("printhost_user");
    config.erase("printhost_password");
    config.erase("printhost_port");
 
    preset->save(nullptr);
    return true;
}

References Slic3r::Preset::config, Slic3r::data_dir(), Slic3r::DynamicConfig::erase(), Slic3r::Preset::file, Slic3r::Preset::name, PRESET_USER_DIR, Slic3r::Preset::save(), Slic3r::Preset::type, and Slic3r::Preset::TYPE_PRINTER.

Referenced by data_init().

Here is the call graph for this function:

Here is the caller graph for this function:

em_unit()

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

inlineinherited

{ return m_em_unit; }

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

Here is the caller graph for this function:

enable_force_rescale()

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

inlineinherited

{ m_force_rescale = true; }

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; }

has_check_box_selected()

bool Slic3r::GUI::ExportConfigsDialog::has_check_box_selected ( )

private

{
    for (std::pair<::CheckBox *, Preset *> checkbox_preset : m_preset) {
        if (checkbox_preset.first->GetValue()) return true;
    }
    for (std::pair<::CheckBox *, std::string> checkbox_filament_name : m_printer_name) {
        if (checkbox_filament_name.first->GetValue()) return true;
    }
 
    return false;
}

References m_preset, and m_printer_name.

Referenced by create_dialog_buttons().

Here is the caller graph for this function:

initial_file_name()

std::string Slic3r::GUI::ExportConfigsDialog::initial_file_name ( const wxString & path, const std::string file_name )

private

{
    std::string             export_path         = into_u8(path);
    boost::filesystem::path printer_export_path = (boost::filesystem::path(export_path) / file_name).make_preferred();
    if (boost::filesystem::exists(printer_export_path)) {
        MessageDialog dlg(this, wxString::Format(_L("The \'%s\' folder already exists in the current directory. Do you want to clear it and rebuild it\?\nIf not, a time suffix will be added, and you can modify the name after creation."), file_name), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxYES_NO | wxYES_DEFAULT | wxCENTRE);
        int           res = dlg.ShowModal();
        if (wxID_YES == res) {
            try {
                boost::filesystem::remove_all(printer_export_path);
            }
            catch(...) {
                MessageDialog dlg(this,
                                  wxString::Format(_L("The file: %s\nmay have been opened by another program.\nPlease close it and try again."),
                                                      encode_path(printer_export_path.string().c_str())),
                                  wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
                dlg.ShowModal();
                return "initial_failed";
            }
            export_path = printer_export_path.string();
        } else if (wxID_NO == res) {
            export_path = printer_export_path.string();
            export_path = export_path.substr(0, export_path.find(".zip"));
            std::string              export_path_with_time;
            boost::filesystem::path *printer_export_path_with_time = nullptr;
            do {
                if (printer_export_path_with_time) {
                    delete printer_export_path_with_time;
                    printer_export_path_with_time = nullptr;
                }
                export_path_with_time         = export_path + " " + get_curr_time() + ".zip";
                printer_export_path_with_time = new boost::filesystem::path(export_path_with_time);
            } while (boost::filesystem::exists(*printer_export_path_with_time));
            export_path = export_path_with_time;
            if (printer_export_path_with_time) {
                delete printer_export_path_with_time;
                printer_export_path_with_time = nullptr;
            }
        } else {
            return "";
        }
    } else {
        export_path = printer_export_path.string();
    }
    return export_path;
}

References _L, Slic3r::encode_path(), Slic3r::GUI::get_curr_time(), Slic3r::GUI::into_u8(), Slic3r::GUI::DPIAware< P >::ShowModal(), and SLIC3R_APP_FULL_NAME.

Referenced by archive_filament_preset_to_file(), archive_printer_preset_to_file(), and archive_process_preset_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

initial_file_path()

std::string Slic3r::GUI::ExportConfigsDialog::initial_file_path ( const wxString & path, const std::string & sub_file_path )

private

{
    std::string             export_path         = into_u8(path);
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "initial file path and path is:" << export_path << " and sub path is: " << sub_file_path;
    boost::filesystem::path printer_export_path = (boost::filesystem::path(export_path) / sub_file_path).make_preferred();
    if (!boost::filesystem::exists(printer_export_path)) {
        boost::filesystem::create_directories(printer_export_path);
        export_path = printer_export_path.string();
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "Same path exists, delete and rebuild, and path is: " << export_path;
    }
    return export_path;
}

References Slic3r::GUI::into_u8().

Referenced by archive_filament_bundle_to_file(), and archive_preset_bundle_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

initial_zip_archive()

mz_bool Slic3r::GUI::ExportConfigsDialog::initial_zip_archive ( mz_zip_archive & zip_archive, const std::string & file_path )

private

{
    mz_zip_zero_struct(&zip_archive);
    mz_bool status;
 
    // Initialize the ZIP file to write to the structure, using memory storage
 
    std::string export_dir = encode_path(file_path.c_str());
    status                 = mz_zip_writer_init_file(&zip_archive, export_dir.c_str(), 0);
    return status;
}

References Slic3r::encode_path().

Referenced by archive_filament_bundle_to_file(), archive_preset_bundle_to_file(), and save_presets_to_zip().

Here is the call graph for this function:

Here is the caller graph for this function:

is_new_scale_factor()

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

inlineprivateinherited

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

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::ExportConfigsDialog::on_dpi_changed ( const wxRect & suggested_rect )

overrideprivatevirtual

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

                                                                     {
    if (m_include_bed_assets)
        m_include_bed_assets->Rescale();
    Layout();
}

References m_include_bed_assets.

on_sys_color_changed()

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

inlineprotectedvirtualinherited

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

{};

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;
    }

save_presets_to_zip()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::save_presets_to_zip ( const std::string & export_file, const std::vector< std::pair< std::string, std::string > > & config_paths )

private

{
    mz_zip_archive zip_archive;
    mz_bool        status = initial_zip_archive(zip_archive, export_file);
 
    if (MZ_FALSE == status) {
        BOOST_LOG_TRIVIAL(info) << "Failed to initialize ZIP archive";
        return ExportCase::INITIALIZE_FAIL;
    }
 
    for (std::pair<std::string, std::string> config_path : config_paths) {
        std::string preset_name = config_path.first;
 
        // Add a file to the ZIP file
        status = mz_zip_writer_add_file(&zip_archive, (preset_name).c_str(), encode_path(config_path.second.c_str()).c_str(), NULL, 0, MZ_DEFAULT_COMPRESSION);
        // status = mz_zip_writer_add_mem(&zip_archive, ("printer/" + printer_preset->name + ".json").c_str(), json_contents, strlen(json_contents), MZ_DEFAULT_COMPRESSION);
        if (MZ_FALSE == status) {
            BOOST_LOG_TRIVIAL(info) << preset_name << " Filament preset failed to add file to ZIP archive";
            mz_zip_writer_end(&zip_archive);
            return ExportCase::ADD_FILE_FAIL;
        }
        BOOST_LOG_TRIVIAL(info) << "Printer preset json add successful: " << preset_name;
    }
    return save_zip_archive_to_file(zip_archive);
}

References ADD_FILE_FAIL, Slic3r::encode_path(), initial_zip_archive(), INITIALIZE_FAIL, and save_zip_archive_to_file().

Referenced by archive_filament_preset_to_file(), archive_printer_preset_to_file(), and archive_process_preset_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

save_zip_archive_to_file()

ExportConfigsDialog::ExportCase Slic3r::GUI::ExportConfigsDialog::save_zip_archive_to_file ( mz_zip_archive & zip_archive )

private

{
    // Complete writing of ZIP file
    mz_bool status = mz_zip_writer_finalize_archive(&zip_archive);
    if (MZ_FALSE == status) {
        BOOST_LOG_TRIVIAL(info) << "Failed to finalize ZIP archive";
        mz_zip_writer_end(&zip_archive);
        return ExportCase::FINALIZE_FAIL;
    }
 
    // Release ZIP file to write structure and related resources
    mz_zip_writer_end(&zip_archive);
 
    return ExportCase::CASE_COUNT;
}

References CASE_COUNT, and FINALIZE_FAIL.

Referenced by archive_filament_bundle_to_file(), archive_preset_bundle_to_file(), and save_presets_to_zip().

Here is the caller graph for this function:

scale_factor()

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

inlineinherited

{ return m_scale_factor; }

select_curr_radiobox()

void Slic3r::GUI::ExportConfigsDialog::select_curr_radiobox ( std::vector< std::pair< RadioBox *, wxString > > & radiobox_list, int btn_idx )

private

{
    int len = radiobox_list.size();
    for (int i = 0; i < len; ++i) {
        if (i == btn_idx) {
            radiobox_list[i].first->SetValue(true);
            const wxString &export_type = radiobox_list[i].second;
            m_preset_sizer->Clear(true);
            m_printer_name.clear();
            m_preset.clear();
            PresetBundle *preset_bundle = wxGetApp().preset_bundle;
            this->Freeze();
            if (export_type == m_exprot_type.preset_bundle) {
                for (std::pair<std::string, Preset *> preset : m_printer_presets) {
                    std::string preset_name = preset.first;
                    //printer preset mast have user's filament or process preset or printer preset is user preset
                    if (m_filament_presets.find(preset_name) == m_filament_presets.end() && m_process_presets.find(preset_name) == m_process_presets.end() && preset.second->is_system) continue;
                    wxString printer_name = wxString::FromUTF8(preset_name);
                    m_preset_sizer->Add(create_checkbox(m_presets_window, preset.second, printer_name, m_preset), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(5));
                }
                m_serial_text->SetLabel(_L("Only display printers with changes to printer, filament, and process presets are displayed."));
            }else if (export_type == m_exprot_type.filament_bundle) {
                for (std::pair<std::string, std::vector<std::pair<std::string, Preset*>>> filament_name_to_preset : m_filament_name_to_presets) {
                    if (filament_name_to_preset.second.empty()) continue;
                    wxString filament_name = wxString::FromUTF8(filament_name_to_preset.first);
                    m_preset_sizer->Add(create_checkbox(m_presets_window, filament_name, m_printer_name), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(5));
                }
                m_serial_text->SetLabel(_L("Only display the filament names with changes to filament presets."));
            } else if (export_type == m_exprot_type.printer_preset) {
                for (std::pair<std::string, Preset *> preset : m_printer_presets) {
                    if (preset.second->is_system) continue;
                    wxString printer_name = wxString::FromUTF8(preset.first);
                    m_preset_sizer->Add(create_checkbox(m_presets_window, preset.second, printer_name, m_preset), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT,
                                        FromDIP(5));
                }
                m_serial_text->SetLabel(_L("Only printer names with user printer presets will be displayed, and each preset you choose will be exported as a ZIP archive."));
            } else if (export_type == m_exprot_type.filament_preset) {
                for (std::pair<std::string, std::vector<std::pair<std::string, Preset *>>> filament_name_to_preset : m_filament_name_to_presets) {
                    if (filament_name_to_preset.second.empty()) continue;
                    wxString filament_name = wxString::FromUTF8(filament_name_to_preset.first);
                    m_preset_sizer->Add(create_checkbox(m_presets_window, filament_name, m_printer_name), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(5));
                }
                m_serial_text->SetLabel(_L("Only the filament names with user filament presets will be displayed, \nand all user filament presets in each filament name you select will be exported as a ZIP archive."));
            } else if (export_type == m_exprot_type.process_preset) {
                for (std::pair<std::string, std::vector<Preset *>> presets : m_process_presets) {
                    Preset *      printer_preset = preset_bundle->printers.find_preset(presets.first, false);
                    if (!printer_preset) continue;
                    if (!printer_preset->is_system) continue;
                    if (preset_bundle->printers.get_preset_base(*printer_preset) != printer_preset) continue;
                    for (Preset *preset : presets.second) {
                        if (!preset->is_system) {
                            wxString printer_name = wxString::FromUTF8(presets.first);
                            m_preset_sizer->Add(create_checkbox(m_presets_window, printer_name, m_printer_name), 0, wxEXPAND | wxTOP | wxLEFT | wxRIGHT, FromDIP(5));
                            break;
                        }
                    }
 
                }
                m_serial_text->SetLabel(_L("Only printer names with changed process presets will be displayed, \nand all user process presets in each printer name you select will be exported as a ZIP archive."));
            }
            //m_presets_window->SetSizerAndFit(m_preset_sizer);
            m_presets_window->Layout();
            m_presets_window->Fit();
            int width  = m_presets_window->GetSize().GetWidth();
            int height = m_presets_window->GetSize().GetHeight();
            m_scrolled_preset_window->SetMinSize(wxSize(std::min(1200, width), std::min(600, height)));
            m_scrolled_preset_window->SetMaxSize(wxSize(std::min(1200, width), std::min(600, height)));
            m_scrolled_preset_window->SetSize(wxSize(std::min(1200, width), std::min(600, height)));
            this->SetSizerAndFit(m_main_sizer);
            Layout();
            Fit();
            Refresh();
            adjust_dialog_in_screen(this);
            this->Thaw();
        } else {
            radiobox_list[i].first->SetValue(false);
        }
    }
    update_include_bed_assets_enabled();
}

References _L, Slic3r::GUI::adjust_dialog_in_screen(), Slic3r::GUI::create_checkbox(), Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_preset_base(), Slic3r::Preset::is_system, m_exprot_type, m_filament_name_to_presets, m_filament_presets, m_main_sizer, m_preset, m_preset_sizer, m_presets_window, m_printer_name, m_printer_presets, m_process_presets, m_scrolled_preset_window, m_serial_text, Slic3r::PresetBundle::printers, and update_include_bed_assets_enabled().

Referenced by create_radio_item().

Here is the call graph for this function:

Here is the caller graph for this function:

set_em_unit()

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

inlineinherited

{ m_em_unit = v; }

set_prev_scale_factor()

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

inlineinherited

{ m_prev_scale_factor = v; }

set_scale_factor()

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

inlineinherited

{ m_scale_factor = v; }

show_export_result()

void Slic3r::GUI::ExportConfigsDialog::show_export_result ( const ExportCase & export_case )

private

{
    MessageDialog *msg_dlg = nullptr;
    switch (export_case) {
    case ExportCase::INITIALIZE_FAIL:
        msg_dlg = new MessageDialog(this, _L("initialize fail"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    case ExportCase::ADD_FILE_FAIL:
        msg_dlg = new MessageDialog(this, _L("add file fail"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    case ExportCase::ADD_BUNDLE_STRUCTURE_FAIL:
        msg_dlg = new MessageDialog(this, _L("add bundle structure file fail"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    case ExportCase::FINALIZE_FAIL:
        msg_dlg = new MessageDialog(this, _L("finalize fail"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    case ExportCase::OPEN_ZIP_WRITTEN_FILE:
        msg_dlg = new MessageDialog(this, _L("open zip written fail"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    case ExportCase::EXPORT_SUCCESS:
        msg_dlg = new MessageDialog(this, _L("Export successful"), wxString(SLIC3R_APP_FULL_NAME) + " - " + _L("Info"), wxOK | wxCENTRE);
        break;
    }
 
    if (msg_dlg) {
        msg_dlg->ShowModal();
        delete msg_dlg;
        msg_dlg = nullptr;
    }
}

References _L, ADD_BUNDLE_STRUCTURE_FAIL, ADD_FILE_FAIL, EXPORT_SUCCESS, FINALIZE_FAIL, INITIALIZE_FAIL, OPEN_ZIP_WRITTEN_FILE, Slic3r::GUI::DPIAware< P >::ShowModal(), and SLIC3R_APP_FULL_NAME.

Referenced by create_dialog_buttons().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowModal()

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

inlineinherited

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

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

Here is the caller graph for this function:

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_include_bed_assets_enabled()

void Slic3r::GUI::ExportConfigsDialog::update_include_bed_assets_enabled ( )

private

{
    const bool on = get_curr_radio_type(m_export_type_btns) == m_exprot_type.preset_bundle;
    if (m_include_bed_assets)
        m_include_bed_assets->Enable(on);
    if (m_include_bed_assets_label)
        m_include_bed_assets_label->Enable(on);
}

References Slic3r::GUI::get_curr_radio_type(), m_export_type_btns, m_exprot_type, m_include_bed_assets, and m_include_bed_assets_label.

Referenced by create_export_config_item(), and select_curr_radiobox().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_can_rescale

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

privateinherited

{ true };

m_em_unit

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

privateinherited

m_export_type_btns

std::vector<std::pair<RadioBox *, wxString> > Slic3r::GUI::ExportConfigsDialog::m_export_type_btns

private

Referenced by create_dialog_buttons(), create_export_config_item(), and update_include_bed_assets_enabled().

m_exprot_type

ExportType Slic3r::GUI::ExportConfigsDialog::m_exprot_type

private

Referenced by ExportConfigsDialog(), create_dialog_buttons(), create_export_config_item(), select_curr_radiobox(), and update_include_bed_assets_enabled().

m_filament_name_to_presets

std::unordered_map<std::string, std::vector<std::pair<std::string, Preset *> > > Slic3r::GUI::ExportConfigsDialog::m_filament_name_to_presets

private

Referenced by ~ExportConfigsDialog(), archive_filament_bundle_to_file(), archive_filament_preset_to_file(), data_init(), and select_curr_radiobox().

m_filament_presets

std::unordered_map<std::string, std::vector<Preset *> > Slic3r::GUI::ExportConfigsDialog::m_filament_presets

private

Referenced by ~ExportConfigsDialog(), archive_preset_bundle_to_file(), data_init(), and select_curr_radiobox().

m_force_rescale

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

privateinherited

{ false };

m_include_bed_assets

::CheckBox* Slic3r::GUI::ExportConfigsDialog::m_include_bed_assets = nullptr

private

Referenced by create_dialog_buttons(), create_export_config_item(), on_dpi_changed(), and update_include_bed_assets_enabled().

m_include_bed_assets_label

wxStaticText* Slic3r::GUI::ExportConfigsDialog::m_include_bed_assets_label = nullptr

private

Referenced by create_export_config_item(), and update_include_bed_assets_enabled().

m_main_sizer

wxBoxSizer* Slic3r::GUI::ExportConfigsDialog::m_main_sizer = nullptr

private

Referenced by ExportConfigsDialog(), and select_curr_radiobox().

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_preset

std::vector<std::pair<::CheckBox *, Preset *> > Slic3r::GUI::ExportConfigsDialog::m_preset

private

Referenced by archive_preset_bundle_to_file(), archive_printer_preset_to_file(), has_check_box_selected(), and select_curr_radiobox().

m_preset_sizer

wxGridSizer* Slic3r::GUI::ExportConfigsDialog::m_preset_sizer = nullptr

private

Referenced by create_select_printer(), and select_curr_radiobox().

m_presets_window

wxPanel* Slic3r::GUI::ExportConfigsDialog::m_presets_window = nullptr

private

Referenced by create_select_printer(), and select_curr_radiobox().

m_prev_scale_factor

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

privateinherited

m_printer_name

std::vector<std::pair<::CheckBox *, std::string> > Slic3r::GUI::ExportConfigsDialog::m_printer_name

private

Referenced by archive_filament_bundle_to_file(), archive_filament_preset_to_file(), archive_process_preset_to_file(), has_check_box_selected(), and select_curr_radiobox().

m_printer_presets

std::unordered_map<std::string, Preset *> Slic3r::GUI::ExportConfigsDialog::m_printer_presets

private

Referenced by ~ExportConfigsDialog(), data_init(), and select_curr_radiobox().

m_process_presets

std::unordered_map<std::string, std::vector<Preset *> > Slic3r::GUI::ExportConfigsDialog::m_process_presets

private

Referenced by ~ExportConfigsDialog(), archive_preset_bundle_to_file(), archive_process_preset_to_file(), data_init(), and select_curr_radiobox().

m_scale_factor

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

privateinherited

m_scrolled_preset_window

wxScrolledWindow* Slic3r::GUI::ExportConfigsDialog::m_scrolled_preset_window = nullptr

private

Referenced by create_select_printer(), and select_curr_radiobox().

m_serial_text

wxStaticText* Slic3r::GUI::ExportConfigsDialog::m_serial_text = nullptr

private

Referenced by create_select_printer(), and select_curr_radiobox().

---

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

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