Slic3r::GUI::SeparatedDragDropPanel Class Reference

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

Inheritance diagram for Slic3r::GUI::SeparatedDragDropPanel:

Collaboration diagram for Slic3r::GUI::SeparatedDragDropPanel:

Public Member Functions
	SeparatedDragDropPanel (wxWindow *parent, const wxString &label, bool use_separation=false)
void	AddColorBlock (const wxColour &color, const std::string &type, int filament_id, bool is_high_flow=false, bool update_ui=true)
void	RemoveColorBlock (ColorPanel *panel, bool update_ui=true)
std::vector< int >	GetAllFilaments () const
std::vector< int >	GetHighFlowFilaments () const
std::vector< int >	GetStandardFilaments () const
std::vector< int >	GetTPUHighFlowFilaments () const
std::vector< ColorPanel * >	get_filament_blocks () const
std::vector< ColorPanel * >	get_high_flow_blocks () const
std::vector< ColorPanel * >	get_standard_blocks () const
void	SetUseSeparation (bool use_separation)
bool	IsUseSeparation () const
void	ClearAllBlocks ()
void	UpdateLabel (const wxString &label)

Private Member Functions
void	UpdateLayout ()

Private Attributes
wxBoxSizer *	m_main_sizer
wxPanel *	m_content_panel
wxBoxSizer *	m_content_sizer
wxPanel *	m_separator = nullptr
Label *	m_label
DragDropPanel *	m_high_flow_panel
DragDropPanel *	m_standard_panel
DragDropPanel *	m_unified_panel
bool	m_use_separation

Detailed Description

Constructor & Destructor Documentation

SeparatedDragDropPanel()

Slic3r::GUI::SeparatedDragDropPanel::SeparatedDragDropPanel	(	wxWindow *	parent,
		const wxString &	label,
		bool	use_separation = false )

                                                                                                           : wxPanel(parent), m_use_separation(use_separation)
{
    SetBackgroundColour(0xF8F8F8);
 
    m_main_sizer = new wxBoxSizer(wxVERTICAL);
 
    auto title_panel = new wxPanel(this);
    title_panel->SetBackgroundColour(0xEEEEEE);
    auto title_sizer = new wxBoxSizer(wxHORIZONTAL);
    title_panel->SetSizer(title_sizer);
 
    m_label = new Label(title_panel, label);
    m_label->SetFont(Label::Head_13);
    m_label->SetBackgroundColour(0xEEEEEE);
 
    title_sizer->Add(m_label, 0, wxALIGN_CENTER | wxALL, FromDIP(5));
 
    m_main_sizer->Add(title_panel, 0, wxEXPAND);
    m_main_sizer->AddSpacer(10);
 
    m_content_panel = new wxPanel(this);
    m_content_panel->SetBackgroundColour(0xF8F8F8);
    m_content_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_content_panel->SetSizer(m_content_sizer);
 
    m_high_flow_panel = new DragDropPanel(m_content_panel, _L("High Flow"), false, true, true);
    m_standard_panel  = new DragDropPanel(m_content_panel, _L("Standard"), false, true, true);
    m_unified_panel   = new DragDropPanel(m_content_panel, wxEmptyString, false, false);
 
    m_high_flow_panel->SetBackgroundColour(0xF8F8F8);
    m_standard_panel->SetBackgroundColour(0xF8F8F8);
    m_unified_panel->SetBackgroundColour(0xF8F8F8);
    m_unified_panel->SetMinSize({FromDIP(260), -1});
 
    m_main_sizer->Add(m_content_panel, 1, wxEXPAND);
 
    UpdateLayout();
 
    auto drop_target = new SeparatedColorDropTarget(this);
    SetDropTarget(drop_target);
 
    SetSizer(m_main_sizer);
    Layout();
    wxGetApp().UpdateDarkUIWin(this);
}

References _L, Label::Head_13, m_content_panel, m_content_sizer, m_high_flow_panel, m_label, m_main_sizer, m_standard_panel, m_unified_panel, m_use_separation, and UpdateLayout().

Here is the call graph for this function:

Member Function Documentation

AddColorBlock()

void Slic3r::GUI::SeparatedDragDropPanel::AddColorBlock	(	const wxColour &	color,
		const std::string &	type,
		int	filament_id,
		bool	is_high_flow = false,
		bool	update_ui = true )

{
    if (m_use_separation) {
        if (is_high_flow) {
            m_high_flow_panel->AddColorBlock(color, type, filament_id, update_ui);
        } else {
            m_standard_panel->AddColorBlock(color, type, filament_id, update_ui);
        }
 
        if (update_ui) {
            CallAfter([this]() {
                Layout();
                GetParent()->Layout();
            });
        }
    } else {
        m_unified_panel->AddColorBlock(color, type, filament_id, update_ui);
    }
}

References m_high_flow_panel, m_standard_panel, m_unified_panel, m_use_separation, and update_ui().

Here is the call graph for this function:

ClearAllBlocks()

void Slic3r::GUI::SeparatedDragDropPanel::ClearAllBlocks

(

)

{
    auto high_flow_blocks = m_high_flow_panel->get_filament_blocks();
    for (auto &block : high_flow_blocks) {
        m_high_flow_panel->RemoveColorBlock(block, false);
    }
 
    auto standard_blocks = m_standard_panel->get_filament_blocks();
    for (auto &block : standard_blocks) {
        m_standard_panel->RemoveColorBlock(block, false);
    }
 
    auto unified_blocks = m_unified_panel->get_filament_blocks();
    for (auto &block : unified_blocks) {
        m_unified_panel->RemoveColorBlock(block, false);
    }
}

References m_high_flow_panel, m_standard_panel, and m_unified_panel.

get_filament_blocks()

std::vector< ColorPanel * > Slic3r::GUI::SeparatedDragDropPanel::get_filament_blocks

(

)

const

{
    if (m_use_separation) {
        auto high_flow = m_high_flow_panel->get_filament_blocks();
        auto standard  = m_standard_panel->get_filament_blocks();
 
        std::vector<ColorPanel *> result;
        result.insert(result.end(), high_flow.begin(), high_flow.end());
        result.insert(result.end(), standard.begin(), standard.end());
        return result;
    } else {
        return m_unified_panel->get_filament_blocks();
    }
}

References m_high_flow_panel, m_standard_panel, m_unified_panel, and m_use_separation.

get_high_flow_blocks()

std::vector< ColorPanel * > Slic3r::GUI::SeparatedDragDropPanel::get_high_flow_blocks

(

)

const

{
    return m_high_flow_panel->get_filament_blocks();
}

References m_high_flow_panel.

get_standard_blocks()

std::vector< ColorPanel * > Slic3r::GUI::SeparatedDragDropPanel::get_standard_blocks

(

)

const

{
    return m_standard_panel->get_filament_blocks();
}

References m_standard_panel.

GetAllFilaments()

std::vector< int > Slic3r::GUI::SeparatedDragDropPanel::GetAllFilaments

(

)

const

{
    if (m_use_separation) {
        auto high_flow = m_high_flow_panel->GetAllFilaments();
        auto standard  = m_standard_panel->GetAllFilaments();
 
        std::vector<int> result;
        result.insert(result.end(), high_flow.begin(), high_flow.end());
        result.insert(result.end(), standard.begin(), standard.end());
        return result;
    } else {
        return m_unified_panel->GetAllFilaments();
    }
}

References m_high_flow_panel, m_standard_panel, m_unified_panel, and m_use_separation.

GetHighFlowFilaments()

std::vector< int > Slic3r::GUI::SeparatedDragDropPanel::GetHighFlowFilaments

(

)

const

{
    if (m_use_separation) {
        return m_high_flow_panel->GetAllFilaments();
    }
    auto nozzle_volumes = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    const int right_eid = 1;
    if (nozzle_volumes->values.size() > right_eid) {
        int volume_type = nozzle_volumes->values[right_eid];
        if (volume_type == static_cast<int>(NozzleVolumeType::nvtHighFlow) ||
            volume_type == static_cast<int>(NozzleVolumeType::nvtE3DHighFlow)) {
            return m_unified_panel->GetAllFilaments();
        }
    }
    return {};
}

References m_high_flow_panel, m_unified_panel, m_use_separation, Slic3r::nvtE3DHighFlow, and Slic3r::nvtHighFlow.

GetStandardFilaments()

std::vector< int > Slic3r::GUI::SeparatedDragDropPanel::GetStandardFilaments

(

)

const

{
    if (m_use_separation) {
        return m_standard_panel->GetAllFilaments();
    }
    auto nozzle_volumes = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    const int right_eid = 1;
    if (nozzle_volumes->values.size() > right_eid) {
        int volume_type = nozzle_volumes->values[right_eid];
        if (volume_type == static_cast<int>(NozzleVolumeType::nvtStandard)) {
            return m_unified_panel->GetAllFilaments();
        }
    }
    return {};
}

References m_standard_panel, m_unified_panel, m_use_separation, and Slic3r::nvtStandard.

GetTPUHighFlowFilaments()

std::vector< int > Slic3r::GUI::SeparatedDragDropPanel::GetTPUHighFlowFilaments

(

)

const

{
    if (m_use_separation) {
        return {};
    }
    auto nozzle_volumes = wxGetApp().preset_bundle->project_config.option<ConfigOptionEnumsGeneric>("nozzle_volume_type");
    const int right_eid = 1;
    if (nozzle_volumes->values.size() > right_eid) {
        int volume_type = nozzle_volumes->values[right_eid];
        if (volume_type == static_cast<int>(NozzleVolumeType::nvtTPUHighFlow)) {
            return m_unified_panel->GetAllFilaments();
        }
    }
    return {};
}

References m_unified_panel, m_use_separation, and Slic3r::nvtTPUHighFlow.

IsUseSeparation()

bool Slic3r::GUI::SeparatedDragDropPanel::IsUseSeparation ( ) const

inline

{ return m_use_separation; }

References m_use_separation.

RemoveColorBlock()

void Slic3r::GUI::SeparatedDragDropPanel::RemoveColorBlock	(	ColorPanel *	panel,
		bool	update_ui = true )

{
    auto high_flow_blocks = m_high_flow_panel->get_filament_blocks();
    auto standard_blocks  = m_standard_panel->get_filament_blocks();
    auto unified_blocks   = m_unified_panel->get_filament_blocks();
 
    if (std::find(high_flow_blocks.begin(), high_flow_blocks.end(), panel) != high_flow_blocks.end()) {
        m_high_flow_panel->RemoveColorBlock(panel, update_ui);
    } else if (std::find(standard_blocks.begin(), standard_blocks.end(), panel) != standard_blocks.end()) {
        m_standard_panel->RemoveColorBlock(panel, update_ui);
    } else if (std::find(unified_blocks.begin(), unified_blocks.end(), panel) != unified_blocks.end()) {
        m_unified_panel->RemoveColorBlock(panel, update_ui);
    }
 
    if (update_ui && m_use_separation) {
        CallAfter([this]() {
            Layout();
            GetParent()->Layout();
        });
    }
}

References m_high_flow_panel, m_standard_panel, m_unified_panel, m_use_separation, and update_ui().

Here is the call graph for this function:

SetUseSeparation()

void Slic3r::GUI::SeparatedDragDropPanel::SetUseSeparation

(

bool

use_separation

)

{
    if (m_use_separation != use_separation) {
        m_use_separation = use_separation;
 
        if (use_separation) {
            auto blocks = m_unified_panel->get_filament_blocks();
            for (auto &block : blocks) {
                m_standard_panel->AddColorBlock(block->GetColor(), block->GetType(), block->GetFilamentId(), false);
                m_unified_panel->RemoveColorBlock(block, false);
            }
        } else {
            auto high_flow_blocks = m_high_flow_panel->get_filament_blocks();
            auto standard_blocks  = m_standard_panel->get_filament_blocks();
 
            for (auto &block : high_flow_blocks) {
                m_unified_panel->AddColorBlock(block->GetColor(), block->GetType(), block->GetFilamentId(), false);
                m_high_flow_panel->RemoveColorBlock(block, false);
            }
 
            for (auto &block : standard_blocks) {
                m_unified_panel->AddColorBlock(block->GetColor(), block->GetType(), block->GetFilamentId(), false);
                m_standard_panel->RemoveColorBlock(block, false);
            }
        }
 
        UpdateLayout();
    }
}

References m_high_flow_panel, m_standard_panel, m_unified_panel, m_use_separation, and UpdateLayout().

Here is the call graph for this function:

UpdateLabel()

void Slic3r::GUI::SeparatedDragDropPanel::UpdateLabel

(

const wxString &

label

)

{
    if (m_label) {
        m_label->SetLabel(label);
        m_label->Refresh();
        Layout();
    }
}

References m_label.

UpdateLayout()

void Slic3r::GUI::SeparatedDragDropPanel::UpdateLayout ( )

private

{
    m_content_sizer->Clear(false);
 
    if (m_use_separation) {
        m_unified_panel->Hide();
        m_high_flow_panel->Show();
        m_standard_panel->Show();
 
        wxSize content_size = m_content_panel->GetSize();
        int panel_width = (content_size.GetWidth() - FromDIP(1) - FromDIP(8)) / 2;
        if (panel_width > 0) {
            m_high_flow_panel->SetMinSize(wxSize(panel_width, -1));
            m_standard_panel->SetMinSize(wxSize(panel_width, -1));
        }
 
        m_content_sizer->Add(m_high_flow_panel, 1, wxEXPAND | wxLEFT, FromDIP(8));
 
        // Create the separator once and re-attach it on relayout; Clear(false) above only
        // detaches, so allocating here would leak a window per relayout.
        if (!m_separator) {
            m_separator = new wxPanel(m_content_panel, wxID_ANY);
            m_separator->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(0xCE, 0xCE, 0xCE)));
            m_separator->SetMinSize(wxSize(FromDIP(1), -1));
        }
        m_separator->Show();
        m_content_sizer->Add(m_separator, 0, wxEXPAND | wxALL, FromDIP(4));
 
        m_content_sizer->Add(m_standard_panel, 1, wxEXPAND | wxRIGHT, FromDIP(8));
    } else {
        m_high_flow_panel->Hide();
        m_standard_panel->Hide();
        if (m_separator)
            m_separator->Hide();
        m_unified_panel->Show();
 
        m_content_sizer->Add(m_unified_panel, 1, wxEXPAND);
    }
    m_content_sizer->Layout();
    Layout();
    Fit();
    if (GetParent()) {
        GetParent()->Layout();
        if (GetParent()->GetParent()) {
            GetParent()->GetParent()->Layout();
        }
    }
}

References StateColor::darkModeColorFor(), m_content_panel, m_content_sizer, m_high_flow_panel, m_separator, m_standard_panel, m_unified_panel, and m_use_separation.

Referenced by SeparatedDragDropPanel(), and SetUseSeparation().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_content_panel

wxPanel* Slic3r::GUI::SeparatedDragDropPanel::m_content_panel

private

Referenced by SeparatedDragDropPanel(), and UpdateLayout().

m_content_sizer

wxBoxSizer* Slic3r::GUI::SeparatedDragDropPanel::m_content_sizer

private

Referenced by SeparatedDragDropPanel(), and UpdateLayout().

m_high_flow_panel

DragDropPanel* Slic3r::GUI::SeparatedDragDropPanel::m_high_flow_panel

private

Referenced by SeparatedDragDropPanel(), AddColorBlock(), ClearAllBlocks(), get_filament_blocks(), get_high_flow_blocks(), GetAllFilaments(), GetHighFlowFilaments(), RemoveColorBlock(), SetUseSeparation(), and UpdateLayout().

m_label

Label* Slic3r::GUI::SeparatedDragDropPanel::m_label

private

Referenced by SeparatedDragDropPanel(), and UpdateLabel().

m_main_sizer

wxBoxSizer* Slic3r::GUI::SeparatedDragDropPanel::m_main_sizer

private

Referenced by SeparatedDragDropPanel().

m_separator

wxPanel* Slic3r::GUI::SeparatedDragDropPanel::m_separator = nullptr

private

Referenced by UpdateLayout().

m_standard_panel

DragDropPanel* Slic3r::GUI::SeparatedDragDropPanel::m_standard_panel

private

Referenced by SeparatedDragDropPanel(), AddColorBlock(), ClearAllBlocks(), get_filament_blocks(), get_standard_blocks(), GetAllFilaments(), GetStandardFilaments(), RemoveColorBlock(), SetUseSeparation(), and UpdateLayout().

m_unified_panel

DragDropPanel* Slic3r::GUI::SeparatedDragDropPanel::m_unified_panel

private

Referenced by SeparatedDragDropPanel(), AddColorBlock(), ClearAllBlocks(), get_filament_blocks(), GetAllFilaments(), GetHighFlowFilaments(), GetStandardFilaments(), GetTPUHighFlowFilaments(), RemoveColorBlock(), SetUseSeparation(), and UpdateLayout().

m_use_separation

bool Slic3r::GUI::SeparatedDragDropPanel::m_use_separation

private

Referenced by SeparatedDragDropPanel(), AddColorBlock(), get_filament_blocks(), GetAllFilaments(), GetHighFlowFilaments(), GetStandardFilaments(), GetTPUHighFlowFilaments(), IsUseSeparation(), RemoveColorBlock(), SetUseSeparation(), and UpdateLayout().

---

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

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