Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp} Namespace Reference

Enumerations
enum	{   kPublishSelectAll = wxID_HIGHEST + 1 , kPublishDeselectAll , kPublishSelectVisible , kPublishDeselectVisible ,   kPublishFilterSelected , kPublishFilterNonSelected }

Functions
wxStaticText *	add_checkbox_label (wxWindow *parent, wxBoxSizer *sizer, ::CheckBox *check, const wxString &label, const wxString &tooltip, int label_width=0)
std::string	filament_color_hex (const DynamicPrintConfig &full, size_t slot)
PublishMaterialIdentity	material_identity (size_t slot, const DynamicPrintConfig &full)
std::string	material_display_name (const std::string &preset_name)
wxString	material_title (size_t slot, const PresetBundle *bundle, const DynamicPrintConfig &full)
std::vector< unsigned int >	mixed_slot_components (const DynamicPrintConfig &full, size_t slot)
wxString	mixed_filament_label (const DynamicPrintConfig &full, size_t slot)
wxColour	mixed_filament_blend_color (const DynamicPrintConfig &full, size_t slot)
wxBitmap	mixed_filament_chip_bitmap (const DynamicPrintConfig &full, size_t slot, int swatch_sz)
wxBitmap	mixed_filament_tab_bitmap (const DynamicPrintConfig &full, size_t slot, int swatch_sz, const wxColour &tab_bg)
std::set< size_t >	project_used_filament_slots (const PresetBundle &bundle, const DynamicPrintConfig &full, const Model &model)
void	add_sentence_with_chips (wxWindow *parent, wxSizer *row, const wxString &sentence, const std::vector< wxWindow * > &chips)

Variables
constexpr long	s_tab_style

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kPublishSelectAll
kPublishDeselectAll
kPublishSelectVisible
kPublishDeselectVisible
kPublishFilterSelected
kPublishFilterNonSelected

     {
    kPublishSelectAll = wxID_HIGHEST + 1,
    kPublishDeselectAll,
    kPublishSelectVisible,
    kPublishDeselectVisible,
    kPublishFilterSelected,
    kPublishFilterNonSelected
};

Function Documentation

add_checkbox_label()

wxStaticText * Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::add_checkbox_label	(	wxWindow *	parent,
		wxBoxSizer *	sizer,
		::CheckBox *	check,
		const wxString &	label,
		const wxString &	tooltip,
		int	label_width = 0 )

{
    check->SetToolTip(tooltip);
    sizer->Add(check, 0, wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM, parent->FromDIP(2));
 
    auto* text = new wxStaticText(parent, wxID_ANY, label);
    text->SetFont(Label::Body_14);
    text->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#363636")));
    if (label_width > 0) {
        text->SetMinSize(wxSize(label_width, -1));
        text->SetMaxSize(wxSize(label_width, -1));
        text->Wrap(label_width);
    }
    text->SetToolTip(tooltip);
    text->SetCursor(wxCURSOR_HAND);
    const auto toggle = [check]() {
        if (!check->IsEnabled())
            return;
        check->SetValue(!check->GetValue());
        wxCommandEvent event(wxEVT_TOGGLEBUTTON, check->GetId());
        event.SetEventObject(check);
        check->GetEventHandler()->ProcessEvent(event);
    };
    text->Bind(wxEVT_LEFT_DOWN, [toggle](wxMouseEvent& event) {
        if (!event.LeftDClick())
            toggle();
    });
    text->Bind(wxEVT_LEFT_DCLICK, [toggle](wxMouseEvent&) {
        toggle();
    });
    sizer->Add(text, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, parent->FromDIP(5));
    return text;
}

References add_checkbox_label(), Label::Body_14, StateColor::darkModeColorFor(), Slic3r::GUI::wxMouseEvent, and wxStaticText.

Referenced by add_checkbox_label().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sentence_with_chips()

void Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::add_sentence_with_chips	(	wxWindow *	parent,
		wxSizer *	row,
		const wxString &	sentence,
		const std::vector< wxWindow * > &	chips )

{
    std::vector<bool> placed(chips.size(), false);
    auto add_text = [&](wxString text) {
        text.Replace("%%", "%"); // the sentence is a format string
        if (text.IsEmpty())
            return;
        auto* label = new wxStaticText(parent, wxID_ANY, text);
        label->SetFont(Label::Body_12);
        label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#6B6B6B")));
        row->Add(label, 0, wxALIGN_CENTER_VERTICAL);
    };
    auto add_chip = [&](size_t i) {
        if (i < chips.size() && chips[i] != nullptr && !placed[i]) {
            placed[i] = true;
            row->Add(chips[i], 0, wxALIGN_CENTER_VERTICAL);
        }
    };
 
    size_t literal = 0, pos = 0;
    while ((pos = sentence.find('%', pos)) != wxString::npos) {
        size_t end = pos + 1;
        while (end < sentence.length() && sentence[end] >= '0' && sentence[end] <= '9')
            ++end;
        if (end == pos + 1 || end >= sentence.length() || sentence[end] != '%') {
            ++pos; // a bare '%'
            continue;
        }
        long index = 0;
        sentence.Mid(pos + 1, end - pos - 1).ToLong(&index);
        add_text(sentence.Mid(literal, pos - literal));
        add_chip(size_t(index - 1));
        literal = pos = end + 1;
    }
    add_text(sentence.Mid(literal));
    for (size_t i = 0; i < chips.size(); ++i) // whatever the translation left out
        add_chip(i);
}

References add_sentence_with_chips(), Label::Body_12, StateColor::darkModeColorFor(), and wxStaticText.

Referenced by add_sentence_with_chips().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_color_hex()

std::string Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::filament_color_hex	(	const DynamicPrintConfig &	full,
		size_t	slot )

{
    if (const auto* colours = full.opt<ConfigOptionStrings>("filament_colour"))
        if (slot < colours->size())
            return colours->get_at(slot);
    return std::string();
}

References filament_color_hex(), and Slic3r::DynamicConfig::opt().

Referenced by filament_color_hex(), and mixed_filament_chip_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

material_display_name()

std::string Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_display_name

(

const std::string &

preset_name

)

{
    const size_t at = preset_name.find_first_of('@');
    if (at == std::string::npos)
        return preset_name;
    std::string bare = preset_name.substr(0, at);
    boost::trim_right(bare);
    return bare.empty() ? preset_name : bare;
}

References material_display_name().

Referenced by material_display_name(), and material_title().

Here is the call graph for this function:

Here is the caller graph for this function:

material_identity()

PublishMaterialIdentity Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_identity	(	size_t	slot,
		const DynamicPrintConfig &	full )

{
    PublishMaterialIdentity identity;
    if (const auto* types = full.opt<ConfigOptionStrings>("filament_type"))
        if (slot < types->size())
            identity.type = types->get_at(slot);
    if (const auto* vendors = full.opt<ConfigOptionStrings>("filament_vendor"))
        if (slot < vendors->size())
            identity.vendor = vendors->get_at(slot);
    if (const auto* ids = full.opt<ConfigOptionStrings>("filament_ids"))
        if (slot < ids->size())
            identity.id = ids->get_at(slot);
    return identity;
}

References Slic3r::identity(), material_identity(), and Slic3r::DynamicConfig::opt().

Referenced by material_identity(), and material_title().

Here is the call graph for this function:

Here is the caller graph for this function:

material_title()

wxString Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::material_title	(	size_t	slot,
		const PresetBundle *	bundle,
		const DynamicPrintConfig &	full )

{
    if (slot < bundle->filament_presets.size()) {
        const Preset* preset = bundle->filaments.find_preset(bundle->filament_presets[slot]);
        if (preset != nullptr && !preset->name.empty()) {
            // Display the name the sidebar does: the alias (already bare-name + variant-tail
            // stripped for root filament presets).
            const std::string& display = preset->alias.empty() ? get_preset_bare_name(preset->name) : preset->alias;
            return from_u8(material_display_name(display));
        }
    }
    const PublishMaterialIdentity identity = material_identity(slot, full);
    if (!identity.type.empty())
        return from_u8(identity.type);
    return _L("Material");
}

References _L, Slic3r::Preset::alias, Slic3r::PresetBundle::filament_presets, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::GUI::from_u8(), Slic3r::get_preset_bare_name(), Slic3r::identity(), material_display_name(), material_identity(), material_title(), and Slic3r::Preset::name.

Referenced by material_title().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_filament_blend_color()

wxColour Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_blend_color	(	const DynamicPrintConfig &	full,
		size_t	slot )

{
    std::vector<wxColour> colors;
    if (const auto* colours = full.opt<ConfigOptionStrings>("filament_colour")) {
        colors.reserve(colours->values.size());
        for (const std::string& hex : colours->values) {
            const wxColour c(hex);
            colors.push_back(c.IsOk() ? c : wxColour(0, 0, 0));
        }
    }
    while (colors.size() <= slot)
        colors.push_back(wxColour("#D9D9D9"));
    recompute_mixed_slot_colors(colors, full);
    return slot < colors.size() ? colors[slot] : wxColour("#D9D9D9");
}

References mixed_filament_blend_color(), Slic3r::DynamicConfig::opt(), and Slic3r::GUI::recompute_mixed_slot_colors().

Referenced by mixed_filament_blend_color(), and mixed_filament_chip_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_filament_chip_bitmap()

wxBitmap Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_chip_bitmap	(	const DynamicPrintConfig &	full,
		size_t	slot,
		int	swatch_sz )

{
    const std::string label = std::to_string(slot + 1);
    const auto* grad_opt    = full.opt<ConfigOptionBools>("filament_mixed_gradient");
    const bool is_gradient  = grad_opt != nullptr && slot < grad_opt->size() && grad_opt->values[slot];
    wxBitmap* icon          = nullptr;
    if (is_gradient) {
        // The same curve-sampled ramp the sidebar chips use; an empty ramp (broken definition)
        // degrades to a plain fade between the slot's two component colours.
        const std::vector<wxColour> ramp = mixed_gradient_ramp(full, slot, swatch_sz);
        if (!ramp.empty()) {
            icon = get_extruder_color_icon(std::vector<std::string>(), true, label, swatch_sz, swatch_sz, &ramp);
        } else {
            std::vector<std::string> hexes;
            for (const unsigned int comp : mixed_slot_components(full, slot)) {
                std::string hex = filament_color_hex(full, size_t(comp) - 1);
                if (hex.empty())
                    hex = "#D9D9D9";
                hexes.push_back(std::move(hex));
            }
            if (hexes.size() >= 2)
                icon = get_extruder_color_icon(std::move(hexes), true, label, swatch_sz, swatch_sz);
        }
    }
    if (icon == nullptr) {
        const wxColour blend = mixed_filament_blend_color(full, slot);
        const std::string blend_hex = blend.IsOk() ?
                                          std::string(wxString::Format("#%02X%02X%02X", blend.Red(), blend.Green(), blend.Blue()).ToUTF8()) :
                                          std::string("#808080");
        icon = get_extruder_color_icon(blend_hex, label, swatch_sz, swatch_sz);
    }
    return icon != nullptr ? *icon : wxNullBitmap;
}

References filament_color_hex(), get_extruder_color_icon(), mixed_filament_blend_color(), mixed_filament_chip_bitmap(), Slic3r::GUI::mixed_gradient_ramp(), mixed_slot_components(), and Slic3r::DynamicConfig::opt().

Referenced by mixed_filament_chip_bitmap(), and mixed_filament_tab_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_filament_label()

wxString Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_label	(	const DynamicPrintConfig &	full,
		size_t	slot )

{
    const std::vector<unsigned int> comps = mixed_slot_components(full, slot);
    if (comps.empty())
        return _L("Mixed filament");
    const auto* grad_opt   = full.opt<ConfigOptionBools>("filament_mixed_gradient");
    const bool is_gradient = grad_opt != nullptr && slot < grad_opt->size() && grad_opt->values[slot];
    const auto* ratios_opt = full.opt<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
    wxString label;
    for (size_t i = 0; i < comps.size(); ++i) {
        if (i > 0)
            label += is_gradient ? wxString::FromUTF8(" \u2192 ") : wxString::FromUTF8(" + ");
        label += wxString::Format("%u", comps[i]);
        if (!is_gradient) {
            double ratio = 100.0 / comps.size();
            if (ratios_opt != nullptr && slot < ratios_opt->size()) {
                const std::vector<double> rs = parse_mixed_ratios(ratios_opt->values[slot], comps.size());
                if (i < rs.size())
                    ratio = rs[i] * 100.0;
            }
            label += wxString::Format(" (%d%%)", int(ratio + 0.5));
        }
    }
    return label;
}

References _L, mixed_filament_label(), mixed_slot_components(), Slic3r::DynamicConfig::opt(), and Slic3r::parse_mixed_ratios().

Referenced by mixed_filament_label().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_filament_tab_bitmap()

wxBitmap Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_filament_tab_bitmap	(	const DynamicPrintConfig &	full,
		size_t	slot,
		int	swatch_sz,
		const wxColour &	tab_bg )

{
    const std::vector<unsigned int> comps = mixed_slot_components(full, slot);
    if (comps.empty())
        return wxNullBitmap;
    const auto* grad_opt   = full.opt<ConfigOptionBools>("filament_mixed_gradient");
    const bool is_gradient = grad_opt != nullptr && slot < grad_opt->size() && grad_opt->values[slot];
    const auto* ratios_opt = full.opt<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
    std::vector<double> ratio_pct(comps.size(), 100.0 / comps.size());
    if (!is_gradient && ratios_opt != nullptr && slot < ratios_opt->size()) {
        const std::vector<double> rs = parse_mixed_ratios(ratios_opt->values[slot], comps.size());
        for (size_t i = 0; i < rs.size() && i < comps.size(); ++i)
            ratio_pct[i] = rs[i] * 100.0;
    }
 
    const auto* colours     = full.opt<ConfigOptionStrings>("filament_colour");
    const wxString lead_sep = wxString::FromUTF8(":");
    const wxString comp_sep = is_gradient ? wxString::FromUTF8("\u2192") : wxString::FromUTF8("+");
 
    // Phase 1 (layout): render every swatch and measure every text piece so the composite
    // width is known before drawing; the dummy bitmap keeps GetTextExtent reliable.
    struct Piece
    {
        enum Kind { Swatch, Text } kind{Text};
        wxBitmap bmp;
        wxString text;
    };
    std::vector<Piece> pieces;
    bool has_lead = false;
    wxBitmap dummy(1, 1);
    wxMemoryDC measure_dc;
    measure_dc.SelectObject(dummy);
    measure_dc.SetFont(::Label::Body_12);
    const int gap = wxWindow::FromDIP(4, nullptr);
 
    auto push_swatch = [&](const std::string& hex, const std::string& label) {
        wxBitmap* icon = get_extruder_color_icon(hex, label, swatch_sz, swatch_sz);
        if (icon == nullptr)
            return;
        pieces.push_back({Piece::Swatch, *icon, wxString()});
    };
    auto push_text = [&](const wxString& text) { pieces.push_back({Piece::Text, wxNullBitmap, text}); };
 
    {
        const wxBitmap chip = mixed_filament_chip_bitmap(full, slot, swatch_sz);
        has_lead            = chip.IsOk();
        if (has_lead)
            pieces.push_back({Piece::Swatch, chip, wxString()});
    }
    for (size_t ci = 0; ci < comps.size(); ++ci) {
        if (pieces.empty())
            break;
        push_text(has_lead && pieces.size() == 1 ? lead_sep : comp_sep); // lead chip may have failed to render
        std::string hex = "#D9D9D9";
        if (colours != nullptr && comps[ci] >= 1 && comps[ci] <= colours->size())
            hex = colours->values[comps[ci] - 1];
        const size_t before = pieces.size();
        push_swatch(hex, std::to_string(comps[ci]));
        if (pieces.size() == before)
            break; // swatch failed: stop cleanly before an orphaned separator/percent pair
        if (!is_gradient) {
            push_text(wxString::Format("%d%%", int(ratio_pct[ci] + 0.5)));
        }
    }
    if (pieces.empty())
        return wxNullBitmap;
 
    int width = 0;
    for (const Piece& p : pieces)
        width += (p.kind == Piece::Swatch ? swatch_sz : measure_dc.GetTextExtent(p.text).x + gap);
 
    // Phase 2 (draw): opaque, filled with the tab strip's background colour. Text goes through
    // the plain DC on every platform (see the function comment for why the alpha route is
    // avoided); chip bitmaps keep their own alpha and composite cleanly onto the fill.
    wxBitmap composite(width, swatch_sz);
    wxMemoryDC memdc;
    memdc.SelectObject(composite);
    memdc.SetBackground(wxBrush(tab_bg));
    memdc.Clear();
    memdc.SetBackgroundMode(wxTRANSPARENT);
    memdc.SetFont(::Label::Body_12);
    memdc.SetTextForeground(StateColor::darkModeColorFor(wxColour("#262E30")));
    int x = 0;
    for (const Piece& p : pieces) {
        if (p.kind == Piece::Swatch) {
            memdc.DrawBitmap(p.bmp, x, 0, true);
            x += swatch_sz;
        } else {
            const wxSize tsz = measure_dc.GetTextExtent(p.text);
            memdc.DrawText(p.text, x + gap / 2, (swatch_sz - tsz.y) / 2);
            x += tsz.x + gap;
        }
    }
    memdc.SelectObject(wxNullBitmap);
    return composite;
}

References Label::Body_12, StateColor::darkModeColorFor(), get_extruder_color_icon(), mixed_filament_chip_bitmap(), mixed_filament_tab_bitmap(), mixed_slot_components(), Slic3r::DynamicConfig::opt(), and Slic3r::parse_mixed_ratios().

Referenced by mixed_filament_tab_bitmap().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_slot_components()

std::vector< unsigned int > Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::mixed_slot_components	(	const DynamicPrintConfig &	full,
		size_t	slot )

{
    const auto* comp_opt = full.opt<ConfigOptionStrings>("filament_mixed_components");
    if (comp_opt == nullptr || slot >= comp_opt->size())
        return {};
    return parse_mixed_components(comp_opt->values[slot]);
}

References mixed_slot_components(), Slic3r::DynamicConfig::opt(), and Slic3r::parse_mixed_components().

Referenced by mixed_filament_chip_bitmap(), mixed_filament_label(), mixed_filament_tab_bitmap(), and mixed_slot_components().

Here is the call graph for this function:

Here is the caller graph for this function:

project_used_filament_slots()

std::set< size_t > Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::project_used_filament_slots	(	const PresetBundle &	bundle,
		const DynamicPrintConfig &	full,
		const Model &	model )

{
    std::set<size_t> used; // 0-based used slots, mixed slots not yet expanded
    if (model.objects.empty())
        return used;
 
    auto add_1based = [&used](int id) {
        if (id > 0)
            used.insert(size_t(id - 1));
    };
 
    const DynamicPrintConfig& print_cfg = bundle.prints.get_edited_preset().config;
    const int glb_support_intf   = print_cfg.opt_int("support_interface_filament");
    const int glb_support        = print_cfg.opt_int("support_filament");
    const int glb_outer_wall     = print_cfg.opt_int("outer_wall_filament_id");
    const int glb_inner_wall     = print_cfg.opt_int("inner_wall_filament_id");
    const int glb_sparse_infill  = print_cfg.opt_int("sparse_infill_filament_id");
    const int glb_internal_solid = print_cfg.opt_int("internal_solid_filament_id");
    const int glb_top_surface    = print_cfg.opt_int("top_surface_filament_id");
    const int glb_bottom_surface = print_cfg.opt_int("bottom_surface_filament_id");
    const bool glb_support_on    = print_cfg.opt_bool("enable_support") || print_cfg.opt_int("raft_layers") > 0;
 
    for (ModelObject* mo : model.objects) {
        for (ModelVolume* mv : mo->volumes)
            for (int e : mv->get_extruders())
                add_1based(e);
 
        for (const auto& range_entry : mo->layer_config_ranges)
            if (const ConfigOption* ext_opt = range_entry.second.option("extruder"))
                add_1based(ext_opt->getInt());
 
        bool obj_support = glb_support_on;
        if (const ConfigOption* s_opt = mo->config.option("enable_support"); s_opt != nullptr)
            obj_support = s_opt->getBool();
        else if (const ConfigOption* r_opt = mo->config.option("raft_layers"); r_opt != nullptr)
            obj_support = r_opt->getInt() > 0;
 
        if (obj_support) {
            if (const ConfigOption* opt = mo->config.option("support_interface_filament"); opt != nullptr && opt->getInt() != 0)
                add_1based(opt->getInt());
            else
                add_1based(glb_support_intf);
 
            if (const ConfigOption* opt = mo->config.option("support_filament"); opt != nullptr && opt->getInt() != 0)
                add_1based(opt->getInt());
            else
                add_1based(glb_support);
        }
 
        auto obj_id = [&mo](const char* key) {
            const ConfigOption* opt = mo->config.option(key);
            return (opt != nullptr) ? opt->getInt() : 0;
        };
 
        int obj_outer_wall = obj_id("outer_wall_filament_id");
        if (obj_outer_wall == 0)
            obj_outer_wall = obj_id("inner_wall_filament_id");
        add_1based(obj_outer_wall != 0 ? obj_outer_wall : glb_outer_wall);
 
        int obj_inner_wall = obj_id("inner_wall_filament_id");
        if (obj_inner_wall == 0)
            obj_inner_wall = obj_id("outer_wall_filament_id");
        add_1based(obj_inner_wall != 0 ? obj_inner_wall : glb_inner_wall);
 
        const int obj_sparse = obj_id("sparse_infill_filament_id");
        add_1based(obj_sparse != 0 ? obj_sparse : glb_sparse_infill);
 
        const int obj_internal_solid = obj_id("internal_solid_filament_id");
        add_1based(obj_internal_solid != 0 ? obj_internal_solid : glb_internal_solid);
 
        int obj_top = obj_id("top_surface_filament_id");
        if (obj_top == 0)
            obj_top = obj_internal_solid;
        add_1based(obj_top != 0 ? obj_top : glb_top_surface);
 
        int obj_bottom = obj_id("bottom_surface_filament_id");
        if (obj_bottom == 0)
            obj_bottom = obj_internal_solid;
        add_1based(obj_bottom != 0 ? obj_bottom : glb_bottom_surface);
    }
 
    for (const auto& plate_entry : model.plates_custom_gcodes)
        for (const CustomGCode::Item& item : plate_entry.second.gcodes)
            if (item.type == CustomGCode::Type::ToolChange)
                add_1based(item.extruder);
 
    // Expand used mixed slots to their physical components and keep each mixed slot itself so the
    // dialog shows the mix. A component both used directly and pulled in via a mix is deduped.
    const auto* is_mixed_opt = full.opt<ConfigOptionBools>("filament_is_mixed");
    const auto* comp_opt     = full.opt<ConfigOptionStrings>("filament_mixed_components");
    if (is_mixed_opt != nullptr && comp_opt != nullptr && has_any_mixed_filament(is_mixed_opt->values)) {
        const std::vector<unsigned int> raw(used.begin(), used.end());
        const std::vector<unsigned int> expanded = expand_mixed_filaments(raw, is_mixed_opt->values, comp_opt->values);
        std::set<size_t> result(expanded.begin(), expanded.end());
        for (unsigned int s : raw)
            if (s < is_mixed_opt->values.size() && is_mixed_opt->values[s])
                result.insert(s);
        return result;
    }
 
    return used;
}

References Slic3r::ModelObject::config, Slic3r::Preset::config, Slic3r::expand_mixed_filaments(), Slic3r::CustomGCode::Item::extruder, Slic3r::PresetCollection::get_edited_preset(), Slic3r::ModelVolume::get_extruders(), Slic3r::has_any_mixed_filament(), Slic3r::ModelObject::layer_config_ranges, Slic3r::Model::objects, Slic3r::DynamicConfig::opt(), Slic3r::DynamicConfig::opt_bool(), Slic3r::DynamicConfig::opt_int(), Slic3r::ModelConfig::option(), Slic3r::Model::plates_custom_gcodes, Slic3r::PresetBundle::prints, project_used_filament_slots(), Slic3r::CustomGCode::ToolChange, Slic3r::CustomGCode::Item::type, Slic3r::ConfigOptionVector< unsigned char >::values, and Slic3r::ModelObject::volumes.

Referenced by project_used_filament_slots().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

s_tab_style

long Slic3r::GUI::anonymous_namespace{PublishSettingsDialog.cpp}::s_tab_style

constexpr

Initial value:

= wxTR_NO_BUTTONS | wxTR_HIDE_ROOT | wxTR_SINGLE | wxTR_NO_LINES | wxBORDER_NONE | wxWANTS_CHARS |
                             wxTR_FULL_ROW_HIGHLIGHT