Slic3r::GUI::FilamentMapManualPanel Class Reference

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

Inheritance diagram for Slic3r::GUI::FilamentMapManualPanel:

Collaboration diagram for Slic3r::GUI::FilamentMapManualPanel:

Public Member Functions
	FilamentMapManualPanel (wxWindow *parent, const std::vector< std::string > &color, const std::vector< std::string > &type, const std::vector< int > &filament_list, const std::vector< int > &filament_map, const std::vector< int > &filament_volume_map)
	~FilamentMapManualPanel ()
std::vector< int >	GetFilamentMaps () const
std::vector< int >	GetFilamentVolumeMaps () const
std::vector< int >	GetLeftFilaments () const
std::vector< int >	GetRightFilaments () const
std::vector< int >	GetRightHighFlowFilaments () const
std::vector< int >	GetRightStandardFilaments () const
std::vector< int >	GetRightTPUHighFlowFilaments () const
void	UpdateNozzleVolumeType ()
void	UpdateNozzleCountDisplay ()
bool	Show (bool show=true) override

Private Member Functions
void	OnTimer (wxTimerEvent &evt)
void	OnSwitchFilament (wxCommandEvent &)
void	SyncPanelHeights ()
void	OnDragDropCompleted (wxCommandEvent &evt)
void	OnSuggestionClicked (wxCommandEvent &event)

Private Attributes
DragDropPanel *	m_left_panel
SeparatedDragDropPanel *	m_right_panel
Label *	m_description
Label *	m_tips
Label *	m_errors
wxPanel *	m_suggestion_panel
ScalableButton *	m_switch_btn
std::vector< int >	m_filament_map
std::vector< int >	m_filament_volume_map
std::vector< int >	m_filament_list
std::vector< std::string >	m_filament_color
std::vector< std::string >	m_filament_type
wxTimer *	m_timer
int	m_invalid_id {-1}
bool	m_force_validation {false}

Detailed Description

Constructor & Destructor Documentation

FilamentMapManualPanel()

Slic3r::GUI::FilamentMapManualPanel::FilamentMapManualPanel	(	wxWindow *	parent,
		const std::vector< std::string > &	color,
		const std::vector< std::string > &	type,
		const std::vector< int > &	filament_list,
		const std::vector< int > &	filament_map,
		const std::vector< int > &	filament_volume_map )

    : wxPanel(parent)
    , m_filament_map(filament_map)
    , m_filament_volume_map(filament_volume_map)
    , m_filament_list(filament_list)
    , m_filament_color(color)
    , m_filament_type(type)
{
    SetName(wxT("FilamentMapManualPanel"));
    SetBackgroundColour(BgNormalColor);
 
    auto top_sizer = new wxBoxSizer(wxVERTICAL);
 
    m_description = new Label(this, _L("We will slice according to this grouping method:"));
    top_sizer->Add(m_description, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
    m_description->Wrap(FromDIP(520));
    top_sizer->AddSpacer(FromDIP(8));
 
    auto drag_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_left_panel  = new DragDropPanel(this, _L("Left Nozzle"), false);
    m_right_panel = new SeparatedDragDropPanel(this, _L("Right Nozzle"), false);
    m_switch_btn  = new ScalableButton(this, wxID_ANY, "switch_filament_maps");
 
    UpdateNozzleVolumeType();
 
    for (size_t idx = 0; idx < m_filament_map.size(); ++idx) {
        auto iter = std::find(m_filament_list.begin(), m_filament_list.end(), idx + 1);
        if (iter == m_filament_list.end()) continue;
        wxColor color = Hex2Color(m_filament_color[idx]);
        std::string type = m_filament_type[idx];
        if (m_filament_map[idx] == 1) {
            m_left_panel->AddColorBlock(color, type, idx + 1);
        } else {
            assert(m_filament_map[idx] == 2);
            bool is_high_flow = (idx < m_filament_volume_map.size()) && (m_filament_volume_map[idx] == static_cast<int>(NozzleVolumeType::nvtHighFlow));
            m_right_panel->AddColorBlock(color, type, idx + 1, is_high_flow);
        }
    }
    m_left_panel->SetMinSize({FromDIP(260), FromDIP(110)});
    m_right_panel->SetMinSize({FromDIP(260), FromDIP(110)});
 
    drag_sizer->Add(m_left_panel, 1, wxEXPAND);
    drag_sizer->Add(m_switch_btn, 0, wxALIGN_CENTER | wxLEFT | wxRIGHT, FromDIP(8));
    drag_sizer->Add(m_right_panel, 1, wxEXPAND);
 
    top_sizer->Add(drag_sizer, 0, wxEXPAND);
 
    m_tips = new Label(this, _L("Tip: You can drag the filaments to reassign them to different nozzles."));
    m_tips->SetFont(Label::Body_14);
    m_tips->SetForegroundColour(TextNormalGreyColor);
    m_tips->Wrap(FromDIP(520));
    top_sizer->AddSpacer(FromDIP(20));
    top_sizer->Add(m_tips, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
 
    m_errors = new Label(this, "");
    m_errors->SetFont(Label::Body_13);
    m_errors->SetForegroundColour(TextErrorColor);
    m_errors->Wrap(FromDIP(520));
    top_sizer->AddSpacer(FromDIP(10));
    top_sizer->Add(m_errors, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
 
    m_errors->Hide();
 
    m_suggestion_panel = new wxPanel(this, wxID_ANY);
    m_suggestion_panel->SetBackgroundColour(*wxWHITE);
    auto suggestion_sizer = new wxBoxSizer(wxHORIZONTAL);
    auto suggestion_text  = new Label(m_suggestion_panel, _L("Please adjust your grouping or click "));
    suggestion_text->SetFont(Label::Body_13);
    suggestion_text->SetForegroundColour(TextErrorColor);
    suggestion_text->SetBackgroundColour(*wxWHITE);
    auto suggestion_btn   = new ScalableButton(m_suggestion_panel, wxID_ANY, "edit", wxEmptyString, wxDefaultSize, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, true, 14);
    suggestion_btn->SetBackgroundColour(*wxWHITE);
    auto suggestion_text2 = new Label(m_suggestion_panel, _L(" to set nozzle count"));
    suggestion_text2->SetFont(Label::Body_13);
    suggestion_text2->SetForegroundColour(TextErrorColor);
    suggestion_text2->SetBackgroundColour(*wxWHITE);
    suggestion_sizer->Add(suggestion_text, 0, wxALIGN_CENTER_VERTICAL);
    suggestion_sizer->Add(suggestion_btn, 0, wxALIGN_CENTER_VERTICAL);
    suggestion_sizer->Add(suggestion_text2, 0, wxALIGN_CENTER_VERTICAL);
    m_suggestion_panel->SetSizer(suggestion_sizer);
    top_sizer->Add(m_suggestion_panel, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
    m_suggestion_panel->Hide();
    suggestion_btn->Bind(wxEVT_BUTTON, &FilamentMapManualPanel::OnSuggestionClicked, this);
 
    // Multi-nozzle: give the user a reachable way to declare, per extruder, how many
    // physical nozzles of each volume type a multi-nozzle extruder carries. This is the
    // fallback "manual" producer of the extruder_nozzle_stats config (the full device nozzle-rack
    // auto-sync is deferred). Gated on the edited printer preset having an extruder with
    // extruder_max_nozzle_count > 1, so the trigger is not even created for any single-nozzle or
    // dual-extruder ({1,1}, H2D) printer - zero UI change for every existing profile.
    if (printer_has_multi_nozzle_extruder()) {
        auto *max_nozzle_counts_opt = wxGetApp().preset_bundle->printers.get_edited_preset().config.option<ConfigOptionIntsNullable>("extruder_max_nozzle_count");
        auto *set_count_link = new Label(this, _L("Set the physical nozzle count..."));
        set_count_link->SetFont(Label::Body_14);
        set_count_link->SetForegroundColour(BorderSelectedColor);
        set_count_link->SetCursor(wxCursor(wxCURSOR_HAND));
        top_sizer->AddSpacer(FromDIP(8));
        top_sizer->Add(set_count_link, 0, wxALIGN_LEFT | wxLEFT, FromDIP(15));
        const std::vector<int> max_counts = max_nozzle_counts_opt->values;
        set_count_link->Bind(wxEVT_LEFT_DOWN, [max_counts](wxMouseEvent &evt) {
            for (int extruder_id = 0; extruder_id < (int) max_counts.size(); ++extruder_id) {
                if (max_counts[extruder_id] > 1 && max_counts[extruder_id] != ConfigOptionIntsNullable::nil_value())
                    GUI::manuallySetNozzleCount(extruder_id);
            }
            evt.Skip();
        });
    }
 
    m_timer = new wxTimer(this);
    Bind(wxEVT_TIMER, &FilamentMapManualPanel::OnTimer, this);
    Bind(wxEVT_DRAG_DROP_COMPLETED, &FilamentMapManualPanel::OnDragDropCompleted, this);
 
    m_switch_btn->Bind(wxEVT_BUTTON, &FilamentMapManualPanel::OnSwitchFilament, this);
 
    SetSizer(top_sizer);
    SetMinSize(wxSize(FromDIP(580), -1));
    Layout();
    Fit();
    GUI::wxGetApp().UpdateDarkUIWin(this);
}

References _L, Slic3r::GUI::BgNormalColor, Label::Body_13, Label::Body_14, Slic3r::GUI::BorderSelectedColor, Slic3r::filament_map(), Slic3r::GUI::Hex2Color(), m_description, m_errors, m_filament_color, m_filament_list, m_filament_map, m_filament_type, m_filament_volume_map, m_left_panel, m_right_panel, m_suggestion_panel, m_switch_btn, m_timer, m_tips, Slic3r::GUI::manuallySetNozzleCount(), Slic3r::ConfigOptionIntsTempl< true >::nil_value(), Slic3r::nvtHighFlow, OnDragDropCompleted(), OnSuggestionClicked(), OnSwitchFilament(), OnTimer(), Slic3r::GUI::printer_has_multi_nozzle_extruder(), Slic3r::GUI::TextErrorColor, Slic3r::GUI::TextNormalGreyColor, UpdateNozzleVolumeType(), Slic3r::ConfigOptionVector< int >::values, and Slic3r::GUI::wxMouseEvent.

Here is the call graph for this function:

~FilamentMapManualPanel()

Slic3r::GUI::FilamentMapManualPanel::~FilamentMapManualPanel

(

)

{
    m_timer->Stop();
    delete m_timer;
}

References m_timer.

Member Function Documentation

GetFilamentMaps()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetFilamentMaps

(

)

const

{
    std::vector<int> new_filament_map = m_filament_map;
    std::vector<int> left_filaments   = this->GetLeftFilaments();
    std::vector<int> right_filaments  = this->GetRightFilaments();
 
    for (int i = 0; i < (int) new_filament_map.size(); ++i) {
        if (std::find(left_filaments.begin(), left_filaments.end(), i + 1) != left_filaments.end()) {
            new_filament_map[i] = 1;
        } else if (std::find(right_filaments.begin(), right_filaments.end(), i + 1) != right_filaments.end()) {
            new_filament_map[i] = 2;
        }
    }
    return new_filament_map;
}

References GetLeftFilaments(), GetRightFilaments(), and m_filament_map.

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFilamentVolumeMaps()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetFilamentVolumeMaps

(

)

const

{
    std::vector<int> volume_map(m_filament_map.size(), 0);
 
    std::vector<int> left_filaments                = this->GetLeftFilaments();
    std::vector<int> right_high_flow_filaments     = this->GetRightHighFlowFilaments();
    std::vector<int> right_standard_filaments      = this->GetRightStandardFilaments();
    std::vector<int> right_tpu_high_flow_filaments = this->GetRightTPUHighFlowFilaments();
 
    auto preset_bundle        = wxGetApp().preset_bundle;
    auto proj_config          = preset_bundle->project_config;
    auto nozzle_volume_values = proj_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
    // The high-flow panel of the right extruder also holds an E3D High Flow nozzle; keep that type
    // instead of writing plain High Flow, which the extruder does not have.
    const int  right_extruder_id      = 1;
    const bool right_e3d_high_flow    = nozzle_volume_values.size() > right_extruder_id &&
                                        nozzle_volume_values[right_extruder_id] == static_cast<int>(NozzleVolumeType::nvtE3DHighFlow);
    const int  right_high_flow_volume = static_cast<int>(right_e3d_high_flow ? NozzleVolumeType::nvtE3DHighFlow : NozzleVolumeType::nvtHighFlow);
 
    for (int i = 0; i < (int) volume_map.size(); ++i) {
        int filament_id = i + 1;
 
        if (std::find(left_filaments.begin(), left_filaments.end(), filament_id) != left_filaments.end()) {
            if (nozzle_volume_values.size() > 0) {
                // Orca: never emit the Hybrid marker as a per-filament value; on a Hybrid
                // extruder each filament prints with a concrete flow, defaulting to Standard.
                volume_map[i] = nozzle_volume_values[0] == static_cast<int>(NozzleVolumeType::nvtHybrid) ?
                                    static_cast<int>(NozzleVolumeType::nvtStandard) :
                                    nozzle_volume_values[0];
            }
        }
        else if (std::find(right_high_flow_filaments.begin(), right_high_flow_filaments.end(), filament_id) != right_high_flow_filaments.end()) {
            volume_map[i] = right_high_flow_volume;
        }
        else if (std::find(right_standard_filaments.begin(), right_standard_filaments.end(), filament_id) != right_standard_filaments.end()) {
            volume_map[i] = static_cast<int>(NozzleVolumeType::nvtStandard);
        }
        else if (std::find(right_tpu_high_flow_filaments.begin(), right_tpu_high_flow_filaments.end(), filament_id) != right_tpu_high_flow_filaments.end()) {
            volume_map[i] = static_cast<int>(NozzleVolumeType::nvtTPUHighFlow);
        }
    }
 
    return volume_map;
}

References GetLeftFilaments(), GetRightHighFlowFilaments(), GetRightStandardFilaments(), GetRightTPUHighFlowFilaments(), m_filament_map, Slic3r::nvtE3DHighFlow, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, and Slic3r::nvtTPUHighFlow.

Referenced by OnTimer().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLeftFilaments()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetLeftFilaments ( ) const

inline

{ return m_left_panel->GetAllFilaments(); }

References m_left_panel.

Referenced by GetFilamentMaps(), and GetFilamentVolumeMaps().

Here is the caller graph for this function:

GetRightFilaments()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetRightFilaments ( ) const

inline

{ return m_right_panel->GetAllFilaments(); }

References m_right_panel.

Referenced by GetFilamentMaps().

Here is the caller graph for this function:

GetRightHighFlowFilaments()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetRightHighFlowFilaments ( ) const

inline

{ return m_right_panel->GetHighFlowFilaments(); }

References m_right_panel.

Referenced by GetFilamentVolumeMaps().

Here is the caller graph for this function:

GetRightStandardFilaments()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetRightStandardFilaments ( ) const

inline

{ return m_right_panel->GetStandardFilaments(); }

References m_right_panel.

Referenced by GetFilamentVolumeMaps().

Here is the caller graph for this function:

GetRightTPUHighFlowFilaments()

std::vector< int > Slic3r::GUI::FilamentMapManualPanel::GetRightTPUHighFlowFilaments ( ) const

inline

{ return m_right_panel->GetTPUHighFlowFilaments(); }

References m_right_panel.

Referenced by GetFilamentVolumeMaps().

Here is the caller graph for this function:

OnDragDropCompleted()

void Slic3r::GUI::FilamentMapManualPanel::OnDragDropCompleted ( wxCommandEvent & evt )

private

{
    SyncPanelHeights();
    event.Skip();
}

References SyncPanelHeights().

Referenced by FilamentMapManualPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSuggestionClicked()

void Slic3r::GUI::FilamentMapManualPanel::OnSuggestionClicked ( wxCommandEvent & event )

private

{
    wxWindow *current = this;
    while (current && !wxDynamicCast(current, wxDialog)) {
        current = current->GetParent();
    }
 
    if (current) {
        wxDialog *dlg = wxDynamicCast(current, wxDialog);
        if (dlg) {
            int invalid_eid = m_invalid_id;
            dlg->EndModal(wxID_CANCEL);
 
            if (invalid_eid >= 0) {
                manuallySetNozzleCount(invalid_eid);
            }
            wxGetApp().plater()->update();
        }
    }
}

References m_invalid_id, and Slic3r::GUI::manuallySetNozzleCount().

Referenced by FilamentMapManualPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSwitchFilament()

void Slic3r::GUI::FilamentMapManualPanel::OnSwitchFilament ( wxCommandEvent & )

private

{
    auto left_blocks  = m_left_panel->get_filament_blocks();
    auto right_blocks = m_right_panel->get_filament_blocks();
 
    for (auto &block : left_blocks) {
        m_right_panel->AddColorBlock(block->GetColor(), block->GetType(), block->GetFilamentId(), false, false);
        m_left_panel->RemoveColorBlock(block, false);
    }
 
    for (auto &block : right_blocks) {
        m_left_panel->AddColorBlock(block->GetColor(), block->GetType(), block->GetFilamentId(), false);
        m_right_panel->RemoveColorBlock(block, false);
    }
    this->GetParent()->Layout();
    this->GetParent()->Fit();
 
    if (m_right_panel->IsUseSeparation()) {
        m_left_panel->Layout();
        m_left_panel->Fit();
        m_right_panel->Layout();
        m_right_panel->Fit();
        SyncPanelHeights();
    }
}

References m_left_panel, m_right_panel, and SyncPanelHeights().

Referenced by FilamentMapManualPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

OnTimer()

void Slic3r::GUI::FilamentMapManualPanel::OnTimer ( wxTimerEvent & evt )

private

{
    bool             valid          = true;
    int              invalid_eid    = -1;
    NozzleVolumeType invalid_nozzle = NozzleVolumeType::nvtStandard;
    auto             preset_bundle  = wxGetApp().preset_bundle;
    auto             proj_config    = preset_bundle->project_config;
    auto             nozzle_volume_values = proj_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
    std::vector<int> filament_map        = GetFilamentMaps();
    std::vector<int> filament_volume_map = GetFilamentVolumeMaps();
    // Orca: only multi-nozzle extruders carry a meaningful nozzle inventory; validating a plain
    // dual-extruder printer against it would flag every grouping whenever the stats are stale.
    if (printer_has_multi_nozzle_extruder()) {
        for (size_t eid = 0; eid < nozzle_volume_values.size(); ++eid) {
            NozzleVolumeType extruder_volume_type = NozzleVolumeType(nozzle_volume_values[eid]);
            bool             extruder_used        = std::find_if(m_filament_list.begin(), m_filament_list.end(),
                                                                 [&filament_map, eid](int fid) {
                                                        return fid - 1 < (int) filament_map.size() && (filament_map[fid - 1] - 1) == (int) eid;
                                                    }) != m_filament_list.end();
 
            if (!extruder_used) {
                continue;
            }
 
            if (extruder_volume_type == nvtHybrid) {
                int standard_count = getExtruderNozzleCount(preset_bundle, eid, NozzleVolumeType::nvtStandard);
                int highflow_count = getExtruderNozzleCount(preset_bundle, eid, NozzleVolumeType::nvtHighFlow);
 
                auto has_material_of_type = [this, eid, &filament_map, &filament_volume_map](NozzleVolumeType volume_type) {
                    return std::find_if(m_filament_list.begin(), m_filament_list.end(),
                                        [eid, &filament_map, &filament_volume_map, volume_type](int fid) {
                                            return fid - 1 < (int) filament_map.size() && (filament_map[fid - 1] - 1) == (int) eid &&
                                                   fid - 1 < (int) filament_volume_map.size() &&
                                                   filament_volume_map[fid - 1] == static_cast<int>(volume_type);
                                        }) != m_filament_list.end();
                };
 
                bool has_standard = has_material_of_type(NozzleVolumeType::nvtStandard);
                bool has_highflow = has_material_of_type(NozzleVolumeType::nvtHighFlow);
 
                if ((has_standard && standard_count == 0) ||
                    (has_highflow && highflow_count == 0)) {
                    valid          = false;
                    invalid_eid    = eid;
                    invalid_nozzle = (has_standard && standard_count == 0) ? NozzleVolumeType::nvtStandard : NozzleVolumeType::nvtHighFlow;
                    break;
                }
            } else {
                int count = getExtruderNozzleCount(preset_bundle, eid, extruder_volume_type);
                if (count == 0) {
                    valid          = false;
                    invalid_eid    = eid;
                    invalid_nozzle = extruder_volume_type;
                    break;
                }
            }
        }
    }
 
    bool update_ui  = m_invalid_id != invalid_eid;
    bool send_event = update_ui || m_force_validation;
 
    m_invalid_id = invalid_eid;
 
    if (update_ui) {
        if (valid) {
            m_errors->Hide();
            m_suggestion_panel->Hide();
        } else {
            // [extruder][nozzle volume type]
            static const char* const error_msgs[2][2] = {
                {L("Error: Left extruder has no available Standard nozzle, current group result is invalid."),
                 L("Error: Left extruder has no available High Flow nozzle, current group result is invalid.")},
                {L("Error: Right extruder has no available Standard nozzle, current group result is invalid."),
                 L("Error: Right extruder has no available High Flow nozzle, current group result is invalid.")}};
            m_errors->SetLabel(_(error_msgs[invalid_eid == 0 ? 0 : 1][invalid_nozzle == NozzleVolumeType::nvtStandard ? 0 : 1]));
            // Re-wrap: wrapping only applies to the label text present when Wrap is called,
            // and the label was empty at construction time.
            m_errors->Wrap(FromDIP(520));
            m_errors->Show();
            m_suggestion_panel->Show();
        }
        m_left_panel->Freeze();
        m_right_panel->Freeze();
        m_tips->Freeze();
        m_description->Freeze();
        Layout();
        Fit();
        this->GetParent()->Layout();
        this->GetParent()->Fit();
        m_left_panel->Thaw();
        m_right_panel->Thaw();
        m_tips->Thaw();
        m_description->Thaw();
    }
 
    if (send_event) {
        wxCommandEvent event(wxEVT_INVALID_MANUAL_MAP);
        event.SetInt(valid);
        ProcessEvent(event);
        m_force_validation = false;
    }
}

References _, count, Slic3r::filament_map(), Slic3r::GUI::getExtruderNozzleCount(), GetFilamentMaps(), GetFilamentVolumeMaps(), L, m_description, m_errors, m_filament_list, m_force_validation, m_invalid_id, m_left_panel, m_right_panel, m_suggestion_panel, m_tips, Slic3r::nvtHighFlow, Slic3r::nvtHybrid, Slic3r::nvtStandard, Slic3r::GUI::printer_has_multi_nozzle_extruder(), and update_ui().

Referenced by FilamentMapManualPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

Show()

bool Slic3r::GUI::FilamentMapManualPanel::Show ( bool show = true )

override

{
    m_force_validation = show;
    if (show) {
        m_timer->Start(500);
        SyncPanelHeights();
    } else {
        m_timer->Stop();
    }
 
    return wxPanel::Show(show);
}

References m_force_validation, m_timer, and SyncPanelHeights().

Here is the call graph for this function:

SyncPanelHeights()

void Slic3r::GUI::FilamentMapManualPanel::SyncPanelHeights ( )

private

{
    if (!m_left_panel || !m_right_panel) return;
 
    auto curr_left  = m_left_panel->GetMinSize();
    auto curr_right = m_right_panel->GetMinSize();
 
    m_left_panel->SetMinSize(wxSize(FromDIP(260), FromDIP(110)));
    m_right_panel->SetMinSize(wxSize(FromDIP(260), FromDIP(110)));
 
    m_left_panel->Layout();
    m_left_panel->Fit();
    m_right_panel->Layout();
    m_right_panel->Fit();
 
    wxSize left_best_size  = m_left_panel->GetBestSize();
    wxSize right_best_size = m_right_panel->GetBestSize();
 
    int  max_height     = std::max(left_best_size.GetHeight(), right_best_size.GetHeight());
    bool height_changed = curr_left.GetHeight() != max_height || curr_right.GetHeight() != max_height;
    if (!height_changed) {
        if (curr_left.GetHeight() > 0)
            m_left_panel->SetMinSize(curr_left);
        if (curr_right.GetHeight() > 0)
            m_right_panel->SetMinSize(curr_right);
        if (GetParent()) {
            GetParent()->Layout();
            GetParent()->Fit();
        }
        return;
    }
 
    m_left_panel->SetMinSize(wxSize(FromDIP(260), max_height));
    m_right_panel->SetMinSize(wxSize(FromDIP(260), max_height));
 
    Layout();
    Fit();
 
    if (GetParent()) {
        GetParent()->Layout();
        GetParent()->Fit();
    }
}

References m_left_panel, and m_right_panel.

Referenced by OnDragDropCompleted(), OnSwitchFilament(), and Show().

Here is the caller graph for this function:

UpdateNozzleCountDisplay()

void Slic3r::GUI::FilamentMapManualPanel::UpdateNozzleCountDisplay

(

)

{
    auto preset_bundle = wxGetApp().preset_bundle;
 
    // Orca: nozzle counts are only tracked (and only meaningful) for multi-nozzle extruders;
    // plain dual-extruder printers keep their unadorned zone titles.
    if (!printer_has_multi_nozzle_extruder()) {
        m_left_panel->UpdateLabel(_L("Left Nozzle"));
        m_right_panel->UpdateLabel(_L("Right Nozzle"));
        return;
    }
 
    // Format the count suffix separately so a translation containing '%' cannot
    // corrupt the wxString::Format output.
    int      left_count = getExtruderNozzleCountTotal(preset_bundle, 0);
    wxString left_title = _L("Left Nozzle") + wxString::Format("(%d)", left_count);
    m_left_panel->UpdateLabel(left_title);
 
    if (m_right_panel->IsUseSeparation()) {
        int      standard_count = getExtruderNozzleCount(preset_bundle, 1, NozzleVolumeType::nvtStandard);
        int      highflow_count = getExtruderNozzleCount(preset_bundle, 1, NozzleVolumeType::nvtHighFlow);
        // TRN Nozzle counts: Std = standard flow, HF = high flow
        wxString right_title    = _L("Right Nozzle") + wxString::Format(_L("(Std: %d, HF: %d)"), standard_count, highflow_count);
        m_right_panel->UpdateLabel(right_title);
    } else {
        int      right_count = getExtruderNozzleCountTotal(preset_bundle, 1);
        wxString right_title = _L("Right Nozzle") + wxString::Format("(%d)", right_count);
        m_right_panel->UpdateLabel(right_title);
    }
}

References _L, Slic3r::GUI::getExtruderNozzleCount(), Slic3r::GUI::getExtruderNozzleCountTotal(), m_left_panel, m_right_panel, Slic3r::nvtHighFlow, Slic3r::nvtStandard, and Slic3r::GUI::printer_has_multi_nozzle_extruder().

Referenced by UpdateNozzleVolumeType().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateNozzleVolumeType()

void Slic3r::GUI::FilamentMapManualPanel::UpdateNozzleVolumeType

(

)

{
    auto check_separation = []() {
        auto preset_bundle        = wxGetApp().preset_bundle;
        auto nozzle_volume_values = preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type")->values;
        if (nozzle_volume_values.size() <= 1)
            return false;
 
        return nozzle_volume_values[1] == static_cast<int>(NozzleVolumeType::nvtHybrid);
    };
    bool should_separate = check_separation();
    m_right_panel->SetUseSeparation(should_separate);
 
    UpdateNozzleCountDisplay();
 
    Layout();
    Fit();
}

References m_right_panel, Slic3r::nvtHybrid, and UpdateNozzleCountDisplay().

Referenced by FilamentMapManualPanel().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_description

Label* Slic3r::GUI::FilamentMapManualPanel::m_description

private

Referenced by FilamentMapManualPanel(), and OnTimer().

m_errors

Label* Slic3r::GUI::FilamentMapManualPanel::m_errors

private

Referenced by FilamentMapManualPanel(), and OnTimer().

m_filament_color

std::vector<std::string> Slic3r::GUI::FilamentMapManualPanel::m_filament_color

private

Referenced by FilamentMapManualPanel().

m_filament_list

std::vector<int> Slic3r::GUI::FilamentMapManualPanel::m_filament_list

private

Referenced by FilamentMapManualPanel(), and OnTimer().

m_filament_map

std::vector<int> Slic3r::GUI::FilamentMapManualPanel::m_filament_map

private

Referenced by FilamentMapManualPanel(), GetFilamentMaps(), and GetFilamentVolumeMaps().

m_filament_type

std::vector<std::string> Slic3r::GUI::FilamentMapManualPanel::m_filament_type

private

Referenced by FilamentMapManualPanel().

m_filament_volume_map

std::vector<int> Slic3r::GUI::FilamentMapManualPanel::m_filament_volume_map

private

Referenced by FilamentMapManualPanel().

m_force_validation

bool Slic3r::GUI::FilamentMapManualPanel::m_force_validation {false}

private

{false};

Referenced by OnTimer(), and Show().

m_invalid_id

int Slic3r::GUI::FilamentMapManualPanel::m_invalid_id {-1}

private

{-1};

Referenced by OnSuggestionClicked(), and OnTimer().

m_left_panel

DragDropPanel* Slic3r::GUI::FilamentMapManualPanel::m_left_panel

private

Referenced by FilamentMapManualPanel(), GetLeftFilaments(), OnSwitchFilament(), OnTimer(), SyncPanelHeights(), and UpdateNozzleCountDisplay().

m_right_panel

SeparatedDragDropPanel* Slic3r::GUI::FilamentMapManualPanel::m_right_panel

private

Referenced by FilamentMapManualPanel(), GetRightFilaments(), GetRightHighFlowFilaments(), GetRightStandardFilaments(), GetRightTPUHighFlowFilaments(), OnSwitchFilament(), OnTimer(), SyncPanelHeights(), UpdateNozzleCountDisplay(), and UpdateNozzleVolumeType().

m_suggestion_panel

wxPanel* Slic3r::GUI::FilamentMapManualPanel::m_suggestion_panel

private

Referenced by FilamentMapManualPanel(), and OnTimer().

m_switch_btn

ScalableButton* Slic3r::GUI::FilamentMapManualPanel::m_switch_btn

private

Referenced by FilamentMapManualPanel().

m_timer

wxTimer* Slic3r::GUI::FilamentMapManualPanel::m_timer

private

Referenced by FilamentMapManualPanel(), ~FilamentMapManualPanel(), and Show().

m_tips

Label* Slic3r::GUI::FilamentMapManualPanel::m_tips

private

Referenced by FilamentMapManualPanel(), and OnTimer().

---

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

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