Slic3r::GUI::ConfigWizard::priv Struct Reference

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

Collaboration diagram for Slic3r::GUI::ConfigWizard::priv:

Public Member Functions
	priv (ConfigWizard *q)
void	load_pages ()
void	init_dialog_size ()
void	load_vendors ()
void	add_page (ConfigWizardPage *page)
void	enable_next (bool enable)
void	set_start_page (ConfigWizard::StartPage start_page)
void	create_3rdparty_pages ()
void	set_run_reason (RunReason run_reason)
void	update_materials (Technology technology)
void	on_custom_setup (const bool custom_wanted)
void	on_printer_pick (PagePrinters *page, const PrinterPickerEvent &evt)
void	select_default_materials_for_printer_model (const VendorProfile::PrinterModel &printer_model, Technology technology)
void	select_default_materials_for_printer_models (Technology technology, const std::set< const VendorProfile::PrinterModel * > &printer_models)
void	on_3rdparty_install (const VendorProfile *vendor, bool install)
bool	on_bnt_finish ()
bool	check_and_install_missing_materials (Technology technology, const std::string &only_for_model_id=std::string())
bool	apply_config (AppConfig *app_config, PresetBundle *preset_bundle, const PresetUpdater *updater, bool &apply_keeped_changes)
void	update_presets_in_config (const std::string &section, const std::string &alias_key, bool add)
bool	check_fff_selected ()
bool	check_sla_selected ()
int	em () const

Public Attributes
ConfigWizard *	q
ConfigWizard::RunReason	run_reason = RR_USER
AppConfig	appconfig_new
BundleMap	bundles
Materials	filaments
Materials	sla_materials
PresetAliases	aliases_fff
PresetAliases	aliases_sla
std::unique_ptr< DynamicPrintConfig >	custom_config
bool	any_fff_selected
bool	any_sla_selected
bool	custom_printer_selected { false }
bool	only_sla_mode { false }
wxScrolledWindow *	hscroll = nullptr
wxBoxSizer *	hscroll_sizer = nullptr
wxBoxSizer *	btnsizer = nullptr
ConfigWizardPage *	page_current = nullptr
ConfigWizardIndex *	index = nullptr
Button *	btn_prev = nullptr
Button *	btn_next = nullptr
Button *	btn_finish = nullptr
Button *	btn_cancel = nullptr
PageMaterials *	page_filaments = nullptr
PageMaterials *	page_sla_materials = nullptr
PageCustom *	page_custom = nullptr
PageFirmware *	page_firmware = nullptr
PageBedShape *	page_bed = nullptr
PageDiameters *	page_diams = nullptr
PageTemperatures *	page_temps = nullptr
std::vector< ConfigWizardPage * >	all_pages

Detailed Description

Constructor & Destructor Documentation

priv()

Slic3r::GUI::ConfigWizard::priv::priv ( ConfigWizard * q )

inline

        : q(q)
        , appconfig_new()
        , filaments(T_FFF)
        , sla_materials(T_SLA)
    {}

References Slic3r::GUI::ConfigWizard::ConfigWizard(), appconfig_new, filaments, q, sla_materials, Slic3r::GUI::T_FFF, and Slic3r::GUI::T_SLA.

Here is the call graph for this function:

Member Function Documentation

add_page()

void Slic3r::GUI::ConfigWizard::priv::add_page

(

ConfigWizardPage *

page

)

{
    const int proportion = (page->shortname == _L("Filaments")) || (page->shortname == _L("SLA Materials")) ? 1 : 0;
    hscroll_sizer->Add(page, proportion, wxEXPAND);
    all_pages.push_back(page);
}

References _L, all_pages, Slic3r::GUI::ConfigWizard::ConfigWizardPage, hscroll_sizer, and Slic3r::GUI::ConfigWizardPage::shortname.

Referenced by create_3rdparty_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_config()

bool Slic3r::GUI::ConfigWizard::priv::apply_config	(	AppConfig *	app_config,
		PresetBundle *	preset_bundle,
		const PresetUpdater *	updater,
		bool &	apply_keeped_changes )

{
    wxString header, caption = _L("Configuration is edited in ConfigWizard");
    const auto enabled_vendors = appconfig_new.vendors();
 
    bool suppress_sla_printer = model_has_multi_part_objects(wxGetApp().model());
    PrinterTechnology preferred_pt = ptAny;
    auto get_preferred_printer_technology = [enabled_vendors, suppress_sla_printer](const std::string& bundle_name, const Bundle& bundle) {
        const auto config = enabled_vendors.find(bundle_name);
        PrinterTechnology pt = ptAny;
        if (config != enabled_vendors.end()) {
            for (const auto& model : bundle.vendor_profile->models) {
                if (const auto model_it = config->second.find(model.id);
                    model_it != config->second.end() && model_it->second.size() > 0) {
                    if (pt == ptAny)
                        pt = model.technology;
                    // if preferred printer model has SLA printer technology it's important to check the model for multypart state
                    if (pt == ptSLA && suppress_sla_printer)
                        continue;
                    else
                        return pt;
                }
            }
        }
        return pt;
    };
    // Prusa printers are considered first, then 3rd party.
    if (preferred_pt = get_preferred_printer_technology("BBL", bundles.bbl_bundle());
        preferred_pt == ptAny || (preferred_pt == ptSLA && suppress_sla_printer)) {
        for (const auto& bundle : bundles) {
            //BBS: set BBL as default
            if (bundle.second.is_bbl_bundle) { continue; }
            if (PrinterTechnology pt = get_preferred_printer_technology(bundle.first, bundle.second); pt == ptAny)
                continue;
            else if (preferred_pt == ptAny)
                preferred_pt = pt;
            if(!(preferred_pt == ptAny || (preferred_pt == ptSLA && suppress_sla_printer)))
                break;
        }
    }
 
    if (preferred_pt == ptSLA && !wxGetApp().may_switch_to_SLA_preset(caption))
        return false;
 
    bool check_unsaved_preset_changes = false;
    if (check_unsaved_preset_changes)
        header = _L("All user presets will be deleted.");
    int act_btns = ActionButtons::KEEP;
    if (!check_unsaved_preset_changes)
        act_btns |= ActionButtons::SAVE;
 
    // Install bundles from resources if needed:
    std::vector<std::string> install_bundles;
    for (const auto &pair : bundles) {
        if (! pair.second.is_in_resources) { continue; }
 
        //BBS: set BBL as default
        if (pair.second.is_bbl_bundle) {
            // Always install Prusa bundle, because it has a lot of filaments/materials
            // likely to be referenced by other profiles.
            install_bundles.emplace_back(pair.first);
            continue;
        }
 
        const auto vendor = enabled_vendors.find(pair.first);
        if (vendor == enabled_vendors.end()) { continue; }
 
        size_t size_sum = 0;
        for (const auto &model : vendor->second) { size_sum += model.second.size(); }
 
        if (size_sum > 0) {
            // This vendor needs to be installed
            install_bundles.emplace_back(pair.first);
        }
    }
    if (!check_unsaved_preset_changes)
        if ((check_unsaved_preset_changes = install_bundles.size() > 0))
            header = _L_PLURAL("A new vendor was installed and one of its printers will be activated", "New vendors were installed and one of their printers will be activated", install_bundles.size());
 
    // Decide whether to create snapshot based on run_reason and the reset profile checkbox
    bool snapshot = true;
    Snapshot::Reason snapshot_reason = Snapshot::SNAPSHOT_UPGRADE;
    switch (run_reason) {
        case ConfigWizard::RR_DATA_EMPTY:
            snapshot = false;
            break;
        case ConfigWizard::RR_DATA_LEGACY:
            snapshot = true;
            break;
        case ConfigWizard::RR_DATA_INCOMPAT:
            // In this case snapshot has already been taken by
            // PresetUpdater with the appropriate reason
            snapshot = false;
            break;
        case ConfigWizard::RR_USER:
            snapshot = false;
            snapshot_reason = Snapshot::SNAPSHOT_USER;
            break;
    }
 
    //BBS: remove snapshot logic
    /*if (snapshot && ! take_config_snapshot_cancel_on_error(*app_config, snapshot_reason, "", _u8L("Do you want to continue changing the configuration?")))
        return false;*/
 
    if (check_unsaved_preset_changes &&
        !wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
        return false;
 
    if (install_bundles.size() > 0) {
        // Install bundles from resources.
        // Don't create snapshot - we've already done that above if applicable.
        if (! updater->install_bundles_rsrc(std::move(install_bundles), false))
            return false;
    } else {
        BOOST_LOG_TRIVIAL(info) << "No bundles need to be installed from resources";
    }
 
    std::string preferred_model;
    std::string preferred_variant;
    const auto enabled_vendors_old = app_config->vendors();
    auto get_preferred_printer_model = [enabled_vendors, enabled_vendors_old, preferred_pt](const std::string& bundle_name, const Bundle& bundle, std::string& variant) {
        const auto config = enabled_vendors.find(bundle_name);
        if (config == enabled_vendors.end())
            return std::string();
        for (const auto& model : bundle.vendor_profile->models) {
            if (const auto model_it = config->second.find(model.id);
                model_it != config->second.end() && model_it->second.size() > 0 &&
                preferred_pt == model.technology) {
                variant = *model_it->second.begin();
                const auto config_old = enabled_vendors_old.find(bundle_name);
                if (config_old == enabled_vendors_old.end())
                    return model.id;
                const auto model_it_old = config_old->second.find(model.id);
                if (model_it_old == config_old->second.end())
                    return model.id;
                else if (model_it_old->second != model_it->second) {
                    for (const auto& var : model_it->second)
                        if (model_it_old->second.find(var) == model_it_old->second.end()) {
                            variant = var;
                            return model.id;
                        }
                }
            }
        }
        if (!variant.empty())
            variant.clear();
        return std::string();
    };
    // Prusa printers are considered first, then 3rd party.
    if (preferred_model = get_preferred_printer_model("BBL", bundles.bbl_bundle(), preferred_variant);
        preferred_model.empty()) {
        for (const auto& bundle : bundles) {
            if (bundle.second.is_bbl_bundle) { continue; }
            if (preferred_model = get_preferred_printer_model(bundle.first, bundle.second, preferred_variant);
                !preferred_model.empty())
                    break;
        }
    }
 
    // if unsaved changes was not cheched till this moment
    if (!check_unsaved_preset_changes) {
        if ((check_unsaved_preset_changes = !preferred_model.empty())) {
            header = _L("A new Printer was installed and it will be activated.");
            if (!wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
                return false;
        }
        else if ((check_unsaved_preset_changes = enabled_vendors_old != enabled_vendors)) {
            header = _L("Some Printers were uninstalled.");
            if (!wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
                return false;
        }
    }
 
    std::string first_added_filament, first_added_sla_material;
    auto get_first_added_material_preset = [this, app_config](const std::string& section_name, std::string& first_added_preset) {
        if (appconfig_new.has_section(section_name)) {
            // get first of new added preset names
            const std::map<std::string, std::string>& old_presets = app_config->has_section(section_name) ? app_config->get_section(section_name) : std::map<std::string, std::string>();
            first_added_preset = get_first_added_preset(old_presets, appconfig_new.get_section(section_name));
        }
    };
    get_first_added_material_preset(AppConfig::SECTION_FILAMENTS, first_added_filament);
 
    //BBS skip sla get_first_added_material_preset(AppConfig::SECTION_MATERIALS, first_added_sla_material);
 
    // if unsaved changes was not cheched till this moment
    if (!check_unsaved_preset_changes) {
        if ((check_unsaved_preset_changes = !first_added_filament.empty() || !first_added_sla_material.empty())) {
            header = !first_added_filament.empty() ? 
                     _L("A new filament was installed and it will be activated.") :
                     _L("A new SLA material was installed and it will be activated.");
            if (!wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
                return false;
        }
        else {
            //BBS
            bool is_filaments_changed = app_config->get_section(AppConfig::SECTION_FILAMENTS) != appconfig_new.get_section(AppConfig::SECTION_FILAMENTS);
            if ((check_unsaved_preset_changes = is_filaments_changed)) {
                header = _L("Some filaments were uninstalled.");
                if (!wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
                    return false;
            }
 
            /*bool is_filaments_changed = app_config->get_section(AppConfig::SECTION_FILAMENTS) != appconfig_new.get_section(AppConfig::SECTION_FILAMENTS);
            bool is_sla_materials_changed = app_config->get_section(AppConfig::SECTION_MATERIALS) != appconfig_new.get_section(AppConfig::SECTION_MATERIALS);
            if ((check_unsaved_preset_changes = is_filaments_changed || is_sla_materials_changed)) {
                header = is_filaments_changed ? _L("Some filaments were uninstalled.") : _L("Some SLA materials were uninstalled.");
                if (!wxGetApp().check_and_keep_current_preset_changes(caption, header, act_btns, &apply_keeped_changes))
                    return false;
            }*/
        }
    }
 
    // apply materials in app_config
    //BBS skip sla
    for (const std::string& section_name : {AppConfig::SECTION_FILAMENTS})
        app_config->set_section(section_name, appconfig_new.get_section(section_name));
 
    app_config->set_vendors(appconfig_new);
 
    if (check_unsaved_preset_changes)
        preset_bundle->load_presets(*app_config, ForwardCompatibilitySubstitutionRule::EnableSilentDisableSystem, 
                                    {preferred_model, preferred_variant, first_added_filament, first_added_sla_material});
 
    if (!only_sla_mode && page_custom->custom_wanted()) {
        // if unsaved changes was not cheched till this moment
        if (!check_unsaved_preset_changes && 
            !wxGetApp().check_and_keep_current_preset_changes(caption, _L("Custom printer was installed and it will be activated."), act_btns, &apply_keeped_changes))
            return false;
 
        page_firmware->apply_custom_config(*custom_config);
        page_bed->apply_custom_config(*custom_config);
        page_diams->apply_custom_config(*custom_config);
        //page_temps->apply_custom_config(*custom_config);
 
#if ENABLE_COPY_CUSTOM_BED_MODEL_AND_TEXTURE
        copy_bed_model_and_texture_if_needed(*custom_config);
#endif // ENABLE_COPY_CUSTOM_BED_MODEL_AND_TEXTURE
 
        custom_config->set_key_value("filament_colour", wxGetApp().preset_bundle->project_config.option("filament_colour"));
        const std::string profile_name = page_custom->profile_name();
        Semver semver(SLIC3R_VERSION);
        preset_bundle->load_config_from_wizard(profile_name, *custom_config, semver);
 
        wxGetApp().plater()->sidebar().update_presets(Slic3r::Preset::Type::TYPE_PRINTER);
        wxGetApp().plater()->sidebar().update_presets(Slic3r::Preset::Type::TYPE_FILAMENT);
        wxGetApp().plater()->sidebar().update_presets(Slic3r::Preset::Type::TYPE_PRINT);
    }
 
    // Update the selections from the compatibilty.
    preset_bundle->export_selections(*app_config);
 
    // Update Preset Combobox
    //auto evt = new SimpleEvent(EVT_UPDATE_PRESET_CB);
    //wxQueueEvent(wxGetApp().mainframe, evt);
 
    return true;
}

References _L, _L_PLURAL, appconfig_new, bundles, custom_config, Slic3r::EnableSilentDisableSystem, Slic3r::PresetBundle::export_selections(), Slic3r::GUI::get_first_added_preset(), Slic3r::AppConfig::get_section(), Slic3r::AppConfig::has_section(), Slic3r::PresetUpdater::install_bundles_rsrc(), Slic3r::GUI::KEEP, Slic3r::PresetBundle::load_config_from_wizard(), Slic3r::PresetBundle::load_presets(), Slic3r::model_has_multi_part_objects(), only_sla_mode, Slic3r::ConfigBase::option(), page_bed, page_custom, page_diams, page_firmware, Slic3r::PresetBundle::project_config, Slic3r::ptAny, Slic3r::ptSLA, Slic3r::GUI::ConfigWizard::RR_DATA_EMPTY, Slic3r::GUI::ConfigWizard::RR_DATA_INCOMPAT, Slic3r::GUI::ConfigWizard::RR_DATA_LEGACY, Slic3r::GUI::ConfigWizard::RR_USER, run_reason, Slic3r::GUI::SAVE, Slic3r::AppConfig::SECTION_FILAMENTS, Slic3r::GUI::section_name(), Slic3r::AppConfig::set_section(), Slic3r::AppConfig::set_vendors(), Slic3r::GUI::Snapshot::SNAPSHOT_UPGRADE, Slic3r::GUI::Snapshot::SNAPSHOT_USER, Slic3r::Preset::TYPE_FILAMENT, Slic3r::Preset::TYPE_PRINT, Slic3r::Preset::TYPE_PRINTER, Slic3r::var(), and Slic3r::AppConfig::vendors().

Here is the call graph for this function:

check_and_install_missing_materials()

bool Slic3r::GUI::ConfigWizard::priv::check_and_install_missing_materials	(	Technology	technology,
		const std::string &	only_for_model_id = std::string() )

{
  // Walk over all installed Printer presets and verify whether there is a filament or SLA material profile installed at the same PresetBundle,
  // which is compatible with it.
    const auto printer_models_missing_materials = [this, only_for_model_id](PrinterTechnology technology, const std::string &section)
    {
    const std::map<std::string, std::string> &appconfig_presets = appconfig_new.has_section(section) ? appconfig_new.get_section(section) : std::map<std::string, std::string>();
      std::set<const VendorProfile::PrinterModel*> printer_models_without_material;
        for (const auto &pair : bundles) {
          const PresetCollection &materials = pair.second.preset_bundle->materials(technology);
          for (const auto &printer : pair.second.preset_bundle->printers) {
                if (printer.is_visible && printer.printer_technology() == technology) {
                const VendorProfile::PrinterModel *printer_model = PresetUtils::system_printer_model(printer);
                assert(printer_model != nullptr);
                if ((only_for_model_id.empty() || only_for_model_id == printer_model->id) &&
                  printer_models_without_material.find(printer_model) == printer_models_without_material.end()) {
                      bool has_material = false;
                        for (const auto& preset : appconfig_presets) {
                    if (preset.second == "1" || preset.second == "true") {
                      const Preset *material = materials.find_preset(preset.first, false);
                      if (material != nullptr && is_compatible_with_printer(PresetWithVendorProfile(*material, nullptr), PresetWithVendorProfile(printer, nullptr))) {
                          has_material = true;
                            break;
                        }
                      }
                  }
                  if (! has_material)
                    printer_models_without_material.insert(printer_model);
              }
                }
            }
        }
        assert(printer_models_without_material.empty() || only_for_model_id.empty() || only_for_model_id == (*printer_models_without_material.begin())->id);
        return printer_models_without_material;
    };
 
    const auto ask_and_select_default_materials = [this](const wxString &message, const std::set<const VendorProfile::PrinterModel*> &printer_models, Technology technology)
    {
        //wxMessageDialog msg(q, message, _L("Notice"), wxYES_NO);
        MessageDialog msg(q, message, _L("Notice"), wxYES_NO);
        if (msg.ShowModal() == wxID_YES)
            select_default_materials_for_printer_models(technology, printer_models);
    };
 
    const auto printer_model_list = [](const std::set<const VendorProfile::PrinterModel*> &printer_models) -> wxString {
      wxString out;
      for (const VendorProfile::PrinterModel *printer_model : printer_models) {
            wxString name = from_u8(printer_model->name);
        out += "\t\t";
        out += name;
        out += "\n";
      }
      return out;
    };
 
    if (any_fff_selected && (technology & T_FFF)) {
      std::set<const VendorProfile::PrinterModel*> printer_models_without_material = printer_models_missing_materials(ptFFF, AppConfig::SECTION_FILAMENTS);
      if (! printer_models_without_material.empty()) {
      if (only_for_model_id.empty())
        ask_and_select_default_materials(
          _L("The following FFF printer models have no filament selected:") +
          "\n\n\t" +
          printer_model_list(printer_models_without_material) +
          "\n\n\t" +
          _L("Do you want to select default filaments for these FFF printer models?"),
          printer_models_without_material,
          T_FFF);
      else
        select_default_materials_for_printer_model(**printer_models_without_material.begin(), T_FFF);
      return false;
    }
    }
 
    /* BBS skip SLA
    if (any_sla_selected && (technology & T_SLA)) {
      std::set<const VendorProfile::PrinterModel*> printer_models_without_material = printer_models_missing_materials(ptSLA, AppConfig::SECTION_MATERIALS);
      if (! printer_models_without_material.empty()) {
          if (only_for_model_id.empty())
              ask_and_select_default_materials(
          _L("The following SLA printer models have no materials selected:") +
                "\n\n\t" +
            printer_model_list(printer_models_without_material) +
          "\n\n\t" +
          _L("Do you want to select default SLA materials for these printer models?"),
          printer_models_without_material,
                T_SLA);
          else
        select_default_materials_for_printer_model(**printer_models_without_material.begin(), T_SLA);
          return false;
      }
    }
    */
 
    return true;
}

References _L, any_fff_selected, appconfig_new, bundles, Slic3r::PresetCollection::find_preset(), Slic3r::GUI::from_u8(), Slic3r::VendorProfile::PrinterModel::id, Slic3r::is_compatible_with_printer(), Slic3r::GUI::ConfigWizard::name(), Slic3r::ptFFF, q, Slic3r::AppConfig::SECTION_FILAMENTS, select_default_materials_for_printer_model(), select_default_materials_for_printer_models(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::PresetUtils::system_printer_model(), and Slic3r::GUI::T_FFF.

Referenced by on_bnt_finish(), and on_printer_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

check_fff_selected()

bool Slic3r::GUI::ConfigWizard::priv::check_fff_selected

(

)

{
    return false;
}

Referenced by on_printer_pick().

Here is the caller graph for this function:

check_sla_selected()

bool Slic3r::GUI::ConfigWizard::priv::check_sla_selected

(

)

{
    return false;
}

Referenced by on_printer_pick().

Here is the caller graph for this function:

create_3rdparty_pages()

void Slic3r::GUI::ConfigWizard::priv::create_3rdparty_pages

(

)

{
    for (const auto &pair : bundles) {
        const VendorProfile *vendor = pair.second.vendor_profile;
        //Orca: add custom as default
        if (vendor->id == PresetBundle::ORCA_DEFAULT_BUNDLE) { continue; }
 
        bool is_fff_technology = false;
        bool is_sla_technology = false;
 
        for (auto& model: vendor->models)
        {
            if (!is_fff_technology && model.technology == ptFFF)
                 is_fff_technology = true;
            if (!is_sla_technology && model.technology == ptSLA)
                 is_sla_technology = true;
        }
 
        PagePrinters* pageFFF = nullptr;
        PagePrinters* pageSLA = nullptr;
 
        if (is_fff_technology) {
            pageFFF = new PagePrinters(q, vendor->name + " " +_L("FFF Technology Printers"), vendor->name+" FFF", *vendor, 1, T_FFF);
            add_page(pageFFF);
        }
 
        if (is_sla_technology) {
            pageSLA = new PagePrinters(q, vendor->name + " " + _L("SLA Technology Printers"), vendor->name+" MSLA", *vendor, 1, T_SLA);
            add_page(pageSLA);
        }
 
        //pages_3rdparty.insert({vendor->id, {pageFFF, pageSLA}});
    }
}

References _L, add_page(), bundles, Slic3r::VendorProfile::id, Slic3r::VendorProfile::models, Slic3r::VendorProfile::name, Slic3r::PresetBundle::ORCA_DEFAULT_BUNDLE, Slic3r::ptFFF, Slic3r::ptSLA, q, Slic3r::GUI::T_FFF, and Slic3r::GUI::T_SLA.

Here is the call graph for this function:

em()

int Slic3r::GUI::ConfigWizard::priv::em ( ) const

inline

{ return 10; }

Referenced by init_dialog_size().

Here is the caller graph for this function:

enable_next()

void Slic3r::GUI::ConfigWizard::priv::enable_next

(

bool

enable

)

{
    btn_next->Enable(enable);
    btn_finish->Enable(enable);
}

References btn_finish, and btn_next.

init_dialog_size()

void Slic3r::GUI::ConfigWizard::priv::init_dialog_size

(

)

{
    // Clamp the Wizard size based on screen dimensions
 
    const auto idx = wxDisplay::GetFromWindow(q);
    wxDisplay display(idx != wxNOT_FOUND ? idx : 0u);
 
    const auto disp_rect = display.GetClientArea();
    wxRect window_rect(
        disp_rect.x + disp_rect.width / 20,
        disp_rect.y + disp_rect.height / 20,
        9*disp_rect.width / 10,
        9*disp_rect.height / 10);
 
    const int width_hint = index->GetSize().GetWidth() + 90 * em()/*std::max(90 * em(), (only_sla_mode ? page_msla->get_width() : page_fff->get_width()) + 30 * em())*/;    // XXX: magic constant, I found no better solution
    if (width_hint < window_rect.width) {
        window_rect.x += (window_rect.width - width_hint) / 2;
        window_rect.width = width_hint;
    }
 
    q->SetSize(window_rect);
}

References em(), index, and q.

Here is the call graph for this function:

load_pages()

void Slic3r::GUI::ConfigWizard::priv::load_pages

(

)

{
    wxWindowUpdateLocker freeze_guard(q);
    (void)freeze_guard;
 
    const ConfigWizardPage *former_active = index->active_page();
 
    index->clear();
 
    // Printers
    if (!only_sla_mode) {
        index->add_page(page_custom);
        if (page_custom->custom_wanted()) {
            index->add_page(page_firmware);
            index->add_page(page_bed);
            index->add_page(page_diams);
            //index->add_page(page_temps);
        }
   
    // Filaments & Materials
        if (any_fff_selected) { index->add_page(page_filaments); }
    }
    if (any_sla_selected) { index->add_page(page_sla_materials); }
 
    // there should to be selected at least one printer
    btn_finish->Enable(any_fff_selected || any_sla_selected || custom_printer_selected);
 
    index->go_to(former_active);   // Will restore the active item/page if possible
 
    q->Layout();
// This Refresh() is needed to avoid ugly artifacts after printer selection, when no one vendor was selected from the very beginnig
    q->Refresh();
}

References any_fff_selected, any_sla_selected, btn_finish, Slic3r::GUI::ConfigWizard::ConfigWizardPage, custom_printer_selected, index, only_sla_mode, page_bed, page_custom, page_diams, page_filaments, page_firmware, page_sla_materials, and q.

Referenced by on_3rdparty_install(), on_custom_setup(), and on_printer_pick().

Here is the call graph for this function:

Here is the caller graph for this function:

load_vendors()

void Slic3r::GUI::ConfigWizard::priv::load_vendors

(

)

{
    bundles = BundleMap::load();
 
    // Load up the set of vendors / models / variants the user has had enabled up till now
    AppConfig *app_config = wxGetApp().app_config;
    if (! app_config->legacy_datadir()) {
        appconfig_new.set_vendors(*app_config);
    } else {
        // In case of legacy datadir, try to guess the preference based on the printer preset files that are present
        //BBS: change directories by design
        const auto printer_dir = fs::path(Slic3r::data_dir()) / PRESET_SYSTEM_DIR / PRESET_PRINTER_NAME;
        for (auto &dir_entry : boost::filesystem::directory_iterator(printer_dir))
            if (Slic3r::is_ini_file(dir_entry)) {
                auto needle = legacy_preset_map.find(dir_entry.path().filename().string());
                if (needle == legacy_preset_map.end()) { continue; }
 
                const auto &model = needle->second.first;
                const auto &variant = needle->second.second;
                appconfig_new.set_variant("BambuResearch", model, variant, true);
            }
    }
 
    // Initialize the is_visible flag in printer Presets
    for (auto &pair : bundles) {
        pair.second.preset_bundle->load_installed_printers(appconfig_new);
    }
 
    // Copy installed filaments and SLA material names from app_config to appconfig_new
    // while resolving current names of profiles, which were renamed in the meantime.
    for (PrinterTechnology technology : { ptFFF, ptSLA }) {
      const std::string &section_name = (technology == ptFFF) ? AppConfig::SECTION_FILAMENTS : AppConfig::SECTION_MATERIALS;
    std::map<std::string, std::string> section_new;
    if (app_config->has_section(section_name)) {
      const std::map<std::string, std::string> &section_old = app_config->get_section(section_name);
            for (const auto& material_name_and_installed : section_old)
        if (material_name_and_installed.second == "true") {
          // Material is installed. Resolve it in bundles.
                    size_t num_found = 0;
          const std::string &material_name = material_name_and_installed.first;
            for (auto &bundle : bundles) {
              const PresetCollection &materials = bundle.second.preset_bundle->materials(technology);
              const Preset           *preset    = materials.find_preset(material_name);
                        if (preset != nullptr) {
                            // Materal preset was found, mark it as installed.
                            section_new[preset->name] = "true";
                            ++ num_found;
                        }
            }
                    if (num_found == 0)
                      BOOST_LOG_TRIVIAL(error) << boost::format("Profile %1% was not found in installed vendor Preset Bundles.") % material_name;
                    else if (num_found > 1)
                      BOOST_LOG_TRIVIAL(error) << boost::format("Profile %1% was found in %2% vendor Preset Bundles.") % material_name % num_found;
                }
    }
        appconfig_new.set_section(section_name, section_new);
    };
}

References appconfig_new, bundles, Slic3r::data_dir(), Slic3r::PresetCollection::find_preset(), Slic3r::AppConfig::get_section(), Slic3r::AppConfig::has_section(), Slic3r::is_ini_file(), Slic3r::AppConfig::legacy_datadir(), Slic3r::GUI::legacy_preset_map, Slic3r::GUI::BundleMap::load(), Slic3r::Preset::name, PRESET_PRINTER_NAME, PRESET_SYSTEM_DIR, Slic3r::ptFFF, Slic3r::ptSLA, Slic3r::AppConfig::SECTION_FILAMENTS, Slic3r::AppConfig::SECTION_MATERIALS, and Slic3r::GUI::section_name().

Here is the call graph for this function:

on_3rdparty_install()

void Slic3r::GUI::ConfigWizard::priv::on_3rdparty_install	(	const VendorProfile *	vendor,
		bool	install )

{
    //auto it = pages_3rdparty.find(vendor->id);
    //wxCHECK_RET(it != pages_3rdparty.end(), "Internal error: GUI page not found for 3rd party vendor profile");
 
    //for (PagePrinters* page : { it->second.first, it->second.second }) 
    //    if (page) {
    //        if (page->install && !install)
    //            page->select_all(false);
    //        page->install = install;
    //        // if some 3rd vendor is selected, select first printer for them
    //        if (install)
    //            page->printer_pickers[0]->select_one(0, true);
    //        page->Layout();
    //    }
 
    load_pages();
}

References load_pages().

Here is the call graph for this function:

on_bnt_finish()

bool Slic3r::GUI::ConfigWizard::priv::on_bnt_finish

(

)

{
    wxBusyCursor wait;
    /* When Filaments or Sla Materials pages are activated, 
     * materials for this pages are automaticaly updated and presets are reloaded.
     * 
     * But, if _Finish_ button was clicked without activation of those pages 
     * (for example, just some printers were added/deleted), 
     * than last changes wouldn't be updated for filaments/materials.
     * SO, do that before close of Wizard
     */
 
    update_materials(T_ANY);
    if (any_fff_selected)
        page_filaments->reload_presets();
 
  // theres no need to check that filament is selected if we have only custom printer
    if (custom_printer_selected && !any_fff_selected && !any_sla_selected) return true;
    // check, that there is selected at least one filament/material
    return check_and_install_missing_materials(T_ANY);
}

References any_fff_selected, any_sla_selected, check_and_install_missing_materials(), custom_printer_selected, page_filaments, Slic3r::GUI::T_ANY, and update_materials().

Here is the call graph for this function:

on_custom_setup()

void Slic3r::GUI::ConfigWizard::priv::on_custom_setup

(

const bool

custom_wanted

)

{
  custom_printer_selected = custom_wanted;
    load_pages();
}

References custom_printer_selected, and load_pages().

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

Here is the call graph for this function:

Here is the caller graph for this function:

on_printer_pick()

void Slic3r::GUI::ConfigWizard::priv::on_printer_pick	(	PagePrinters *	page,
		const PrinterPickerEvent &	evt )

{
    if (check_sla_selected() != any_sla_selected ||
        check_fff_selected() != any_fff_selected) {
        any_fff_selected = check_fff_selected();
        any_sla_selected = check_sla_selected();
 
        load_pages();
    }
 
    // Update the is_visible flag on relevant printer profiles
    for (auto &pair : bundles) {
        if (pair.first != evt.vendor_id) { continue; }
 
        for (auto &preset : pair.second.preset_bundle->printers) {
            if (preset.config.opt_string("printer_model") == evt.model_id
                && preset.config.opt_string("printer_variant") == evt.variant_name) {
                preset.is_visible = evt.enable;
            }
        }
 
        // When a printer model is picked, but there is no material installed compatible with this printer model,
        // install default materials for selected printer model silently.
    check_and_install_missing_materials(page->technology, evt.model_id);
    }
 
    if (page->technology & T_FFF) {
        page_filaments->clear();
    }
}

References any_fff_selected, any_sla_selected, bundles, check_and_install_missing_materials(), check_fff_selected(), check_sla_selected(), Slic3r::GUI::PrinterPickerEvent::enable, load_pages(), Slic3r::GUI::PrinterPickerEvent::model_id, page_filaments, Slic3r::GUI::T_FFF, Slic3r::GUI::PagePrinters::technology, Slic3r::GUI::PrinterPickerEvent::variant_name, and Slic3r::GUI::PrinterPickerEvent::vendor_id.

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

Here is the call graph for this function:

Here is the caller graph for this function:

select_default_materials_for_printer_model()

void Slic3r::GUI::ConfigWizard::priv::select_default_materials_for_printer_model	(	const VendorProfile::PrinterModel &	printer_model,
		Technology	technology )

{
    PageMaterials* page_materials = technology & T_FFF ? page_filaments : page_sla_materials;
    for (const std::string& material : printer_model.default_materials)
        appconfig_new.set(page_materials->materials->appconfig_section(), material, "true");
}

References appconfig_new, Slic3r::GUI::Materials::appconfig_section(), Slic3r::VendorProfile::PrinterModel::default_materials, Slic3r::GUI::PageMaterials::materials, page_filaments, page_sla_materials, and Slic3r::GUI::T_FFF.

Referenced by check_and_install_missing_materials().

Here is the call graph for this function:

Here is the caller graph for this function:

select_default_materials_for_printer_models()

void Slic3r::GUI::ConfigWizard::priv::select_default_materials_for_printer_models	(	Technology	technology,
		const std::set< const VendorProfile::PrinterModel * > &	printer_models )

{
    PageMaterials     *page_materials    = technology & T_FFF ? page_filaments : page_sla_materials;
    const std::string &appconfig_section = page_materials->materials->appconfig_section();
 
    // Iterate printer_models and select default materials. If none available -> msg to user.
    std::vector<const VendorProfile::PrinterModel*> models_without_default;
    for (const VendorProfile::PrinterModel* printer_model : printer_models) {
        if (printer_model->default_materials.empty()) {
            models_without_default.emplace_back(printer_model);
        } else {
            for (const std::string& material : printer_model->default_materials)
                appconfig_new.set(appconfig_section, material, "true");
        }
    }
 
    if (!models_without_default.empty()) {
        std::string printer_names = "\n\n";
        for (const VendorProfile::PrinterModel* printer_model : models_without_default) {
            printer_names += printer_model->name + "\n";
        }
        printer_names += "\n\n";
        std::string message = (technology & T_FFF ?
            GUI::format(_L("The following printer profiles have no default filament: %1%Please select one manually."), printer_names) :
            GUI::format(_L("The following printer profiles have no default material: %1%Please select one manually."), printer_names));
        MessageDialog msg(q, message, _L("Notice"), wxOK);
        msg.ShowModal();
    }
 
    update_materials(technology);
    ((technology & T_FFF) ? page_filaments : page_sla_materials)->reload_presets();
}

References _L, appconfig_new, Slic3r::GUI::Materials::appconfig_section(), Slic3r::GUI::format(), Slic3r::GUI::PageMaterials::materials, page_filaments, page_sla_materials, q, Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::T_FFF, and update_materials().

Referenced by check_and_install_missing_materials().

Here is the call graph for this function:

Here is the caller graph for this function:

set_run_reason()

void Slic3r::GUI::ConfigWizard::priv::set_run_reason

(

RunReason

run_reason

)

{
    this->run_reason = run_reason;
    for (auto &page : all_pages) {
        page->set_run_reason(run_reason);
    }
}

References all_pages, and run_reason.

set_start_page()

void Slic3r::GUI::ConfigWizard::priv::set_start_page

(

ConfigWizard::StartPage

start_page

)

{
    switch (start_page) {
        case ConfigWizard::SP_CUSTOM:
            index->go_to(page_custom);
            btn_next->SetFocus();
            break;
        case ConfigWizard::SP_FILAMENTS:
            index->go_to(page_filaments);
            btn_finish->SetFocus();
            break;
        case ConfigWizard::SP_MATERIALS:
            index->go_to(page_sla_materials);
            btn_finish->SetFocus();
            break;
        default:
            index->go_to(page_custom);
            btn_next->SetFocus();
            break;
    }
}

References btn_finish, btn_next, index, page_custom, page_filaments, page_sla_materials, Slic3r::GUI::ConfigWizard::SP_CUSTOM, Slic3r::GUI::ConfigWizard::SP_FILAMENTS, and Slic3r::GUI::ConfigWizard::SP_MATERIALS.

update_materials()

void Slic3r::GUI::ConfigWizard::priv::update_materials

(

Technology

technology

)

{
    if (any_fff_selected && (technology & T_FFF)) {
        filaments.clear();
        aliases_fff.clear();
        // Iterate filaments in all bundles
        for (const auto &pair : bundles) {
            for (const auto &filament : pair.second.preset_bundle->filaments) {
                // Check if filament is already added
                if (filaments.containts(&filament))
          continue;
                // Iterate printers in all bundles
                for (const auto &printer : pair.second.preset_bundle->printers) {
          if (!printer.is_visible || printer.printer_technology() != ptFFF)
            continue;
                    // Filter out inapplicable printers
          if (is_compatible_with_printer(PresetWithVendorProfile(filament, filament.vendor), PresetWithVendorProfile(printer, printer.vendor))) {
            if (!filaments.containts(&filament)) {
              filaments.push(&filament);
              if (!filament.alias.empty())
                aliases_fff[filament.alias].insert(filament.name); 
            } 
            filaments.add_printer(&printer);
                    }
        }
        
            }
        }
        // count compatible printers
        for (const auto& preset : filaments.presets) {
 
            const auto filter = [preset](const std::pair<std::string, size_t> element) {
                return preset->alias == element.first;
            };
            if (std::find_if(filaments.compatibility_counter.begin(), filaments.compatibility_counter.end(), filter) != filaments.compatibility_counter.end()) {
                continue;
            }
            std::vector<size_t> idx_with_same_alias;
            for (size_t i = 0; i < filaments.presets.size(); ++i) {
                if (preset->alias == filaments.presets[i]->alias)
                    idx_with_same_alias.push_back(i);
            }
            size_t counter = 0;
            for (const auto& printer : filaments.printers) {
                if (!(*printer).is_visible || (*printer).printer_technology() != ptFFF)
                    continue;
                bool compatible = false;
                // Test otrher materials with same alias
                for (size_t i = 0; i < idx_with_same_alias.size() && !compatible; ++i) {
                    const Preset& prst = *(filaments.presets[idx_with_same_alias[i]]);
                    const Preset& prntr = *printer;
                    if (is_compatible_with_printer(PresetWithVendorProfile(prst, prst.vendor), PresetWithVendorProfile(prntr, prntr.vendor))) {
                        compatible = true;
                        break;
                    }
                }
                if (compatible)
                    counter++;
            }
            filaments.compatibility_counter.emplace_back(preset->alias, counter);
        }
    }
 
    if (any_sla_selected && (technology & T_SLA)) {
        sla_materials.clear();
        aliases_sla.clear();
 
        // Iterate SLA materials in all bundles
        for (const auto &pair : bundles) {
            for (const auto &material : pair.second.preset_bundle->sla_materials) {
                // Check if material is already added
                if (sla_materials.containts(&material))
                  continue;
                // Iterate printers in all bundles
        // For now, we only allow the profiles to be compatible with another profiles inside the same bundle.
                for (const auto& printer : pair.second.preset_bundle->printers) {
                    if(!printer.is_visible || printer.printer_technology() != ptSLA)
                        continue;
                    // Filter out inapplicable printers
                    if (is_compatible_with_printer(PresetWithVendorProfile(material, nullptr), PresetWithVendorProfile(printer, nullptr))) {
                        // Check if material is already added
                        if(!sla_materials.containts(&material)) {
                            sla_materials.push(&material);
                            if (!material.alias.empty())
                                aliases_sla[material.alias].insert(material.name);
                        }
                        sla_materials.add_printer(&printer);
                    }
                }
            }
        }
        // count compatible printers        
        for (const auto& preset : sla_materials.presets) {
            
            const auto filter = [preset](const std::pair<std::string, size_t> element) {
                return preset->alias == element.first;
            };
            if (std::find_if(sla_materials.compatibility_counter.begin(), sla_materials.compatibility_counter.end(), filter) != sla_materials.compatibility_counter.end()) {
                continue;
            }
            std::vector<size_t> idx_with_same_alias;
            for (size_t i = 0; i < sla_materials.presets.size(); ++i) {
                if(preset->alias == sla_materials.presets[i]->alias)
                    idx_with_same_alias.push_back(i);
            }
            size_t counter = 0;
            for (const auto& printer : sla_materials.printers) {
                if (!(*printer).is_visible || (*printer).printer_technology() != ptSLA)
                    continue;
                bool compatible = false;
                // Test otrher materials with same alias
                for (size_t i = 0; i < idx_with_same_alias.size() && !compatible; ++i) {
                    const Preset& prst = *(sla_materials.presets[idx_with_same_alias[i]]);
                    const Preset& prntr = *printer;
                    if (is_compatible_with_printer(PresetWithVendorProfile(prst, prst.vendor), PresetWithVendorProfile(prntr, prntr.vendor))) {
                        compatible = true;
                        break;
                    }
                }
                if (compatible)
                    counter++;
            }
            sla_materials.compatibility_counter.emplace_back(preset->alias, counter);
        }
    }
}

References aliases_fff, aliases_sla, any_fff_selected, any_sla_selected, bundles, filaments, Slic3r::is_compatible_with_printer(), Slic3r::ptFFF, Slic3r::ptSLA, sla_materials, Slic3r::GUI::T_FFF, Slic3r::GUI::T_SLA, and Slic3r::Preset::vendor.

Referenced by Slic3r::GUI::PageMaterials::on_activate(), on_bnt_finish(), and select_default_materials_for_printer_models().

Here is the call graph for this function:

Here is the caller graph for this function:

update_presets_in_config()

void Slic3r::GUI::ConfigWizard::priv::update_presets_in_config	(	const std::string &	section,
		const std::string &	alias_key,
		bool	add )

{
    const PresetAliases& aliases = section == AppConfig::SECTION_FILAMENTS ? aliases_fff : aliases_sla;
 
    auto update = [this, add](const std::string& s, const std::string& key) {
      assert(! s.empty());
        if (add)
            appconfig_new.set(s, key, "true");
        else
            appconfig_new.erase(s, key); 
    };
 
    // add or delete presets had a same alias 
    auto it = aliases.find(alias_key);
    if (it != aliases.end())
        for (const std::string& name : it->second)
            update(section, name);
}

References aliases_fff, aliases_sla, appconfig_new, Slic3r::GUI::ConfigWizard::name(), and Slic3r::AppConfig::SECTION_FILAMENTS.

Referenced by Slic3r::GUI::PageMaterials::select_material(), and Slic3r::GUI::PageMaterials::update_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

aliases_fff

PresetAliases Slic3r::GUI::ConfigWizard::priv::aliases_fff

Referenced by update_materials(), and update_presets_in_config().

aliases_sla

PresetAliases Slic3r::GUI::ConfigWizard::priv::aliases_sla

Referenced by update_materials(), and update_presets_in_config().

all_pages

std::vector<ConfigWizardPage*> Slic3r::GUI::ConfigWizard::priv::all_pages

Referenced by add_page(), and set_run_reason().

any_fff_selected

bool Slic3r::GUI::ConfigWizard::priv::any_fff_selected

Referenced by check_and_install_missing_materials(), load_pages(), on_bnt_finish(), on_printer_pick(), and update_materials().

any_sla_selected

bool Slic3r::GUI::ConfigWizard::priv::any_sla_selected

Referenced by load_pages(), on_bnt_finish(), on_printer_pick(), and update_materials().

appconfig_new

AppConfig Slic3r::GUI::ConfigWizard::priv::appconfig_new

Referenced by Slic3r::GUI::PagePrinters::PagePrinters(), priv(), apply_config(), check_and_install_missing_materials(), load_vendors(), select_default_materials_for_printer_model(), select_default_materials_for_printer_models(), Slic3r::GUI::PageMaterials::update_lists(), and update_presets_in_config().

btn_cancel

Button* Slic3r::GUI::ConfigWizard::priv::btn_cancel = nullptr

btn_finish

Button* Slic3r::GUI::ConfigWizard::priv::btn_finish = nullptr

Referenced by enable_next(), load_pages(), and set_start_page().

btn_next

Button* Slic3r::GUI::ConfigWizard::priv::btn_next = nullptr

Referenced by enable_next(), and set_start_page().

btn_prev

Button* Slic3r::GUI::ConfigWizard::priv::btn_prev = nullptr

btnsizer

wxBoxSizer* Slic3r::GUI::ConfigWizard::priv::btnsizer = nullptr

bundles

BundleMap Slic3r::GUI::ConfigWizard::priv::bundles

Referenced by apply_config(), check_and_install_missing_materials(), create_3rdparty_pages(), load_vendors(), on_printer_pick(), and update_materials().

custom_config

std::unique_ptr<DynamicPrintConfig> Slic3r::GUI::ConfigWizard::priv::custom_config

Referenced by apply_config().

custom_printer_selected

bool Slic3r::GUI::ConfigWizard::priv::custom_printer_selected { false }

{ false }; 

Referenced by load_pages(), on_bnt_finish(), and on_custom_setup().

filaments

Materials Slic3r::GUI::ConfigWizard::priv::filaments

Referenced by priv(), and update_materials().

hscroll

wxScrolledWindow* Slic3r::GUI::ConfigWizard::priv::hscroll = nullptr

hscroll_sizer

wxBoxSizer* Slic3r::GUI::ConfigWizard::priv::hscroll_sizer = nullptr

Referenced by add_page().

index

ConfigWizardIndex* Slic3r::GUI::ConfigWizard::priv::index = nullptr

Referenced by init_dialog_size(), load_pages(), and set_start_page().

only_sla_mode

bool Slic3r::GUI::ConfigWizard::priv::only_sla_mode { false }

{ false };

Referenced by apply_config(), and load_pages().

page_bed

PageBedShape* Slic3r::GUI::ConfigWizard::priv::page_bed = nullptr

Referenced by apply_config(), and load_pages().

page_current

ConfigWizardPage* Slic3r::GUI::ConfigWizard::priv::page_current = nullptr

page_custom

PageCustom* Slic3r::GUI::ConfigWizard::priv::page_custom = nullptr

Referenced by apply_config(), load_pages(), and set_start_page().

page_diams

PageDiameters* Slic3r::GUI::ConfigWizard::priv::page_diams = nullptr

Referenced by apply_config(), and load_pages().

page_filaments

PageMaterials* Slic3r::GUI::ConfigWizard::priv::page_filaments = nullptr

Referenced by load_pages(), on_bnt_finish(), on_printer_pick(), select_default_materials_for_printer_model(), select_default_materials_for_printer_models(), and set_start_page().

page_firmware

PageFirmware* Slic3r::GUI::ConfigWizard::priv::page_firmware = nullptr

Referenced by apply_config(), and load_pages().

page_sla_materials

PageMaterials* Slic3r::GUI::ConfigWizard::priv::page_sla_materials = nullptr

Referenced by load_pages(), select_default_materials_for_printer_model(), select_default_materials_for_printer_models(), and set_start_page().

page_temps

PageTemperatures* Slic3r::GUI::ConfigWizard::priv::page_temps = nullptr

q

ConfigWizard* Slic3r::GUI::ConfigWizard::priv::q

Referenced by priv(), check_and_install_missing_materials(), create_3rdparty_pages(), init_dialog_size(), load_pages(), and select_default_materials_for_printer_models().

run_reason

ConfigWizard::RunReason Slic3r::GUI::ConfigWizard::priv::run_reason = RR_USER

Referenced by apply_config(), and set_run_reason().

sla_materials

Materials Slic3r::GUI::ConfigWizard::priv::sla_materials

Referenced by priv(), and update_materials().

---

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

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