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

Inheritance diagram for Slic3r::GUI::TextureImportDialog:

Collaboration diagram for Slic3r::GUI::TextureImportDialog:

Public Member Functions
	TextureImportDialog (wxWindow *parent, const Slic3r::TexturedMesh &textured_mesh, const std::vector< TextureFilamentEntry > &filament_entries, std::function< bool()> initial_cancel_callback={}, std::function< bool(int)> initial_progress_callback={})
	~TextureImportDialog ()
int	ShowModal () override
void	on_dpi_changed (const wxRect &suggested_rect) override
Slic3r::PaintedMesh	get_painted_mesh () const
std::vector< Slic3r::FilamentMatch >	get_matches () const
bool	was_skipped () const
bool	fallback_to_geometry_only () const
const std::vector< std::array< float, 4 > > &	get_new_filament_colors () const
const std::vector< std::string > &	get_new_filament_preset_names () const
const std::vector< TextureNewMixedFilament > &	get_new_mixed_filaments () const
const std::vector< TextureFilamentEntry > &	get_filament_entries () const
size_t	get_existing_filament_count () const
void	EndModal (int retCode) override
float	scale_factor () const
float	prev_scale_factor () const
void	set_scale_factor (float v)
void	set_prev_scale_factor (float v)
void	set_em_unit (int v)
bool	force_rescale () const
int	em_unit () const
const wxFont &	normal_font () const
void	enable_force_rescale ()

Protected Member Functions
virtual void	on_sys_color_changed ()

Private Member Functions
void	build_ui ()
void	build_preview_panel (wxWindow parent, wxSizer sizer)
void	build_params_panel (wxWindow parent, wxSizer sizer)
void	build_mapping_panel (wxWindow parent, wxSizer sizer)
void	build_bottom_buttons (wxSizer *sizer)
void	set_state (TextureImportState new_state)
void	update_ui_for_state ()
void	start_computation (bool auto_color=false, bool initial=false)
void	cancel_computation ()
void	on_computation_complete (wxCommandEvent &evt)
void	on_computation_progress (wxCommandEvent &evt)
void	on_computation_error (wxCommandEvent &evt)
void	on_mesh_repair_decision_required (wxCommandEvent &evt)
void	rebuild_mapping_rows ()
void	do_auto_match ()
void	sort_current_matches_by_filament_index ()
void	restore_current_match_order (const std::vector< Slic3r::FilamentMatch > &previous_matches)
std::vector< Slic3r::FilamentMatch >	build_matches_from_rows () const
void	update_filament_color_map ()
void	show_filament_popup (size_t row_index)
void	dismiss_filament_popup ()
void	dismiss_filament_popup_on_wheel (wxMouseEvent &evt)
void	show_auto_mix_popup ()
void	dismiss_auto_mix_popup ()
void	set_auto_mix_mode (TextureAutoMixMode mode)
void	apply_auto_standard_mix (TextureAutoMixMode mode)
void	reset_auto_mix ()
void	update_auto_mix_reset_visibility ()
bool	add_decomposed_mixed_filament (size_t row_index)
int	add_virtual_filament (const std::array< float, 4 > &rgba, const std::string &hex, const std::string &preset_name=std::string())
int	add_virtual_mixed_filament (const std::string &color_hex, const std::vector< int > &component_dialog_indices, const std::vector< int > &ratios)
size_t	max_filament_count () const
bool	can_add_virtual_filament () const
void	update_drop_warning_visibility ()
void	compact_used_virtual_filaments ()
int	find_closest_filament_index (const std::array< std::size_t, 3 > &color) const
std::vector< int >	compute_display_numbers () const
void	on_color_preset_clicked (wxCommandEvent &evt)
void	on_color_slider_changed (wxCommandEvent &evt)
void	on_color_spin_changed (wxCommandEvent &evt)
void	on_color_spin_text_changed (wxCommandEvent &evt)
void	on_smooth_slider_changed (wxCommandEvent &evt)
void	on_smooth_spin_changed (wxCommandEvent &evt)
void	on_smooth_spin_text_changed (wxCommandEvent &evt)
void	on_apply_clicked (wxCommandEvent &evt)
void	on_auto_merge_toggled (wxCommandEvent &evt)
void	highlight_view_button (int view_index)
void	on_skip_clicked (wxCommandEvent &evt)
void	on_ok_clicked (wxCommandEvent &evt)
void	set_color_count_value (int value, bool update_spin)
void	set_smooth_value (int value, bool update_spin)
void	preview_spin_text_value (SpinInput spin, AccentSlider slider, int &param, int min_value, int max_value, const wxString &text, std::function< void()> on_value_changed={})
void	update_color_count_preset_buttons ()
bool	has_valid_result () const
bool	is_params_dirty () const
void	update_confirm_button_state ()
void	style_confirm_button (bool dirty)
	wxDECLARE_EVENT_TABLE ()
void	update_em_unit ()
bool	is_new_scale_factor () const
void	rescale (const wxRect &suggested_rect)

Private Attributes
Slic3r::TexturedMesh	m_textured_mesh
std::vector< std::string >	m_filament_color_strs
std::vector< std::string >	m_filament_names
std::vector< std::array< float, 4 > >	m_filament_colors_rgba
std::vector< TextureFilamentEntry >	m_filament_entries
size_t	m_existing_filament_count = 0
std::vector< std::array< float, 4 > >	m_new_filament_colors
std::vector< std::string >	m_new_filament_preset_names
std::vector< TextureNewMixedFilament >	m_new_mixed_filaments
std::string	m_default_virtual_filament_preset_name
TextureImportState	m_state = TextureImportState::Idle
bool	m_skipped = false
bool	m_fallback_to_geometry_only = false
bool	m_filaments_dropped = false
bool	m_auto_merge_enabled = true
TextureAutoMixMode	m_auto_mix_mode = TextureAutoMixMode::CMYW
int	m_auto_mix_font_point_size = 10
Slic3r::PaintedMesh	m_painted
std::vector< Slic3r::FilamentMatch >	m_current_matches
std::unique_ptr< std::thread >	m_worker
std::atomic< bool >	m_cancel_flag {false}
std::mutex	m_result_mutex
Slic3r::PaintedMesh	m_pending_result
std::function< bool()>	m_initial_cancel_callback
std::function< bool(int)>	m_initial_progress_callback
bool	m_current_computation_initial = false
bool	m_initial_computation_pending = false
bool	m_initial_computation_cancelled = false
bool	m_initial_computation_failed = false
bool	m_initial_tooltips_set = false
bool	m_current_computation_auto_color = false
Slic3r::TexturePaintingSettings::MeshRepairDecision	m_mesh_repair_decision
Button *	m_btn_color_4 = nullptr
Button *	m_btn_color_8 = nullptr
Button *	m_btn_color_16 = nullptr
Button *	m_btn_color_auto = nullptr
AccentSlider *	m_color_slider = nullptr
SpinInput *	m_color_spin = nullptr
AccentSlider *	m_smooth_slider = nullptr
SpinInput *	m_smooth_spin = nullptr
Button *	m_btn_apply = nullptr
wxCheckBox *	m_auto_merge_cb = nullptr
Button *	m_btn_auto_mix = nullptr
Button *	m_btn_mix_reset = nullptr
bool	m_auto_mix_applied = false
AutoMixSelectPopup *	m_auto_mix_popup = nullptr
wxScrolledWindow *	m_mapping_scroll = nullptr
wxBoxSizer *	m_mapping_sizer = nullptr
std::vector< FilamentMappingRow >	m_mapping_rows
FilamentSelectPopup *	m_filament_popup = nullptr
int	m_filament_popup_row = -1
int	m_skip_next_filament_popup_row = -1
TexturePreviewCanvas *	m_preview_canvas = nullptr
wxPanel *	m_tab_panel = nullptr
Button *	m_btn_view_original = nullptr
Button *	m_btn_view_multicolor = nullptr
ProgressDialog *	m_progress_dlg = nullptr
Button *	m_btn_skip = nullptr
Button *	m_btn_ok = nullptr
wxStaticText *	m_drop_warning_label = nullptr
int	m_param_color_count = 4
int	m_param_smooth = 5
int	m_applied_color_count = -1
int	m_applied_smooth = -1
wxStaticText *	m_hint_label = nullptr
float	m_scale_factor
int	m_em_unit
wxFont	m_normal_font
float	m_prev_scale_factor
bool	m_can_rescale
bool	m_force_rescale
int	m_new_font_point_size

Static Private Attributes
static const int	ID_COLOR_4 = wxID_HIGHEST + 200
static const int	ID_COLOR_8 = wxID_HIGHEST + 201
static const int	ID_COLOR_16 = wxID_HIGHEST + 202
static const int	ID_COLOR_AUTO = wxID_HIGHEST + 203
static const int	ID_BTN_APPLY = wxID_HIGHEST + 204
static const int	ID_BTN_SKIP = wxID_HIGHEST + 205
static const int	ID_VIEW_ORIGINAL = wxID_HIGHEST + 206
static const int	ID_VIEW_MULTICOLOR = wxID_HIGHEST + 207

Detailed Description

Constructor & Destructor Documentation

◆ TextureImportDialog()

Slic3r::GUI::TextureImportDialog::TextureImportDialog	(	wxWindow *	parent,
		const Slic3r::TexturedMesh &	textured_mesh,
		const std::vector< TextureFilamentEntry > &	filament_entries,
		std::function< bool()>	initial_cancel_callback = {},
		std::function< bool(int)>	initial_progress_callback = {} )

◆ ~TextureImportDialog()

Slic3r::GUI::TextureImportDialog::~TextureImportDialog ( )

{
    dismiss_auto_mix_popup();
    dismiss_filament_popup();
    m_cancel_flag = true;
    if (m_worker && m_worker->joinable())
        m_worker->join();
}

References dismiss_auto_mix_popup(), dismiss_filament_popup(), m_cancel_flag, and m_worker.

Here is the call graph for this function:

Member Function Documentation

◆ add_decomposed_mixed_filament()

bool Slic3r::GUI::TextureImportDialog::add_decomposed_mixed_filament ( size_t row_index )

private

{
    if (row_index >= m_mapping_rows.size())
        return false;
 
    std::vector<std::string> physical_colors;
    std::vector<std::string> physical_names;
    std::vector<std::string> physical_types;
    std::vector<int> physical_dialog_indices;
    std::vector<size_t> physical_config_indices;
    auto& preset_bundle = *wxGetApp().preset_bundle;
    for (const auto& entry : m_filament_entries) {
        if (entry.kind != TextureFilamentKind::ExistingPhysical)
            continue;
        physical_colors.push_back(entry.color_hex);
        physical_names.push_back(entry.name);
        const size_t cfg_idx = entry.project_config_index;
        Preset* preset = nullptr;
        if (cfg_idx < preset_bundle.filament_presets.size())
            preset = preset_bundle.filaments.find_preset(preset_bundle.filament_presets[cfg_idx]);
        physical_types.push_back(filament_type_for_color_decompose(preset));
        physical_dialog_indices.push_back(entry.dialog_index);
        physical_config_indices.push_back(cfg_idx);
    }
    if (physical_colors.empty())
        return false;
 
    wxColour target(m_mapping_rows[row_index].source_hex);
    ColorDecomposeDialog dlg(this, -1, target, physical_colors, physical_names, physical_types,
                             m_filament_entries.size(), max_filament_count(),
                             std::move(physical_config_indices));
    // Count "new physical filaments" with the exact reuse rule of the write-back
    // loop below: a base color is only new if no existing OR virtual official
    // Bambu Basic filament already carries that color. This keeps the dialog's
    // filament-limit pre-check consistent with what add_decomposed_mixed_filament
    // will actually create, so already-present virtual base colors are not
    // double counted (which previously could wrongly disable OK).
    dlg.set_missing_physical_calculator([this](const ColorDecomposeResult& result) -> size_t {
        size_t missing = 0;
        for (const DecomposeComponent& comp : result.components) {
            if (comp.filament_index > 0)
                continue; // reuses a physical slot passed to the dialog, no new filament
            const std::string comp_hex = texture_normalize_color_hex(
                comp.colour.GetAsString(wxC2S_HTML_SYNTAX).ToStdString());
            bool found = false;
            for (const auto& entry : m_filament_entries) {
                if (!texture_entry_is_physical(entry.kind))
                    continue;
                if (texture_normalize_color_hex(entry.color_hex) != comp_hex)
                    continue;
                if (texture_entry_official_basic(entry)) {
                    found = true;
                    break;
                }
            }
            if (!found)
                ++missing;
        }
        return missing;
    });
    if (dlg.ShowModal() != wxID_OK)
        return false;
 
    ColorDecomposeResult result = dlg.get_result();
    std::vector<int> component_dialog_indices;
    std::vector<int> ratios;
    for (const DecomposeComponent& comp : result.components) {
        ratios.push_back(comp.ratio);
        if (comp.filament_index > 0) {
            const size_t physical_idx = (size_t)(comp.filament_index - 1);
            if (physical_idx >= physical_dialog_indices.size())
                return false;
            component_dialog_indices.push_back(physical_dialog_indices[physical_idx]);
            continue;
        }
 
        const std::string comp_hex = texture_normalize_color_hex(comp.colour.GetAsString(wxC2S_HTML_SYNTAX).ToStdString());
        int existing_idx = -1;
        for (const auto& entry : m_filament_entries) {
            if (!texture_entry_is_physical(entry.kind))
                continue;
            if (texture_normalize_color_hex(entry.color_hex) != comp_hex)
                continue;
            if (texture_entry_official_basic(entry)) {
                existing_idx = entry.dialog_index;
                break;
            }
        }
        if (existing_idx < 0) {
            std::array<float, 4> rgba = parse_color_string(comp_hex);
            existing_idx = add_virtual_filament(rgba, comp_hex);
            if (existing_idx < 0)
                return false;
        }
        component_dialog_indices.push_back(existing_idx);
    }
 
    if (component_dialog_indices.size() < 2 || component_dialog_indices.size() != ratios.size())
        return false;
 
    const std::string mixed_hex = texture_normalize_color_hex(
        result.matched_color.GetAsString(wxC2S_HTML_SYNTAX).ToStdString());
    int mixed_idx = add_virtual_mixed_filament(mixed_hex, component_dialog_indices, ratios);
    if (mixed_idx < 0)
        return false;
 
    m_mapping_rows[row_index].target_filament_idx = mixed_idx;
    if (row_index < m_current_matches.size())
        m_current_matches[row_index].filament_index = mixed_idx;
    rebuild_mapping_rows();
    update_filament_color_map();
    return true;
}

References add_virtual_filament(), add_virtual_mixed_filament(), Slic3r::GUI::DecomposeComponent::colour, Slic3r::GUI::ColorDecomposeResult::components, Slic3r::GUI::ExistingPhysical, Slic3r::GUI::DecomposeComponent::filament_index, Slic3r::GUI::filament_type_for_color_decompose(), Slic3r::GUI::ColorDecomposeDialog::get_result(), m_current_matches, m_filament_entries, m_mapping_rows, Slic3r::GUI::ColorDecomposeResult::matched_color, max_filament_count(), Slic3r::GUI::parse_color_string(), Slic3r::GUI::DecomposeComponent::ratio, rebuild_mapping_rows(), Slic3r::GUI::ColorDecomposeDialog::set_missing_physical_calculator(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::texture_entry_is_physical(), Slic3r::GUI::texture_entry_official_basic(), Slic3r::GUI::texture_normalize_color_hex(), and update_filament_color_map().

Referenced by show_filament_popup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_virtual_filament()

int Slic3r::GUI::TextureImportDialog::add_virtual_filament	(	const std::array< float, 4 > &	rgba,
		const std::string &	hex,
		const std::string &	preset_name = std::string() )

private

{
    if (m_filament_color_strs.size() != m_filament_colors_rgba.size() ||
        m_filament_names.size() != m_filament_colors_rgba.size() ||
        m_filament_entries.size() != m_filament_colors_rgba.size()) {
        return -1;
    }
    if (!can_add_virtual_filament()) {
        // Mark that this do_auto_match() run hit the filament cap and had to
        // drop at least one cluster. The mapping itself still falls back via
        // find_closest_filament_index() below; this flag only drives the
        // inline orange warning above the bottom buttons.
        // Note: only the false -> true transition happens here; the flag is
        // cleared exclusively at the entry of do_auto_match() so it always
        // reflects the most recent match, never an accumulated history.
        m_filaments_dropped = true;
        return -1;
    }
 
    const int new_idx = (int)m_filament_colors_rgba.size();
    m_filament_colors_rgba.push_back(rgba);
    m_filament_color_strs.push_back(hex);
    m_filament_names.push_back(DEFAULT_VIRTUAL_FILAMENT_NAME);
    TextureFilamentEntry entry;
    entry.kind = TextureFilamentKind::NewPhysical;
    entry.dialog_index = new_idx;
    entry.project_config_index = size_t(-1);
    entry.color_hex = texture_normalize_color_hex(hex);
    entry.name = DEFAULT_VIRTUAL_FILAMENT_NAME;
    entry.preset_name = preset_name.empty() ? m_default_virtual_filament_preset_name : preset_name;
    m_filament_entries.push_back(entry);
    m_new_filament_colors.push_back(rgba);
    m_new_filament_preset_names.push_back(preset_name.empty() ? m_default_virtual_filament_preset_name : preset_name);
    return new_idx;
}

References can_add_virtual_filament(), Slic3r::GUI::TextureFilamentEntry::color_hex, DEFAULT_VIRTUAL_FILAMENT_NAME, Slic3r::GUI::TextureFilamentEntry::dialog_index, Slic3r::GUI::TextureFilamentEntry::kind, m_default_virtual_filament_preset_name, m_filament_color_strs, m_filament_colors_rgba, m_filament_entries, m_filament_names, m_filaments_dropped, m_new_filament_colors, m_new_filament_preset_names, Slic3r::GUI::TextureFilamentEntry::name, Slic3r::GUI::NewPhysical, Slic3r::GUI::TextureFilamentEntry::preset_name, Slic3r::GUI::TextureFilamentEntry::project_config_index, and Slic3r::GUI::texture_normalize_color_hex().

Referenced by add_decomposed_mixed_filament(), apply_auto_standard_mix(), do_auto_match(), and show_filament_popup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_virtual_mixed_filament()

int Slic3r::GUI::TextureImportDialog::add_virtual_mixed_filament	(	const std::string &	color_hex,
		const std::vector< int > &	component_dialog_indices,
		const std::vector< int > &	ratios )

private

{
    if (m_filament_color_strs.size() != m_filament_colors_rgba.size() ||
        m_filament_names.size() != m_filament_colors_rgba.size() ||
        m_filament_entries.size() != m_filament_colors_rgba.size()) {
        return -1;
    }
    if (component_dialog_indices.size() < 2 || component_dialog_indices.size() != ratios.size())
        return -1;
    for (int idx : component_dialog_indices) {
        if (idx < 0 || idx >= (int)m_filament_entries.size() ||
            !texture_entry_is_physical(m_filament_entries[idx].kind)) {
            return -1;
        }
    }
    if (!can_add_virtual_filament()) {
        m_filaments_dropped = true;
        return -1;
    }
 
    const int new_idx = (int)m_filament_colors_rgba.size();
    TextureFilamentEntry entry;
    entry.kind = TextureFilamentKind::NewMixed;
    entry.dialog_index = new_idx;
    entry.project_config_index = size_t(-1);
    entry.color_hex = texture_normalize_color_hex(color_hex);
    entry.name = DEFAULT_VIRTUAL_FILAMENT_NAME;
    entry.mixed_ratios = ratios;
    for (int idx : component_dialog_indices)
        entry.mixed_components.push_back((unsigned int)(idx + 1));
 
    TextureNewMixedFilament mixed;
    mixed.dialog_index = entry.dialog_index;
    mixed.color_hex = entry.color_hex;
    mixed.component_dialog_indices = component_dialog_indices;
    mixed.ratios = ratios;
 
    m_filament_entries.push_back(entry);
    m_filament_color_strs.push_back(entry.color_hex);
    m_filament_names.push_back(entry.name);
    m_filament_colors_rgba.push_back(parse_color_string(entry.color_hex));
    m_new_mixed_filaments.push_back(mixed);
    return entry.dialog_index;
}

Referenced by add_decomposed_mixed_filament(), and apply_auto_standard_mix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_auto_standard_mix()

void Slic3r::GUI::TextureImportDialog::apply_auto_standard_mix ( TextureAutoMixMode mode )

private

{
    if (m_mapping_rows.empty())
        return;
    m_filaments_dropped = false;
 
    auto find_or_add_base_physical = [this](const std::string& color_hex) -> int {
        const std::string normalized = texture_normalize_color_hex(color_hex);
        for (const auto& entry : m_filament_entries) {
            if (!texture_entry_is_physical(entry.kind))
                continue;
            if (texture_normalize_color_hex(entry.color_hex) != normalized)
                continue;
            if (texture_entry_is_pla_basic(entry))
                return entry.dialog_index;
        }
 
        std::array<float, 4> rgba = parse_color_string(normalized);
        int idx = add_virtual_filament(rgba, normalized, m_default_virtual_filament_preset_name);
        if (idx >= 0 && idx < (int)m_filament_entries.size()) {
            m_filament_entries[idx].type = DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE;
            m_filament_entries[idx].name = DEFAULT_VIRTUAL_FILAMENT_NAME;
        }
        return idx;
    };
 
    auto find_existing_mixed = [this](const std::vector<int>& component_indices, const std::vector<int>& ratios) -> int {
        for (const auto& entry : m_filament_entries) {
            if (!texture_entry_is_mixed(entry.kind) || entry.mixed_components.size() != component_indices.size() ||
                entry.mixed_ratios.size() != ratios.size())
                continue;
            bool same = true;
            for (size_t i = 0; i < component_indices.size(); ++i) {
                if (entry.mixed_components[i] != (unsigned int)(component_indices[i] + 1) ||
                    entry.mixed_ratios[i] != ratios[i]) {
                    same = false;
                    break;
                }
            }
            if (same)
                return entry.dialog_index;
        }
        return -1;
    };
 
    bool changed = false;
    const auto recipe_mode = texture_recipe_mode(mode);
    for (size_t row_index = 0; row_index < m_mapping_rows.size(); ++row_index) {
        Slic3r::ColorDecomposeRgb target_rgb;
        if (!Slic3r::color_decompose_hex_to_rgb(m_mapping_rows[row_index].source_hex, target_rgb))
            continue;
 
        auto recipe = Slic3r::lookup_standard_recipe(target_rgb, recipe_mode, DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE);
        if (!recipe.valid || recipe.components.size() < 2)
            continue;
 
        std::vector<int> component_dialog_indices;
        std::vector<int> ratios;
        for (const auto& comp : recipe.components) {
            int component_idx = find_or_add_base_physical(comp.color_hex);
            if (component_idx < 0) {
                component_dialog_indices.clear();
                break;
            }
            component_dialog_indices.push_back(component_idx);
            ratios.push_back(comp.ratio);
        }
        if (component_dialog_indices.size() < 2 || component_dialog_indices.size() != ratios.size())
            continue;
 
        int mixed_idx = find_existing_mixed(component_dialog_indices, ratios);
        if (mixed_idx < 0)
            mixed_idx = add_virtual_mixed_filament(recipe.matched_color_hex, component_dialog_indices, ratios);
        if (mixed_idx < 0)
            continue;
 
        m_mapping_rows[row_index].target_filament_idx = mixed_idx;
        if (row_index < m_current_matches.size()) {
            m_current_matches[row_index].filament_index = mixed_idx;
            m_current_matches[row_index].filament_color = m_filament_colors_rgba[mixed_idx];
            m_current_matches[row_index].delta_e = Slic3r::compute_delta_e(
                m_current_matches[row_index].cluster_color, m_current_matches[row_index].filament_color);
            if (mixed_idx >= (int)m_existing_filament_count)
                m_current_matches[row_index].delta_e = 0.0;
        }
        changed = true;
    }
 
    if (!changed)
        return;
 
    m_auto_mix_applied = true;
    compact_used_virtual_filaments();
    update_filament_color_map();
    rebuild_mapping_rows();
    update_drop_warning_visibility();
    update_auto_mix_reset_visibility();
}

References add_virtual_filament(), add_virtual_mixed_filament(), Slic3r::color_decompose_hex_to_rgb(), compact_used_virtual_filaments(), Slic3r::compute_delta_e(), DEFAULT_VIRTUAL_FILAMENT_BASIC_TYPE, DEFAULT_VIRTUAL_FILAMENT_NAME, Slic3r::lookup_standard_recipe(), m_auto_mix_applied, m_current_matches, m_default_virtual_filament_preset_name, m_existing_filament_count, m_filament_colors_rgba, m_filament_entries, m_filaments_dropped, m_mapping_rows, Slic3r::GUI::parse_color_string(), rebuild_mapping_rows(), Slic3r::GUI::texture_entry_is_mixed(), Slic3r::GUI::texture_entry_is_physical(), Slic3r::GUI::texture_entry_is_pla_basic(), Slic3r::GUI::texture_normalize_color_hex(), Slic3r::GUI::texture_recipe_mode(), update_auto_mix_reset_visibility(), update_drop_warning_visibility(), and update_filament_color_map().

Referenced by set_auto_mix_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_bottom_buttons()

void Slic3r::GUI::TextureImportDialog::build_bottom_buttons ( wxSizer * sizer )

private

{
    m_drop_warning_label = new wxStaticText(this, wxID_ANY,
        wxString::Format(
            _L_PLURAL("The project supports up to %d filament. Extra filaments will be discarded.",
                      "The project supports up to %d filaments. Extra filaments will be discarded.",
                      (int)max_filament_count()),
            (int)max_filament_count()));
    m_drop_warning_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#FF6F00")));
    m_drop_warning_label->SetFont(texture_import_section_title_font(this));
    m_drop_warning_label->Hide();
    sizer->Add(m_drop_warning_label, 0, wxALIGN_LEFT | wxBOTTOM, FromDIP(4));
 
    wxBoxSizer* btn_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_btn_skip = new Button(this, _L("Skip Matching"));
    m_btn_skip->SetId(ID_BTN_SKIP);
    m_btn_skip->SetToolTip(_L("Skip filament mapping and import as a single-color model"));
    m_btn_skip->SetStyle(ButtonStyle::Regular, ButtonType::Choice);
 
    m_btn_ok = new Button(this, _L("Confirm"));
    m_btn_ok->SetId(wxID_OK);
    m_btn_ok->SetStyle(ButtonStyle::Confirm, ButtonType::Choice);
    m_btn_ok->EnableTooltipEvenDisabled();
    
    btn_sizer->AddStretchSpacer();
    btn_sizer->Add(m_btn_ok, 0, wxRIGHT, FromDIP(16)); // Match ordering of choice buttons on whole UI
    btn_sizer->Add(m_btn_skip, 0);
 
    sizer->Add(btn_sizer, 0, wxEXPAND | wxTOP, FromDIP(8));
}

References _L, _L_PLURAL, Choice, Confirm, StateColor::darkModeColorFor(), ID_BTN_SKIP, m_btn_ok, m_btn_skip, m_drop_warning_label, max_filament_count(), Regular, texture_import_section_title_font(), and wxStaticText.

Referenced by build_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_mapping_panel()

void Slic3r::GUI::TextureImportDialog::build_mapping_panel	(	wxWindow *	parent,
		wxSizer *	sizer )

private

{
    wxColour secondary_fg = StateColor::darkModeColorFor(wxColour("#363636"));
 
    wxBoxSizer* header_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxStaticText* lbl_mapping = new wxStaticText(parent, wxID_ANY, _L("Filament Mapping"));
    lbl_mapping->SetForegroundColour(secondary_fg);
    lbl_mapping->SetFont(Label::Head_14);
    m_auto_mix_font_point_size = lbl_mapping->GetFont().GetPointSize();
    header_sizer->Add(lbl_mapping, 0, wxALIGN_CENTER_VERTICAL);
 
    m_btn_mix_reset = new Button(parent, "", "revert_btn", wxBORDER_NONE, 16);
    m_btn_mix_reset->SetCanFocus(false);
    m_btn_mix_reset->SetStyle(ButtonStyle::Regular, ButtonType::Icon);
    m_btn_mix_reset->SetToolTip(_L("Reset filament mapping to the state before one-click mixing"));
    m_btn_mix_reset->Bind(wxEVT_BUTTON, [this](wxCommandEvent& evt) {
        reset_auto_mix();
        evt.Skip();
    });
    m_btn_mix_reset->Hide();
    header_sizer->Add(m_btn_mix_reset, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, FromDIP(6));
 
    header_sizer->AddStretchSpacer();
 
    m_btn_auto_mix = new Button(parent, auto_mix_mode_label(m_auto_mix_mode), "drop_down", 0, 16);
    m_btn_auto_mix->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
    m_btn_auto_mix->SetToolTip(_L("Choose the one-click auto-mix mode for texture color import"));
    m_btn_auto_mix->Bind(wxEVT_BUTTON, [this](wxCommandEvent& evt) { // ORCA show popup on click instead
        show_auto_mix_popup();
        evt.Skip();
    });
    header_sizer->Add(m_btn_auto_mix, 0, wxALIGN_CENTER_VERTICAL);
 
    sizer->Add(header_sizer, 0, wxEXPAND | wxBOTTOM, FromDIP(4));
 
    wxBoxSizer* merge_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_auto_merge_cb = new wxCheckBox(parent, wxID_ANY, _L("Auto-merge same filament"));
    m_auto_merge_cb->SetFont(Label::Body_14);
    m_auto_merge_cb->SetToolTip(_L("Automatically merge identical filaments into existing filaments in the project"));
    m_auto_merge_cb->SetForegroundColour(secondary_fg);
    m_auto_merge_cb->SetValue(true);
    m_auto_merge_cb->Bind(wxEVT_CHECKBOX, &TextureImportDialog::on_auto_merge_toggled, this);
    merge_sizer->Add(m_auto_merge_cb, 0, wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM, FromDIP(5));
 
    sizer->Add(merge_sizer, 0, wxEXPAND | wxBOTTOM, FromDIP(8));
 
    m_mapping_scroll = new wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition,
                                             wxSize(-1, FromDIP(300)));
    m_mapping_scroll->SetScrollRate(0, FromDIP(20));
    m_mapping_scroll->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    m_mapping_scroll->Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
 
    m_mapping_sizer = new wxBoxSizer(wxVERTICAL);
    m_mapping_scroll->SetSizer(m_mapping_sizer);
 
    sizer->Add(m_mapping_scroll, 1, wxEXPAND | wxBOTTOM, FromDIP(8));
}

References _L, Slic3r::GUI::auto_mix_mode_label(), Label::Body_14, StateColor::darkModeColorFor(), dismiss_filament_popup_on_wheel(), Label::Head_14, Icon, m_auto_merge_cb, m_auto_mix_font_point_size, m_auto_mix_mode, m_btn_auto_mix, m_btn_mix_reset, m_mapping_scroll, m_mapping_sizer, on_auto_merge_toggled(), Parameter, Regular, reset_auto_mix(), show_auto_mix_popup(), and wxStaticText.

Referenced by build_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_matches_from_rows()

std::vector< Slic3r::FilamentMatch > Slic3r::GUI::TextureImportDialog::build_matches_from_rows ( ) const

private

{
    std::vector<Slic3r::FilamentMatch> matches(m_mapping_rows.size());
    for (size_t i = 0; i < m_mapping_rows.size(); ++i) {
        auto& m = matches[i];
        m.cluster_index = m_mapping_rows[i].cluster_id;
        m.cluster_color = m_mapping_rows[i].source_color;
 
        int sel = m_mapping_rows[i].target_filament_idx;
        if (sel >= 0 && sel < (int)m_filament_colors_rgba.size()) {
            m.filament_index = sel;
            m.filament_color = m_filament_colors_rgba[sel];
            m.delta_e = Slic3r::compute_delta_e(m.cluster_color, m.filament_color);
        }
    }
    return matches;
}

References Slic3r::compute_delta_e(), m_filament_colors_rgba, and m_mapping_rows.

Referenced by get_matches(), and on_ok_clicked().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_params_panel()

void Slic3r::GUI::TextureImportDialog::build_params_panel	(	wxWindow *	parent,
		wxSizer *	sizer )

private

{
    wxColour label_fg = StateColor::darkModeColorFor(wxColour("#363636"));
 
    wxBoxSizer* color_header_sizer = new wxBoxSizer(wxHORIZONTAL);
    wxStaticText* lbl_colors = new wxStaticText(parent, wxID_ANY, _L("Color Count"));
    lbl_colors->SetForegroundColour(label_fg);
    lbl_colors->SetFont(Label::Head_14);
    color_header_sizer->Add(lbl_colors, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(8));
 
    m_btn_color_4    = new Button(parent, "4");
    m_btn_color_4->SetId(ID_COLOR_4);
    m_btn_color_8    = new Button(parent, "8");
    m_btn_color_8->SetId(ID_COLOR_8);
    m_btn_color_16   = new Button(parent, "16");
    m_btn_color_16->SetId(ID_COLOR_16);
    m_btn_color_auto = new Button(parent, _L("Auto"));
    m_btn_color_auto->SetId(ID_COLOR_AUTO);
    m_btn_color_auto->SetStyle(ButtonStyle::Regular, ButtonType::Window);
 
    update_color_count_preset_buttons();
 
    color_header_sizer->AddStretchSpacer();
    color_header_sizer->Add(m_btn_color_4,  0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(2));
    color_header_sizer->Add(m_btn_color_8,  0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(2));
    color_header_sizer->Add(m_btn_color_16, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(color_header_sizer, 0, wxBOTTOM, FromDIP(4));
 
    wxBoxSizer* color_slider_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_color_slider = new AccentSlider(parent, m_param_color_count, 1, (int)max_filament_count());
    m_color_spin = new SpinInput(parent, wxString::Format("%d", m_param_color_count),
                                 wxEmptyString, wxDefaultPosition,
                                 wxSize(FromDIP(60), FromDIP(28)),
                                 wxTE_PROCESS_ENTER, 1, (int)max_filament_count(), m_param_color_count);
 
    m_color_slider->Bind(wxEVT_SLIDER, &TextureImportDialog::on_color_slider_changed, this);
    m_color_spin->Bind(wxEVT_SPINCTRL, &TextureImportDialog::on_color_spin_changed, this);
    m_color_spin->Bind(EVT_SPINCTRL_TEXT, &TextureImportDialog::on_color_spin_text_changed, this);
 
    color_slider_sizer->Add(m_color_slider, 1, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(4));
    color_slider_sizer->Add(m_color_spin, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(color_slider_sizer, 0, wxEXPAND | wxBOTTOM, FromDIP(8));
 
    wxStaticText* lbl_smooth = new wxStaticText(parent, wxID_ANY, _L("Smooth Level"));
    lbl_smooth->SetForegroundColour(label_fg);
    lbl_smooth->SetFont(Label::Head_14);
    sizer->Add(lbl_smooth, 0, wxBOTTOM, FromDIP(4));
 
    wxBoxSizer* smooth_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_smooth_slider = new AccentSlider(parent, m_param_smooth, 0, 10);
    m_smooth_spin = new SpinInput(parent, wxString::Format("%d", m_param_smooth),
                                  wxEmptyString, wxDefaultPosition,
                                  wxSize(FromDIP(60), FromDIP(28)),
                                  wxTE_PROCESS_ENTER, 0, 10, m_param_smooth);
 
    m_smooth_slider->Bind(wxEVT_SLIDER, &TextureImportDialog::on_smooth_slider_changed, this);
    m_smooth_spin->Bind(wxEVT_SPINCTRL, &TextureImportDialog::on_smooth_spin_changed, this);
    m_smooth_spin->Bind(EVT_SPINCTRL_TEXT, &TextureImportDialog::on_smooth_spin_text_changed, this);
 
    smooth_sizer->Add(m_smooth_slider, 1, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(4));
    smooth_sizer->Add(m_smooth_spin, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(smooth_sizer, 0, wxEXPAND | wxBOTTOM, FromDIP(4));
 
    m_btn_apply = new Button(parent, _L("Apply"));
    m_btn_apply->SetId(ID_BTN_APPLY);
    m_btn_apply->SetStyle(ButtonStyle::Regular, ButtonType::Window);
 
    // Defer attaching the Auto/Apply tooltips until the dialog has actually
    // been shown. On macOS, AppKit creates NSTrackingArea and dispatches a
    // synthetic mouseEntered: as soon as the window first becomes visible,
    // which would otherwise pop the native tooltip without the user actually
    // hovering when the cursor happens to land on these buttons as the dialog
    // appears.
    Bind(wxEVT_SHOW, [this](wxShowEvent& e) {
        e.Skip();
        if (!e.IsShown() || m_initial_tooltips_set)
            return;
        m_initial_tooltips_set = true;
        CallAfter([this]() {
            if (m_btn_color_auto)
                m_btn_color_auto->SetToolTip(_L("Automatically determine the optimal color count only and recompute filament mapping"));
            if (m_btn_apply)
                m_btn_apply->SetToolTip(_L("Convert texture to painting using the specified color count and smooth level"));
        });
    });
 
    wxBoxSizer* apply_sizer = new wxBoxSizer(wxHORIZONTAL);
    apply_sizer->Add(m_btn_color_auto, 0, wxRIGHT, FromDIP(4));
    apply_sizer->Add(m_btn_apply, 0);
    sizer->Add(apply_sizer, 0, wxALIGN_RIGHT | wxBOTTOM | wxTOP, FromDIP(8));
 
    m_hint_label = new wxStaticText(parent, wxID_ANY,
        _L("Reminder: parameters changed, click Apply to take effect"));
    m_hint_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour("#FF6F00")));
    m_hint_label->SetFont(texture_import_section_title_font(parent));
    m_hint_label->Hide();
    sizer->Add(m_hint_label, 0, wxBOTTOM, FromDIP(4));
 
    auto* mapping_separator = new StaticLine(parent);
    mapping_separator->SetLineColour(wxColour(SEPARATOR_COLOUR_KEY));
    sizer->Add(mapping_separator, 0, wxEXPAND | wxBOTTOM, FromDIP(8));
}

References _L, StateColor::darkModeColorFor(), Label::Head_14, ID_BTN_APPLY, ID_COLOR_16, ID_COLOR_4, ID_COLOR_8, ID_COLOR_AUTO, m_btn_apply, m_btn_color_16, m_btn_color_4, m_btn_color_8, m_btn_color_auto, m_color_slider, m_color_spin, m_hint_label, m_initial_tooltips_set, m_param_color_count, m_param_smooth, m_smooth_slider, m_smooth_spin, max_filament_count(), on_color_slider_changed(), on_color_spin_changed(), on_color_spin_text_changed(), on_smooth_slider_changed(), on_smooth_spin_changed(), on_smooth_spin_text_changed(), Regular, SEPARATOR_COLOUR_KEY, texture_import_section_title_font(), update_color_count_preset_buttons(), Window, and wxStaticText.

Referenced by build_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_preview_panel()

void Slic3r::GUI::TextureImportDialog::build_preview_panel	(	wxWindow *	parent,
		wxSizer *	sizer )

private

{
    wxColour preview_bg = StateColor::darkModeColorFor(wxColour("#EEEEEE"));
    wxColour preview_bd = texture_import_separator_colour();
 
    wxPanel* preview_container = new wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
    preview_container->SetBackgroundColour(preview_bg);
    preview_container->SetBackgroundStyle(wxBG_STYLE_PAINT);
    preview_container->Bind(wxEVT_PAINT, [preview_bg, preview_bd](wxPaintEvent& e) {
        auto* p = static_cast<wxPanel*>(e.GetEventObject());
        wxAutoBufferedPaintDC dc(p);
        wxSize sz = p->GetClientSize();
        dc.SetBrush(wxBrush(p->GetParent()->GetBackgroundColour()));
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.DrawRectangle(0, 0, sz.x, sz.y);
        dc.SetBrush(wxBrush(preview_bg));
        dc.SetPen(wxPen(preview_bd, 1));
        dc.DrawRoundedRectangle(0, 0, sz.x, sz.y, 4);
    });
 
    wxBoxSizer* container_sizer = new wxBoxSizer(wxVERTICAL);
 
    wxGLAttributes canvas_attrs;
    canvas_attrs.PlatformDefaults().RGBA().DoubleBuffer().Depth(24).EndList();
    m_preview_canvas = new TexturePreviewCanvas(preview_container, canvas_attrs);
    container_sizer->Add(m_preview_canvas, 1, wxEXPAND | wxALL, FromDIP(1));
 
    preview_container->SetSizer(container_sizer);
    sizer->Add(preview_container, 1, wxEXPAND);
 
    m_tab_panel = new wxPanel(preview_container, wxID_ANY);
    m_tab_panel->SetBackgroundColour(preview_bg);
 
    m_btn_view_original   = new Button(m_tab_panel, _L("Original"));
    m_btn_view_original->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
    m_btn_view_original->SetId(ID_VIEW_ORIGINAL);
    m_btn_view_multicolor = new Button(m_tab_panel, _L("Multi-Color"));
    m_btn_view_multicolor->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
    m_btn_view_multicolor->SetId(ID_VIEW_MULTICOLOR);
 
    const int view_button_height = FromDIP(27);
    m_btn_view_original->SetToolTip(_L("Your input texture model"));
    m_btn_view_multicolor->SetToolTip(_L("Processed multi-color model"));
 
    wxBoxSizer* tab_sizer = new wxBoxSizer(wxHORIZONTAL);
    tab_sizer->Add(m_btn_view_original,   0, wxRIGHT, FromDIP(2));
    tab_sizer->Add(m_btn_view_multicolor, 0);
    m_tab_panel->SetSizer(tab_sizer);
    m_tab_panel->Fit();
 
    m_btn_view_multicolor->Hide();
    auto preview_original = [this](wxMouseEvent& e) {
        if (m_preview_canvas) {
            m_preview_canvas->set_render_mode(TexturePreviewCanvas::RenderMode::Original);
            highlight_view_button(0);
        }
        e.Skip();
    };
    auto preview_multicolor = [this](wxMouseEvent& e) {
        if (m_preview_canvas) {
            m_preview_canvas->set_render_mode(TexturePreviewCanvas::RenderMode::MultiColor);
            highlight_view_button(1);
        }
        e.Skip();
    };
    auto restore_filament_if_outside = [this](wxMouseEvent& e) {
        if (m_preview_canvas && m_tab_panel) {
            wxWindow* event_window = wxDynamicCast(e.GetEventObject(), wxWindow);
            wxPoint screen_pos = event_window ? event_window->ClientToScreen(e.GetPosition()) : wxGetMousePosition();
            wxPoint panel_pos = m_tab_panel->ScreenToClient(screen_pos);
            if (!m_tab_panel->GetClientRect().Contains(panel_pos)) {
                const bool mapping_ready = (m_state == TextureImportState::Ready);
                m_preview_canvas->set_render_mode(mapping_ready ? TexturePreviewCanvas::RenderMode::FilamentMap :
                                                            TexturePreviewCanvas::RenderMode::Original);
                highlight_view_button(-1);
            }
        }
        e.Skip();
    };
 
    m_btn_view_original->Bind(wxEVT_ENTER_WINDOW, preview_original);
    m_btn_view_multicolor->Bind(wxEVT_ENTER_WINDOW, preview_multicolor);
    m_btn_view_original->Bind(wxEVT_LEAVE_WINDOW, restore_filament_if_outside);
    m_btn_view_multicolor->Bind(wxEVT_LEAVE_WINDOW, restore_filament_if_outside);
    m_tab_panel->Bind(wxEVT_LEAVE_WINDOW, restore_filament_if_outside);
 
    auto update_preview_overlay_buttons = [this]() {
        if (m_tab_panel) {
            m_tab_panel->Fit();
            m_tab_panel->SetPosition(wxPoint(FromDIP(8), FromDIP(8)));
            m_tab_panel->Raise();
        }
    };
 
    preview_container->Bind(wxEVT_SIZE, [update_preview_overlay_buttons](wxSizeEvent& e) {
        e.Skip();
        update_preview_overlay_buttons();
    });
    update_preview_overlay_buttons();
 
    highlight_view_button(-1);
}

References _L, StateColor::darkModeColorFor(), Slic3r::GUI::TexturePreviewCanvas::FilamentMap, highlight_view_button(), ID_VIEW_MULTICOLOR, ID_VIEW_ORIGINAL, m_btn_view_multicolor, m_btn_view_original, m_preview_canvas, m_state, m_tab_panel, Slic3r::GUI::TexturePreviewCanvas::MultiColor, Slic3r::GUI::TexturePreviewCanvas::Original, Parameter, Slic3r::GUI::Ready, Regular, texture_import_separator_colour(), and Slic3r::GUI::wxMouseEvent.

Referenced by build_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_ui()

void Slic3r::GUI::TextureImportDialog::build_ui ( )

private

{
    const wxColour dialog_bg = StateColor::darkModeColorFor(*wxWHITE);
    SetBackgroundColour(dialog_bg);
    SetForegroundColour(StateColor::darkModeColorFor(wxColour("#363636")));
 
    wxBoxSizer* root_sizer = new wxBoxSizer(wxVERTICAL);
 
    auto line_top = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxSize(-1, 1));
    line_top->SetBackgroundColour(texture_import_separator_colour());
    root_sizer->Add(line_top, 0, wxEXPAND);
 
    wxBoxSizer* main_sizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBoxSizer* left_sizer = new wxBoxSizer(wxVERTICAL);
    build_preview_panel(this, left_sizer);
    main_sizer->Add(left_sizer, 3, wxEXPAND | wxALL, FromDIP(8));
 
    wxBoxSizer* right_sizer = new wxBoxSizer(wxVERTICAL);
    build_params_panel(this, right_sizer);
    build_mapping_panel(this, right_sizer);
    build_bottom_buttons(right_sizer);
    main_sizer->Add(right_sizer, 2, wxEXPAND | wxALL, FromDIP(8));
 
    root_sizer->Add(main_sizer, 1, wxEXPAND);
 
    SetSizer(root_sizer);
    Layout();
    Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
 
#ifdef __WXMSW__
    wxPanel* size_grip_cover = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
    size_grip_cover->SetBackgroundColour(dialog_bg);
    size_grip_cover->SetBackgroundStyle(wxBG_STYLE_COLOUR);
 
    auto update_size_grip_cover = [this, size_grip_cover]() {
        const int cover_size = FromDIP(20);
        wxSize client_size = GetClientSize();
        size_grip_cover->SetSize(client_size.x - cover_size, client_size.y - cover_size, cover_size, cover_size);
        size_grip_cover->Raise();
    };
    update_size_grip_cover();
 
    Bind(wxEVT_SIZE, [update_size_grip_cover](wxSizeEvent& e) {
        e.Skip();
        update_size_grip_cover();
    });
#endif
}

References build_bottom_buttons(), build_mapping_panel(), build_params_panel(), build_preview_panel(), StateColor::darkModeColorFor(), dismiss_filament_popup_on_wheel(), and texture_import_separator_colour().

Here is the call graph for this function:

◆ can_add_virtual_filament()

bool Slic3r::GUI::TextureImportDialog::can_add_virtual_filament ( ) const

private

{
    return m_filament_colors_rgba.size() < max_filament_count();
}

References m_filament_colors_rgba, and max_filament_count().

Referenced by add_virtual_filament(), and add_virtual_mixed_filament().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel_computation()

void Slic3r::GUI::TextureImportDialog::cancel_computation ( )

private

{
    m_cancel_flag = true;
    if (m_worker && m_worker->joinable())
        m_worker->join();
    m_worker.reset();
 
    if (m_progress_dlg) {
        m_progress_dlg->Destroy();
        m_progress_dlg = nullptr;
    }
 
    if (m_current_computation_initial) {
        m_initial_computation_cancelled = true;
        m_initial_computation_pending = false;
        m_current_computation_initial = false;
    }
}

References m_cancel_flag, m_current_computation_initial, m_initial_computation_cancelled, m_initial_computation_pending, m_progress_dlg, and m_worker.

Referenced by on_skip_clicked(), and start_computation().

Here is the caller graph for this function:

◆ compact_used_virtual_filaments()

void Slic3r::GUI::TextureImportDialog::compact_used_virtual_filaments ( )

private

{
    if (m_current_matches.empty())
        return;
 
    const std::vector<std::array<float, 4>> old_colors = m_filament_colors_rgba;
    const std::vector<std::string> old_color_strs = m_filament_color_strs;
    const std::vector<std::string> old_names = m_filament_names;
    const std::vector<TextureFilamentEntry> old_entries = m_filament_entries;
 
    auto old_new_mixed_has_valid_components = [&old_entries, &old_colors](const TextureFilamentEntry& entry) {
        if (entry.kind != TextureFilamentKind::NewMixed)
            return true;
        if (entry.mixed_components.size() < 2 || entry.mixed_components.size() != entry.mixed_ratios.size())
            return false;
        for (unsigned int comp : entry.mixed_components) {
            int comp_idx = comp >= 1 ? (int)comp - 1 : -1;
            if (comp_idx < 0 || comp_idx >= (int)old_entries.size() || comp_idx >= (int)old_colors.size() ||
                !texture_entry_is_physical(old_entries[comp_idx].kind)) {
                return false;
            }
        }
        return true;
    };
 
    std::set<int> used_virtual_indices;
    for (const auto& m : m_current_matches) {
        if (m.filament_index >= (int)m_existing_filament_count &&
            m.filament_index < (int)old_colors.size()) {
            if (m.filament_index < (int)old_entries.size() &&
                old_entries[m.filament_index].kind == TextureFilamentKind::NewMixed &&
                !old_new_mixed_has_valid_components(old_entries[m.filament_index])) {
                continue;
            }
            used_virtual_indices.insert(m.filament_index);
        }
    }
    bool added_dependency = true;
    while (added_dependency) {
        added_dependency = false;
        std::vector<int> current_used(used_virtual_indices.begin(), used_virtual_indices.end());
        for (int used_idx : current_used) {
            if (used_idx < 0 || used_idx >= (int)old_entries.size() ||
                old_entries[used_idx].kind != TextureFilamentKind::NewMixed ||
                !old_new_mixed_has_valid_components(old_entries[used_idx]))
                continue;
            for (unsigned int comp : old_entries[used_idx].mixed_components) {
                int comp_idx = comp >= 1 ? (int)comp - 1 : -1;
                if (comp_idx >= (int)m_existing_filament_count && comp_idx < (int)old_entries.size() &&
                    used_virtual_indices.insert(comp_idx).second) {
                    added_dependency = true;
                }
            }
        }
    }
 
    std::vector<std::array<float, 4>> compact_colors;
    std::vector<std::string> compact_color_strs;
    std::vector<std::string> compact_names;
    std::vector<TextureFilamentEntry> compact_entries;
    compact_colors.reserve(m_existing_filament_count + used_virtual_indices.size());
    compact_color_strs.reserve(m_existing_filament_count + used_virtual_indices.size());
    compact_names.reserve(m_existing_filament_count + used_virtual_indices.size());
    compact_entries.reserve(m_existing_filament_count + used_virtual_indices.size());
 
    const size_t existing_count = std::min(m_existing_filament_count, old_colors.size());
    for (size_t i = 0; i < existing_count; ++i) {
        compact_colors.push_back(old_colors[i]);
        compact_color_strs.push_back(i < old_color_strs.size() ? old_color_strs[i] : "");
        compact_names.push_back(i < old_names.size() ? old_names[i] : GUI::format(_u8L("Filament %d"), i + 1));
        TextureFilamentEntry entry = i < old_entries.size() ? old_entries[i] : TextureFilamentEntry{};
        entry.dialog_index = (int)i;
        entry.color_hex = texture_normalize_color_hex(compact_color_strs.back());
        entry.name = compact_names.back();
        compact_entries.push_back(entry);
    }
 
    std::map<int, int> old_to_new;
    std::vector<std::array<float, 4>> compact_new_colors;
    std::vector<std::string> compact_new_preset_names;
    compact_new_colors.reserve(used_virtual_indices.size());
    compact_new_preset_names.reserve(used_virtual_indices.size());
 
    for (int old_idx : used_virtual_indices) {
        old_to_new[old_idx] = (int)compact_colors.size();
        compact_colors.push_back(old_colors[old_idx]);
        compact_color_strs.push_back(old_idx < (int)old_color_strs.size() ? old_color_strs[old_idx] : "");
        compact_names.push_back(old_idx < (int)old_names.size() ? old_names[old_idx] : DEFAULT_VIRTUAL_FILAMENT_NAME);
        TextureFilamentEntry entry = old_idx < (int)old_entries.size() ? old_entries[old_idx] : TextureFilamentEntry{};
        entry.dialog_index = (int)compact_entries.size();
        entry.color_hex = texture_normalize_color_hex(compact_color_strs.back());
        entry.name = compact_names.back();
        if (entry.kind == TextureFilamentKind::NewPhysical) {
            compact_new_colors.push_back(old_colors[old_idx]);
            compact_new_preset_names.push_back(entry.preset_name.empty() ? m_default_virtual_filament_preset_name : entry.preset_name);
        }
        compact_entries.push_back(entry);
    }
 
    m_filament_colors_rgba = std::move(compact_colors);
    m_filament_color_strs = std::move(compact_color_strs);
    m_filament_names = std::move(compact_names);
    m_filament_entries = std::move(compact_entries);
    m_new_filament_colors = std::move(compact_new_colors);
    m_new_filament_preset_names = std::move(compact_new_preset_names);
    m_new_mixed_filaments.clear();
    std::set<int> invalid_compacted_mixed_indices;
    for (auto& entry : m_filament_entries) {
        if (entry.kind != TextureFilamentKind::NewMixed)
            continue;
        TextureNewMixedFilament mixed;
        mixed.dialog_index = entry.dialog_index;
        mixed.color_hex = entry.color_hex;
        mixed.ratios = entry.mixed_ratios;
        mixed.component_dialog_indices.reserve(entry.mixed_components.size());
        bool valid_components = entry.mixed_components.size() >= 2 &&
            entry.mixed_components.size() == entry.mixed_ratios.size();
        for (unsigned int comp : entry.mixed_components) {
            int old_comp_idx = comp >= 1 ? (int)comp - 1 : -1;
            if (old_comp_idx < 0) {
                valid_components = false;
                break;
            }
            auto remap_it = old_to_new.find(old_comp_idx);
            int new_comp_idx = remap_it != old_to_new.end() ? remap_it->second : old_comp_idx;
            if (new_comp_idx < 0 || new_comp_idx >= (int)m_filament_entries.size() ||
                !texture_entry_is_physical(m_filament_entries[new_comp_idx].kind)) {
                valid_components = false;
                break;
            }
            mixed.component_dialog_indices.push_back(new_comp_idx);
        }
        if (!valid_components) {
            invalid_compacted_mixed_indices.insert(entry.dialog_index);
            continue;
        }
        entry.mixed_components.clear();
        for (int comp_idx : mixed.component_dialog_indices)
            entry.mixed_components.push_back((unsigned int)(comp_idx + 1));
        m_new_mixed_filaments.push_back(mixed);
    }
 
    auto find_closest_physical_filament_index = [this](const std::array<std::size_t, 3>& color) {
        int best_idx = -1;
        double best_delta = std::numeric_limits<double>::max();
        const size_t filament_count = std::min(m_filament_colors_rgba.size(), max_filament_count());
        for (size_t i = 0; i < filament_count && i < m_filament_entries.size(); ++i) {
            if (!texture_entry_is_physical(m_filament_entries[i].kind))
                continue;
            const double delta = Slic3r::compute_delta_e(color, m_filament_colors_rgba[i]);
            if (delta < best_delta) {
                best_delta = delta;
                best_idx = (int)i;
            }
        }
        return best_idx;
    };
 
    for (auto& m : m_current_matches) {
        auto it = old_to_new.find(m.filament_index);
        if (it != old_to_new.end()) {
            m.filament_index = it->second;
        } else if (m.filament_index >= (int)m_existing_filament_count) {
            m.filament_index = find_closest_filament_index(m.cluster_color);
        }
        if (invalid_compacted_mixed_indices.count(m.filament_index) > 0) {
            int fallback_idx = find_closest_physical_filament_index(m.cluster_color);
            m.filament_index = fallback_idx >= 0 ? fallback_idx : find_closest_filament_index(m.cluster_color);
        }
 
        if (m.filament_index >= 0 && m.filament_index < (int)m_filament_colors_rgba.size()) {
            m.filament_color = m_filament_colors_rgba[m.filament_index];
            m.delta_e = Slic3r::compute_delta_e(m.cluster_color, m.filament_color);
            if (m.filament_index >= (int)m_existing_filament_count)
                m.delta_e = 0.0;
        }
    }
}

Referenced by apply_auto_standard_mix(), do_auto_match(), on_auto_merge_toggled(), on_computation_complete(), on_ok_clicked(), and reset_auto_mix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_display_numbers()

std::vector< int > Slic3r::GUI::TextureImportDialog::compute_display_numbers ( ) const

private

{
    // Assigns each entry a 1-based display number in the order the sidebar will
    // show after apply: ExistingPhysical, NewPhysical, ExistingMixed, NewMixed.
    // This keeps the dialog's visible IDs in sync with the post-apply sidebar,
    // instead of the raw dialog_index (which interleaves physicals and mixeds
    // by processing order and causes e.g. CMYW to show 4,5,6,8 instead of 3,4,5,6).
    // MUST mirror ordering in apply_textured_mesh_import_result (Plater.cpp:9896):
    //   - ExistingPhysical keeps its project_config_index
    //   - NewPhysical is inserted at existing_physical_count + new_order
    //   - ExistingMixed shifts to project_config_index + new_physical_count
    //   - NewMixed is appended after all existing mixeds
    std::vector<int> result(m_filament_entries.size(), 0);
    int next = 1;
 
    auto assign_group = [&](TextureFilamentKind kind, bool by_project_config_index) {
        if (by_project_config_index) {
            std::vector<const TextureFilamentEntry*> group;
            for (const auto& e : m_filament_entries)
                if (e.kind == kind)
                    group.push_back(&e);
            std::sort(group.begin(), group.end(),
                      [](const TextureFilamentEntry* a, const TextureFilamentEntry* b) {
                          return a->project_config_index < b->project_config_index;
                      });
            for (const auto* e : group) {
                if (e->dialog_index >= 0 && e->dialog_index < (int)result.size())
                    result[e->dialog_index] = next;
                ++next;
            }
        } else {
            for (const auto& e : m_filament_entries) {
                if (e.kind != kind)
                    continue;
                if (e.dialog_index >= 0 && e.dialog_index < (int)result.size())
                    result[e.dialog_index] = next;
                ++next;
            }
        }
    };
 
    assign_group(TextureFilamentKind::ExistingPhysical, true);
    assign_group(TextureFilamentKind::NewPhysical,      false);
    assign_group(TextureFilamentKind::ExistingMixed,    true);
    assign_group(TextureFilamentKind::NewMixed,         false);
    return result;
}

References Slic3r::GUI::ExistingMixed, Slic3r::GUI::ExistingPhysical, m_filament_entries, Slic3r::GUI::NewMixed, and Slic3r::GUI::NewPhysical.

Referenced by rebuild_mapping_rows(), and show_filament_popup().

Here is the caller graph for this function:

◆ dismiss_auto_mix_popup()

void Slic3r::GUI::TextureImportDialog::dismiss_auto_mix_popup ( )

private

{
    if (!m_auto_mix_popup)
        return;
 
    AutoMixSelectPopup* popup = m_auto_mix_popup;
    m_auto_mix_popup = nullptr;
    if (popup->IsShown())
        popup->Dismiss();
    else
        popup->Destroy();
}

References m_auto_mix_popup.

Referenced by ~TextureImportDialog(), dismiss_filament_popup_on_wheel(), reset_auto_mix(), show_auto_mix_popup(), and update_ui_for_state().

Here is the caller graph for this function:

◆ dismiss_filament_popup()

void Slic3r::GUI::TextureImportDialog::dismiss_filament_popup ( )

private

{
    if (!m_filament_popup) {
        m_filament_popup_row = -1;
        return;
    }
 
    FilamentSelectPopup* popup = m_filament_popup;
    m_filament_popup = nullptr;
    m_filament_popup_row = -1;
    if (popup->IsShown())
        popup->Dismiss();
    else
        popup->Destroy();
}

References m_filament_popup, and m_filament_popup_row.

Referenced by ~TextureImportDialog(), dismiss_filament_popup_on_wheel(), and show_filament_popup().

Here is the caller graph for this function:

◆ dismiss_filament_popup_on_wheel()

void Slic3r::GUI::TextureImportDialog::dismiss_filament_popup_on_wheel ( wxMouseEvent & evt )

private

{
    dismiss_filament_popup();
    dismiss_auto_mix_popup();
    evt.Skip();
}

References dismiss_auto_mix_popup(), dismiss_filament_popup(), and Slic3r::GUI::wxMouseEvent.

Referenced by build_mapping_panel(), build_ui(), and rebuild_mapping_rows().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_auto_match()

void Slic3r::GUI::TextureImportDialog::do_auto_match ( )

private

{
    if (m_painted.cluster_colors.empty()) return;
 
    // do_auto_match() always rebuilds the baseline mapping without any mixed
    // filaments, so it is the common entry for every "revert one-click mix"
    // path. Clear the applied flag here; callers refresh the reset button.
    m_auto_mix_applied = false;
 
    // Reset the "filaments were dropped" flag at the start of every run, so it
    // strictly reflects what happens during *this* match (no historical
    // accumulation). add_virtual_filament() will flip it back to true if and
    // only if it hits the global filament cap below.
    m_filaments_dropped = false;
 
    // Drop any virtual filaments left over from previous match runs that the
    // current m_current_matches no longer references. Without this, the
    // residual virtual filaments inflate m_filament_colors_rgba.size() at the
    // entry of this match, which can make add_virtual_filament() fail (and
    // wrongly flip m_filaments_dropped to true) even when the *real* count
    // of needed virtual filaments for this run is well below the global cap.
    // This is purely a state cleanup; it does not change any mapping rule.
    compact_used_virtual_filaments();
 
    const auto previous_matches = m_current_matches;
 
    std::map<std::array<std::size_t, 3>, int> previous_virtual_by_cluster;
    for (const auto& match : previous_matches) {
        if (match.filament_index >= (int)m_existing_filament_count &&
            match.filament_index < (int)m_filament_entries.size() &&
            texture_entry_is_physical(m_filament_entries[match.filament_index].kind)) {
            previous_virtual_by_cluster[match.cluster_color] = match.filament_index;
        }
    }
 
    auto find_virtual_filament_by_color = [this](const std::array<std::size_t, 3>& color) -> int {
        std::string hex = rgb_to_hex(color).ToStdString();
        for (size_t i = m_existing_filament_count; i < m_filament_color_strs.size(); ++i) {
            if (m_filament_color_strs[i] == hex &&
                i < m_filament_entries.size() && texture_entry_is_physical(m_filament_entries[i].kind))
                return (int)i;
        }
        return -1;
    };
 
    auto get_or_add_virtual_filament = [this, &previous_virtual_by_cluster, &find_virtual_filament_by_color](
        const std::array<std::size_t, 3>& color) -> int {
        auto previous_it = previous_virtual_by_cluster.find(color);
        if (previous_it != previous_virtual_by_cluster.end() &&
            previous_it->second >= (int)m_existing_filament_count &&
            previous_it->second < (int)m_filament_colors_rgba.size()) {
            return previous_it->second;
        }
 
        int existing_idx = find_virtual_filament_by_color(color);
        if (existing_idx >= 0)
            return existing_idx;
 
        std::array<float, 4> rgba = {
            color[0] / 255.f,
            color[1] / 255.f,
            color[2] / 255.f,
            1.f
        };
        return add_virtual_filament(rgba, rgb_to_hex(color).ToStdString());
    };
 
    if (m_auto_merge_cb && m_auto_merge_cb->GetValue()) {
        // Match clusters to closest existing filaments
        std::vector<std::string> names;
        for (size_t i = 0; i < m_existing_filament_count; ++i)
            names.push_back(m_filament_names.size() > i ? m_filament_names[i] : GUI::format(_u8L("Filament %d"), i + 1));
 
        std::vector<std::array<float, 4>> existing_filament_colors(
            m_filament_colors_rgba.begin(),
            m_filament_colors_rgba.begin() + std::min(m_existing_filament_count, m_filament_colors_rgba.size()));
 
        m_current_matches = Slic3r::match_clusters_to_filaments(
            m_painted.cluster_colors, existing_filament_colors, names);
 
        // For clusters with poor match (CIEDE2000 ΔE > 5), create virtual filaments.
        constexpr double NEW_FILAMENT_THRESHOLD = 5.0;
        std::map<std::array<std::size_t, 3>, int> virtual_color_index;
 
        for (auto& m : m_current_matches) {
            if (m.delta_e <= NEW_FILAMENT_THRESHOLD)
                continue;
 
            auto it = virtual_color_index.find(m.cluster_color);
            if (it != virtual_color_index.end()) {
                m.filament_index = it->second;
            } else {
                int new_idx = get_or_add_virtual_filament(m.cluster_color);
                if (new_idx >= 0)
                    virtual_color_index[m.cluster_color] = new_idx;
                m.filament_index = new_idx >= 0 ? new_idx : find_closest_filament_index(m.cluster_color);
            }
            if (m.filament_index >= 0 && m.filament_index < (int)m_filament_colors_rgba.size()) {
                m.filament_color = m_filament_colors_rgba[m.filament_index];
                m.delta_e = Slic3r::compute_delta_e(m.cluster_color, m.filament_color);
                if (m.filament_index >= (int)m_existing_filament_count)
                    m.delta_e = 0.0;
            }
        }
    } else {
        // Keep all virtual filaments in this dialog; unused ones are pruned only on OK.
        m_current_matches.clear();
        std::map<std::array<std::size_t, 3>, int> virtual_map;
 
        for (size_t i = 0; i < m_painted.cluster_colors.size(); ++i) {
            const auto& cc = m_painted.cluster_colors[i];
            Slic3r::FilamentMatch fm;
            fm.cluster_index = (int)i;
            fm.cluster_color = cc;
 
            auto it = virtual_map.find(cc);
            if (it != virtual_map.end()) {
                fm.filament_index = it->second;
            } else {
                int idx = get_or_add_virtual_filament(cc);
                if (idx >= 0)
                    virtual_map[cc] = idx;
                fm.filament_index = idx >= 0 ? idx : find_closest_filament_index(cc);
            }
            if (fm.filament_index >= 0 && fm.filament_index < (int)m_filament_colors_rgba.size()) {
                fm.filament_color = m_filament_colors_rgba[fm.filament_index];
                fm.delta_e = Slic3r::compute_delta_e(fm.cluster_color, fm.filament_color);
                if (fm.filament_index >= (int)m_existing_filament_count)
                    fm.delta_e = 0.0;
            }
            m_current_matches.push_back(fm);
        }
    }
 
    update_filament_color_map();
}

References _u8L, add_virtual_filament(), Slic3r::FilamentMatch::cluster_color, Slic3r::FilamentMatch::cluster_index, compact_used_virtual_filaments(), Slic3r::compute_delta_e(), Slic3r::FilamentMatch::delta_e, Slic3r::FilamentMatch::filament_color, Slic3r::FilamentMatch::filament_index, find_closest_filament_index(), Slic3r::GUI::format(), m_auto_merge_cb, m_auto_mix_applied, m_current_matches, m_existing_filament_count, m_filament_color_strs, m_filament_colors_rgba, m_filament_entries, m_filament_names, m_filaments_dropped, m_painted, Slic3r::match_clusters_to_filaments(), Slic3r::GUI::rgb_to_hex(), Slic3r::GUI::texture_entry_is_physical(), and update_filament_color_map().

Referenced by on_auto_merge_toggled(), on_computation_complete(), and reset_auto_mix().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ em_unit()

int Slic3r::GUI::DPIAware< wxDialog >::em_unit ( ) const

inlineinherited

203{ return m_em_unit; }

Slic3r::GUI::DPIAware

Definition GUI_Utils.hpp:107

Here is the caller graph for this function:

◆ enable_force_rescale()

void Slic3r::GUI::DPIAware< wxDialog >::enable_force_rescale ( )

inlineinherited

206{ m_force_rescale = true; }

◆ EndModal()

void Slic3r::GUI::DPIDialog::EndModal ( int retCode )

inlineoverrideinherited

    {
        if (!dialogStack.empty() && dialogStack.front() != this) {
            // This is a bug in wxWidgets
            // when the dialog is not top modal dialog, EndModal() just hide dialog without quit 
            // the modal event loop. And the modal event loop blocks us from bottom widgets.
            // Solution: let user click it manually or close outside. FIXME
            BOOST_LOG_TRIVIAL(warning) << "DPIAware::EndModal Error: dialogStack is not empty, but top dialog is not this one. retCode=" << retCode;
            return;
        }
 
        return wxDialog::EndModal(retCode);
    }

References Slic3r::GUI::dialogStack.

◆ fallback_to_geometry_only()

bool Slic3r::GUI::TextureImportDialog::fallback_to_geometry_only ( ) const

inline

213{ return m_fallback_to_geometry_only; }

Slic3r::GUI::TextureImportDialog::m_fallback_to_geometry_only

bool m_fallback_to_geometry_only

Definition TextureImportDialog.hpp:328

References m_fallback_to_geometry_only.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ find_closest_filament_index()

int Slic3r::GUI::TextureImportDialog::find_closest_filament_index ( const std::array< std::size_t, 3 > & color ) const

private

{
    int best_idx = -1;
    double best_delta = std::numeric_limits<double>::max();
    const size_t filament_count = std::min(m_filament_colors_rgba.size(), max_filament_count());
    for (size_t i = 0; i < filament_count; ++i) {
        const double delta = Slic3r::compute_delta_e(color, m_filament_colors_rgba[i]);
        if (delta < best_delta) {
            best_delta = delta;
            best_idx = (int)i;
        }
    }
    return best_idx;
}

References Slic3r::compute_delta_e(), m_filament_colors_rgba, and max_filament_count().

Referenced by compact_used_virtual_filaments(), and do_auto_match().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_rescale()

bool Slic3r::GUI::DPIAware< wxDialog >::force_rescale ( ) const

inlineinherited

201{ return m_force_rescale; }

◆ get_existing_filament_count()

size_t Slic3r::GUI::TextureImportDialog::get_existing_filament_count ( ) const

inline

220{ return m_existing_filament_count; }

References m_existing_filament_count.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ get_filament_entries()

const std::vector< TextureFilamentEntry > & Slic3r::GUI::TextureImportDialog::get_filament_entries ( ) const

inline

219{ return m_filament_entries; }

References m_filament_entries.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ get_matches()

std::vector< Slic3r::FilamentMatch > Slic3r::GUI::TextureImportDialog::get_matches ( ) const

{
    if (!m_current_matches.empty())
        return m_current_matches;
    return build_matches_from_rows();
}

References build_matches_from_rows(), and m_current_matches.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_new_filament_colors()

const std::vector< std::array< float, 4 > > & Slic3r::GUI::TextureImportDialog::get_new_filament_colors ( ) const

inline

216{ return m_new_filament_colors; }

References m_new_filament_colors.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ get_new_filament_preset_names()

const std::vector< std::string > & Slic3r::GUI::TextureImportDialog::get_new_filament_preset_names ( ) const

inline

217{ return m_new_filament_preset_names; }

References m_new_filament_preset_names.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ get_new_mixed_filaments()

const std::vector< TextureNewMixedFilament > & Slic3r::GUI::TextureImportDialog::get_new_mixed_filaments ( ) const

inline

218{ return m_new_mixed_filaments; }

References m_new_mixed_filaments.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ get_painted_mesh()

Slic3r::PaintedMesh Slic3r::GUI::TextureImportDialog::get_painted_mesh ( ) const

{
    return m_painted;
}

References m_painted.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ has_valid_result()

bool Slic3r::GUI::TextureImportDialog::has_valid_result ( ) const

private

{
    if (m_painted.face_colors.empty() || m_current_matches.empty() || m_mapping_rows.empty())
        return false;
 
    if (m_mapping_rows.size() != m_current_matches.size())
        return false;
 
    const int filament_count = (int)std::min(m_filament_colors_rgba.size(), max_filament_count());
    for (const auto& row : m_mapping_rows) {
        if (row.target_filament_idx < 0 || row.target_filament_idx >= filament_count)
            return false;
    }
    return true;
}

References m_current_matches, m_filament_colors_rgba, m_mapping_rows, m_painted, and max_filament_count().

Referenced by on_computation_error(), on_mesh_repair_decision_required(), on_ok_clicked(), update_confirm_button_state(), and update_ui_for_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ highlight_view_button()

void Slic3r::GUI::TextureImportDialog::highlight_view_button ( int view_index )

private

{
    Button* btns[] = { m_btn_view_original, m_btn_view_multicolor };
 
    for (int i = 0; i < 2; ++i) {
        if (!btns[i]) continue;
        btns[i]->SetStyle(i == view_index ? ButtonStyle::Confirm : ButtonStyle::Regular, ButtonType::Parameter);
        btns[i]->Refresh();
    }
}

References Confirm, m_btn_view_multicolor, m_btn_view_original, Parameter, Regular, and Button::SetStyle().

Referenced by build_preview_panel(), and on_computation_complete().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_new_scale_factor()

bool Slic3r::GUI::DPIAware< wxDialog >::is_new_scale_factor ( ) const

inlineprivateinherited

262{ return fabs(m_scale_factor - m_prev_scale_factor) > 0.001; }

◆ is_params_dirty()

bool Slic3r::GUI::TextureImportDialog::is_params_dirty ( ) const

private

{
    if (m_applied_color_count < 0)
        return false;
    return m_param_color_count != m_applied_color_count
        || m_param_smooth      != m_applied_smooth;
}

References m_applied_color_count, m_applied_smooth, m_param_color_count, and m_param_smooth.

Referenced by on_ok_clicked(), update_confirm_button_state(), and update_ui_for_state().

Here is the caller graph for this function:

◆ max_filament_count()

size_t Slic3r::GUI::TextureImportDialog::max_filament_count ( ) const

private

{
    return static_cast<size_t>(EnforcerBlockerType::ExtruderMax);
}

References Slic3r::ExtruderMax.

Referenced by add_decomposed_mixed_filament(), build_bottom_buttons(), build_params_panel(), can_add_virtual_filament(), compact_used_virtual_filaments(), find_closest_filament_index(), has_valid_result(), on_color_spin_text_changed(), on_computation_complete(), and set_color_count_value().

Here is the caller graph for this function:

◆ normal_font()

const wxFont & Slic3r::GUI::DPIAware< wxDialog >::normal_font ( ) const

inlineinherited

205{ return m_normal_font; }

Here is the caller graph for this function:

◆ on_apply_clicked()

void Slic3r::GUI::TextureImportDialog::on_apply_clicked ( wxCommandEvent & evt )

private

{
    start_computation();
}

References start_computation().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_auto_merge_toggled()

void Slic3r::GUI::TextureImportDialog::on_auto_merge_toggled ( wxCommandEvent & evt )

private

{
    bool auto_merge_enabled = !m_auto_merge_cb || m_auto_merge_cb->GetValue();
    m_auto_merge_enabled = auto_merge_enabled;
 
    if (m_state == TextureImportState::Ready) {
        const auto previous_matches = m_current_matches;
        do_auto_match();
        restore_current_match_order(previous_matches);
        compact_used_virtual_filaments();
        update_filament_color_map();
        rebuild_mapping_rows();
        update_drop_warning_visibility();
        update_auto_mix_reset_visibility();
    }
}

References compact_used_virtual_filaments(), do_auto_match(), m_auto_merge_cb, m_auto_merge_enabled, m_current_matches, m_state, Slic3r::GUI::Ready, rebuild_mapping_rows(), restore_current_match_order(), update_auto_mix_reset_visibility(), update_drop_warning_visibility(), and update_filament_color_map().

Referenced by build_mapping_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_color_preset_clicked()

void Slic3r::GUI::TextureImportDialog::on_color_preset_clicked ( wxCommandEvent & evt )

private

{
    int id = evt.GetId();
    int color_count = m_param_color_count;
    if (id == ID_COLOR_4)  { color_count = 4; }
    if (id == ID_COLOR_8)  { color_count = 8; }
    if (id == ID_COLOR_16) { color_count = 16; }
 
    if (id == ID_COLOR_AUTO) {
        start_computation(true);
        return;
    }
 
    set_color_count_value(color_count, true);
}

References ID_COLOR_16, ID_COLOR_4, ID_COLOR_8, ID_COLOR_AUTO, m_param_color_count, set_color_count_value(), and start_computation().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_color_slider_changed()

void Slic3r::GUI::TextureImportDialog::on_color_slider_changed ( wxCommandEvent & evt )

private

{
    set_color_count_value(m_color_slider->GetValue(), true);
}

References m_color_slider, and set_color_count_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_color_spin_changed()

void Slic3r::GUI::TextureImportDialog::on_color_spin_changed ( wxCommandEvent & evt )

private

{
    set_color_count_value(m_color_spin->GetValue(), true);
}

References m_color_spin, and set_color_count_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_color_spin_text_changed()

void Slic3r::GUI::TextureImportDialog::on_color_spin_text_changed ( wxCommandEvent & evt )

private

{
    preview_spin_text_value(m_color_spin, m_color_slider, m_param_color_count,
                            1, (int)max_filament_count(), evt.GetString(),
                            [this]() { update_color_count_preset_buttons(); });
}

References m_color_slider, m_color_spin, m_param_color_count, max_filament_count(), and preview_spin_text_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_computation_complete()

void Slic3r::GUI::TextureImportDialog::on_computation_complete ( wxCommandEvent & evt )

private

{
    bool initial = m_current_computation_initial;
 
    if (m_progress_dlg) {
        m_progress_dlg->Destroy();
        m_progress_dlg = nullptr;
    }
 
    {
        std::lock_guard<std::mutex> lock(m_result_mutex);
        m_painted = std::move(m_pending_result);
    }
 
    int actual_colors = (int)m_painted.cluster_colors.size();
    if (actual_colors >= 2 && actual_colors <= (int)max_filament_count()) {
        set_color_count_value(actual_colors, true);
    }
 
    m_preview_canvas->set_painted_mesh_data(m_painted.vertices, m_painted.indices);
    m_preview_canvas->set_face_colors(m_painted.face_colors);
 
    // A fresh texture computation replaces m_painted, so virtual filaments from
    // the previous computation must not consume capacity when deciding whether
    // this run drops extra colors. Rebuild virtual filaments from this result.
    m_current_matches.clear();
    if (m_filament_colors_rgba.size() > m_existing_filament_count)
        m_filament_colors_rgba.resize(m_existing_filament_count);
    if (m_filament_color_strs.size() > m_existing_filament_count)
        m_filament_color_strs.resize(m_existing_filament_count);
    if (m_filament_names.size() > m_existing_filament_count)
        m_filament_names.resize(m_existing_filament_count);
    if (m_filament_entries.size() > m_existing_filament_count)
        m_filament_entries.resize(m_existing_filament_count);
    while (m_filament_entries.size() < m_existing_filament_count) {
        TextureFilamentEntry entry;
        entry.kind = TextureFilamentKind::ExistingPhysical;
        entry.dialog_index = (int)m_filament_entries.size();
        entry.project_config_index = m_filament_entries.size();
        m_filament_entries.push_back(entry);
    }
    for (size_t i = 0; i < m_filament_entries.size(); ++i) {
        m_filament_entries[i].dialog_index = (int)i;
        m_filament_entries[i].color_hex = i < m_filament_color_strs.size() ?
            texture_normalize_color_hex(m_filament_color_strs[i]) : "#808080";
        m_filament_entries[i].name = i < m_filament_names.size() ?
            m_filament_names[i] : GUI::format(_u8L("Filament %d"), i + 1);
    }
    m_new_filament_colors.clear();
    m_new_filament_preset_names.clear();
    m_new_mixed_filaments.clear();
 
    do_auto_match();
    compact_used_virtual_filaments();
    sort_current_matches_by_filament_index();
    update_filament_color_map();
    rebuild_mapping_rows();
 
    m_applied_color_count = m_param_color_count;
    m_applied_smooth      = m_param_smooth;
 
    set_state(TextureImportState::Ready);
    update_drop_warning_visibility();
    update_auto_mix_reset_visibility();
 
    m_btn_view_multicolor->Show();
    if (m_tab_panel) {
        m_tab_panel->GetSizer()->Layout();
        m_tab_panel->Fit();
        m_tab_panel->SetPosition(wxPoint(FromDIP(8), FromDIP(8)));
    }
    GetSizer()->Layout();
 
    m_preview_canvas->set_render_mode(TexturePreviewCanvas::RenderMode::FilamentMap);
    highlight_view_button(-1);
 
    if (initial) {
        m_initial_computation_pending = false;
        m_current_computation_initial = false;
    }
}

References _u8L, compact_used_virtual_filaments(), Slic3r::GUI::TextureFilamentEntry::dialog_index, do_auto_match(), Slic3r::GUI::ExistingPhysical, Slic3r::GUI::TexturePreviewCanvas::FilamentMap, Slic3r::GUI::format(), highlight_view_button(), Slic3r::GUI::TextureFilamentEntry::kind, m_applied_color_count, m_applied_smooth, m_btn_view_multicolor, m_current_computation_initial, m_current_matches, m_existing_filament_count, m_filament_color_strs, m_filament_colors_rgba, m_filament_entries, m_filament_names, m_initial_computation_pending, m_new_filament_colors, m_new_filament_preset_names, m_new_mixed_filaments, m_painted, m_param_color_count, m_param_smooth, m_pending_result, m_preview_canvas, m_progress_dlg, m_result_mutex, m_tab_panel, max_filament_count(), Slic3r::GUI::TextureFilamentEntry::project_config_index, Slic3r::GUI::Ready, rebuild_mapping_rows(), set_color_count_value(), set_state(), sort_current_matches_by_filament_index(), Slic3r::GUI::texture_normalize_color_hex(), update_auto_mix_reset_visibility(), update_drop_warning_visibility(), and update_filament_color_map().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_computation_error()

void Slic3r::GUI::TextureImportDialog::on_computation_error ( wxCommandEvent & evt )

private

{
    bool initial = m_current_computation_initial;
 
    if (m_progress_dlg) {
        m_progress_dlg->Destroy();
        m_progress_dlg = nullptr;
    }
 
    if (m_cancel_flag.load()) {
        if (initial) {
            m_initial_computation_cancelled = true;
            m_initial_computation_pending = false;
            m_current_computation_initial = false;
            return;
        }
        if (has_valid_result()) {
            if (m_applied_color_count >= 0) {
                m_param_color_count = m_applied_color_count;
                m_color_slider->SetValue(m_param_color_count);
                m_color_spin->SetValue(m_param_color_count);
                update_color_count_preset_buttons();
            }
            if (m_applied_smooth >= 0) {
                m_param_smooth = m_applied_smooth;
                m_smooth_slider->SetValue(m_param_smooth);
                m_smooth_spin->SetValue(m_param_smooth);
            }
            set_state(TextureImportState::Ready);
            return;
        }
        set_state(TextureImportState::Idle);
        return;
    }
 
    if (initial) {
        m_initial_computation_failed = true;
        m_initial_computation_pending = false;
        m_current_computation_initial = false;
        m_fallback_to_geometry_only = true;
        return;
    }
 
    set_state(TextureImportState::Error);
    Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
        _L("Computation failed. Please adjust parameters and retry."),
        _L("Error"), wxOK | wxICON_ERROR);
    dlg.ShowModal();
}

References _L, Slic3r::GUI::Error, has_valid_result(), Slic3r::GUI::Idle, m_applied_color_count, m_applied_smooth, m_cancel_flag, m_color_slider, m_color_spin, m_current_computation_initial, m_fallback_to_geometry_only, m_initial_computation_cancelled, m_initial_computation_failed, m_initial_computation_pending, m_param_color_count, m_param_smooth, m_progress_dlg, m_smooth_slider, m_smooth_spin, Slic3r::GUI::Ready, set_state(), Slic3r::GUI::DPIAware< P >::ShowModal(), and update_color_count_preset_buttons().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_computation_progress()

void Slic3r::GUI::TextureImportDialog::on_computation_progress ( wxCommandEvent & evt )

private

{
    if (m_progress_dlg) {
        if (!m_progress_dlg->Update(evt.GetInt()))
            m_cancel_flag = true;
    } else if (m_current_computation_initial && m_initial_progress_callback) {
        if (!m_initial_progress_callback(evt.GetInt()))
            m_cancel_flag = true;
    }
}

References m_cancel_flag, m_current_computation_initial, m_initial_progress_callback, and m_progress_dlg.

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

Here is the caller graph for this function:

◆ on_dpi_changed()

void Slic3r::GUI::TextureImportDialog::on_dpi_changed ( const wxRect & suggested_rect )

overridevirtual

Implements Slic3r::GUI::DPIAware< wxDialog >.

{
    // All control sizes below are baked into persistent properties (min size,
    // corner radius, fixed wxSize) using FromDIP() at build time. The base
    // DPIAware::rescale() only rescales fonts; it does not recompute these
    // stored pixel values. Re-apply them here so the layout stays consistent
    // when the dialog is dragged to a screen with a different DPI.
    SetMinSize(wxSize(FromDIP(800), FromDIP(500)));
 
    const int view_button_height = FromDIP(27);
    for (Button* btn : {m_btn_view_original, m_btn_view_multicolor}) {
        if (btn) btn->Rescale(); // ORCA Rescale applies all style automatically when combined with SetStyle
    }
 
    update_color_count_preset_buttons(); // ORCA Rescale applies all style automatically when combined with SetStyle
 
    if (m_color_spin)
        m_color_spin->SetMinSize(wxSize(FromDIP(60), FromDIP(28)));
    if (m_smooth_spin)
        m_smooth_spin->SetMinSize(wxSize(FromDIP(60), FromDIP(28)));
 
    if (m_mapping_scroll) {
        m_mapping_scroll->SetMinSize(wxSize(-1, FromDIP(300)));
        m_mapping_scroll->SetScrollRate(0, FromDIP(20));
    }
 
    // ORCA Rescale applies all style automatically when combined with SetStyle
    if (m_btn_skip)       m_btn_skip->Rescale();
    if (m_btn_ok)         m_btn_ok->Rescale();
    if (m_btn_color_auto) m_btn_color_auto->Rescale();
    if (m_btn_apply)      m_btn_apply->Rescale();
    if (m_btn_auto_mix)   m_btn_auto_mix->Rescale();
    if (m_btn_mix_reset)  m_btn_mix_reset->Rescale();
 
    // Mapping rows store their panel sizes (source/target/arrow/row height)
    // as fixed FromDIP min/max sizes, so rebuild them to pick up the new DPI.
    rebuild_mapping_rows();
 
    if (wxSizer* sizer = GetSizer())
        sizer->Layout();
    Layout();
    Refresh();
    wxGetApp().UpdateDlgDarkUI(this);
}

References m_btn_apply, m_btn_auto_mix, m_btn_color_auto, m_btn_mix_reset, m_btn_ok, m_btn_skip, m_btn_view_multicolor, m_btn_view_original, m_color_spin, m_mapping_scroll, m_smooth_spin, rebuild_mapping_rows(), and update_color_count_preset_buttons().

Here is the call graph for this function:

◆ on_mesh_repair_decision_required()

void Slic3r::GUI::TextureImportDialog::on_mesh_repair_decision_required ( wxCommandEvent & evt )

private

{
    bool initial = m_current_computation_initial;
    bool auto_color = m_current_computation_auto_color;
 
    if (m_progress_dlg) {
        m_progress_dlg->Destroy();
        m_progress_dlg = nullptr;
    }
 
    Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
        _L("The mesh has non-manifold geometry or open boundaries. You can import it as-is or repair it before importing."),
        _L("Mesh repair"), wxYES_NO | wxCANCEL | wxICON_WARNING | wxYES_DEFAULT);
    dlg.SetButtonLabel(wxID_YES, _L("Import without repair"));
    dlg.SetButtonLabel(wxID_NO, _L("Repair and import"), true);
    dlg.SetButtonLabel(wxID_CANCEL, _L("Cancel"));
    // "Repair and import" is the recommended action here, so the accent moves off the default YES
    // button onto NO. MsgDialog::add_button already styled both as ButtonType::Choice, so restyling
    // with the same type swaps only the palette and leaves the geometry alone.
    if (auto* yes_btn = dynamic_cast<Button*>(dlg.FindWindow(wxID_YES))) {
        yes_btn->SetStyle(ButtonStyle::Regular, ButtonType::Choice);
        //yes_btn->SetMinSize(wxSize(FromDIP(180), FromDIP(32))); // Height not matches and will cause issues on longer translations. let dialog manages it
    }
    if (auto* no_btn = dynamic_cast<Button*>(dlg.FindWindow(wxID_NO))) {
        no_btn->SetStyle(ButtonStyle::Confirm, ButtonType::Choice);
        //no_btn->SetMinSize(wxSize(FromDIP(160), FromDIP(32))); // Height not matches and will cause issues on longer translations. let dialog manages it
    }
    dlg.Layout();
    dlg.Fit();
    dlg.CenterOnParent();
    int ret = dlg.ShowModal();
    if (ret == wxID_CANCEL) {
        m_cancel_flag = true;
        if (initial) {
            m_initial_computation_cancelled = true;
            m_initial_computation_pending = false;
            m_current_computation_initial = false;
        } else if (has_valid_result()) {
            set_state(TextureImportState::Ready);
        } else {
            set_state(TextureImportState::Idle);
        }
        return;
    }
    m_mesh_repair_decision = (ret == wxID_NO)
        ? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
        : Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
 
    start_computation(auto_color, initial);
}

References _L, Choice, Confirm, has_valid_result(), Slic3r::GUI::Idle, Slic3r::TexturePaintingSettings::ImportWithoutRepair, m_cancel_flag, m_current_computation_auto_color, m_current_computation_initial, m_initial_computation_cancelled, m_initial_computation_pending, m_mesh_repair_decision, m_progress_dlg, Slic3r::GUI::Ready, Regular, Slic3r::TexturePaintingSettings::RepairAndImport, set_state(), Slic3r::GUI::MsgDialog::SetButtonLabel(), Slic3r::GUI::DPIAware< P >::ShowModal(), and start_computation().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_ok_clicked()

void Slic3r::GUI::TextureImportDialog::on_ok_clicked ( wxCommandEvent & evt )

private

{
    if (m_state != TextureImportState::Ready || !has_valid_result() || is_params_dirty())
        return;
 
    m_current_matches = build_matches_from_rows();
    if (m_current_matches.empty())
        return;
 
    compact_used_virtual_filaments();
 
    EndModal(wxID_OK);
}

References build_matches_from_rows(), compact_used_virtual_filaments(), Slic3r::GUI::DPIDialog::EndModal(), has_valid_result(), is_params_dirty(), m_current_matches, m_state, and Slic3r::GUI::Ready.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_skip_clicked()

void Slic3r::GUI::TextureImportDialog::on_skip_clicked ( wxCommandEvent & evt )

private

{
    m_skipped = true;
    m_new_filament_colors.clear();
    m_new_filament_preset_names.clear();
    m_new_mixed_filaments.clear();
    m_current_matches.clear();
    cancel_computation();
    EndModal(wxID_CANCEL);
}

References cancel_computation(), Slic3r::GUI::DPIDialog::EndModal(), m_current_matches, m_new_filament_colors, m_new_filament_preset_names, m_new_mixed_filaments, and m_skipped.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_smooth_slider_changed()

void Slic3r::GUI::TextureImportDialog::on_smooth_slider_changed ( wxCommandEvent & evt )

private

{
    set_smooth_value(m_smooth_slider->GetValue(), true);
}

References m_smooth_slider, and set_smooth_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_smooth_spin_changed()

void Slic3r::GUI::TextureImportDialog::on_smooth_spin_changed ( wxCommandEvent & evt )

private

{
    set_smooth_value(m_smooth_spin->GetValue(), true);
}

References m_smooth_spin, and set_smooth_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_smooth_spin_text_changed()

void Slic3r::GUI::TextureImportDialog::on_smooth_spin_text_changed ( wxCommandEvent & evt )

private

{
    preview_spin_text_value(m_smooth_spin, m_smooth_slider, m_param_smooth,
                            0, 10, evt.GetString());
}

References m_param_smooth, m_smooth_slider, m_smooth_spin, and preview_spin_text_value().

Referenced by build_params_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_sys_color_changed()

virtual void Slic3r::GUI::DPIAware< wxDialog >::on_sys_color_changed ( )

inlineprotectedvirtualinherited

Reimplemented in PrintHostQueueDialog, Slic3r::GUI::ColorPickerDialog, Slic3r::GUI::ConfigWizard, Slic3r::GUI::DesignTextDialog, Slic3r::GUI::DiffPresetDialog, Slic3r::GUI::EditGCodeDialog, Slic3r::GUI::MultiMachinePickPage, Slic3r::GUI::ObjectTableDialog, Slic3r::GUI::PhysicalPrinterDialog, Slic3r::GUI::PrintHostQueueDialog, Slic3r::GUI::PublishSettingsDialog, Slic3r::GUI::SavePresetDialog, Slic3r::GUI::SendMultiMachinePage, and Slic3r::GUI::UnsavedChangesDialog.

226{};

◆ prev_scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::prev_scale_factor ( ) const

inlineinherited

196{ return m_prev_scale_factor; }

◆ preview_spin_text_value()

void Slic3r::GUI::TextureImportDialog::preview_spin_text_value	(	SpinInput *	spin,
		AccentSlider *	slider,
		int &	param,
		int	min_value,
		int	max_value,
		const wxString &	text,
		std::function< void()>	on_value_changed = {} )

private

{
    long value;
    if (!text.ToLong(&value))
        return;
 
    wxTextCtrl* tc = spin->GetTextCtrl();
    long parsed = value;
    value = std::clamp((int)parsed, min_value, max_value);
 
    wxString normalized = text;
    if (parsed > max_value || (text.length() > 1 && text[0] == '0'))
        normalized = wxString::Format("%ld", value);
 
    if (normalized != text) {
        long pos = tc->GetInsertionPoint();
        tc->ChangeValue(normalized);
        if (parsed > max_value)
            tc->SetInsertionPointEnd();
        else
            tc->SetInsertionPoint(std::min<long>(normalized.length(), std::max(0L, pos - 1)));
    }
 
    param = (int)value;
    slider->SetValue(param);
    if (on_value_changed)
        on_value_changed();
    update_confirm_button_state();
}

References SpinInput::GetTextCtrl(), L, AccentSlider::SetValue(), and update_confirm_button_state().

Referenced by on_color_spin_text_changed(), and on_smooth_spin_text_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rebuild_mapping_rows()

void Slic3r::GUI::TextureImportDialog::rebuild_mapping_rows ( )

private

{
    m_mapping_scroll->Freeze();
    m_mapping_sizer->Clear(true);
    m_mapping_rows.clear();
 
    if (m_current_matches.empty()) {
        m_mapping_scroll->FitInside();
        m_mapping_scroll->Thaw();
        return;
    }
 
    auto get_target_wxcolor = [this](int idx) -> wxColour {
        if (idx >= 0 && idx < (int)m_filament_colors_rgba.size()) {
            const auto& c = m_filament_colors_rgba[idx];
            return wxColour((unsigned char)(c[0] * 255.f),
                            (unsigned char)(c[1] * 255.f),
                            (unsigned char)(c[2] * 255.f));
        }
        return wxColour(128, 128, 128);
    };
 
    const auto display_numbers = compute_display_numbers();
    auto display_number = [display_numbers](int idx) -> int {
        return (idx >= 0 && idx < (int)display_numbers.size() && display_numbers[idx] > 0)
            ? display_numbers[idx] : idx + 1;
    };
 
    auto get_filament_label = [this, display_number](int idx) -> wxString {
        if (idx >= 0 && idx < (int)m_filament_names.size())
            return filament_name_to_wx_string(m_filament_names[idx]);
        return wxString::Format(_L("Filament %d"), display_number(idx));
    };
 
    const wxColour dash_clr   = StateColor::darkModeColorFor(wxColour("#ACACAC"));
    const wxColour hex_fg     = texture_import_text_colour();
    const wxColour card_bg    = StateColor::darkModeColorFor(wxColour("#FFFFFF"));
    const wxColour card_bd    = StateColor::darkModeColorFor(wxColour("#DBDBDB"));
    const wxColour name_fg    = texture_import_text_colour();
    const wxColour chev_clr   = StateColor::darkModeColorFor(wxColour("#6B6B6A"));
 
    m_mapping_rows.resize(m_current_matches.size());
    for (size_t ci = 0; ci < m_current_matches.size(); ++ci) {
        auto& row = m_mapping_rows[ci];
        row.cluster_id = m_current_matches[ci].cluster_index;
        row.source_color = m_current_matches[ci].cluster_color;
        row.source_hex = rgb_to_hex(row.source_color).ToStdString();
        row.target_filament_idx = m_current_matches[ci].filament_index;
 
        wxColour src_wx_color(
            (unsigned char)row.source_color[0],
            (unsigned char)row.source_color[1],
            (unsigned char)row.source_color[2]);
 
        // --- Row container ---
        wxPanel* row_panel = new wxPanel(m_mapping_scroll, wxID_ANY);
        row_panel->SetBackgroundColour(m_mapping_scroll->GetBackgroundColour());
        row_panel->Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
        wxBoxSizer* row_sizer = new wxBoxSizer(wxHORIZONTAL);
 
        // --- Source card (dashed border, circle + hex) ---
        const int src_w = FromDIP(138);
        const int target_min_w = FromDIP(239);
        const int row_h = FromDIP(32); // ORCA compact row height
        row.source_panel = new wxPanel(row_panel, wxID_ANY, wxDefaultPosition, wxSize(src_w, row_h),
                                       wxTAB_TRAVERSAL | wxFULL_REPAINT_ON_RESIZE);
        row.source_panel->SetMinSize(wxSize(src_w, row_h));
        row.source_panel->SetMaxSize(wxSize(src_w, row_h));
        row.source_panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
 
        row.source_panel->Bind(wxEVT_PAINT, [this, ci, src_wx_color, dash_clr, hex_fg](wxPaintEvent& e) {
            auto* p = static_cast<wxPanel*>(e.GetEventObject());
            wxAutoBufferedPaintDC dc(p);
            wxSize sz = p->GetClientSize();
 
            dc.SetBrush(wxBrush(p->GetParent()->GetBackgroundColour()));
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.DrawRectangle(0, 0, sz.x, sz.y);
 
            wxPen dash_pen(dash_clr, 1, wxPENSTYLE_SHORT_DASH);
            dc.SetPen(dash_pen);
            dc.SetBrush(wxBrush(p->GetParent()->GetBackgroundColour()));
            int r = 0; //p->FromDIP(8);
            dc.DrawRoundedRectangle(0, 0, sz.x, sz.y, r);
 
            // Color circle 20px
            int cd = p->FromDIP(20); // ORCA match size of swatches
            int cx = p->FromDIP(6); // ORCA match margins
            int cy = (sz.y - cd) / 2;
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(src_wx_color));
            dc.DrawEllipse(cx, cy, cd, cd);
            draw_filament_swatch_ellipse_border(dc, src_wx_color, cx, cy, cd, cd);
 
            if (ci < m_mapping_rows.size()) {
                wxFont hex_font = p->GetFont();
                hex_font.SetPointSize(9);
                dc.SetFont(hex_font);
                dc.SetTextForeground(hex_fg);
                wxString hex_str = wxString::Format("# %s", m_mapping_rows[ci].source_hex.substr(1));
                wxSize tsz = dc.GetTextExtent(hex_str);
                dc.DrawText(hex_str, cx + cd + p->FromDIP(6), (sz.y - tsz.y) / 2);
            }
        });
        row.source_panel->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
            e.Skip();
            static_cast<wxWindow*>(e.GetEventObject())->Refresh();
        });
        row.source_panel->Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
 
        row_sizer->Add(row.source_panel, 0, wxEXPAND);
 
        // --- Arrow panel (dashed arrow) ---
        const int arrow_w = FromDIP(24);
        wxPanel* arrow_panel = new wxPanel(row_panel, wxID_ANY, wxDefaultPosition, wxSize(arrow_w, row_h));
        arrow_panel->SetMinSize(wxSize(arrow_w, row_h));
        arrow_panel->SetMaxSize(wxSize(arrow_w, row_h));
        arrow_panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
        arrow_panel->Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
        arrow_panel->Bind(wxEVT_PAINT, [dash_clr](wxPaintEvent& e) {
            auto* p = static_cast<wxPanel*>(e.GetEventObject());
            wxAutoBufferedPaintDC dc(p);
            wxSize sz = p->GetClientSize();
 
            dc.SetBrush(wxBrush(p->GetParent()->GetBackgroundColour()));
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.DrawRectangle(0, 0, sz.x, sz.y);
 
            int mid_y = sz.y / 2;
            int margin = p->FromDIP(2);
            int arrow_tip = sz.x - margin;
            int arrow_start = margin;
 
            wxPen dash_pen(dash_clr, p->FromDIP(1), wxPENSTYLE_SHORT_DASH);
            dc.SetPen(dash_pen);
            dc.DrawLine(arrow_start, mid_y, arrow_tip - p->FromDIP(4), mid_y);
 
            int ah = p->FromDIP(4);
            wxPoint tri[3] = {
                {arrow_tip, mid_y},
                {arrow_tip - ah, mid_y - ah / 2},
                {arrow_tip - ah, mid_y + ah / 2}
            };
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(dash_clr));
            dc.DrawPolygon(3, tri);
        });
 
        row_sizer->Add(arrow_panel, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, FromDIP(4));
 
        // --- Target card (numbered square + material name + chevron) ---
        row.target_panel = new wxPanel(row_panel, wxID_ANY, wxDefaultPosition, wxSize(-1, row_h),
                                       wxTAB_TRAVERSAL | wxFULL_REPAINT_ON_RESIZE);
        row.target_panel->SetMinSize(wxSize(target_min_w, row_h));
        row.target_panel->SetToolTip(get_filament_label(row.target_filament_idx));
        row.target_panel->SetBackgroundStyle(wxBG_STYLE_PAINT);
        row.target_panel->SetCursor(wxCursor(wxCURSOR_HAND));
 
        row.target_panel->Bind(wxEVT_PAINT, [this, ci, get_target_wxcolor, get_filament_label,
                                              display_number, card_bg, card_bd, name_fg, chev_clr](wxPaintEvent& e) {
            auto* p = static_cast<wxPanel*>(e.GetEventObject());
            wxAutoBufferedPaintDC dc(p);
            wxSize sz = p->GetClientSize();
 
            dc.SetBrush(wxBrush(p->GetParent()->GetBackgroundColour()));
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.DrawRectangle(0, 0, sz.x, sz.y);
 
            if (ci >= m_mapping_rows.size()) return;
            int fil_idx = m_mapping_rows[ci].target_filament_idx;
 
            int r = 0; //p->FromDIP(8);
            dc.SetBrush(wxBrush(card_bg));
            dc.SetPen(wxPen(card_bd, 1));
            dc.DrawRoundedRectangle(0, 0, sz.x, sz.y, r);
 
            if (fil_idx >= 0 && fil_idx < (int)m_filament_entries.size() &&
                texture_entry_is_mixed(m_filament_entries[fil_idx].kind)) {
                const TextureFilamentEntry& entry = m_filament_entries[fil_idx];
                wxFont mixed_font = p->GetFont();
                mixed_font.SetPointSize(10);
                dc.SetFont(mixed_font);
 
                int x = p->FromDIP(6);// ORCA Match left margins
                const int sw = p->FromDIP(20); // ORCA match size of swatches
                const int sw_r = 0; //p->FromDIP(6);
                const int sw_y = (sz.y - sw) / 2;
                for (size_t mi = 0; mi < entry.mixed_components.size() && mi < entry.mixed_ratios.size(); ++mi) {
                    if (mi > 0) {
                        dc.SetTextForeground(name_fg);
                        wxString plus = "+";
                        wxSize psz = dc.GetTextExtent(plus);
                        dc.DrawText(plus, x, (sz.y - psz.y) / 2);
                        x += psz.x + p->FromDIP(4);
                    }
 
                    const unsigned int comp_id = entry.mixed_components[mi];
                    const int comp_idx = comp_id >= 1 ? (int)comp_id - 1 : -1;
                    wxColour comp_clr("#D9D9D9");
                    if (comp_idx >= 0 && comp_idx < (int)m_filament_colors_rgba.size()) {
                        const auto& c = m_filament_colors_rgba[comp_idx];
                        comp_clr = wxColour((unsigned char)(c[0] * 255.f),
                                            (unsigned char)(c[1] * 255.f),
                                            (unsigned char)(c[2] * 255.f));
                    }
 
                    dc.SetPen(*wxTRANSPARENT_PEN);
                    dc.SetBrush(wxBrush(comp_clr));
                    dc.DrawRoundedRectangle(x, sw_y, sw, sw, sw_r);
                    draw_filament_swatch_border(dc, comp_clr, x, sw_y, sw, sw, sw_r);
 
                    wxString num_str = wxString::Format("%d", display_number(comp_idx));
                    wxSize nsz = dc.GetTextExtent(num_str);
                    dc.SetTextForeground(comp_clr.GetLuminance() < 0.51 ? *wxWHITE : *wxBLACK); // ORCA match used foreground color with other swatches
                    dc.DrawText(num_str, x + (sw - nsz.x) / 2, sw_y + (sw - nsz.y) / 2);
                    x += sw + p->FromDIP(5);
 
                    dc.SetTextForeground(name_fg);
                    wxString pct = wxString::Format("%d%%", entry.mixed_ratios[mi]);
                    wxSize pct_sz = dc.GetTextExtent(pct);
                    dc.DrawText(pct, x, (sz.y - pct_sz.y) / 2);
                    x += pct_sz.x + p->FromDIP(5);
                    if (x > sz.x - p->FromDIP(34))
                        break;
                }
 
                int chev_cx = sz.x - p->FromDIP(14);
                int chev_cy = sz.y / 2;
                int hw = p->FromDIP(3);
                int hh = p->FromDIP(2);
                dc.SetPen(wxPen(chev_clr, p->FromDIP(1) > 0 ? p->FromDIP(1) : 1));
                dc.DrawLine(chev_cx - hw, chev_cy - hh, chev_cx, chev_cy + hh);
                dc.DrawLine(chev_cx, chev_cy + hh, chev_cx + hw, chev_cy - hh);
                return;
            }
 
            // Numbered color square 32x32, rounded 6px
            int sq = p->FromDIP(20); // ORCA match size of swatches
            int sq_x = p->FromDIP(6);// ORCA Match left margins
            int sq_y = (sz.y - sq) / 2;
            int sq_r = 0; //p->FromDIP(6);
            wxColour fil_clr = get_target_wxcolor(fil_idx);
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(fil_clr));
            dc.DrawRoundedRectangle(sq_x, sq_y, sq, sq, sq_r);
            draw_filament_swatch_border(dc, fil_clr, sq_x, sq_y, sq, sq, sq_r);
 
            {
                wxFont num_font = p->GetFont();
                num_font.SetPointSize(10);
                dc.SetFont(num_font);
                dc.SetTextForeground(fil_clr.GetLuminance() < 0.51 ? *wxWHITE : *wxBLACK); // ORCA match used foreground color with other swatches
                wxString num_str = wxString::Format("%d", display_number(fil_idx));
                wxSize nsz = dc.GetTextExtent(num_str);
                dc.DrawText(num_str, sq_x + (sq - nsz.x) / 2, sq_y + (sq - nsz.y) / 2);
            }
 
            // Material name
            {
                wxFont name_font = p->GetFont();
                name_font.SetPointSize(9);
                dc.SetFont(name_font);
                dc.SetTextForeground(name_fg);
                wxString name_str = get_filament_label(fil_idx);
                int text_x = sq_x + sq + p->FromDIP(8);
                int max_text_w = sz.x - text_x - p->FromDIP(24);
                if (max_text_w > 0) {
                    name_str = ellipsize_text(dc, name_str, max_text_w);
                    wxSize tsz = dc.GetTextExtent(name_str);
                    dc.DrawText(name_str, text_x, (sz.y - tsz.y) / 2);
                }
            }
 
            // Dropdown chevron at right edge
            {
                int chev_cx = sz.x - p->FromDIP(14);
                int chev_cy = sz.y / 2;
                int hw = p->FromDIP(3);
                int hh = p->FromDIP(2);
                dc.SetPen(wxPen(chev_clr, p->FromDIP(1) > 0 ? p->FromDIP(1) : 1));
                dc.DrawLine(chev_cx - hw, chev_cy - hh, chev_cx, chev_cy + hh);
                dc.DrawLine(chev_cx, chev_cy + hh, chev_cx + hw, chev_cy - hh);
            }
        });
 
        row.target_panel->Bind(wxEVT_LEFT_DOWN, [this, ci](wxMouseEvent&) {
            show_filament_popup(ci);
        });
        row.target_panel->Bind(wxEVT_SIZE, [](wxSizeEvent& e) {
            e.Skip();
            static_cast<wxWindow*>(e.GetEventObject())->Refresh();
        });
        row.target_panel->Bind(wxEVT_MOUSEWHEEL, &TextureImportDialog::dismiss_filament_popup_on_wheel, this);
 
        row_sizer->Add(row.target_panel, 1, wxEXPAND);
 
        row_panel->SetSizer(row_sizer);
        m_mapping_sizer->Add(row_panel, 0, wxEXPAND | wxBOTTOM, FromDIP(12));
    }
 
    m_mapping_scroll->FitInside();
    m_mapping_scroll->Layout();
    m_mapping_scroll->Thaw();
}

References _L, compute_display_numbers(), StateColor::darkModeColorFor(), dismiss_filament_popup_on_wheel(), draw_filament_swatch_border(), draw_filament_swatch_ellipse_border(), ellipsize_text(), Slic3r::GUI::filament_name_to_wx_string(), m_current_matches, m_filament_colors_rgba, m_filament_entries, m_filament_names, m_mapping_rows, m_mapping_scroll, m_mapping_sizer, Slic3r::GUI::TextureFilamentEntry::mixed_components, Slic3r::GUI::TextureFilamentEntry::mixed_ratios, Slic3r::GUI::rgb_to_hex(), show_filament_popup(), Slic3r::GUI::texture_entry_is_mixed(), texture_import_text_colour(), and Slic3r::GUI::wxMouseEvent.

Referenced by add_decomposed_mixed_filament(), apply_auto_standard_mix(), on_auto_merge_toggled(), on_computation_complete(), on_dpi_changed(), reset_auto_mix(), and show_filament_popup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rescale()

void Slic3r::GUI::DPIAware< wxDialog >::rescale ( const wxRect & suggested_rect )

inlineprivateinherited

    {
        this->Freeze();
 
        m_force_rescale = false;
 
        // set normal application font as a current window font
        m_normal_font = this->GetFont();
 
        update_em_unit();
 
        // rescale missed controls sizes and images
        on_dpi_changed(suggested_rect);
 
        this->Layout();
        this->Thaw();
 
        // reset previous scale factor from current scale factor value
        m_prev_scale_factor = m_scale_factor;
    }

◆ reset_auto_mix()

void Slic3r::GUI::TextureImportDialog::reset_auto_mix ( )

private

{
    if (m_state != TextureImportState::Ready || !m_auto_mix_applied)
        return;
 
    dismiss_auto_mix_popup();
 
    // Clear mixed filament references so the compact inside do_auto_match()
    // removes them (and their exclusively-owned base physicals) from the
    // filament arrays, giving the baseline matching a clean starting state.
    for (auto& m : m_current_matches) {
        if (m.filament_index >= 0 && m.filament_index < (int)m_filament_entries.size() &&
            texture_entry_is_mixed(m_filament_entries[m.filament_index].kind)) {
            m.filament_index = -1;
        }
    }
 
    // Re-run the baseline auto-match (same flow as the auto-merge toggle) so the
    // mapping reverts to the pre-mix state: every colour matches an existing
    // physical filament or a virtual physical filament, with no mixed filaments.
    const auto previous_matches = m_current_matches;
    do_auto_match();
    restore_current_match_order(previous_matches);
    compact_used_virtual_filaments();
    update_filament_color_map();
    rebuild_mapping_rows();
    update_drop_warning_visibility();
    update_auto_mix_reset_visibility();
}

References compact_used_virtual_filaments(), dismiss_auto_mix_popup(), do_auto_match(), m_auto_mix_applied, m_current_matches, m_filament_entries, m_state, Slic3r::GUI::Ready, rebuild_mapping_rows(), restore_current_match_order(), Slic3r::GUI::texture_entry_is_mixed(), update_auto_mix_reset_visibility(), update_drop_warning_visibility(), and update_filament_color_map().

Referenced by build_mapping_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restore_current_match_order()

void Slic3r::GUI::TextureImportDialog::restore_current_match_order ( const std::vector< Slic3r::FilamentMatch > & previous_matches )

private

{
    if (previous_matches.empty() || m_current_matches.size() < 2)
        return;
 
    std::map<int, size_t> previous_order_by_cluster;
    for (size_t i = 0; i < previous_matches.size(); ++i) {
        if (previous_matches[i].cluster_index >= 0)
            previous_order_by_cluster.emplace(previous_matches[i].cluster_index, i);
    }
 
    std::stable_sort(m_current_matches.begin(), m_current_matches.end(),
        [&previous_order_by_cluster](const auto& lhs, const auto& rhs) {
            const auto lhs_it = previous_order_by_cluster.find(lhs.cluster_index);
            const auto rhs_it = previous_order_by_cluster.find(rhs.cluster_index);
            const bool lhs_known = lhs_it != previous_order_by_cluster.end();
            const bool rhs_known = rhs_it != previous_order_by_cluster.end();
 
            if (lhs_known != rhs_known)
                return lhs_known;
            if (!lhs_known)
                return false;
 
            return lhs_it->second < rhs_it->second;
        });
}

References m_current_matches.

Referenced by on_auto_merge_toggled(), and reset_auto_mix().

Here is the caller graph for this function:

◆ scale_factor()

float Slic3r::GUI::DPIAware< wxDialog >::scale_factor ( ) const

inlineinherited

195{ return m_scale_factor; }

◆ set_auto_mix_mode()

void Slic3r::GUI::TextureImportDialog::set_auto_mix_mode ( TextureAutoMixMode mode )

private

{
    m_auto_mix_mode = mode;
    if (m_btn_auto_mix) {
        m_btn_auto_mix->SetLabel(auto_mix_mode_label(mode));
        m_btn_auto_mix->Refresh();
    }
    apply_auto_standard_mix(mode);
}

References apply_auto_standard_mix(), Slic3r::GUI::auto_mix_mode_label(), m_auto_mix_mode, and m_btn_auto_mix.

Referenced by show_auto_mix_popup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_color_count_value()

void Slic3r::GUI::TextureImportDialog::set_color_count_value	(	int	value,
		bool	update_spin )

private

{
    m_param_color_count = std::clamp(value, 1, (int)max_filament_count());
    m_color_slider->SetValue(m_param_color_count);
    if (update_spin)
        m_color_spin->SetValue(m_param_color_count);
    update_color_count_preset_buttons();
    update_confirm_button_state();
}

References m_color_slider, m_color_spin, m_param_color_count, max_filament_count(), update_color_count_preset_buttons(), and update_confirm_button_state().

Referenced by on_color_preset_clicked(), on_color_slider_changed(), on_color_spin_changed(), and on_computation_complete().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::set_em_unit ( int v )

inlineinherited

200{ m_em_unit = v; }

◆ set_prev_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_prev_scale_factor ( float v )

inlineinherited

199{ m_prev_scale_factor = v; }

◆ set_scale_factor()

void Slic3r::GUI::DPIAware< wxDialog >::set_scale_factor ( float v )

inlineinherited

198{ m_scale_factor = v; }

◆ set_smooth_value()

void Slic3r::GUI::TextureImportDialog::set_smooth_value	(	int	value,
		bool	update_spin )

private

{
    m_param_smooth = std::clamp(value, 0, 10);
    m_smooth_slider->SetValue(m_param_smooth);
    if (update_spin)
        m_smooth_spin->SetValue(m_param_smooth);
    update_confirm_button_state();
}

References m_param_smooth, m_smooth_slider, m_smooth_spin, and update_confirm_button_state().

Referenced by on_smooth_slider_changed(), and on_smooth_spin_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_state()

void Slic3r::GUI::TextureImportDialog::set_state ( TextureImportState new_state )

private

{
    m_state = new_state;
    update_ui_for_state();
}

References m_state, and update_ui_for_state().

Referenced by on_computation_complete(), on_computation_error(), on_mesh_repair_decision_required(), and start_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_auto_mix_popup()

void Slic3r::GUI::TextureImportDialog::show_auto_mix_popup ( )

private

{
    if (!m_btn_auto_mix || !m_btn_auto_mix->IsEnabled())
        return;
 
    if (m_auto_mix_popup && m_auto_mix_popup->IsShown())
        return;
    dismiss_auto_mix_popup();
 
    auto on_select = [this](TextureAutoMixMode mode) {
        set_auto_mix_mode(mode);
    };
    auto on_close = [this]() {
        m_auto_mix_popup = nullptr;
    };
 
    auto* popup = new AutoMixSelectPopup(this, m_auto_mix_mode, m_btn_auto_mix->GetSize().x,
                                         m_auto_mix_font_point_size,
                                         on_select, on_close);
    wxPoint pos = m_btn_auto_mix->ClientToScreen(wxPoint(0, m_btn_auto_mix->GetSize().y));
    wxRect display_rect;
    int display_idx = wxDisplay::GetFromPoint(pos);
    if (display_idx != wxNOT_FOUND)
        display_rect = wxDisplay(display_idx).GetClientArea();
    else
        display_rect = wxDisplay().GetClientArea();
    pos.x = std::clamp(pos.x, display_rect.GetLeft(),
                       std::max(display_rect.GetLeft(), display_rect.GetRight() - popup->GetSize().x));
    popup->Position(pos, wxSize(0, 0));
    popup->Bind(wxEVT_DESTROY, [this, popup](wxWindowDestroyEvent& e) {
        e.Skip();
        if (m_auto_mix_popup == popup)
            m_auto_mix_popup = nullptr;
    });
    m_auto_mix_popup = popup;
    popup->Popup();
}

References dismiss_auto_mix_popup(), m_auto_mix_font_point_size, m_auto_mix_mode, m_auto_mix_popup, m_btn_auto_mix, and set_auto_mix_mode().

Referenced by build_mapping_panel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_filament_popup()

void Slic3r::GUI::TextureImportDialog::show_filament_popup ( size_t row_index )

private

{
    if (row_index >= m_mapping_rows.size()) return;
 
    if (m_skip_next_filament_popup_row == (int)row_index) {
        m_skip_next_filament_popup_row = -1;
        return;
    }
 
    if (m_filament_popup && m_filament_popup->IsShown()) {
        if (m_filament_popup_row == (int)row_index) {
            dismiss_filament_popup();
            return;
        }
        dismiss_filament_popup();
    }
 
    const auto display_numbers = compute_display_numbers();
    auto display_number = [display_numbers](int idx) -> int {
        return (idx >= 0 && idx < (int)display_numbers.size() && display_numbers[idx] > 0)
            ? display_numbers[idx] : idx + 1;
    };
 
    auto on_select = [this, row_index, display_number](int idx) {
        if (row_index >= m_mapping_rows.size()) return;
        m_mapping_rows[row_index].target_filament_idx = idx;
        if (row_index < m_current_matches.size())
            m_current_matches[row_index].filament_index = idx;
        if (m_mapping_rows[row_index].target_panel) {
            wxString label = (idx >= 0 && idx < (int)m_filament_names.size())
                ? filament_name_to_wx_string(m_filament_names[idx])
                : wxString::Format(_L("Filament %d"), display_number(idx));
            m_mapping_rows[row_index].target_panel->SetToolTip(label);
            m_mapping_rows[row_index].target_panel->Refresh();
        }
        update_filament_color_map();
    };
 
    auto on_add_filament = [this, row_index](wxColour clr) {
        std::array<float, 4> rgba = {clr.Red() / 255.f, clr.Green() / 255.f,
                                     clr.Blue() / 255.f, 1.0f};
        std::string hex = wxString::Format("#%02X%02X%02X",
            clr.Red(), clr.Green(), clr.Blue()).ToStdString();
        int new_idx = add_virtual_filament(rgba, hex);
        if (new_idx < 0)
            return;
 
        if (row_index < m_mapping_rows.size()) {
            m_mapping_rows[row_index].target_filament_idx = new_idx;
            if (row_index < m_current_matches.size())
                m_current_matches[row_index].filament_index = new_idx;
        }
        rebuild_mapping_rows();
        update_filament_color_map();
    };
 
    auto on_decompose_color = [this, row_index]() {
        CallAfter([this, row_index]() {
            add_decomposed_mixed_filament(row_index);
        });
    };
 
    wxPanel* tp = m_mapping_rows[row_index].target_panel;
    if (!tp) return;
 
    auto on_close = [this, row_index](bool closed_by_action) {
        if (m_filament_popup_row == (int)row_index) {
            m_filament_popup = nullptr;
            m_filament_popup_row = -1;
        }
        if (!closed_by_action) {
            m_skip_next_filament_popup_row = (int)row_index;
            CallAfter([this, row_index]() {
                if (m_skip_next_filament_popup_row == (int)row_index)
                    m_skip_next_filament_popup_row = -1;
            });
        }
    };
 
    auto* popup = new FilamentSelectPopup(
        this, m_filament_entries, m_filament_colors_rgba, m_filament_names,
        m_existing_filament_count, tp->GetSize().x, tp, on_select, on_add_filament,
        on_decompose_color,
        [this]() { return can_add_virtual_filament(); },
        on_close,
        display_numbers);
 
    wxPoint pos = tp->ClientToScreen(wxPoint(0, tp->GetSize().y));
    wxRect display_rect;
    int display_idx = wxDisplay::GetFromPoint(pos);
    if (display_idx != wxNOT_FOUND)
        display_rect = wxDisplay(display_idx).GetClientArea();
    else
        display_rect = wxDisplay().GetClientArea();
    pos.x = std::clamp(pos.x, display_rect.GetLeft(),
                       std::max(display_rect.GetLeft(), display_rect.GetRight() - popup->GetSize().x));
    popup->Position(pos, wxSize(0, 0));
    popup->Bind(wxEVT_DESTROY, [this, popup](wxWindowDestroyEvent& e) {
        e.Skip();
        if (m_filament_popup == popup) {
            m_filament_popup = nullptr;
            m_filament_popup_row = -1;
        }
    });
    m_filament_popup = popup;
    m_filament_popup_row = (int)row_index;
    popup->Popup();
}

References _L, add_decomposed_mixed_filament(), add_virtual_filament(), compute_display_numbers(), dismiss_filament_popup(), Slic3r::GUI::filament_name_to_wx_string(), m_current_matches, m_existing_filament_count, m_filament_colors_rgba, m_filament_entries, m_filament_names, m_filament_popup, m_filament_popup_row, m_mapping_rows, m_skip_next_filament_popup_row, rebuild_mapping_rows(), and update_filament_color_map().

Referenced by rebuild_mapping_rows().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShowModal()

int Slic3r::GUI::TextureImportDialog::ShowModal ( )

override

{
    if (m_state == TextureImportState::Idle && m_painted.face_colors.empty()) {
        start_computation(true, true);
 
        while (m_initial_computation_pending) {
            if (auto* event_loop = wxEventLoopBase::GetActive())
                event_loop->Yield();
            else
                wxYield();
            if (m_progress_dlg && m_progress_dlg->WasCancelled())
                m_cancel_flag = true;
            if (m_initial_cancel_callback && m_initial_cancel_callback())
                m_cancel_flag = true;
            wxMilliSleep(10);
        }
 
        if (m_worker && m_worker->joinable())
            m_worker->join();
        m_worker.reset();
 
        if (m_initial_computation_cancelled || m_initial_computation_failed)
            return wxID_CANCEL;
    }
 
    ScopedInteractiveBusyCursorSuspender busy_cursor_suspender;
    return DPIDialog::ShowModal();
}

References Slic3r::GUI::Idle, m_cancel_flag, m_initial_cancel_callback, m_initial_computation_cancelled, m_initial_computation_failed, m_initial_computation_pending, m_painted, m_progress_dlg, m_state, m_worker, Slic3r::GUI::DPIAware< wxDialog >::ShowModal(), and start_computation().

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sort_current_matches_by_filament_index()

void Slic3r::GUI::TextureImportDialog::sort_current_matches_by_filament_index ( )

private

{
    std::stable_sort(m_current_matches.begin(), m_current_matches.end(),
        [](const auto& lhs, const auto& rhs) {
            const bool lhs_valid = lhs.filament_index >= 0;
            const bool rhs_valid = rhs.filament_index >= 0;
 
            if (lhs_valid != rhs_valid)
                return lhs_valid;
            if (!lhs_valid)
                return false;
 
            return lhs.filament_index < rhs.filament_index;
        });
}

References m_current_matches.

Referenced by on_computation_complete().

Here is the caller graph for this function:

◆ start_computation()

void Slic3r::GUI::TextureImportDialog::start_computation	(	bool	auto_color = false,
		bool	initial = false )

private

{
    cancel_computation();
 
    m_cancel_flag = false;
    m_current_computation_initial = initial;
    m_current_computation_auto_color = auto_color;
    if (initial) {
        m_initial_computation_pending = true;
        m_initial_computation_cancelled = false;
        m_initial_computation_failed = false;
    }
    set_state(TextureImportState::Computing);
 
    bool silent_initial = initial && static_cast<bool>(m_initial_cancel_callback);
    if (!silent_initial) {
        m_progress_dlg = new ProgressDialog(
            _L("Processing"), _L("Computing texture colors..."),
            100, initial ? GetParent() : this, wxPD_APP_MODAL | wxPD_CAN_ABORT | wxPD_AUTO_HIDE);
    }
 
    Slic3r::TexturePaintingSettings settings;
    settings.target_colors_num = auto_color ? 0 : (size_t)m_param_color_count;
    settings.smooth_weight     = m_param_smooth / 10.0;
    settings.mesh_repair_decision = m_mesh_repair_decision;
    settings.mesh_repair_callback = [](const indexed_triangle_set& mesh,
                                       indexed_triangle_set&       repaired_mesh,
                                       std::function<void(const char*, unsigned)> progress_callback,
                                       std::function<bool()>       cancel_callback,
                                       std::string*                error_message) -> bool {
        if (progress_callback)
            progress_callback(_u8L("Repairing mesh").c_str(), 0);
 
        struct Canceled {};
        TriangleMesh tm(mesh);
        try {
            if (!repair_mesh(tm, nullptr, error_message, [&cancel_callback](int) {
                    if (cancel_callback && cancel_callback())
                        throw Canceled();
                }))
                return false;
        } catch (const Canceled &) {
            return false;
        }
        repaired_mesh = tm.its;
        if (progress_callback)
            progress_callback(_u8L("Repairing mesh").c_str(), 100);
        return true;
    };
 
    Slic3r::TexturedMesh mesh_copy = m_textured_mesh;
    wxEvtHandler* handler = this;
 
    m_worker = std::make_unique<std::thread>([this, settings, mesh_copy, handler]() {
        Slic3r::PaintedMesh result;
 
        auto progress_cb = [handler](int percent, const char*) {
            auto* evt = new wxCommandEvent(EVT_TEXTURE_COMPUTE_PROGRESS);
            evt->SetInt(percent);
            wxQueueEvent(handler, evt);
        };
 
        auto cancel_cb = [this]() -> bool {
            return m_cancel_flag.load();
        };
 
        auto worker_settings = settings;
        bool mesh_repair_decision_required = false;
        worker_settings.mesh_repair_decision_required = &mesh_repair_decision_required;
        bool ok;
        if (!mesh_copy.precomputed_face_colors.empty()) {
            ok = Slic3r::face_colors_to_painting(
                mesh_copy, result, worker_settings, progress_cb, cancel_cb);
        } else {
            ok = Slic3r::texture_to_painting(mesh_copy, result, worker_settings, progress_cb, cancel_cb);
        }
 
        if (m_cancel_flag.load()) {
            wxQueueEvent(handler, new wxCommandEvent(EVT_TEXTURE_COMPUTE_ERROR));
            return;
        }
 
        if (!ok && mesh_repair_decision_required) {
            wxQueueEvent(handler, new wxCommandEvent(EVT_TEXTURE_MESH_REPAIR_DECISION));
            return;
        }
 
        {
            std::lock_guard<std::mutex> lock(m_result_mutex);
            m_pending_result = std::move(result);
        }
 
        if (ok) {
            wxQueueEvent(handler, new wxCommandEvent(EVT_TEXTURE_COMPUTE_DONE));
        } else {
            wxQueueEvent(handler, new wxCommandEvent(EVT_TEXTURE_COMPUTE_ERROR));
        }
    });
}

References _L, _u8L, cancel_computation(), Slic3r::GUI::Computing, Slic3r::face_colors_to_painting(), Slic3r::TriangleMesh::its, m_cancel_flag, m_current_computation_auto_color, m_current_computation_initial, m_initial_cancel_callback, m_initial_computation_cancelled, m_initial_computation_failed, m_initial_computation_pending, m_mesh_repair_decision, m_param_color_count, m_param_smooth, m_pending_result, m_progress_dlg, m_result_mutex, m_textured_mesh, m_worker, Slic3r::TexturePaintingSettings::mesh_repair_callback, Slic3r::TexturePaintingSettings::mesh_repair_decision, Slic3r::TexturePaintingSettings::mesh_repair_decision_required, Slic3r::TexturedMesh::precomputed_face_colors, Slic3r::repair_mesh(), set_state(), Slic3r::TexturePaintingSettings::smooth_weight, Slic3r::TexturePaintingSettings::target_colors_num, and Slic3r::texture_to_painting().

Referenced by on_apply_clicked(), on_color_preset_clicked(), on_mesh_repair_decision_required(), and ShowModal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ style_confirm_button()

void Slic3r::GUI::TextureImportDialog::style_confirm_button ( bool dirty )

private

{
    if (dirty) {
        m_btn_ok->SetToolTip(_L("Reminder: parameters changed, click Apply to take effect"));
    } else {
        m_btn_ok->UnsetToolTip();
    }
    if (m_hint_label)
        m_hint_label->Show(dirty);
}

References _L, m_btn_ok, and m_hint_label.

Referenced by update_confirm_button_state(), and update_ui_for_state().

Here is the caller graph for this function:

◆ update_auto_mix_reset_visibility()

void Slic3r::GUI::TextureImportDialog::update_auto_mix_reset_visibility ( )

private

{
    if (!m_btn_mix_reset)
        return;
    if (m_btn_mix_reset->Show(m_auto_mix_applied)) {
        if (wxWindow* parent = m_btn_mix_reset->GetParent())
            parent->Layout();
    }
}

References m_auto_mix_applied, and m_btn_mix_reset.

Referenced by apply_auto_standard_mix(), on_auto_merge_toggled(), on_computation_complete(), and reset_auto_mix().

Here is the caller graph for this function:

◆ update_color_count_preset_buttons()

void Slic3r::GUI::TextureImportDialog::update_color_count_preset_buttons ( )

private

{
    auto update = [this](auto* btn, int count) {
        if (btn) btn->SetStyle(m_param_color_count == count ? ButtonStyle::Confirm : ButtonStyle::Regular, ButtonType::Window);
    };
    update(m_btn_color_4 , 4);
    update(m_btn_color_8 , 8);
    update(m_btn_color_16, 16);
}

References Confirm, count, m_btn_color_16, m_btn_color_4, m_btn_color_8, m_param_color_count, Regular, and Window.

Referenced by build_params_panel(), on_computation_error(), on_dpi_changed(), and set_color_count_value().

Here is the caller graph for this function:

◆ update_confirm_button_state()

void Slic3r::GUI::TextureImportDialog::update_confirm_button_state ( )

private

{
    if (m_state != TextureImportState::Ready)
        return;
 
    if (!has_valid_result()) {
        m_btn_ok->Enable(false);
        if (m_hint_label) m_hint_label->Hide();
        m_btn_ok->Refresh();
        Layout();
        return;
    }
 
    m_btn_ok->Enable(true);
    style_confirm_button(is_params_dirty());
 
    m_btn_ok->Refresh();
    Layout();
}

References has_valid_result(), is_params_dirty(), m_btn_ok, m_hint_label, m_state, Slic3r::GUI::Ready, and style_confirm_button().

Referenced by preview_spin_text_value(), set_color_count_value(), and set_smooth_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_drop_warning_visibility()

void Slic3r::GUI::TextureImportDialog::update_drop_warning_visibility ( )

private

{
    if (!m_drop_warning_label) return;
    // Show only when the most recent do_auto_match() ran into the filament
    // cap AND we are in the Ready state. The flag is reset at every
    // do_auto_match() entry, so any "clean" re-run automatically hides the
    // warning even if a previous run had dropped clusters.
    const bool show = (m_state == TextureImportState::Ready) && m_filaments_dropped;
    if (m_drop_warning_label->IsShown() == show) return;
    m_drop_warning_label->Show(show);
    Layout();
}

References m_drop_warning_label, m_filaments_dropped, m_state, and Slic3r::GUI::Ready.

Referenced by apply_auto_standard_mix(), on_auto_merge_toggled(), on_computation_complete(), and reset_auto_mix().

Here is the caller graph for this function:

◆ update_em_unit()

void Slic3r::GUI::DPIAware< wxDialog >::update_em_unit ( )

inlineprivateinherited

    {
        // Linux specific issue : get_dpi_for_window(this) still doesn't responce to the Display's scale in new wxWidgets(3.1.3).
        // So, calculate the m_em_unit value from the font size, as before
#if !defined(__WXGTK__)
        m_em_unit = std::max<size_t>(10, 10.0f * m_scale_factor);
#else
        // initialize default width_unit according to the width of the one symbol ("m") of the currently active font of this window.
        m_em_unit = std::max<size_t>(10, this->GetTextExtent("m").x - 1);
#endif // __WXGTK__
    }

◆ update_filament_color_map()

void Slic3r::GUI::TextureImportDialog::update_filament_color_map ( )

private

{
    std::map<std::array<std::size_t, 3>, std::array<float, 3>> color_map;
    for (const auto& m : m_current_matches) {
        if (m.filament_index >= 0 && m.filament_index < (int)m_filament_colors_rgba.size()) {
            color_map[m.cluster_color] = {
                m_filament_colors_rgba[m.filament_index][0],
                m_filament_colors_rgba[m.filament_index][1],
                m_filament_colors_rgba[m.filament_index][2]
            };
        }
    }
    m_preview_canvas->set_filament_color_map(color_map);
}

References m_current_matches, m_filament_colors_rgba, and m_preview_canvas.

Referenced by add_decomposed_mixed_filament(), apply_auto_standard_mix(), do_auto_match(), on_auto_merge_toggled(), on_computation_complete(), reset_auto_mix(), and show_filament_popup().

Here is the caller graph for this function:

◆ update_ui_for_state()

void Slic3r::GUI::TextureImportDialog::update_ui_for_state ( )

private

{
    bool computing = (m_state == TextureImportState::Computing);
    bool ready     = (m_state == TextureImportState::Ready);
    bool idle      = (m_state == TextureImportState::Idle);
    bool valid     = has_valid_result();
 
    m_color_slider->Enable(!computing);
    m_color_spin->Enable(!computing);
    m_smooth_slider->Enable(!computing);
    m_smooth_spin->Enable(!computing);
    m_btn_apply->Enable(!computing);
    m_btn_color_4->Enable(!computing);
    m_btn_color_8->Enable(!computing);
    m_btn_color_16->Enable(!computing);
    m_btn_color_auto->Enable(!computing);
    if (m_btn_auto_mix)
        m_btn_auto_mix->Enable(!computing);
    if (m_btn_mix_reset)
        m_btn_mix_reset->Enable(!computing);
    if (computing)
        dismiss_auto_mix_popup();
 
    m_btn_ok->Enable(ready && valid);
    m_btn_skip->Enable(ready || idle);
 
    m_auto_merge_cb->Enable(!computing);
 
    m_preview_canvas->set_computing_overlay(computing);
 
    if (ready && valid)
        style_confirm_button(is_params_dirty());
    else if (m_hint_label)
        m_hint_label->Hide();
 
    m_btn_ok->Refresh();
    Layout();
}

References Slic3r::GUI::Computing, dismiss_auto_mix_popup(), has_valid_result(), Slic3r::GUI::Idle, is_params_dirty(), m_auto_merge_cb, m_btn_apply, m_btn_auto_mix, m_btn_color_16, m_btn_color_4, m_btn_color_8, m_btn_color_auto, m_btn_mix_reset, m_btn_ok, m_btn_skip, m_color_slider, m_color_spin, m_hint_label, m_preview_canvas, m_smooth_slider, m_smooth_spin, m_state, Slic3r::GUI::Ready, and style_confirm_button().

Referenced by set_state().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ was_skipped()

bool Slic3r::GUI::TextureImportDialog::was_skipped ( ) const

inline

212{ return m_skipped; }

References m_skipped.

Referenced by Slic3r::GUI::Plater::priv::run_textured_mesh_import_dialog().

Here is the caller graph for this function:

◆ wxDECLARE_EVENT_TABLE()

Slic3r::GUI::TextureImportDialog::wxDECLARE_EVENT_TABLE ( )

private

Member Data Documentation

◆ ID_BTN_APPLY

const int Slic3r::GUI::TextureImportDialog::ID_BTN_APPLY = wxID_HIGHEST + 204

staticprivate

Referenced by build_params_panel(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_BTN_SKIP

const int Slic3r::GUI::TextureImportDialog::ID_BTN_SKIP = wxID_HIGHEST + 205

staticprivate

Referenced by build_bottom_buttons(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_COLOR_16

const int Slic3r::GUI::TextureImportDialog::ID_COLOR_16 = wxID_HIGHEST + 202

staticprivate

Referenced by build_params_panel(), on_color_preset_clicked(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_COLOR_4

const int Slic3r::GUI::TextureImportDialog::ID_COLOR_4 = wxID_HIGHEST + 200

staticprivate

Referenced by build_params_panel(), on_color_preset_clicked(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_COLOR_8

const int Slic3r::GUI::TextureImportDialog::ID_COLOR_8 = wxID_HIGHEST + 201

staticprivate

Referenced by build_params_panel(), on_color_preset_clicked(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_COLOR_AUTO

const int Slic3r::GUI::TextureImportDialog::ID_COLOR_AUTO = wxID_HIGHEST + 203

staticprivate

Referenced by build_params_panel(), on_color_preset_clicked(), and Slic3r::GUI::wxBEGIN_EVENT_TABLE().

◆ ID_VIEW_MULTICOLOR

const int Slic3r::GUI::TextureImportDialog::ID_VIEW_MULTICOLOR = wxID_HIGHEST + 207

staticprivate

Referenced by build_preview_panel().

◆ ID_VIEW_ORIGINAL

const int Slic3r::GUI::TextureImportDialog::ID_VIEW_ORIGINAL = wxID_HIGHEST + 206

staticprivate

Referenced by build_preview_panel().

◆ m_applied_color_count

int Slic3r::GUI::TextureImportDialog::m_applied_color_count = -1

private

Referenced by is_params_dirty(), on_computation_complete(), and on_computation_error().

◆ m_applied_smooth

int Slic3r::GUI::TextureImportDialog::m_applied_smooth = -1

private

Referenced by is_params_dirty(), on_computation_complete(), and on_computation_error().

◆ m_auto_merge_cb

wxCheckBox* Slic3r::GUI::TextureImportDialog::m_auto_merge_cb = nullptr

private

Referenced by build_mapping_panel(), do_auto_match(), on_auto_merge_toggled(), and update_ui_for_state().

◆ m_auto_merge_enabled

bool Slic3r::GUI::TextureImportDialog::m_auto_merge_enabled = true

private

Referenced by on_auto_merge_toggled().

◆ m_auto_mix_applied

bool Slic3r::GUI::TextureImportDialog::m_auto_mix_applied = false

private

Referenced by apply_auto_standard_mix(), do_auto_match(), reset_auto_mix(), and update_auto_mix_reset_visibility().

◆ m_auto_mix_font_point_size

int Slic3r::GUI::TextureImportDialog::m_auto_mix_font_point_size = 10

private

Referenced by build_mapping_panel(), and show_auto_mix_popup().

◆ m_auto_mix_mode

TextureAutoMixMode Slic3r::GUI::TextureImportDialog::m_auto_mix_mode = TextureAutoMixMode::CMYW

private

Referenced by build_mapping_panel(), set_auto_mix_mode(), and show_auto_mix_popup().

◆ m_auto_mix_popup

AutoMixSelectPopup* Slic3r::GUI::TextureImportDialog::m_auto_mix_popup = nullptr

private

Referenced by dismiss_auto_mix_popup(), and show_auto_mix_popup().

◆ m_btn_apply

Button* Slic3r::GUI::TextureImportDialog::m_btn_apply = nullptr

private

Referenced by build_params_panel(), on_dpi_changed(), and update_ui_for_state().

◆ m_btn_auto_mix

Button* Slic3r::GUI::TextureImportDialog::m_btn_auto_mix = nullptr

private

Referenced by build_mapping_panel(), on_dpi_changed(), set_auto_mix_mode(), show_auto_mix_popup(), and update_ui_for_state().

◆ m_btn_color_16

Button* Slic3r::GUI::TextureImportDialog::m_btn_color_16 = nullptr

private

Referenced by build_params_panel(), update_color_count_preset_buttons(), and update_ui_for_state().

◆ m_btn_color_4

Button* Slic3r::GUI::TextureImportDialog::m_btn_color_4 = nullptr

private

Referenced by build_params_panel(), update_color_count_preset_buttons(), and update_ui_for_state().

◆ m_btn_color_8

Button* Slic3r::GUI::TextureImportDialog::m_btn_color_8 = nullptr

private

Referenced by build_params_panel(), update_color_count_preset_buttons(), and update_ui_for_state().

◆ m_btn_color_auto

Button* Slic3r::GUI::TextureImportDialog::m_btn_color_auto = nullptr

private

Referenced by build_params_panel(), on_dpi_changed(), and update_ui_for_state().

◆ m_btn_mix_reset

Button* Slic3r::GUI::TextureImportDialog::m_btn_mix_reset = nullptr

private

Referenced by build_mapping_panel(), on_dpi_changed(), update_auto_mix_reset_visibility(), and update_ui_for_state().

◆ m_btn_ok

Button* Slic3r::GUI::TextureImportDialog::m_btn_ok = nullptr

private

Referenced by build_bottom_buttons(), on_dpi_changed(), style_confirm_button(), update_confirm_button_state(), and update_ui_for_state().

◆ m_btn_skip

Button* Slic3r::GUI::TextureImportDialog::m_btn_skip = nullptr

private

Referenced by build_bottom_buttons(), on_dpi_changed(), and update_ui_for_state().

◆ m_btn_view_multicolor

Button* Slic3r::GUI::TextureImportDialog::m_btn_view_multicolor = nullptr

private

Referenced by build_preview_panel(), highlight_view_button(), on_computation_complete(), and on_dpi_changed().

◆ m_btn_view_original

Button* Slic3r::GUI::TextureImportDialog::m_btn_view_original = nullptr

private

Referenced by build_preview_panel(), highlight_view_button(), and on_dpi_changed().

◆ m_can_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_can_rescale

privateinherited

235{ true };

◆ m_cancel_flag

std::atomic<bool> Slic3r::GUI::TextureImportDialog::m_cancel_flag {false}

private

344{false};

Referenced by ~TextureImportDialog(), cancel_computation(), on_computation_error(), on_computation_progress(), on_mesh_repair_decision_required(), ShowModal(), and start_computation().

◆ m_color_slider

AccentSlider* Slic3r::GUI::TextureImportDialog::m_color_slider = nullptr

private

Referenced by build_params_panel(), on_color_slider_changed(), on_color_spin_text_changed(), on_computation_error(), set_color_count_value(), and update_ui_for_state().

◆ m_color_spin

SpinInput* Slic3r::GUI::TextureImportDialog::m_color_spin = nullptr

private

Referenced by build_params_panel(), on_color_spin_changed(), on_color_spin_text_changed(), on_computation_error(), on_dpi_changed(), set_color_count_value(), and update_ui_for_state().

◆ m_current_computation_auto_color

bool Slic3r::GUI::TextureImportDialog::m_current_computation_auto_color = false

private

Referenced by on_mesh_repair_decision_required(), and start_computation().

◆ m_current_computation_initial

bool Slic3r::GUI::TextureImportDialog::m_current_computation_initial = false

private

Referenced by cancel_computation(), on_computation_complete(), on_computation_error(), on_computation_progress(), on_mesh_repair_decision_required(), and start_computation().

◆ m_current_matches

std::vector<Slic3r::FilamentMatch> Slic3r::GUI::TextureImportDialog::m_current_matches

private

Referenced by add_decomposed_mixed_filament(), apply_auto_standard_mix(), compact_used_virtual_filaments(), do_auto_match(), get_matches(), has_valid_result(), on_auto_merge_toggled(), on_computation_complete(), on_ok_clicked(), on_skip_clicked(), rebuild_mapping_rows(), reset_auto_mix(), restore_current_match_order(), show_filament_popup(), sort_current_matches_by_filament_index(), and update_filament_color_map().

◆ m_default_virtual_filament_preset_name

std::string Slic3r::GUI::TextureImportDialog::m_default_virtual_filament_preset_name

private

Referenced by add_virtual_filament(), apply_auto_standard_mix(), and compact_used_virtual_filaments().

◆ m_drop_warning_label

wxStaticText* Slic3r::GUI::TextureImportDialog::m_drop_warning_label = nullptr

private

Referenced by build_bottom_buttons(), and update_drop_warning_visibility().

◆ m_em_unit

int Slic3r::GUI::DPIAware< wxDialog >::m_em_unit

privateinherited

◆ m_existing_filament_count

size_t Slic3r::GUI::TextureImportDialog::m_existing_filament_count = 0

private

Referenced by apply_auto_standard_mix(), compact_used_virtual_filaments(), do_auto_match(), get_existing_filament_count(), on_computation_complete(), and show_filament_popup().

◆ m_fallback_to_geometry_only

bool Slic3r::GUI::TextureImportDialog::m_fallback_to_geometry_only = false

private

Referenced by fallback_to_geometry_only(), and on_computation_error().

◆ m_filament_color_strs

std::vector<std::string> Slic3r::GUI::TextureImportDialog::m_filament_color_strs

private

Referenced by add_virtual_filament(), add_virtual_mixed_filament(), compact_used_virtual_filaments(), do_auto_match(), and on_computation_complete().

◆ m_filament_colors_rgba

std::vector<std::array<float, 4> > Slic3r::GUI::TextureImportDialog::m_filament_colors_rgba

private

Referenced by add_virtual_filament(), add_virtual_mixed_filament(), apply_auto_standard_mix(), build_matches_from_rows(), can_add_virtual_filament(), compact_used_virtual_filaments(), do_auto_match(), find_closest_filament_index(), has_valid_result(), on_computation_complete(), rebuild_mapping_rows(), show_filament_popup(), and update_filament_color_map().

◆ m_filament_entries

std::vector<TextureFilamentEntry> Slic3r::GUI::TextureImportDialog::m_filament_entries

private

Referenced by add_decomposed_mixed_filament(), add_virtual_filament(), add_virtual_mixed_filament(), apply_auto_standard_mix(), compact_used_virtual_filaments(), compute_display_numbers(), do_auto_match(), get_filament_entries(), on_computation_complete(), rebuild_mapping_rows(), reset_auto_mix(), and show_filament_popup().

◆ m_filament_names

std::vector<std::string> Slic3r::GUI::TextureImportDialog::m_filament_names

private

Referenced by add_virtual_filament(), add_virtual_mixed_filament(), compact_used_virtual_filaments(), do_auto_match(), on_computation_complete(), rebuild_mapping_rows(), and show_filament_popup().

◆ m_filament_popup

FilamentSelectPopup* Slic3r::GUI::TextureImportDialog::m_filament_popup = nullptr

private

Referenced by dismiss_filament_popup(), and show_filament_popup().

◆ m_filament_popup_row

int Slic3r::GUI::TextureImportDialog::m_filament_popup_row = -1

private

Referenced by dismiss_filament_popup(), and show_filament_popup().

◆ m_filaments_dropped

bool Slic3r::GUI::TextureImportDialog::m_filaments_dropped = false

private

Referenced by add_virtual_filament(), add_virtual_mixed_filament(), apply_auto_standard_mix(), do_auto_match(), and update_drop_warning_visibility().

◆ m_force_rescale

bool Slic3r::GUI::DPIAware< wxDialog >::m_force_rescale

privateinherited

236{ false };

◆ m_hint_label

wxStaticText* Slic3r::GUI::TextureImportDialog::m_hint_label = nullptr

private

Referenced by build_params_panel(), style_confirm_button(), update_confirm_button_state(), and update_ui_for_state().

◆ m_initial_cancel_callback

std::function<bool()> Slic3r::GUI::TextureImportDialog::m_initial_cancel_callback

private

Referenced by ShowModal(), and start_computation().

◆ m_initial_computation_cancelled

bool Slic3r::GUI::TextureImportDialog::m_initial_computation_cancelled = false

private

Referenced by cancel_computation(), on_computation_error(), on_mesh_repair_decision_required(), ShowModal(), and start_computation().

◆ m_initial_computation_failed

bool Slic3r::GUI::TextureImportDialog::m_initial_computation_failed = false

private

Referenced by on_computation_error(), ShowModal(), and start_computation().

◆ m_initial_computation_pending

bool Slic3r::GUI::TextureImportDialog::m_initial_computation_pending = false

private

Referenced by cancel_computation(), on_computation_complete(), on_computation_error(), on_mesh_repair_decision_required(), ShowModal(), and start_computation().

◆ m_initial_progress_callback

std::function<bool(int)> Slic3r::GUI::TextureImportDialog::m_initial_progress_callback

private

Referenced by on_computation_progress().

◆ m_initial_tooltips_set

bool Slic3r::GUI::TextureImportDialog::m_initial_tooltips_set = false

private

Referenced by build_params_panel().

◆ m_mapping_rows

std::vector<FilamentMappingRow> Slic3r::GUI::TextureImportDialog::m_mapping_rows

private

Referenced by add_decomposed_mixed_filament(), apply_auto_standard_mix(), build_matches_from_rows(), has_valid_result(), rebuild_mapping_rows(), and show_filament_popup().

◆ m_mapping_scroll

wxScrolledWindow* Slic3r::GUI::TextureImportDialog::m_mapping_scroll = nullptr

private

Referenced by build_mapping_panel(), on_dpi_changed(), and rebuild_mapping_rows().

◆ m_mapping_sizer

wxBoxSizer* Slic3r::GUI::TextureImportDialog::m_mapping_sizer = nullptr

private

Referenced by build_mapping_panel(), and rebuild_mapping_rows().

◆ m_mesh_repair_decision

Slic3r::TexturePaintingSettings::MeshRepairDecision Slic3r::GUI::TextureImportDialog::m_mesh_repair_decision

private

Initial value:

=

Slic3r::TexturePaintingSettings::MeshRepairDecision::Ask

@ Ask

Definition TexturePainting.hpp:75

Referenced by on_mesh_repair_decision_required(), and start_computation().

◆ m_new_filament_colors

std::vector<std::array<float, 4> > Slic3r::GUI::TextureImportDialog::m_new_filament_colors

private

Referenced by add_virtual_filament(), compact_used_virtual_filaments(), get_new_filament_colors(), on_computation_complete(), and on_skip_clicked().

◆ m_new_filament_preset_names

std::vector<std::string> Slic3r::GUI::TextureImportDialog::m_new_filament_preset_names

private

Referenced by add_virtual_filament(), compact_used_virtual_filaments(), get_new_filament_preset_names(), on_computation_complete(), and on_skip_clicked().

◆ m_new_font_point_size

int Slic3r::GUI::DPIAware< wxDialog >::m_new_font_point_size

privateinherited

◆ m_new_mixed_filaments

std::vector<TextureNewMixedFilament> Slic3r::GUI::TextureImportDialog::m_new_mixed_filaments

private

Referenced by add_virtual_mixed_filament(), compact_used_virtual_filaments(), get_new_mixed_filaments(), on_computation_complete(), and on_skip_clicked().

◆ m_normal_font

wxFont Slic3r::GUI::DPIAware< wxDialog >::m_normal_font

privateinherited

◆ m_painted

Slic3r::PaintedMesh Slic3r::GUI::TextureImportDialog::m_painted

private

Referenced by do_auto_match(), get_painted_mesh(), has_valid_result(), on_computation_complete(), and ShowModal().

◆ m_param_color_count

int Slic3r::GUI::TextureImportDialog::m_param_color_count = 4

private

Referenced by build_params_panel(), is_params_dirty(), on_color_preset_clicked(), on_color_spin_text_changed(), on_computation_complete(), on_computation_error(), set_color_count_value(), start_computation(), and update_color_count_preset_buttons().

◆ m_param_smooth

int Slic3r::GUI::TextureImportDialog::m_param_smooth = 5

private

Referenced by build_params_panel(), is_params_dirty(), on_computation_complete(), on_computation_error(), on_smooth_spin_text_changed(), set_smooth_value(), and start_computation().

◆ m_pending_result

Slic3r::PaintedMesh Slic3r::GUI::TextureImportDialog::m_pending_result

private

Referenced by on_computation_complete(), and start_computation().

◆ m_prev_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_prev_scale_factor

privateinherited

◆ m_preview_canvas

TexturePreviewCanvas* Slic3r::GUI::TextureImportDialog::m_preview_canvas = nullptr

private

Referenced by build_preview_panel(), on_computation_complete(), update_filament_color_map(), and update_ui_for_state().

◆ m_progress_dlg

ProgressDialog* Slic3r::GUI::TextureImportDialog::m_progress_dlg = nullptr

private

Referenced by cancel_computation(), on_computation_complete(), on_computation_error(), on_computation_progress(), on_mesh_repair_decision_required(), ShowModal(), and start_computation().

◆ m_result_mutex

std::mutex Slic3r::GUI::TextureImportDialog::m_result_mutex

private

Referenced by on_computation_complete(), and start_computation().

◆ m_scale_factor

float Slic3r::GUI::DPIAware< wxDialog >::m_scale_factor

privateinherited

◆ m_skip_next_filament_popup_row

int Slic3r::GUI::TextureImportDialog::m_skip_next_filament_popup_row = -1

private

Referenced by show_filament_popup().

◆ m_skipped

bool Slic3r::GUI::TextureImportDialog::m_skipped = false

private

Referenced by on_skip_clicked(), and was_skipped().

◆ m_smooth_slider

AccentSlider* Slic3r::GUI::TextureImportDialog::m_smooth_slider = nullptr

private

Referenced by build_params_panel(), on_computation_error(), on_smooth_slider_changed(), on_smooth_spin_text_changed(), set_smooth_value(), and update_ui_for_state().

◆ m_smooth_spin

SpinInput* Slic3r::GUI::TextureImportDialog::m_smooth_spin = nullptr

private

Referenced by build_params_panel(), on_computation_error(), on_dpi_changed(), on_smooth_spin_changed(), on_smooth_spin_text_changed(), set_smooth_value(), and update_ui_for_state().

◆ m_state

TextureImportState Slic3r::GUI::TextureImportDialog::m_state = TextureImportState::Idle

private

Referenced by build_preview_panel(), on_auto_merge_toggled(), on_ok_clicked(), reset_auto_mix(), set_state(), ShowModal(), update_confirm_button_state(), update_drop_warning_visibility(), and update_ui_for_state().

◆ m_tab_panel

wxPanel* Slic3r::GUI::TextureImportDialog::m_tab_panel = nullptr

private

Referenced by build_preview_panel(), and on_computation_complete().

◆ m_textured_mesh

Slic3r::TexturedMesh Slic3r::GUI::TextureImportDialog::m_textured_mesh

private

Referenced by start_computation().

◆ m_worker

std::unique_ptr<std::thread> Slic3r::GUI::TextureImportDialog::m_worker

private

Referenced by ~TextureImportDialog(), cancel_computation(), ShowModal(), and start_computation().

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

/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/TextureImportDialog.hpp
/home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/TextureImportDialog.cpp

	OrcaSlicer latest OrcaSlicer

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TextureImportDialog()

◆ ~TextureImportDialog()

Member Function Documentation

◆ add_decomposed_mixed_filament()

◆ add_virtual_filament()

◆ add_virtual_mixed_filament()

◆ apply_auto_standard_mix()

◆ build_bottom_buttons()

◆ build_mapping_panel()

◆ build_matches_from_rows()

◆ build_params_panel()

◆ build_preview_panel()

◆ build_ui()

◆ can_add_virtual_filament()

◆ cancel_computation()

◆ compact_used_virtual_filaments()

◆ compute_display_numbers()

◆ dismiss_auto_mix_popup()

◆ dismiss_filament_popup()

◆ dismiss_filament_popup_on_wheel()

◆ do_auto_match()

◆ em_unit()

◆ enable_force_rescale()

◆ EndModal()

◆ fallback_to_geometry_only()

◆ find_closest_filament_index()

◆ force_rescale()

◆ get_existing_filament_count()

◆ get_filament_entries()

◆ get_matches()

◆ get_new_filament_colors()

◆ get_new_filament_preset_names()

◆ get_new_mixed_filaments()

◆ get_painted_mesh()

◆ has_valid_result()

◆ highlight_view_button()

◆ is_new_scale_factor()

◆ is_params_dirty()

◆ max_filament_count()

◆ normal_font()

◆ on_apply_clicked()

◆ on_auto_merge_toggled()

◆ on_color_preset_clicked()

◆ on_color_slider_changed()

◆ on_color_spin_changed()

◆ on_color_spin_text_changed()

◆ on_computation_complete()

◆ on_computation_error()

◆ on_computation_progress()

◆ on_dpi_changed()

◆ on_mesh_repair_decision_required()

◆ on_ok_clicked()

◆ on_skip_clicked()

◆ on_smooth_slider_changed()

◆ on_smooth_spin_changed()

◆ on_smooth_spin_text_changed()

◆ on_sys_color_changed()

◆ prev_scale_factor()

◆ preview_spin_text_value()

◆ rebuild_mapping_rows()

◆ rescale()

◆ reset_auto_mix()

◆ restore_current_match_order()

◆ scale_factor()

◆ set_auto_mix_mode()

◆ set_color_count_value()

◆ set_em_unit()

◆ set_prev_scale_factor()

◆ set_scale_factor()

◆ set_smooth_value()

◆ set_state()

◆ show_auto_mix_popup()

◆ show_filament_popup()