Slic3r::GUI::FlowRateWizard Class Reference

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

Inheritance diagram for Slic3r::GUI::FlowRateWizard:

Collaboration diagram for Slic3r::GUI::FlowRateWizard:

Public Member Functions
	FlowRateWizard (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
	~FlowRateWizard ()
void	set_cali_method (CalibrationMethod method) override
void	on_cali_job_finished (wxString evt_data) override
void	cache_coarse_info (MachineObject *obj)
void	on_cali_job_finished (wxCommandEvent &event)
CalibrationWizardPageStep *	get_curr_step ()
void	show_step (CalibrationWizardPageStep *step)
virtual void	set_cali_style (CalibrationStyle style)
CalibMode	get_calibration_mode ()
bool	save_preset (const std::string &old_preset_name, const std::string &new_preset_name, const std::map< std::string, ConfigOption * > &key_values, wxString &message)
bool	save_preset_with_index (const std::string &old_preset_name, const std::string &new_preset_name, const std::map< std::string, ConfigIndexValue > &key_values, wxString &message)
virtual void	cache_preset_info (MachineObject *obj, float nozzle_dia, BedType bed_type)
virtual void	recover_preset_info (MachineObject *obj)
virtual void	back_preset_info (MachineObject *obj, bool cali_finish, bool back_cali_flag=true)
void	msw_rescale ()
void	on_sys_color_changed ()
bool	built () const
bool	build_step ()

Protected Member Functions
void	create_pages ()
void	on_cali_action (wxCommandEvent &evt)
void	on_cali_start (CaliPresetStage stage=CaliPresetStage::CALI_MANULA_STAGE_NONE, float cali_value=0.0f, FlowRatioCaliSource from_page=FlowRatioCaliSource::FROM_PRESET_PAGE)
void	on_cali_save ()
void	update (MachineObject *obj) override
void	on_device_connected (MachineObject *obj) override
std::map< std::string, ConfigIndexValue >	generate_index_key_value (MachineObject *obj, const std::string &key, float value)
void	on_cali_go_home ()
void	add_page_step (CalibrationWizardPageStep *&step, std::function< CalibrationWizardPage *()> make)
void	add_build_step (std::function< void()> step)
void	add_build_steps_of (StagedBuild &child)

Protected Attributes
wxScrolledWindow *	m_scrolledWindow
wxBoxSizer *	m_all_pages_sizer
CalibMode	m_mode
CalibrationStyle	m_cali_style
CalibrationMethod	m_cali_method { CalibrationMethod::CALI_METHOD_MANUAL }
MachineObject *	curr_obj { nullptr }
MachineObject *	last_obj { nullptr }
CalibrationWizardPageStep *	m_curr_step { nullptr }
CalibrationWizardPageStep *	start_step { nullptr }
CalibrationWizardPageStep *	preset_step { nullptr }
CalibrationWizardPageStep *	cali_step { nullptr }
CalibrationWizardPageStep *	save_step { nullptr }
CalibrationWizardPageStep *	cali_coarse_step { nullptr }
CalibrationWizardPageStep *	coarse_save_step { nullptr }
CalibrationWizardPageStep *	cali_fine_step { nullptr }
CalibrationWizardPageStep *	fine_save_step { nullptr }
std::vector< CalibrationWizardPageStep * >	m_page_steps
SecondaryCheckDialog *	go_home_dialog = nullptr

Private Member Functions
StagedBuild *	unfinished_child () const

Private Attributes
std::vector< std::function< void()> >	m_steps
std::vector< StagedBuild * >	m_children
size_t	m_next_step { 0 }

Detailed Description

Constructor & Destructor Documentation

FlowRateWizard()

Slic3r::GUI::FlowRateWizard::FlowRateWizard	(	wxWindow *	parent,
		wxWindowID	id = wxID_ANY,
		const wxPoint &	pos = wxDefaultPosition,
		const wxSize &	size = wxDefaultSize,
		long	style = wxTAB_TRAVERSAL )

    : CalibrationWizard(parent, CalibMode::Calib_Flow_Rate, id, pos, size, style)
{
    create_pages();
}

References Slic3r::GUI::CalibrationWizard::CalibrationWizard(), FlowRateWizard(), Slic3r::Calib_Flow_Rate, create_pages(), and style.

Referenced by FlowRateWizard().

Here is the call graph for this function:

Here is the caller graph for this function:

~FlowRateWizard()

Slic3r::GUI::FlowRateWizard::~FlowRateWizard ( )

inline

{};

Member Function Documentation

add_build_step()

void Slic3r::GUI::StagedBuild::add_build_step ( std::function< void()> step )

inlineprotectedinherited

{ m_steps.push_back(std::move(step)); }

References m_steps.

Referenced by Slic3r::GUI::StatusBasePanel::StatusBasePanel(), Slic3r::GUI::StatusPanel::StatusPanel(), add_build_steps_of(), Slic3r::GUI::CalibrationWizard::add_page_step(), Slic3r::GUI::StatusBasePanel::create_machine_control_page(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::AuxiliaryPanel::init_tabpanel(), and Slic3r::GUI::MonitorPanel::init_tabpanel().

Here is the caller graph for this function:

add_build_steps_of()

void Slic3r::GUI::StagedBuild::add_build_steps_of ( StagedBuild & child )

inlineprotectedinherited

    {
        m_children.push_back(&child);
        for (size_t i = child.m_next_step; i < child.m_steps.size(); ++i)
            add_build_step([&child] { child.build_step(); });
    }

References add_build_step(), build_step(), m_children, m_next_step, and m_steps.

Referenced by Slic3r::GUI::ProjectPanel::ProjectPanel(), Slic3r::GUI::CalibrationPanel::init_tabpanel(), and Slic3r::GUI::MonitorPanel::init_tabpanel().

Here is the call graph for this function:

Here is the caller graph for this function:

add_page_step()

void Slic3r::GUI::CalibrationWizard::add_page_step ( CalibrationWizardPageStep *& step, std::function< CalibrationWizardPage *()> make )

protectedinherited

{
    add_build_step([this, &step, make = std::move(make)] {
        step = new CalibrationWizardPageStep(make());
        m_all_pages_sizer->Add(step->page, 1, wxEXPAND | wxALL, FromDIP(25));
        step->page->Hide();
    });
}

References Slic3r::GUI::StagedBuild::add_build_step(), and m_all_pages_sizer.

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), and Slic3r::GUI::PressureAdvanceWizard::create_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

back_preset_info()

void Slic3r::GUI::CalibrationWizard::back_preset_info ( MachineObject * obj, bool cali_finish, bool back_cali_flag = true )

virtualinherited

{
    if (!obj)
        return;
 
    PrinterCaliInfo printer_cali_info;
    printer_cali_info.dev_id           = obj->get_dev_id();
    printer_cali_info.cali_finished    = cali_finish;
    printer_cali_info.cache_flow_ratio = obj->cache_flow_ratio;
    printer_cali_info.selected_presets = obj->selected_cali_preset;
    printer_cali_info.cache_flow_rate_calibration_type = obj->flow_ratio_calibration_type;
    wxGetApp().app_config->save_printer_cali_infos(printer_cali_info, back_cali_flag);
}

References Slic3r::PrinterCaliInfo::cache_flow_rate_calibration_type, Slic3r::MachineObject::cache_flow_ratio, Slic3r::PrinterCaliInfo::cache_flow_ratio, Slic3r::PrinterCaliInfo::cali_finished, Slic3r::PrinterCaliInfo::dev_id, Slic3r::MachineObject::flow_ratio_calibration_type, Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::selected_cali_preset, and Slic3r::PrinterCaliInfo::selected_presets.

Referenced by Slic3r::GUI::FlowRateWizard::cache_coarse_info(), cache_preset_info(), on_cali_go_home(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_save().

Here is the call graph for this function:

Here is the caller graph for this function:

build_step()

bool Slic3r::GUI::StagedBuild::build_step ( )

inlineinherited

    {
        if (m_next_step < m_steps.size()) {
            // Copied out, since a step may queue more steps and reallocate m_steps.
            auto step = std::move(m_steps[m_next_step++]);
            step();
        } else if (StagedBuild* child = unfinished_child()) {
            child->build_step();
        }
        return !built();
    }

References built(), m_next_step, m_steps, and unfinished_child().

Referenced by add_build_steps_of().

Here is the call graph for this function:

Here is the caller graph for this function:

built()

bool Slic3r::GUI::StagedBuild::built ( ) const

inlineinherited

    {
        return m_next_step == m_steps.size() &&
               std::all_of(m_children.begin(), m_children.end(), [](const StagedBuild* child) { return child->built(); });
    }

References m_children, m_next_step, and m_steps.

Referenced by Slic3r::GUI::StatusPanel::~StatusPanel(), build_step(), Slic3r::GUI::CalibrationPanel::show_status(), Slic3r::GUI::MonitorPanel::show_status(), Slic3r::GUI::CalibrationPanel::update_all(), and Slic3r::GUI::MonitorPanel::update_all().

Here is the caller graph for this function:

cache_coarse_info()

void Slic3r::GUI::FlowRateWizard::cache_coarse_info

(

MachineObject *

obj

)

{
    if (!obj) return;
 
    CalibrationFlowCoarseSavePage *coarse_page = (static_cast<CalibrationFlowCoarseSavePage *>(coarse_save_step->page));
    if (!coarse_page)
        return;
 
    wxString out_name;
    coarse_page->get_result(&obj->cache_flow_ratio, &out_name);
 
    back_preset_info(obj, false);
}

References Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::MachineObject::cache_flow_ratio, Slic3r::GUI::CalibrationWizard::coarse_save_step, and Slic3r::GUI::CalibrationFlowCoarseSavePage::get_result().

Referenced by on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

cache_preset_info()

void Slic3r::GUI::CalibrationWizard::cache_preset_info ( MachineObject * obj, float nozzle_dia, BedType bed_type )

virtualinherited

{
    if (!obj) return;
 
    CalibrationPresetPage* preset_page = (static_cast<CalibrationPresetPage*>(preset_step->page));
 
    std::map<int, Preset*> selected_filaments = preset_page->get_selected_filaments();
 
    obj->selected_cali_preset.clear();
    for (auto& item : selected_filaments) {
        CaliPresetInfo result;
        result.tray_id = item.first;
        result.nozzle_diameter = nozzle_dia;
        result.bed_type        = bed_type;
        result.filament_id = item.second->filament_id;
        result.setting_id = item.second->setting_id;
        result.name = item.second->name;
 
        if (obj->is_multi_extruders()) {
            int ams_id, slot_id, tray_id;
            get_tray_ams_and_slot_id(curr_obj, result.tray_id, ams_id, slot_id, tray_id);
            result.extruder_id = preset_page->get_extruder_id_by_tray_id(result.tray_id);
            result.nozzle_diameter  = preset_page->get_nozzle_diameter(result.extruder_id);
        }
        else {
            result.extruder_id = 0;
        }
        result.nozzle_volume_type = preset_page->get_nozzle_volume_type(result.extruder_id);
 
        obj->selected_cali_preset.push_back(result);
    }
 
    CaliPresetStage stage;
    preset_page->get_cali_stage(stage, obj->cache_flow_ratio);
 
    back_preset_info(obj, false);
}

References back_preset_info(), Slic3r::CaliPresetInfo::bed_type, Slic3r::MachineObject::cache_flow_ratio, curr_obj, Slic3r::CaliPresetInfo::extruder_id, Slic3r::CaliPresetInfo::filament_id, Slic3r::GUI::CalibrationPresetPage::get_cali_stage(), Slic3r::GUI::CalibrationPresetPage::get_extruder_id_by_tray_id(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_diameter(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_volume_type(), Slic3r::GUI::CalibrationPresetPage::get_selected_filaments(), Slic3r::GUI::get_tray_ams_and_slot_id(), Slic3r::MachineObject::is_multi_extruders(), Slic3r::CaliPresetInfo::name, Slic3r::CaliPresetInfo::nozzle_diameter, Slic3r::CaliPresetInfo::nozzle_volume_type, preset_step, Slic3r::MachineObject::selected_cali_preset, Slic3r::CaliPresetInfo::setting_id, and Slic3r::CaliPresetInfo::tray_id.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

create_pages()

void Slic3r::GUI::FlowRateWizard::create_pages ( )

protected

{
    add_page_step(start_step, [this] { return new CalibrationFlowRateStartPage(m_scrolledWindow); });
    add_page_step(preset_step, [this] { return new CalibrationPresetPage(m_scrolledWindow, m_mode, false); });
 
    // manual
    add_page_step(cali_coarse_step, [this] { return new CalibrationCaliPage(m_scrolledWindow, m_mode, CaliPageType::CALI_PAGE_CALI); });
    add_page_step(coarse_save_step, [this] { return new CalibrationFlowCoarseSavePage(m_scrolledWindow); });
    add_page_step(cali_fine_step, [this] { return new CalibrationCaliPage(m_scrolledWindow, m_mode, CaliPageType::CALI_PAGE_FINE_CALI); });
    add_page_step(fine_save_step, [this] { return new CalibrationFlowFineSavePage(m_scrolledWindow); });
 
    // auto
    add_page_step(cali_step, [this] { return new CalibrationCaliPage(m_scrolledWindow, m_mode); });
    add_page_step(save_step, [this] { return new CalibrationFlowX1SavePage(m_scrolledWindow); });
 
    add_build_step([this] {
        m_page_steps.push_back(start_step);
        m_page_steps.push_back(preset_step);
        m_page_steps.push_back(cali_coarse_step);
        m_page_steps.push_back(coarse_save_step);
        m_page_steps.push_back(cali_fine_step);
        m_page_steps.push_back(fine_save_step);
 
        //m_page_steps.push_back(cali_step);
        //m_page_steps.push_back(save_step);
 
        for (int i = 0; i < m_page_steps.size() - 1; i++) {
            m_page_steps[i]->chain(m_page_steps[i + 1]);
        }
 
        for (int i = 0; i < m_page_steps.size(); i++) {
            m_page_steps[i]->page->Bind(EVT_CALI_ACTION, &FlowRateWizard::on_cali_action, this);
        }
 
        cali_step->page->Bind(EVT_CALI_ACTION, &FlowRateWizard::on_cali_action, this);
        save_step->page->Bind(EVT_CALI_ACTION, &FlowRateWizard::on_cali_action, this);
 
        if (!m_page_steps.empty())
            show_step(m_page_steps.front());
 
        set_cali_method(CalibrationMethod::CALI_METHOD_MANUAL);
    });
}

References Slic3r::GUI::StagedBuild::add_build_step(), Slic3r::GUI::CalibrationWizard::add_page_step(), Slic3r::GUI::CalibrationWizard::cali_coarse_step, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_PAGE_CALI, Slic3r::GUI::CALI_PAGE_FINE_CALI, Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::GUI::CalibrationWizard::coarse_save_step, Slic3r::GUI::CalibrationWizard::fine_save_step, Slic3r::GUI::CalibrationWizard::m_mode, Slic3r::GUI::CalibrationWizard::m_page_steps, Slic3r::GUI::CalibrationWizard::m_scrolledWindow, on_cali_action(), Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::save_step, set_cali_method(), Slic3r::GUI::CalibrationWizard::show_step(), and Slic3r::GUI::CalibrationWizard::start_step.

Referenced by FlowRateWizard().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_index_key_value()

std::map< std::string, ConfigIndexValue > Slic3r::GUI::FlowRateWizard::generate_index_key_value ( MachineObject * obj, const std::string & key, float value )

protected

{
    std::map<std::string, ConfigIndexValue> key_value_map;
    if (!obj)
        return key_value_map;
 
    std::map<int, TrayInfo> selected_filaments = get_cached_selected_filament_for_multi_extruder(obj);
    int  index = 0;
    if (!selected_filaments.empty()) {
        TrayInfo tray_info = selected_filaments.begin()->second;
        // todo multi_extruder: get_extruder_type from obj
        ExtruderType extruder_type = ExtruderType::etDirectDrive;
        index = get_index_for_extruder_parameter(tray_info.preset->config, "filament_flow_ratio", tray_info.extruder_id, extruder_type, tray_info.nozzle_volume_type);
        ConfigIndexValue config_value;
        config_value.index = index;
        config_value.value = value;
        key_value_map.insert(std::make_pair("filament_flow_ratio", config_value));
    }
 
    return key_value_map;
}

References Slic3r::Preset::config, Slic3r::etDirectDrive, Slic3r::GUI::TrayInfo::extruder_id, Slic3r::GUI::get_cached_selected_filament_for_multi_extruder(), Slic3r::get_index_for_extruder_parameter(), Slic3r::GUI::ConfigIndexValue::index, Slic3r::GUI::TrayInfo::nozzle_volume_type, Slic3r::GUI::TrayInfo::preset, and Slic3r::GUI::ConfigIndexValue::value.

Referenced by on_cali_save(), and on_cali_start().

Here is the call graph for this function:

Here is the caller graph for this function:

get_calibration_mode()

CalibMode Slic3r::GUI::CalibrationWizard::get_calibration_mode ( )

inlineinherited

{ return m_mode; }

References m_mode.

get_curr_step()

CalibrationWizardPageStep * Slic3r::GUI::CalibrationWizard::get_curr_step ( )

inlineinherited

{ return m_curr_step; }

References m_curr_step.

Referenced by on_cali_go_home().

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::CalibrationWizard::msw_rescale ( )

inherited

{
    for (int i = 0; i < m_page_steps.size(); i++) {
        if (m_page_steps[i]->page)
            m_page_steps[i]->page->msw_rescale();
    }
}

References m_page_steps.

on_cali_action()

void Slic3r::GUI::FlowRateWizard::on_cali_action ( wxCommandEvent & evt )

protected

{
    CaliPageActionType action = static_cast<CaliPageActionType>(evt.GetInt());
    if (action == CaliPageActionType::CALI_ACTION_MANAGE_RESULT) {
        ;
    }
    else if (action == CaliPageActionType::CALI_ACTION_MANUAL_CALI) {
        preset_step->page->set_cali_filament_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
        this->set_cali_method(CalibrationMethod::CALI_METHOD_MANUAL);
        preset_step->page->on_device_connected(curr_obj);
        show_step(m_curr_step->next);
    }
    else if (action == CaliPageActionType::CALI_ACTION_AUTO_CALI) {
        CalibrationFilamentMode fila_mode = get_cali_filament_mode(curr_obj, m_mode);
        preset_step->page->set_cali_filament_mode(fila_mode);
        this->set_cali_method(CalibrationMethod::CALI_METHOD_AUTO);
        preset_step->page->on_device_connected(curr_obj);
        show_step(m_curr_step->next);
    }
    else if (action == CaliPageActionType::CALI_ACTION_NEXT) {
        show_step(m_curr_step->next);
    }
    else if (action == CaliPageActionType::CALI_ACTION_CALI_NEXT) {
        show_step(m_curr_step->next);
    }
    else if (action == CaliPageActionType::CALI_ACTION_PREV) {
        show_step(m_curr_step->prev);
    }
    else if (action == CaliPageActionType::CALI_ACTION_CALI) {
        if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO) {
            on_cali_start();
        }
        else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            CaliPresetStage stage = CaliPresetStage::CALI_MANULA_STAGE_NONE;
            float cali_value = 0.0f;
            static_cast<CalibrationPresetPage*>(preset_step->page)->get_cali_stage(stage, cali_value);
            on_cali_start(stage, cali_value, FlowRatioCaliSource::FROM_PRESET_PAGE);
            if (stage == CaliPresetStage::CALI_MANUAL_STAGE_2) {
                // set next step page
                m_curr_step->chain(cali_fine_step);
            }
            // automatically jump to next step when print job is sending finished.
        }
        else {
            on_cali_start();
        }
    }
    else if (action == CaliPageActionType::CALI_ACTION_FLOW_CALI_STAGE_2) {
        if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            float new_flow_ratio = 0.0f;
            wxString temp_name = ""; // unused
            auto coarse_save_page = static_cast<CalibrationFlowCoarseSavePage*>(m_curr_step->page);
            if (!coarse_save_page->get_result(&new_flow_ratio, &temp_name)) {
                return;
            }
            on_cali_start(CaliPresetStage::CALI_MANUAL_STAGE_2, new_flow_ratio, FlowRatioCaliSource::FROM_COARSE_PAGE);
            // automatically jump to next step when print job is sending finished.
        }
    }
    else if (action == CaliPageActionType::CALI_ACTION_FLOW_SAVE) {
        on_cali_save();
    }
    else if (action == CaliPageActionType::CALI_ACTION_FLOW_COARSE_SAVE) {
        auto coarse_save_page = static_cast<CalibrationFlowCoarseSavePage*>(coarse_save_step->page);
        if (coarse_save_page->is_skip_fine_calibration()) {
            on_cali_save();
        }
    }
    else if (action == CaliPageActionType::CALI_ACTION_FLOW_FINE_SAVE) {
        on_cali_save();
    }
    else if (action == CaliPageActionType::CALI_ACTION_GO_HOME) {
        on_cali_go_home();
    }
}

References Slic3r::GUI::CALI_ACTION_AUTO_CALI, Slic3r::GUI::CALI_ACTION_CALI, Slic3r::GUI::CALI_ACTION_CALI_NEXT, Slic3r::GUI::CALI_ACTION_FLOW_CALI_STAGE_2, Slic3r::GUI::CALI_ACTION_FLOW_COARSE_SAVE, Slic3r::GUI::CALI_ACTION_FLOW_FINE_SAVE, Slic3r::GUI::CALI_ACTION_FLOW_SAVE, Slic3r::GUI::CALI_ACTION_GO_HOME, Slic3r::GUI::CALI_ACTION_MANAGE_RESULT, Slic3r::GUI::CALI_ACTION_MANUAL_CALI, Slic3r::GUI::CALI_ACTION_NEXT, Slic3r::GUI::CALI_ACTION_PREV, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::GUI::CALI_MANUAL_STAGE_2, Slic3r::GUI::CALI_MANULA_STAGE_NONE, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_MODEL_SINGLE, Slic3r::GUI::CalibrationWizard::coarse_save_step, Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::FROM_COARSE_PAGE, Slic3r::GUI::FROM_PRESET_PAGE, Slic3r::GUI::get_cali_filament_mode(), Slic3r::GUI::CalibrationWizard::m_cali_method, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::m_mode, Slic3r::GUI::CalibrationWizard::on_cali_go_home(), on_cali_save(), on_cali_start(), Slic3r::GUI::CalibrationWizard::preset_step, set_cali_method(), and Slic3r::GUI::CalibrationWizard::show_step().

Referenced by create_pages().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_go_home()

void Slic3r::GUI::CalibrationWizard::on_cali_go_home ( )

protectedinherited

{
    // can go home? confirm to continue
    CalibrationMethod method;
    int cali_stage = 0;
    CalibMode obj_cali_mode = get_obj_calibration_mode(curr_obj, method, cali_stage);
 
    bool double_confirm = false;
    CaliPageType page_type = get_curr_step()->page->get_page_type();
    if (page_type == CaliPageType::CALI_PAGE_COARSE_SAVE ||
        page_type == CaliPageType::CALI_PAGE_FINE_SAVE ||
        page_type == CaliPageType::CALI_PAGE_COMMON_SAVE ||
        page_type == CaliPageType::CALI_PAGE_FLOW_SAVE ||
        page_type == CaliPageType::CALI_PAGE_PA_SAVE) {
        double_confirm = true;
    }
    if (obj_cali_mode == m_mode && curr_obj && (curr_obj->is_in_printing() || double_confirm)) {
        if (go_home_dialog == nullptr)
            go_home_dialog = new SecondaryCheckDialog(this, wxID_ANY, _L("Confirm"));
 
        go_home_dialog->Bind(EVT_SECONDARY_CHECK_CONFIRM, [this](wxCommandEvent &e) {
            if (curr_obj) {
                curr_obj->command_task_abort();
            } else {
                assert(false);
            }
            if (!m_page_steps.empty()) {
                back_preset_info(curr_obj, true);
                show_step(m_page_steps.front());
            }
        });
 
        go_home_dialog->update_text(_L("Are you sure to cancel the current calibration and return to the home page?"));
        go_home_dialog->on_show();
    } else {
        if (!m_page_steps.empty()) {
            back_preset_info(curr_obj, true, obj_cali_mode == m_mode);
            show_step(m_page_steps.front());
        }
    }
}

References _L, back_preset_info(), Slic3r::GUI::CALI_PAGE_COARSE_SAVE, Slic3r::GUI::CALI_PAGE_COMMON_SAVE, Slic3r::GUI::CALI_PAGE_FINE_SAVE, Slic3r::GUI::CALI_PAGE_FLOW_SAVE, Slic3r::GUI::CALI_PAGE_PA_SAVE, curr_obj, get_curr_step(), Slic3r::GUI::get_obj_calibration_mode(), Slic3r::GUI::CalibrationWizardPage::get_page_type(), go_home_dialog, m_mode, m_page_steps, Slic3r::GUI::CalibrationWizardPageStep::page, and show_step().

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_action(), and Slic3r::GUI::PressureAdvanceWizard::on_cali_action().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_job_finished() [1/2]

void Slic3r::GUI::CalibrationWizard::on_cali_job_finished ( wxCommandEvent & event )

inherited

{
    this->on_cali_job_finished(event.GetString());
    event.Skip();
}

References on_cali_job_finished().

Referenced by CalibrationWizard(), and on_cali_job_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_job_finished() [2/2]

void Slic3r::GUI::FlowRateWizard::on_cali_job_finished ( wxString evt_data )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizard.

{
    int       cali_stage = 0;
    CalibMode obj_cali_mode = CalibUtils::get_calib_mode_by_name(evt_data.ToStdString(), cali_stage);
 
    if (obj_cali_mode == m_mode) {
        if (cali_stage == 1) {
            if (m_curr_step != cali_coarse_step)
                show_step(cali_coarse_step);
            // change ui, hide
            static_cast<CalibrationPresetPage*>(preset_step->page)->on_cali_finished_job();
        }
        else if (cali_stage == 2) {
            if (m_curr_step != cali_fine_step) {
                show_step(cali_fine_step);
            }
            // change ui, hide
            static_cast<CalibrationPresetPage*>(preset_step->page)->on_cali_finished_job();
            static_cast<CalibrationFlowCoarseSavePage*>(coarse_save_step->page)->on_cali_finished_job();
        }
        else
            show_step(cali_coarse_step);
    }
}

References Slic3r::GUI::CalibrationWizard::cali_coarse_step, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::GUI::CalibrationWizard::coarse_save_step, Slic3r::GUI::CalibUtils::get_calib_mode_by_name(), Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::m_mode, Slic3r::GUI::CalibrationWizard::preset_step, and Slic3r::GUI::CalibrationWizard::show_step().

Here is the call graph for this function:

on_cali_save()

void Slic3r::GUI::FlowRateWizard::on_cali_save ( )

protected

{
    if (curr_obj) {
        if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO) {
            std::vector<std::pair<wxString, float>> new_results;
            auto save_page = static_cast<CalibrationFlowX1SavePage*>(save_step->page);
            if (!save_page->get_result(new_results)) {
                return;
            }
            if (save_page->is_all_failed()) {
                MessageDialog msg_dlg(nullptr, _L("The failed test result has been dropped."), wxEmptyString, wxOK);
                msg_dlg.ShowModal();
                back_preset_info(curr_obj, true);
                show_step(start_step);
                return;
            }
 
            std::string old_preset_name;
            CalibrationPresetPage* preset_page = (static_cast<CalibrationPresetPage*>(preset_step->page));
            std::map<int, Preset*> selected_filaments = get_cached_selected_filament(curr_obj);
            if (!selected_filaments.empty()) {
                old_preset_name = selected_filaments.begin()->second->name;
            }
            for (int i = 0; i < new_results.size(); i++) {
                std::map<std::string, ConfigOption*> key_value_map;
                key_value_map.insert(std::make_pair("filament_flow_ratio", new ConfigOptionFloatsNullable{ new_results[i].second }));
                wxString message;
                if (!save_preset(old_preset_name, into_u8(new_results[i].first), key_value_map, message)) {
                    MessageDialog error_msg_dlg(nullptr, message, wxEmptyString, wxICON_WARNING | wxOK);
                    error_msg_dlg.ShowModal();
                    return;
                }
            }
 
            MessageDialog msg_dlg(nullptr, _L("Flow rate calibration result has been saved to preset."), wxEmptyString, wxOK);
            msg_dlg.ShowModal();
        }
        else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
            float new_flow_ratio = 0.0f;
            wxString new_preset_name = "";
            if(m_curr_step->page->get_page_type() == CaliPageType::CALI_PAGE_COARSE_SAVE)
            {
                auto coarse_save_page = static_cast<CalibrationFlowCoarseSavePage*>(m_curr_step->page);
                if (!coarse_save_page->get_result(&new_flow_ratio, &new_preset_name)) {
                    BOOST_LOG_TRIVIAL(info) << "flow_rate_cali: get coarse result failed";
                    return;
                }
            }
            else if (m_curr_step->page->get_page_type() == CaliPageType::CALI_PAGE_FINE_SAVE)
            {
                auto fine_save_page = static_cast<CalibrationFlowFineSavePage*>(m_curr_step->page);
                if (!fine_save_page->get_result(&new_flow_ratio, &new_preset_name)) {
                    BOOST_LOG_TRIVIAL(info) << "flow_rate_cali: get fine result failed";
                    return;
                }
            }
            else {
                BOOST_LOG_TRIVIAL(info) << "flow_rate_cali: get result failed, not get result";
                return;
            }
 
            if (!CalibUtils::validate_input_name(new_preset_name))
                return;
 
            std::string old_preset_name;
            CalibrationPresetPage* preset_page = (static_cast<CalibrationPresetPage*>(preset_step->page));
            std::map<int, TrayInfo> selected_filaments = get_cached_selected_filament_for_multi_extruder(curr_obj);
            std::map<std::string, ConfigIndexValue> key_value_map = generate_index_key_value(curr_obj, "filament_flow_ratio", new_flow_ratio);
 
            if (!selected_filaments.empty()) {
                old_preset_name = selected_filaments.begin()->second.preset->name;
            }
 
            wxString message;
            if (!save_preset_with_index(old_preset_name, into_u8(new_preset_name), key_value_map, message)) {
                MessageDialog error_msg_dlg(nullptr, message, wxEmptyString, wxICON_WARNING | wxOK);
                error_msg_dlg.ShowModal();
                return;
            }
 
            MessageDialog msg_dlg(nullptr, _L("Flow rate calibration result has been saved to preset."), wxEmptyString, wxOK);
            msg_dlg.ShowModal();
        }
        else {
            assert(false);
        }
    }
    back_preset_info(curr_obj, true);
    show_step(start_step);
}

References _L, Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_PAGE_COARSE_SAVE, Slic3r::GUI::CALI_PAGE_FINE_SAVE, Slic3r::GUI::CalibrationWizard::curr_obj, generate_index_key_value(), Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::get_cached_selected_filament_for_multi_extruder(), Slic3r::GUI::into_u8(), Slic3r::GUI::CalibrationWizard::m_cali_method, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::save_preset(), Slic3r::GUI::CalibrationWizard::save_preset_with_index(), Slic3r::GUI::CalibrationWizard::save_step, Slic3r::GUI::CalibrationWizard::show_step(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::CalibrationWizard::start_step, and Slic3r::GUI::CalibUtils::validate_input_name().

Referenced by on_cali_action().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_start()

void Slic3r::GUI::FlowRateWizard::on_cali_start ( CaliPresetStage stage = CaliPresetStage::CALI_MANULA_STAGE_NONE, float cali_value = 0.0f, FlowRatioCaliSource from_page = FlowRatioCaliSource::FROM_PRESET_PAGE )

protected

{
    if (!curr_obj) return;
 
    //clean flow rate result
    curr_obj->reset_flow_rate_cali_result();
 
    float nozzle_dia = 0.4;
    std::string setting_id;
    BedType plate_type = BedType::btDefault;
 
    CalibrationPresetPage* preset_page = (static_cast<CalibrationPresetPage*>(preset_step->page));
 
    preset_page->get_preset_info(nozzle_dia, plate_type);
 
    std::map<int, Preset*> selected_filaments = preset_page->get_selected_filaments();
    if (from_page == FlowRatioCaliSource::FROM_PRESET_PAGE) {
        if (selected_filaments.empty()) {
            MessageDialog msg_dlg(nullptr, _L("Please select filament to calibrate."), wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
        CalibrationWizard::cache_preset_info(curr_obj, nozzle_dia, plate_type);
    }
    else if (from_page == FlowRatioCaliSource::FROM_COARSE_PAGE) {
        selected_filaments = get_cached_selected_filament(curr_obj);
        if (selected_filaments.empty()) {
            MessageDialog msg_dlg(nullptr, _L("Please select filament to calibrate."), wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
        cache_coarse_info(curr_obj);
    }
 
    if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO) {
        X1CCalibInfos calib_infos;
        for (auto& item : selected_filaments) {
            int nozzle_temp = -1;
            int bed_temp = -1;
            float max_volumetric_speed = -1;
 
            if (!get_preset_info(item.second->config, plate_type, nozzle_temp, bed_temp, max_volumetric_speed)) {
                BOOST_LOG_TRIVIAL(error) << "CaliPreset: get preset info error";
            }
 
            X1CCalibInfos::X1CCalibInfo calib_info;
            calib_info.tray_id          = item.first;
            get_tray_ams_and_slot_id(curr_obj, item.first, calib_info.ams_id, calib_info.slot_id, calib_info.tray_id);
            calib_info.extruder_id      = preset_page->get_extruder_id_by_tray_id(item.first);
            calib_info.extruder_type    = preset_page->get_extruder_type(calib_info.extruder_id);
            calib_info.nozzle_volume_type = preset_page->get_nozzle_volume_type(calib_info.extruder_id);
            calib_info.nozzle_diameter  = preset_page->get_nozzle_diameter(calib_info.extruder_id);
            calib_info.filament_id      = item.second->filament_id;
            calib_info.setting_id       = item.second->setting_id;
            calib_info.bed_temp         = bed_temp;
            calib_info.nozzle_temp      = nozzle_temp;
            calib_info.max_volumetric_speed = max_volumetric_speed;
            float flow_ratio = 0.98;
            if (get_flow_ratio(item.second->config, flow_ratio))
                calib_info.flow_rate = flow_ratio;
            calib_infos.calib_datas.push_back(calib_info);
        }
        calib_infos.cali_mode = CalibMode::Calib_Flow_Rate;
 
        wxString wx_err_string;
        CalibUtils::calib_flowrate_X1C(calib_infos, wx_err_string);
        if (!wx_err_string.empty()) {
            MessageDialog msg_dlg(nullptr, wx_err_string, wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
        show_step(m_curr_step->next);
 
        CalibrationCaliPage *cali_page = (static_cast<CalibrationCaliPage *>(cali_step->page));
        cali_page->clear_last_job_status();
    }
    else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
        CalibrationFlowCoarseSavePage* coarse_page = (static_cast<CalibrationFlowCoarseSavePage*>(coarse_save_step->page));
        CalibInfo calib_info;
        calib_info.dev_id            = curr_obj->get_dev_id();
        Preset* temp_filament_preset = nullptr;
        int cali_stage = -1;
        wxString wx_err_string;
 
        // Recover to coarse and start fine print, should recover the selected_filaments
        CalibrationMethod temp_method;
        int temp_cali_tage = 0;
        CalibMode obj_cali_mode = get_obj_calibration_mode(curr_obj, temp_method, temp_cali_tage);
        if (selected_filaments.empty() && stage == CaliPresetStage::CALI_MANUAL_STAGE_2 && obj_cali_mode == CalibMode::Calib_Flow_Rate) {
            if (!curr_obj->selected_cali_preset.empty()) {
                int selected_tray_id = curr_obj->selected_cali_preset.front().tray_id;
                PresetCollection *filament_presets = &wxGetApp().preset_bundle->filaments;
                Preset* preset = filament_presets->find_preset(curr_obj->selected_cali_preset.front().name);
                plate_type = curr_obj->selected_cali_preset.front().bed_type;
                if (preset) {
                    selected_filaments.insert(std::make_pair(selected_tray_id, preset));
                }
            }
        }
 
        if (!selected_filaments.empty()) {
            int selected_tray_id  = 0;
            get_tray_ams_and_slot_id(curr_obj, selected_filaments.begin()->first, calib_info.ams_id, calib_info.slot_id, selected_tray_id);
            calib_info.select_ams         = std::to_string(selected_tray_id);
            calib_info.extruder_id = preset_page->get_extruder_id_by_tray_id(selected_filaments.begin()->first);
            if (from_page == FlowRatioCaliSource::FROM_COARSE_PAGE) {
                // The fine pass must run on the extruder the coarse pass used. The cache records it;
                // the preset page's selection may have changed or been reset since.
                const auto cached = get_cached_selected_filament_for_multi_extruder(curr_obj);
                const auto it     = cached.find(selected_filaments.begin()->first);
                if (it != cached.end())
                    calib_info.extruder_id = it->second.extruder_id;
            }
            calib_info.extruder_type      = preset_page->get_extruder_type(calib_info.extruder_id);
            calib_info.nozzle_volume_type = preset_page->get_nozzle_volume_type(calib_info.extruder_id);
            calib_info.nozzle_diameter    = preset_page->get_nozzle_diameter(calib_info.extruder_id);
            Preset* preset = selected_filaments.begin()->second;
            temp_filament_preset = new Preset(preset->type, preset->name + "_temp");
            temp_filament_preset->config = preset->config;
            if (preset->type == Preset::TYPE_FILAMENT)
                temp_filament_preset->filament_id = preset->filament_id;
 
            calib_info.bed_type = plate_type;
            calib_info.printer_prest = preset_page->get_printer_preset(curr_obj, preset_page->get_nozzle_diameter(calib_info.extruder_id));
            calib_info.print_prest = preset_page->get_print_preset();
            calib_info.params.mode = CalibMode::Calib_Flow_Rate;
 
            if (stage == CaliPresetStage::CALI_MANUAL_STAGE_1) {
                cali_stage = 1;
                calib_info.process_bar = preset_page->get_sending_progress_bar();
            }
            else if (stage == CaliPresetStage::CALI_MANUAL_STAGE_2) {
                cali_stage = 2;
                auto flow_ratio_values = temp_filament_preset->config.option<ConfigOptionFloatsNullable>("filament_flow_ratio")->values;
                std::map<std::string, ConfigIndexValue> key_value_map = generate_index_key_value(curr_obj, "filament_flow_ratio", cali_value);
                if (!key_value_map.empty()) {
                    flow_ratio_values[key_value_map.begin()->second.index] = key_value_map.begin()->second.value;
                }
 
                temp_filament_preset->config.set_key_value("filament_flow_ratio", new ConfigOptionFloatsNullable{flow_ratio_values});
                if (from_page == FlowRatioCaliSource::FROM_PRESET_PAGE) {
                    calib_info.process_bar = preset_page->get_sending_progress_bar();
                }
                else if (from_page == FlowRatioCaliSource::FROM_COARSE_PAGE) {
                    calib_info.process_bar = coarse_page->get_sending_progress_bar();
                }
            }
            calib_info.filament_prest = temp_filament_preset;
 
            std::map<int, DynamicPrintConfig> filament_list = preset_page->get_filament_ams_list();
            calib_info.filament_color = filament_list[selected_filaments.begin()->first].opt_string("filament_colour", 0u);
 
            if (cali_stage > 0) {
                if (!CalibUtils::calib_flowrate(cali_stage, calib_info, wx_err_string)) {
                    if (!wx_err_string.empty()) {
                        MessageDialog msg_dlg(nullptr, wx_err_string, wxEmptyString, wxICON_WARNING | wxOK);
                        msg_dlg.ShowModal();
                    }
                    return;
                }
            }
            else {
                wx_err_string = _L("Internal Error") + wxString(": Invalid calibration stage");
            }
        } else {
            wx_err_string = _L("Please select at least one filament for calibration");
        }
 
        if (!wx_err_string.empty()) {
            MessageDialog msg_dlg(nullptr, wx_err_string, wxEmptyString, wxICON_WARNING | wxOK);
            msg_dlg.ShowModal();
            return;
        }
        if (temp_filament_preset)
            delete temp_filament_preset;
 
        if (cali_stage == 1) {
            CalibrationCaliPage *cali_coarse_page = (static_cast<CalibrationCaliPage *>(cali_coarse_step->page));
            cali_coarse_page->clear_last_job_status();
            preset_page->on_cali_start_job();
        }
        else if (cali_stage == 2) {
            CalibrationCaliPage *cali_fine_page = (static_cast<CalibrationCaliPage *>(cali_fine_step->page));
            cali_fine_page->clear_last_job_status();
            if (from_page == FlowRatioCaliSource::FROM_PRESET_PAGE) {
                preset_page->on_cali_start_job();
            }
            else if (from_page == FlowRatioCaliSource::FROM_COARSE_PAGE) {
                coarse_page->on_cali_start_job();
            }
        }
    } else {
        assert(false);
    }
}

References _L, Slic3r::GUI::CalibInfo::ams_id, Slic3r::X1CCalibInfos::X1CCalibInfo::ams_id, Slic3r::X1CCalibInfos::X1CCalibInfo::bed_temp, Slic3r::GUI::CalibInfo::bed_type, Slic3r::btDefault, cache_coarse_info(), Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::CalibrationWizard::cali_coarse_step, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::GUI::CALI_MANUAL_STAGE_1, Slic3r::GUI::CALI_MANUAL_STAGE_2, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::X1CCalibInfos::cali_mode, Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::X1CCalibInfos::calib_datas, Slic3r::Calib_Flow_Rate, Slic3r::GUI::CalibUtils::calib_flowrate(), Slic3r::GUI::CalibUtils::calib_flowrate_X1C(), Slic3r::GUI::CalibrationCaliPage::clear_last_job_status(), Slic3r::GUI::CalibrationWizard::coarse_save_step, Slic3r::Preset::config, Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::CalibInfo::dev_id, Slic3r::GUI::CalibInfo::extruder_id, Slic3r::X1CCalibInfos::X1CCalibInfo::extruder_id, Slic3r::GUI::CalibInfo::extruder_type, Slic3r::X1CCalibInfos::X1CCalibInfo::extruder_type, Slic3r::GUI::CalibInfo::filament_color, Slic3r::Preset::filament_id, Slic3r::X1CCalibInfos::X1CCalibInfo::filament_id, Slic3r::GUI::CalibInfo::filament_prest, Slic3r::PresetCollection::find_preset(), Slic3r::X1CCalibInfos::X1CCalibInfo::flow_rate, Slic3r::GUI::FROM_COARSE_PAGE, Slic3r::GUI::FROM_PRESET_PAGE, generate_index_key_value(), Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::get_cached_selected_filament_for_multi_extruder(), Slic3r::GUI::CalibrationPresetPage::get_extruder_id_by_tray_id(), Slic3r::GUI::CalibrationPresetPage::get_extruder_type(), Slic3r::GUI::CalibrationPresetPage::get_filament_ams_list(), Slic3r::GUI::get_flow_ratio(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_diameter(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_volume_type(), Slic3r::GUI::get_obj_calibration_mode(), Slic3r::GUI::CalibrationPresetPage::get_preset_info(), Slic3r::GUI::get_preset_info(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::GUI::CalibrationPresetPage::get_printer_preset(), Slic3r::GUI::CalibrationPresetPage::get_selected_filaments(), Slic3r::GUI::CalibrationFlowCoarseSavePage::get_sending_progress_bar(), Slic3r::GUI::CalibrationPresetPage::get_sending_progress_bar(), Slic3r::GUI::get_tray_ams_and_slot_id(), Slic3r::GUI::CalibrationWizard::m_cali_method, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::X1CCalibInfos::X1CCalibInfo::max_volumetric_speed, Slic3r::Calib_Params::mode, Slic3r::Preset::name, Slic3r::GUI::CalibInfo::nozzle_diameter, Slic3r::X1CCalibInfos::X1CCalibInfo::nozzle_diameter, Slic3r::X1CCalibInfos::X1CCalibInfo::nozzle_temp, Slic3r::GUI::CalibInfo::nozzle_volume_type, Slic3r::X1CCalibInfos::X1CCalibInfo::nozzle_volume_type, Slic3r::GUI::CalibrationFlowCoarseSavePage::on_cali_start_job(), Slic3r::GUI::CalibrationPresetPage::on_cali_start_job(), Slic3r::ConfigBase::option(), Slic3r::GUI::CalibInfo::params, Slic3r::Preset, Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::CalibInfo::printer_prest, Slic3r::GUI::CalibInfo::process_bar, Slic3r::GUI::CalibInfo::select_ams, Slic3r::DynamicConfig::set_key_value(), Slic3r::X1CCalibInfos::X1CCalibInfo::setting_id, Slic3r::GUI::CalibrationWizard::show_step(), Slic3r::GUI::DPIAware< P >::ShowModal(), Slic3r::GUI::CalibInfo::slot_id, Slic3r::X1CCalibInfos::X1CCalibInfo::slot_id, Slic3r::X1CCalibInfos::X1CCalibInfo::tray_id, Slic3r::Preset::type, and Slic3r::Preset::TYPE_FILAMENT.

Referenced by on_cali_action().

Here is the call graph for this function:

Here is the caller graph for this function:

on_device_connected()

void Slic3r::GUI::FlowRateWizard::on_device_connected ( MachineObject * obj )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::CalibrationWizard.

{
    CalibrationWizard::on_device_connected(obj);
 
    CalibrationMethod method;
    int cali_stage = 0;
    CalibMode obj_cali_mode = get_obj_calibration_mode(obj, method, cali_stage);
 
    // show cali step when obj is in pa calibration
    if (obj) {
        this->set_cali_method(method);
        if (obj_cali_mode == m_mode) {
            if (!obj->cali_finished && (obj->is_in_printing() || obj->is_printing_finished())) {
                if (method == CalibrationMethod::CALI_METHOD_MANUAL) {
                    if (cali_stage == 1) {
                        if (m_curr_step != cali_coarse_step)
                            show_step(cali_coarse_step);
                    }
                    else if (cali_stage == 2) {
                        if (m_curr_step != cali_fine_step) {
                            show_step(cali_fine_step);
                        }
                    }
                    else
                        show_step(cali_coarse_step);
                }
                else if (method == CalibrationMethod::CALI_METHOD_AUTO) {
                    if (m_curr_step != cali_step)
                        show_step(cali_step);
                }
            }
        }
    }
}

References Slic3r::GUI::CalibrationWizard::cali_coarse_step, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::MachineObject::cali_finished, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::GUI::get_obj_calibration_mode(), Slic3r::MachineObject::is_in_printing(), Slic3r::MachineObject::is_printing_finished(), Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::m_mode, Slic3r::GUI::CalibrationWizard::on_device_connected(), set_cali_method(), and Slic3r::GUI::CalibrationWizard::show_step().

Here is the call graph for this function:

on_sys_color_changed()

void Slic3r::GUI::CalibrationWizard::on_sys_color_changed ( )

inherited

{
    for (int i = 0; i < m_page_steps.size(); i++) {
        if (m_page_steps[i]->page)
            m_page_steps[i]->page->on_sys_color_changed();
    }
}

References m_page_steps.

recover_preset_info()

void Slic3r::GUI::CalibrationWizard::recover_preset_info ( MachineObject * obj )

virtualinherited

{
    std::vector<PrinterCaliInfo> back_infos = wxGetApp().app_config->get_printer_cali_infos();
    for (const auto& back_info : back_infos) {
        if (obj && (obj->get_dev_id() == back_info.dev_id) ) {
            obj->set_dev_id(back_info.dev_id);
            obj->cali_finished    = back_info.cali_finished;
            obj->cache_flow_ratio = back_info.cache_flow_ratio;
            obj->selected_cali_preset = back_info.selected_presets;
            obj->flow_ratio_calibration_type = back_info.cache_flow_rate_calibration_type;
        }
    }
}

References Slic3r::MachineObject::cache_flow_ratio, Slic3r::MachineObject::cali_finished, Slic3r::MachineObject::flow_ratio_calibration_type, Slic3r::MachineObject::get_dev_id(), Slic3r::MachineObject::selected_cali_preset, and Slic3r::MachineObject::set_dev_id().

Referenced by on_device_connected().

Here is the call graph for this function:

Here is the caller graph for this function:

save_preset()

bool Slic3r::GUI::CalibrationWizard::save_preset ( const std::string & old_preset_name, const std::string & new_preset_name, const std::map< std::string, ConfigOption * > & key_values, wxString & message )

inherited

{
    if (new_preset_name.empty()) {
        message = _L("The name cannot be empty.");
        return false;
    }
 
    PresetCollection *filament_presets = &wxGetApp().preset_bundle->filaments;
    Preset* preset = filament_presets->find_preset(old_preset_name);
    if (!preset) {
        message = wxString::Format(_L("The selected preset: %s was not found."), old_preset_name);
        return false;
    }
 
    Preset temp_preset = *preset;
 
    std::string new_name = filament_presets->get_preset_name_by_alias(new_preset_name);
    bool exist_preset = false;
    // If name is current, get the editing preset
    Preset *new_preset = filament_presets->find_preset(new_name);
    if (new_preset) {
        if (new_preset->is_system) {
            message = _L("The name cannot be the same as the system preset name.");
            return false;
        }
 
        if (new_preset != preset) {
            message = _L("The name is the same as another existing preset name");
            return false;
        }
        if (new_preset != &filament_presets->get_edited_preset()) new_preset = &temp_preset;
        exist_preset = true;
    } else {
        new_preset = &temp_preset;
    }
 
    for (auto item : key_values) {
        new_preset->config.set_key_value(item.first, item.second);
    }
 
    // Save the preset into Slic3r::data_dir / presets / section_name / preset_name.ini
    filament_presets->save_current_preset(new_name, false, false, new_preset);
 
    // BBS create new settings
    new_preset = filament_presets->find_preset(new_name, false, true);
    // Preset* preset = &m_presets.preset(it - m_presets.begin(), true);
    if (!new_preset) {
        BOOST_LOG_TRIVIAL(info) << "create new preset failed";
        message = _L("create new preset failed.");
        return false;
    }
 
    // set sync_info for sync service
    if (exist_preset) {
        new_preset->sync_info = "update";
        BOOST_LOG_TRIVIAL(info) << "sync_preset: update preset = " << new_preset->name;
    } else {
        new_preset->sync_info = "create";
        if (wxGetApp().is_user_login()) new_preset->user_id = wxGetApp().getAgent()->get_user_id();
        BOOST_LOG_TRIVIAL(info) << "sync_preset: create preset = " << new_preset->name;
    }
    new_preset->save_info();
 
    // Mark the print & filament enabled if they are compatible with the currently selected preset.
    // If saving the preset changes compatibility with other presets, keep the now incompatible dependent presets selected, however with a "red flag" icon showing that they are
    // no more compatible.
    wxGetApp().preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
 
    // BBS if create a new prset name, preset changed from preset name to new preset name
    if (!exist_preset) { wxGetApp().plater()->sidebar().update_presets_from_to(Preset::Type::TYPE_FILAMENT, old_preset_name, new_preset->name); }
 
    // todo: zhimin
    // wxGetApp().mainframe->update_filament_tab_ui();
    return true;
}

References _L, Slic3r::Preset::config, Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_preset_name_by_alias(), Slic3r::Preset::is_system, Slic3r::Preset::name, Slic3r::Never, Slic3r::PresetCollection::save_current_preset(), Slic3r::Preset::save_info(), Slic3r::DynamicConfig::set_key_value(), Slic3r::Preset::sync_info, Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::user_id.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_save(), and Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save().

Here is the call graph for this function:

Here is the caller graph for this function:

save_preset_with_index()

bool Slic3r::GUI::CalibrationWizard::save_preset_with_index ( const std::string & old_preset_name, const std::string & new_preset_name, const std::map< std::string, ConfigIndexValue > & key_values, wxString & message )

inherited

{
    if (new_preset_name.empty()) {
        message = _L("The name cannot be empty.");
        return false;
    }
 
    PresetCollection *filament_presets = &wxGetApp().preset_bundle->filaments;
    Preset           *preset           = filament_presets->find_preset(old_preset_name);
    if (!preset) {
        message = wxString::Format(_L("The selected preset: %s was not found."), old_preset_name);
        return false;
    }
 
    Preset temp_preset = *preset;
 
    std::string new_name     = filament_presets->get_preset_name_by_alias(new_preset_name);
    bool        exist_preset = false;
    // If name is current, get the editing preset
    Preset *new_preset = filament_presets->find_preset(new_name);
    if (new_preset) {
        if (new_preset->is_system) {
            message = _L("The name cannot be the same as the system preset name.");
            return false;
        }
 
        if (new_preset != preset) {
            message = _L("The name is the same as another existing preset name");
            return false;
        }
        if (new_preset != &filament_presets->get_edited_preset())
            new_preset = &temp_preset;
        exist_preset = true;
    } else {
        new_preset = &temp_preset;
    }
 
    for (auto item : key_values) {
        auto config_opt = new_preset->config.option<ConfigOptionFloatsNullable>(item.first);
        if (config_opt) {
            auto& config_value = config_opt->values;
            config_value[item.second.index] = item.second.value;
        }
        else {
            message = wxString::Format(_L("Could not find parameter: %s."), item.first);
        }
    }
 
    // Save the preset into Slic3r::data_dir / presets / section_name / preset_name.ini
    filament_presets->save_current_preset(new_name, false, false, new_preset);
 
    // BBS create new settings
    new_preset = filament_presets->find_preset(new_name, false, true);
    // Preset* preset = &m_presets.preset(it - m_presets.begin(), true);
    if (!new_preset) {
        BOOST_LOG_TRIVIAL(info) << "create new preset failed";
        message = _L("create new preset failed.");
        return false;
    }
 
    // set sync_info for sync service
    if (exist_preset) {
        new_preset->sync_info = "update";
        BOOST_LOG_TRIVIAL(info) << "sync_preset: update preset = " << new_preset->name;
    } else {
        new_preset->sync_info = "create";
        if (wxGetApp().is_user_login()) new_preset->user_id = wxGetApp().getAgent()->get_user_id();
        BOOST_LOG_TRIVIAL(info) << "sync_preset: create preset = " << new_preset->name;
    }
    new_preset->save_info();
 
    // Mark the print & filament enabled if they are compatible with the currently selected preset.
    // If saving the preset changes compatibility with other presets, keep the now incompatible dependent presets selected, however with a "red flag" icon showing that they are
    // no more compatible.
    wxGetApp().preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
 
    // BBS if create a new prset name, preset changed from preset name to new preset name
    if (!exist_preset) { wxGetApp().plater()->sidebar().update_presets_from_to(Preset::Type::TYPE_FILAMENT, old_preset_name, new_preset->name); }
 
    return true;
}

References _L, Slic3r::Preset::config, Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_edited_preset(), Slic3r::PresetCollection::get_preset_name_by_alias(), Slic3r::Preset::is_system, Slic3r::Preset::name, Slic3r::Never, Slic3r::ConfigBase::option(), Slic3r::PresetCollection::save_current_preset(), Slic3r::Preset::save_info(), Slic3r::Preset::sync_info, Slic3r::Preset::TYPE_FILAMENT, and Slic3r::Preset::user_id.

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_save().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cali_method()

void Slic3r::GUI::FlowRateWizard::set_cali_method ( CalibrationMethod method )

overridevirtual

Reimplemented from Slic3r::GUI::CalibrationWizard.

{
    m_cali_method = method;
    if (method == CalibrationMethod::CALI_METHOD_AUTO || method == CalibrationMethod::CALI_METHOD_NEW_AUTO) {
        m_page_steps.clear();
        m_page_steps.push_back(start_step);
        m_page_steps.push_back(preset_step);
        m_page_steps.push_back(cali_step);
        m_page_steps.push_back(save_step);
 
        for (int i = 0; i < m_page_steps.size() - 1; i++) {
            m_page_steps[i]->chain(m_page_steps[i + 1]);
        }
    }
    else if (method == CalibrationMethod::CALI_METHOD_MANUAL) {
        m_page_steps.clear();
        m_page_steps.push_back(start_step);
        m_page_steps.push_back(preset_step);
        m_page_steps.push_back(cali_coarse_step);
        m_page_steps.push_back(coarse_save_step);
        m_page_steps.push_back(cali_fine_step);
        m_page_steps.push_back(fine_save_step);
 
        for (int i = 0; i < m_page_steps.size() - 1; i++) {
            m_page_steps[i]->chain(m_page_steps[i + 1]);
        }
    }
    else {
        assert(false);
    }
    CalibrationWizard::set_cali_method(method);
}

References Slic3r::GUI::CalibrationWizard::cali_coarse_step, Slic3r::GUI::CalibrationWizard::cali_fine_step, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_METHOD_NEW_AUTO, Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::GUI::CalibrationWizard::coarse_save_step, Slic3r::GUI::CalibrationWizard::fine_save_step, Slic3r::GUI::CalibrationWizard::m_cali_method, Slic3r::GUI::CalibrationWizard::m_page_steps, Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::save_step, Slic3r::GUI::CalibrationWizard::set_cali_method(), and Slic3r::GUI::CalibrationWizard::start_step.

Referenced by create_pages(), on_cali_action(), and on_device_connected().

Here is the call graph for this function:

Here is the caller graph for this function:

set_cali_style()

virtual void Slic3r::GUI::CalibrationWizard::set_cali_style ( CalibrationStyle style )

inlinevirtualinherited

                                                        {
        m_cali_style = style;
    }

References m_cali_style, and style.

show_step()

void Slic3r::GUI::CalibrationWizard::show_step ( CalibrationWizardPageStep * step )

inherited

{
    if (!step)
        return;
 
    if (m_curr_step) {
        m_curr_step->page->Hide();
    }
 
    m_curr_step = step;
 
    if (m_curr_step) {
        m_curr_step->page->Show();
    }
 
    Layout();
}

References m_curr_step.

Referenced by CalibrationWizard(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_action(), Slic3r::GUI::PressureAdvanceWizard::on_cali_action(), on_cali_go_home(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), Slic3r::GUI::PressureAdvanceWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), on_device_connected(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), and Slic3r::GUI::PressureAdvanceWizard::on_device_connected().

Here is the caller graph for this function:

unfinished_child()

StagedBuild * Slic3r::GUI::StagedBuild::unfinished_child ( ) const

inlineprivateinherited

    {
        auto it = std::find_if(m_children.begin(), m_children.end(), [](const StagedBuild* child) { return !child->built(); });
        return it == m_children.end() ? nullptr : *it;
    }

References m_children.

Referenced by build_step().

Here is the caller graph for this function:

update()

void Slic3r::GUI::FlowRateWizard::update ( MachineObject * obj )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::CalibrationWizard.

{
    CalibrationWizard::update(obj);
}

References Slic3r::GUI::CalibrationWizard::update().

Here is the call graph for this function:

Member Data Documentation

cali_coarse_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::cali_coarse_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

cali_fine_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::cali_fine_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

cali_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::cali_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), Slic3r::GUI::PressureAdvanceWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

coarse_save_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::coarse_save_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::cache_coarse_info(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_start(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

curr_obj

MachineObject* Slic3r::GUI::CalibrationWizard::curr_obj { nullptr }

protectedinherited

{ nullptr };

Referenced by cache_preset_info(), Slic3r::GUI::PressureAdvanceWizard::can_save_cali_result(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::PressureAdvanceWizard::on_cali_action(), on_cali_go_home(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), and update().

fine_save_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::fine_save_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

go_home_dialog

SecondaryCheckDialog* Slic3r::GUI::CalibrationWizard::go_home_dialog = nullptr

protectedinherited

Referenced by on_cali_go_home().

last_obj

MachineObject* Slic3r::GUI::CalibrationWizard::last_obj { nullptr }

protectedinherited

{ nullptr };

m_all_pages_sizer

wxBoxSizer* Slic3r::GUI::CalibrationWizard::m_all_pages_sizer

protectedinherited

Referenced by CalibrationWizard(), add_page_step(), and Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages().

m_cali_method

CalibrationMethod Slic3r::GUI::CalibrationWizard::m_cali_method { CalibrationMethod::CALI_METHOD_MANUAL }

protectedinherited

{ CalibrationMethod::CALI_METHOD_MANUAL };

Referenced by Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), set_cali_method(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

m_cali_style

CalibrationStyle Slic3r::GUI::CalibrationWizard::m_cali_style

protectedinherited

Referenced by set_cali_style().

m_children

std::vector<StagedBuild*> Slic3r::GUI::StagedBuild::m_children

privateinherited

Referenced by add_build_steps_of(), built(), and unfinished_child().

m_curr_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::m_curr_step { nullptr }

protectedinherited

{ nullptr };

Referenced by CalibrationWizard(), get_curr_step(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_action(), Slic3r::GUI::PressureAdvanceWizard::on_cali_action(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), Slic3r::GUI::PressureAdvanceWizard::on_device_connected(), and show_step().

m_mode

CalibMode Slic3r::GUI::CalibrationWizard::m_mode

protectedinherited

Referenced by CalibrationWizard(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), get_calibration_mode(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::PressureAdvanceWizard::on_cali_action(), on_cali_go_home(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), Slic3r::GUI::PressureAdvanceWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::FlowRateWizard::on_device_connected(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_device_connected(), and Slic3r::GUI::PressureAdvanceWizard::on_device_connected().

m_next_step

size_t Slic3r::GUI::StagedBuild::m_next_step { 0 }

privateinherited

{ 0 };

Referenced by add_build_steps_of(), build_step(), and built().

m_page_steps

std::vector<CalibrationWizardPageStep*> Slic3r::GUI::CalibrationWizard::m_page_steps

protectedinherited

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), msw_rescale(), on_cali_go_home(), on_device_connected(), on_sys_color_changed(), set_cali_method(), Slic3r::GUI::FlowRateWizard::set_cali_method(), and update().

m_scrolledWindow

wxScrolledWindow* Slic3r::GUI::CalibrationWizard::m_scrolledWindow

protectedinherited

Referenced by CalibrationWizard(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), and Slic3r::GUI::PressureAdvanceWizard::create_pages().

m_steps

std::vector<std::function<void()> > Slic3r::GUI::StagedBuild::m_steps

privateinherited

Referenced by add_build_step(), add_build_steps_of(), build_step(), and built().

preset_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::preset_step { nullptr }

protectedinherited

{ nullptr };

Referenced by cache_preset_info(), Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_action(), Slic3r::GUI::PressureAdvanceWizard::on_cali_action(), Slic3r::GUI::FlowRateWizard::on_cali_job_finished(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_job_finished(), Slic3r::GUI::PressureAdvanceWizard::on_cali_job_finished(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), Slic3r::GUI::FlowRateWizard::on_cali_start(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_start(), Slic3r::GUI::PressureAdvanceWizard::on_cali_start(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

save_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::save_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

start_step

CalibrationWizardPageStep* Slic3r::GUI::CalibrationWizard::start_step { nullptr }

protectedinherited

{ nullptr };

Referenced by Slic3r::GUI::FlowRateWizard::create_pages(), Slic3r::GUI::MaxVolumetricSpeedWizard::create_pages(), Slic3r::GUI::PressureAdvanceWizard::create_pages(), Slic3r::GUI::FlowRateWizard::on_cali_save(), Slic3r::GUI::MaxVolumetricSpeedWizard::on_cali_save(), Slic3r::GUI::PressureAdvanceWizard::on_cali_save(), and Slic3r::GUI::FlowRateWizard::set_cali_method().

---

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

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