Slic3r::GUI::PageMaterials Struct Reference

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

Inheritance diagram for Slic3r::GUI::PageMaterials:

Collaboration diagram for Slic3r::GUI::PageMaterials:

Public Member Functions
	PageMaterials (ConfigWizard *parent, Materials *materials, wxString title, wxString shortname, wxString list1name)
void	reload_presets ()
void	update_lists (int sel_type, int sel_vendor, int last_selected_printer=-1)
void	on_material_highlighted (int sel_material)
void	on_material_hovered (int sel_material)
void	select_material (int i)
void	select_all (bool select)
void	clear ()
void	set_compatible_printers_html_window (const std::vector< std::string > &printer_names, bool all_printers=false)
void	clear_compatible_printers_label ()
void	sort_list_data (StringList *list, bool add_All_item, bool material_type_ordering)
void	sort_list_data (PresetList *list, const std::vector< ProfilePrintData > &data)
void	on_paint ()
void	on_mouse_move_on_profiles (wxMouseEvent &evt)
void	on_mouse_enter_profiles (wxMouseEvent &evt)
void	on_mouse_leave_profiles (wxMouseEvent &evt)
virtual void	on_activate () override
template<class T>
T *	append (T *thing, int proportion=0, int flag=wxEXPAND|wxTOP|wxBOTTOM, int border=10)
wxStaticText *	append_text (wxString text)
void	append_spacer (int space)
ConfigWizard::priv *	wizard_p () const
virtual void	apply_custom_config (DynamicPrintConfig &config)
virtual void	set_run_reason (ConfigWizard::RunReason run_reason)

Public Attributes
Materials *	materials
StringList *	list_printer
StringList *	list_type
StringList *	list_vendor
PresetList *	list_profile
wxArrayInt	sel_printers_prev
int	sel_type_prev
int	sel_vendor_prev
bool	presets_loaded
wxFlexGridSizer *	grid
wxHtmlWindow *	html_window
int	compatible_printers_width = { 100 }
std::string	empty_printers_label
bool	first_paint = { false }
int	last_hovered_item = { -1 }
ConfigWizard *	parent
const wxString	shortname
wxBoxSizer *	content
const unsigned	indent

Static Public Attributes
static const std::string	EMPTY

Detailed Description

Constructor & Destructor Documentation

PageMaterials()

Slic3r::GUI::PageMaterials::PageMaterials	(	ConfigWizard *	parent,
		Materials *	materials,
		wxString	title,
		wxString	shortname,
		wxString	list1name )

    : ConfigWizardPage(parent, std::move(title), std::move(shortname))
    , materials(materials)
  , list_printer(new  StringList(this, wxLB_MULTIPLE))
    , list_type(new StringList(this))
    , list_vendor(new StringList(this))
    , list_profile(new PresetList(this))
{
    SetBackgroundColour(*wxWHITE);
    append_spacer(VERTICAL_SPACING);
 
    const int em = parent->em_unit();
    const int list_h = 30*em;
 
 
  list_printer->SetMinSize(wxSize(23*em, list_h));
    list_type->SetMinSize(wxSize(13*em, list_h));
    list_vendor->SetMinSize(wxSize(13*em, list_h));
    list_profile->SetMinSize(wxSize(23*em, list_h));
 
    grid = new wxFlexGridSizer(4, em/2, em);
    grid->AddGrowableCol(3, 1);
    grid->AddGrowableRow(1, 1);
 
  grid->Add(new wxStaticText(this, wxID_ANY, _L("Printer:")));
    grid->Add(new wxStaticText(this, wxID_ANY, list1name));
    grid->Add(new wxStaticText(this, wxID_ANY, _L("Vendor:")));
    grid->Add(new wxStaticText(this, wxID_ANY, _L("Profile:")));
 
  grid->Add(list_printer, 0, wxEXPAND);
    grid->Add(list_type, 0, wxEXPAND);
    grid->Add(list_vendor, 0, wxEXPAND);
    grid->Add(list_profile, 1, wxEXPAND);
 
    auto *btn_sizer = new wxBoxSizer(wxHORIZONTAL);
    auto *sel_all = new Button(this, _L("All"));
    auto *sel_none = new Button(this, _L("None"));
 
    wxGetApp().UpdateDarkUI(sel_all);
    wxGetApp().UpdateDarkUI(sel_none);
 
 
    btn_sizer->Add(sel_all, 0, wxRIGHT, em / 2);
    btn_sizer->Add(sel_none);
 
    wxGetApp().UpdateDarkUI(list_printer);
    wxGetApp().UpdateDarkUI(list_type);
    wxGetApp().UpdateDarkUI(list_vendor);
    wxGetApp().UpdateDarkUI(sel_all);
    wxGetApp().UpdateDarkUI(sel_none);
    wxGetApp().UpdateDarkUI(list_profile);
 
    grid->Add(new wxBoxSizer(wxHORIZONTAL));
    grid->Add(new wxBoxSizer(wxHORIZONTAL));
    grid->Add(new wxBoxSizer(wxHORIZONTAL));
    grid->Add(btn_sizer, 0, wxALIGN_RIGHT);
 
    append(grid, 1, wxEXPAND);
 
    append_spacer(VERTICAL_SPACING);
 
    html_window = new wxHtmlWindow(this, wxID_ANY, wxDefaultPosition,
        wxSize(60 * em, 20 * em), wxHW_SCROLLBAR_AUTO);
    append(html_window, 0, wxEXPAND);
 
  list_printer->Bind(wxEVT_LISTBOX, [this](wxCommandEvent& evt) {
    update_lists(list_type->GetSelection(), list_vendor->GetSelection(), evt.GetInt());
    });
    list_type->Bind(wxEVT_LISTBOX, [this](wxCommandEvent &) {
        update_lists(list_type->GetSelection(), list_vendor->GetSelection());
    });
    list_vendor->Bind(wxEVT_LISTBOX, [this](wxCommandEvent &) {
        update_lists(list_type->GetSelection(), list_vendor->GetSelection());
    });
 
    list_profile->Bind(wxEVT_CHECKLISTBOX, [this](wxCommandEvent &evt) { select_material(evt.GetInt()); });
    list_profile->Bind(wxEVT_LISTBOX, [this](wxCommandEvent& evt) { on_material_highlighted(evt.GetInt()); });
 
    sel_all->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) { select_all(true); });
    sel_none->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) { select_all(false); });
    /*
    Bind(wxEVT_PAINT, [this](wxPaintEvent& evt) {on_paint();});
 
    list_profile->Bind(wxEVT_MOTION, [this](wxMouseEvent& evt) { on_mouse_move_on_profiles(evt); });
    list_profile->Bind(wxEVT_ENTER_WINDOW, [this](wxMouseEvent& evt) { on_mouse_enter_profiles(evt); });
    list_profile->Bind(wxEVT_LEAVE_WINDOW, [this](wxMouseEvent& evt) { on_mouse_leave_profiles(evt); });
    */
    reload_presets();
    set_compatible_printers_html_window(std::vector<std::string>(), false);
}

References Slic3r::GUI::ConfigWizardPage::ConfigWizardPage(), _L, Slic3r::GUI::ConfigWizardPage::append(), Slic3r::GUI::ConfigWizardPage::append_spacer(), grid, html_window, list_printer, list_profile, list_type, list_vendor, materials, on_material_highlighted(), Slic3r::GUI::ConfigWizardPage::parent, reload_presets(), select_all(), select_material(), set_compatible_printers_html_window(), Slic3r::GUI::ConfigWizardPage::shortname, update_lists(), Slic3r::GUI::VERTICAL_SPACING, and wxStaticText.

Here is the call graph for this function:

Member Function Documentation

append()

template<class T>

T * Slic3r::GUI::ConfigWizardPage::append ( T * thing, int proportion = 0, int flag = wxEXPAND|wxTOP|wxBOTTOM, int border = 10 )

inlineinherited

    {
        content->Add(thing, proportion, flag, border);
        return thing;
    }

References content.

Referenced by Slic3r::GUI::PageBedShape::PageBedShape(), Slic3r::GUI::PageCustom::PageCustom(), Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::PageFirmware::PageFirmware(), Slic3r::GUI::PageMaterials::PageMaterials(), Slic3r::GUI::PagePrinters::PagePrinters(), Slic3r::GUI::PageTemperatures::PageTemperatures(), Slic3r::GUI::PageWelcome::PageWelcome(), and append_text().

Here is the caller graph for this function:

append_spacer()

void Slic3r::GUI::ConfigWizardPage::append_spacer ( int space )

inherited

{
    // FIXME: scaling
    content->AddSpacer(space);
}

References content.

Referenced by Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::PageMaterials::PageMaterials(), and Slic3r::GUI::PageTemperatures::PageTemperatures().

Here is the caller graph for this function:

append_text()

wxStaticText * Slic3r::GUI::ConfigWizardPage::append_text ( wxString text )

inherited

{
    auto *widget = new wxStaticText(this, wxID_ANY, text, wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT);
    widget->Wrap(WRAP_WIDTH);
    widget->SetMinSize(wxSize(WRAP_WIDTH, -1));
    append(widget);
    return widget;
}

References append(), Slic3r::GUI::WRAP_WIDTH, and wxStaticText.

Referenced by Slic3r::GUI::PageBedShape::PageBedShape(), Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::PageFirmware::PageFirmware(), Slic3r::GUI::PageTemperatures::PageTemperatures(), and Slic3r::GUI::PageWelcome::PageWelcome().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_custom_config()

virtual void Slic3r::GUI::ConfigWizardPage::apply_custom_config ( DynamicPrintConfig & config )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::PageBedShape, Slic3r::GUI::PageDiameters, Slic3r::GUI::PageFirmware, and Slic3r::GUI::PageTemperatures.

{}

clear()

void Slic3r::GUI::PageMaterials::clear

(

)

{
  list_printer->Clear();
    list_type->Clear();
    list_vendor->Clear();
    list_profile->Clear();
  sel_printers_prev.Clear();
    sel_type_prev = wxNOT_FOUND;
    sel_vendor_prev = wxNOT_FOUND;
    presets_loaded = false;
}

References list_printer, list_profile, list_type, list_vendor, presets_loaded, sel_printers_prev, sel_type_prev, and sel_vendor_prev.

Referenced by reload_presets().

Here is the caller graph for this function:

clear_compatible_printers_label()

void Slic3r::GUI::PageMaterials::clear_compatible_printers_label

(

)

{
    set_compatible_printers_html_window(std::vector<std::string>(), false);
}

References set_compatible_printers_html_window().

Referenced by on_material_highlighted(), and update_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

on_activate()

void Slic3r::GUI::PageMaterials::on_activate ( )

overridevirtual

Reimplemented from Slic3r::GUI::ConfigWizardPage.

{
    if (! presets_loaded) {
        wizard_p()->update_materials(materials->technology);
        reload_presets();
    }
    first_paint = true;
}

References first_paint, materials, presets_loaded, reload_presets(), Slic3r::GUI::ConfigWizard::priv::update_materials(), and Slic3r::GUI::ConfigWizardPage::wizard_p().

Here is the call graph for this function:

on_material_highlighted()

void Slic3r::GUI::PageMaterials::on_material_highlighted

(

int

sel_material

)

{
    if (sel_material == last_hovered_item)
        return;
    if (sel_material == -1) {
        clear_compatible_printers_label();
        return;
    }
    last_hovered_item = sel_material;
    std::vector<std::string> tabs;
    tabs.push_back(std::string());
    tabs.push_back(std::string());
    tabs.push_back(std::string());
    //selected material string
    std::string material_name = list_profile->get_data(sel_material);
    // get material preset
    const std::vector<const Preset*> matching_materials = materials->get_presets_by_alias(material_name);
    if (matching_materials.empty())
    {
        clear_compatible_printers_label();
        return;
    }
    //find matching printers
    std::vector<std::string> names;
    for (const Preset* printer : materials->printers) {
        for (const Preset* material : matching_materials) {
            if (is_compatible_with_printer(PresetWithVendorProfile(*material, material->vendor), PresetWithVendorProfile(*printer, printer->vendor))) {
                names.push_back(printer->name);
                break;
            }
        }
    }
    set_compatible_printers_html_window(names, names.size() == materials->printers.size());
}

References clear_compatible_printers_label(), Slic3r::is_compatible_with_printer(), last_hovered_item, list_profile, materials, Slic3r::Preset::name, set_compatible_printers_html_window(), and Slic3r::Preset::vendor.

Referenced by PageMaterials().

Here is the call graph for this function:

Here is the caller graph for this function:

on_material_hovered()

void Slic3r::GUI::PageMaterials::on_material_hovered

(

int

sel_material

)

{
 
}

Referenced by on_mouse_leave_profiles(), and on_mouse_move_on_profiles().

Here is the caller graph for this function:

on_mouse_enter_profiles()

void Slic3r::GUI::PageMaterials::on_mouse_enter_profiles

(

wxMouseEvent &

evt

)

{}

References Slic3r::GUI::wxMouseEvent.

on_mouse_leave_profiles()

void Slic3r::GUI::PageMaterials::on_mouse_leave_profiles

(

wxMouseEvent &

evt

)

{
    on_material_hovered(-1);
}

References on_material_hovered(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_mouse_move_on_profiles()

void Slic3r::GUI::PageMaterials::on_mouse_move_on_profiles

(

wxMouseEvent &

evt

)

{
    const wxClientDC dc(list_profile);
    const wxPoint pos = evt.GetLogicalPosition(dc);
    int item = list_profile->HitTest(pos);
    on_material_hovered(item);
}

References list_profile, on_material_hovered(), and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

on_paint()

void Slic3r::GUI::PageMaterials::on_paint

(

)

{
}

reload_presets()

void Slic3r::GUI::PageMaterials::reload_presets

(

)

{
    clear();
 
  list_printer->append(_L("(All)"), &EMPTY);
    //list_printer->SetLabelMarkup("<b>bald</b>");
  for (const Preset* printer : materials->printers) {
    list_printer->append(printer->name, &printer->name);
  }
    sort_list_data(list_printer, true, false);
    if (list_printer->GetCount() > 0) {
        list_printer->SetSelection(0);
        sel_printers_prev.Clear();
        sel_type_prev = wxNOT_FOUND;
        sel_vendor_prev = wxNOT_FOUND;
        update_lists(0, 0, 0);
    }
 
    presets_loaded = true;
}

References _L, clear(), EMPTY, list_printer, materials, Slic3r::Preset::name, presets_loaded, sel_printers_prev, sel_type_prev, sel_vendor_prev, sort_list_data(), and update_lists().

Referenced by PageMaterials(), and on_activate().

Here is the call graph for this function:

Here is the caller graph for this function:

select_all()

void Slic3r::GUI::PageMaterials::select_all

(

bool

select

)

{
    wxWindowUpdateLocker freeze_guard(this);
    (void)freeze_guard;
 
    for (unsigned i = 0; i < list_profile->GetCount(); i++) {
        const bool current = list_profile->IsChecked(i);
        if (current != select) {
            list_profile->Check(i, select);
            select_material(i);
        }
    }
}

References list_profile, and select_material().

Referenced by PageMaterials().

Here is the call graph for this function:

Here is the caller graph for this function:

select_material()

void Slic3r::GUI::PageMaterials::select_material

(

int

i

)

{
    const bool checked = list_profile->IsChecked(i);
 
    const std::string& alias_key = list_profile->get_data(i);
    wizard_p()->update_presets_in_config(materials->appconfig_section(), alias_key, checked);
}

References list_profile, materials, Slic3r::GUI::ConfigWizard::priv::update_presets_in_config(), and Slic3r::GUI::ConfigWizardPage::wizard_p().

Referenced by PageMaterials(), and select_all().

Here is the call graph for this function:

Here is the caller graph for this function:

set_compatible_printers_html_window()

void Slic3r::GUI::PageMaterials::set_compatible_printers_html_window	(	const std::vector< std::string > &	printer_names,
		bool	all_printers = false )

{
    const auto bgr_clr = html_window->GetParent()->GetBackgroundColour();
//#if defined(__APPLE__)
//        html_window->GetParent()->GetBackgroundColour();
//#else 
//#if defined(_WIN32)
//        html_window->GetParent()->GetBackgroundColour();
//#else
//        wxSystemSettings::GetColour(wxSYS_COLOUR_MENU);
//#endif
//#endif
    const auto text_clr = wxGetApp().get_label_clr_default();
    const auto bgr_clr_str = encode_color(ColorRGB(bgr_clr.Red(), bgr_clr.Green(), bgr_clr.Blue()));
    const auto text_clr_str = encode_color(ColorRGB(text_clr.Red(), text_clr.Green(), text_clr.Blue()));
    wxString first_line = format_wxstr(_L("%1% marked with <b>*</b> are <b>not</b> compatible with some installed printers."), materials->technology == T_FFF ? _L("Filaments") : _L("SLA materials"));
    wxString text;
    if (all_printers) {
        wxString second_line = format_wxstr(_L("All installed printers are compatible with the selected %1%."), materials->technology == T_FFF ? _L("filament") : _L("SLA material"));
        text = wxString::Format(
            "<html>"
            "<style>"
            "table{border-spacing: 1px;}"
            "</style>"
            "<body bgcolor= %s>"
            "<font color=%s>"
            "<font size=\"3\">"
            "%s<br /><br />%s"
            "</font>"
            "</font>"
            "</body>"
            "</html>"
            , bgr_clr_str
            , text_clr_str
            , first_line
            , second_line
            );
    } else {
        wxString second_line;
        if (!printer_names.empty())
            second_line = (materials->technology == T_FFF ?
                          _L("Only the following installed printers are compatible with the selected filaments") :
                          _L("Only the following installed printers are compatible with the selected SLA materials")) + ":";
        text = wxString::Format(
            "<html>"
            "<style>"
            "table{border-spacing: 1px;}"
            "</style>"
            "<body bgcolor= %s>"
            "<font color=%s>"
            "<font size=\"3\">"
            "%s<br /><br />%s"
            "<table>"
            "<tr>"
            , bgr_clr_str
            , text_clr_str
            , first_line
            , second_line);
        for (size_t i = 0; i < printer_names.size(); ++i)
        {
            text += wxString::Format("<td>%s</td>", boost::nowide::widen(printer_names[i]));
            if (i % 3 == 2) {
                text += wxString::Format(
                    "</tr>"
                    "<tr>");
            }
        }
        text += wxString::Format(
            "</tr>"
            "</table>"
            "</font>"
            "</font>"
            "</body>"
            "</html>"
        );
    }
   
    wxFont font = get_default_font_for_dpi(this, get_dpi_for_window(this));
    const int fs = font.GetPointSize();
    int size[] = { fs,fs,fs,fs,fs,fs,fs };
    html_window->SetFonts(font.GetFaceName(), font.GetFaceName(), size);
    html_window->SetPage(text);
}

References _L, Slic3r::encode_color(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::get_default_font_for_dpi(), Slic3r::GUI::get_dpi_for_window(), html_window, materials, and Slic3r::GUI::T_FFF.

Referenced by PageMaterials(), clear_compatible_printers_label(), and on_material_highlighted().

Here is the call graph for this function:

Here is the caller graph for this function:

set_run_reason()

virtual void Slic3r::GUI::ConfigWizardPage::set_run_reason ( ConfigWizard::RunReason run_reason )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::PagePrinters, and Slic3r::GUI::PageWelcome.

{}

sort_list_data() [1/2]

void Slic3r::GUI::PageMaterials::sort_list_data	(	PresetList *	list,
		const std::vector< ProfilePrintData > &	data )

{
    // sort data
    // then prusa profiles
    // then the rest
    // in alphabetical order
    std::vector<ProfilePrintData> prusa_profiles;
    std::vector<ProfilePrintData> other_profiles;
    //for (int i = 0; i < data.size(); ++i) {
    for (const auto& item : data) {
        const std::string& name = item.name;
        if (name.find("Bambu") != std::string::npos)
            prusa_profiles.emplace_back(item);
        else
            other_profiles.emplace_back(item);
    }
    std::sort(prusa_profiles.begin(), prusa_profiles.end(), [](ProfilePrintData a, ProfilePrintData b) {
        return a.name.get() < b.name.get();
        });
    std::sort(other_profiles.begin(), other_profiles.end(), [](ProfilePrintData a, ProfilePrintData b) {
        return a.name.get() < b.name.get();
        });
    list->Clear();
    for (size_t i = 0; i < prusa_profiles.size(); ++i) {
        list->append(std::string(prusa_profiles[i].name) + (prusa_profiles[i].omnipresent ? "" : " *"), &const_cast<std::string&>(prusa_profiles[i].name.get()));
        list->Check(i, prusa_profiles[i].checked);
    }
    for (size_t i = 0; i < other_profiles.size(); ++i) {
        list->append(std::string(other_profiles[i].name) + (other_profiles[i].omnipresent ? "" : " *"), &const_cast<std::string&>(other_profiles[i].name.get()));
        list->Check(i + prusa_profiles.size(), other_profiles[i].checked);
    }
}

References Slic3r::GUI::DataList< T, D >::append().

Here is the call graph for this function:

sort_list_data() [2/2]

void Slic3r::GUI::PageMaterials::sort_list_data	(	StringList *	list,
		bool	add_All_item,
		bool	material_type_ordering )

{
// get data from list
// sort data
// first should be <all>
// then prusa profiles
// then the rest
// in alphabetical order
    
    std::vector<std::reference_wrapper<const std::string>> prusa_profiles;
    std::vector<std::reference_wrapper<const std::string>> other_profiles;
    for (int i = 0 ; i < list->size(); ++i) {
        const std::string& data = list->get_data(i);
        if (data == EMPTY) // do not sort <all> item
            continue;
        if (!material_type_ordering && data.find("Bambu") != std::string::npos)
            prusa_profiles.push_back(data);
        else 
            other_profiles.push_back(data);
    }
    if(material_type_ordering) {
        
        const ConfigOptionDef* def = print_config_def.get("filament_type");
        std::vector<std::string>enum_values = def->enum_values;
        size_t end_of_sorted = 0;
        for (size_t vals = 0; vals < enum_values.size(); vals++) {
            for (size_t profs = end_of_sorted; profs < other_profiles.size(); profs++)
            {
                // find instead compare because PET vs PETG
                if (other_profiles[profs].get().find(enum_values[vals]) != std::string::npos) {
                    //swap
                    if(profs != end_of_sorted) {
                        std::reference_wrapper<const std::string> aux = other_profiles[end_of_sorted];
                        other_profiles[end_of_sorted] = other_profiles[profs];
                        other_profiles[profs] = aux;
                    }
                    end_of_sorted++;
                    break;
                }
            }
        }
    } else {
        std::sort(prusa_profiles.begin(), prusa_profiles.end(), [](std::reference_wrapper<const std::string> a, std::reference_wrapper<const std::string> b) {
            return a.get() < b.get();
            });
        std::sort(other_profiles.begin(), other_profiles.end(), [](std::reference_wrapper<const std::string> a, std::reference_wrapper<const std::string> b) {
            return a.get() < b.get();
            });
    }
    
    list->Clear();
    if (add_All_item)
        list->append(_L("(All)"), &EMPTY);
    for (const auto& item : prusa_profiles)
        list->append(item, &const_cast<std::string&>(item.get()));
    for (const auto& item : other_profiles)
        list->append(item.get() == Materials::UNKNOWN ? _L(item.get()) : from_u8(item.get()), &const_cast<std::string&>(item.get()));
}     

References _L, Slic3r::GUI::DataList< T, D >::append(), EMPTY, Slic3r::ConfigOptionDef::enum_values, Slic3r::GUI::from_u8(), Slic3r::GUI::DataList< T, D >::get_data(), Slic3r::print_config_def, Slic3r::GUI::DataList< T, D >::size(), and Slic3r::GUI::Materials::UNKNOWN.

Referenced by reload_presets(), and update_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

update_lists()

void Slic3r::GUI::PageMaterials::update_lists	(	int	sel_type,
		int	sel_vendor,
		int	last_selected_printer = -1 )

{
  wxWindowUpdateLocker freeze_guard(this);
  (void)freeze_guard;
 
  wxArrayInt sel_printers;
  int sel_printers_count = list_printer->GetSelections(sel_printers);
 
    if (sel_printers != sel_printers_prev) {
 
        // Refresh type list
    list_type->Clear();
    list_type->append(_L("(All)"), &EMPTY);
    if (sel_printers_count > 0) {
            // If all is selected with other printers
            // unselect "all" or all printers depending on last value
            if (sel_printers[0] == 0 && sel_printers_count > 1) {
                if (last_selected_printer == 0) {
                    list_printer->SetSelection(wxNOT_FOUND);
                    list_printer->SetSelection(0);
                } else {
                    list_printer->SetSelection(0, false);
                    sel_printers_count = list_printer->GetSelections(sel_printers);
                }
            }
      if (sel_printers[0] != 0) {
                for (int i = 0; i < sel_printers_count; i++) {
          const std::string& printer_name = list_printer->get_data(sel_printers[i]);
          const Preset* printer = nullptr;
          for (const Preset* it : materials->printers) {
            if (it->name == printer_name) {
              printer = it;
              break;
            }
          }
          materials->filter_presets(printer, EMPTY, EMPTY, [this](const Preset* p) {
            const std::string& type = this->materials->get_type(p);
            if (list_type->find(type) == wxNOT_FOUND) {
              list_type->append(type, &type);
            }
            });
        }
      } else {
                //clear selection except "ALL"
                list_printer->SetSelection(wxNOT_FOUND);
                list_printer->SetSelection(0);
                sel_printers_count = list_printer->GetSelections(sel_printers);
 
        materials->filter_presets(nullptr, EMPTY, EMPTY, [this](const Preset* p) {
          const std::string& type = this->materials->get_type(p);
          if (list_type->find(type) == wxNOT_FOUND) {
            list_type->append(type, &type);
          }
          });
      }
            sort_list_data(list_type, true, true);
    }
 
    sel_printers_prev = sel_printers;
    sel_type = 0;
    sel_type_prev = wxNOT_FOUND;
    list_type->SetSelection(sel_type);
    list_profile->Clear();
  }
  
  if (sel_type != sel_type_prev) {
    // Refresh vendor list
 
    // XXX: The vendor list is created with quadratic complexity here,
    // but the number of vendors is going to be very small this shouldn't be a problem.
 
    list_vendor->Clear();
    list_vendor->append(_L("(All)"), &EMPTY);
    if (sel_printers_count != 0 && sel_type != wxNOT_FOUND) {
      const std::string& type = list_type->get_data(sel_type);
      // find printer preset
            for (int i = 0; i < sel_printers_count; i++) {
        const std::string& printer_name = list_printer->get_data(sel_printers[i]);
        const Preset* printer = nullptr;
        for (const Preset* it : materials->printers) {
          if (it->name == printer_name) {
            printer = it;
            break;
          }
        }
        materials->filter_presets(printer, type, EMPTY, [this](const Preset* p) {
          const std::string& vendor = this->materials->get_vendor(p);
          if (list_vendor->find(vendor) == wxNOT_FOUND) {
            list_vendor->append(vendor, &vendor);
          }
          });
      }
            sort_list_data(list_vendor, true, false);
    }
 
    sel_type_prev = sel_type;
    sel_vendor = 0;
    sel_vendor_prev = wxNOT_FOUND;
    list_vendor->SetSelection(sel_vendor);
    list_profile->Clear();
  }
         
  if (sel_vendor != sel_vendor_prev) {
    // Refresh material list
 
    list_profile->Clear();
        clear_compatible_printers_label();
    if (sel_printers_count != 0 && sel_type != wxNOT_FOUND && sel_vendor != wxNOT_FOUND) {
      const std::string& type = list_type->get_data(sel_type);
      const std::string& vendor = list_vendor->get_data(sel_vendor);
      // finst printer preset
            std::vector<ProfilePrintData> to_list;
            for (int i = 0; i < sel_printers_count; i++) {
        const std::string& printer_name = list_printer->get_data(sel_printers[i]);
        const Preset* printer = nullptr;
        for (const Preset* it : materials->printers) {
          if (it->name == printer_name) {
            printer = it;
            break;
          }
        }
 
        materials->filter_presets(printer, type, vendor, [this, &to_list](const Preset* p) {
          const std::string& section = materials->appconfig_section();
                    bool checked = wizard_p()->appconfig_new.has(section, p->name);
                    bool was_checked = false;
 
                    int cur_i = list_profile->find(p->alias);
                    if (cur_i == wxNOT_FOUND) {
                        cur_i = list_profile->append(p->alias + (materials->get_omnipresent(p) ? "" : " *"), &p->alias);
                        to_list.emplace_back(p->alias, materials->get_omnipresent(p), checked);
                    }
                    else {
                        was_checked = list_profile->IsChecked(cur_i);
                        to_list[cur_i].checked = checked || was_checked;
                    }
                    list_profile->Check(cur_i, checked || was_checked);
 
          /* Update preset selection in config.
           * If one preset from aliases bundle is selected,
           * than mark all presets with this aliases as selected
           * */
          if (checked && !was_checked)
            wizard_p()->update_presets_in_config(section, p->alias, true);
          else if (!checked && was_checked)
            wizard_p()->appconfig_new.set(section, p->name, "true");
          });
      }
            sort_list_data(list_profile, to_list);
    }
 
    sel_vendor_prev = sel_vendor;
  }
    //wxGetApp().UpdateDarkUI(list_profile);
}

References _L, Slic3r::Preset::alias, Slic3r::GUI::ConfigWizard::priv::appconfig_new, clear_compatible_printers_label(), EMPTY, Slic3r::AppConfig::has(), list_printer, list_profile, list_type, list_vendor, materials, Slic3r::Preset::name, sel_printers_prev, sel_type_prev, sel_vendor_prev, Slic3r::AppConfig::set(), sort_list_data(), Slic3r::GUI::ConfigWizard::priv::update_presets_in_config(), and Slic3r::GUI::ConfigWizardPage::wizard_p().

Referenced by PageMaterials(), and reload_presets().

Here is the call graph for this function:

Here is the caller graph for this function:

wizard_p()

ConfigWizard::priv * Slic3r::GUI::ConfigWizardPage::wizard_p ( ) const

inlineinherited

{ return parent->p.get(); }

References parent.

Referenced by Slic3r::GUI::PageBedShape::PageBedShape(), Slic3r::GUI::PageCustom::PageCustom(), Slic3r::GUI::PagePrinters::PagePrinters(), Slic3r::GUI::PageMaterials::on_activate(), Slic3r::GUI::PageMaterials::select_material(), and Slic3r::GUI::PageMaterials::update_lists().

Here is the caller graph for this function:

Member Data Documentation

compatible_printers_width

int Slic3r::GUI::PageMaterials::compatible_printers_width = { 100 }

{ 100 };

content

wxBoxSizer* Slic3r::GUI::ConfigWizardPage::content

inherited

Referenced by ConfigWizardPage(), append(), and append_spacer().

EMPTY

const std::string Slic3r::GUI::PageMaterials::EMPTY

static

Referenced by reload_presets(), sort_list_data(), and update_lists().

empty_printers_label

std::string Slic3r::GUI::PageMaterials::empty_printers_label

first_paint

bool Slic3r::GUI::PageMaterials::first_paint = { false }

{ false };

Referenced by on_activate().

grid

wxFlexGridSizer* Slic3r::GUI::PageMaterials::grid

Referenced by PageMaterials().

html_window

wxHtmlWindow* Slic3r::GUI::PageMaterials::html_window

Referenced by PageMaterials(), and set_compatible_printers_html_window().

indent

const unsigned Slic3r::GUI::ConfigWizardPage::indent

inherited

Referenced by ConfigWizardPage(), Slic3r::GUI::PagePrinters::PagePrinters(), and Slic3r::GUI::ConfigWizardIndex::add_page().

last_hovered_item

int Slic3r::GUI::PageMaterials::last_hovered_item = { -1 }

{ -1 } ;

Referenced by on_material_highlighted().

list_printer

StringList* Slic3r::GUI::PageMaterials::list_printer

Referenced by PageMaterials(), clear(), reload_presets(), and update_lists().

list_profile

PresetList* Slic3r::GUI::PageMaterials::list_profile

Referenced by PageMaterials(), clear(), on_material_highlighted(), on_mouse_move_on_profiles(), select_all(), select_material(), and update_lists().

list_type

StringList * Slic3r::GUI::PageMaterials::list_type

Referenced by PageMaterials(), clear(), and update_lists().

list_vendor

StringList * Slic3r::GUI::PageMaterials::list_vendor

Referenced by PageMaterials(), clear(), and update_lists().

materials

Materials* Slic3r::GUI::PageMaterials::materials

Referenced by Slic3r::GUI::ConfigWizard::ConfigWizard(), PageMaterials(), on_activate(), on_material_highlighted(), reload_presets(), Slic3r::GUI::ConfigWizard::priv::select_default_materials_for_printer_model(), Slic3r::GUI::ConfigWizard::priv::select_default_materials_for_printer_models(), select_material(), set_compatible_printers_html_window(), and update_lists().

parent

ConfigWizard* Slic3r::GUI::ConfigWizardPage::parent

inherited

Referenced by ConfigWizardPage(), Slic3r::GUI::PageBedShape::PageBedShape(), Slic3r::GUI::PageCustom::PageCustom(), Slic3r::GUI::PageDiameters::PageDiameters(), Slic3r::GUI::PageFirmware::PageFirmware(), Slic3r::GUI::PageMaterials::PageMaterials(), Slic3r::GUI::PagePrinters::PagePrinters(), Slic3r::GUI::PageTemperatures::PageTemperatures(), Slic3r::GUI::PageWelcome::PageWelcome(), and wizard_p().

presets_loaded

bool Slic3r::GUI::PageMaterials::presets_loaded

Referenced by clear(), on_activate(), and reload_presets().

sel_printers_prev

wxArrayInt Slic3r::GUI::PageMaterials::sel_printers_prev

Referenced by clear(), reload_presets(), and update_lists().

sel_type_prev

int Slic3r::GUI::PageMaterials::sel_type_prev

Referenced by clear(), reload_presets(), and update_lists().

sel_vendor_prev

int Slic3r::GUI::PageMaterials::sel_vendor_prev

Referenced by clear(), reload_presets(), and update_lists().

shortname

const wxString Slic3r::GUI::ConfigWizardPage::shortname

inherited

Referenced by ConfigWizardPage(), Slic3r::GUI::PageMaterials::PageMaterials(), Slic3r::GUI::PagePrinters::PagePrinters(), Slic3r::GUI::ConfigWizard::priv::add_page(), and Slic3r::GUI::ConfigWizardIndex::add_page().

---

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