Slic3r::GUI::PressureAdvanceWizard Class Reference

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

Inheritance diagram for Slic3r::GUI::PressureAdvanceWizard:

Collaboration diagram for Slic3r::GUI::PressureAdvanceWizard:

Public Member Functions
	PressureAdvanceWizard (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
	~PressureAdvanceWizard ()
void	on_cali_job_finished (wxString evt_data) override
void	on_cali_job_finished (wxCommandEvent &event)
CalibrationWizardPageStep *	get_curr_step ()
void	show_step (CalibrationWizardPageStep *step)
virtual void	set_cali_style (CalibrationStyle style)
virtual void	set_cali_method (CalibrationMethod method)
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_start ()
void	on_cali_save ()
void	on_cali_action (wxCommandEvent &evt)
void	update (MachineObject *obj) override
void	on_device_connected (MachineObject *obj) override
bool	can_save_cali_result (const std::vector< PACalibResult > &new_pa_cali_results)
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
bool	m_show_result_dialog = false
std::vector< PACalibResult >	m_calib_results_history
int	cali_version = -1
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

PressureAdvanceWizard()

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

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

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

Here is the call graph for this function:

~PressureAdvanceWizard()

Slic3r::GUI::PressureAdvanceWizard::~PressureAdvanceWizard ( )

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_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:

can_save_cali_result()

bool Slic3r::GUI::PressureAdvanceWizard::can_save_cali_result ( const std::vector< PACalibResult > & new_pa_cali_results )

protected

{
    if (!curr_obj)
        return false;
 
    std::vector<PACalibResult> to_save_result;
    for (auto &result : new_pa_cali_results) {
        auto iter = std::find_if(to_save_result.begin(), to_save_result.end(), [this, &result](const PACalibResult &item) {
            bool has_same_name = (item.name == result.name && item.filament_id == result.filament_id);
            if (curr_obj && curr_obj->is_multi_extruders()) {
                has_same_name &= (item.extruder_id == result.extruder_id && item.nozzle_volume_type == result.nozzle_volume_type);
            }
            return has_same_name;
        });
        if (iter != to_save_result.end()) {
            MessageDialog msg_dlg(nullptr, wxString::Format(_L("Only one of the results with the same name: %s will be saved. Are you sure you want to override the other results?"), iter->name), wxEmptyString,
                                  wxICON_WARNING | wxYES_NO);
            if (msg_dlg.ShowModal() != wxID_YES) {
                return false;
            } else {
                break;
            }
        }
        to_save_result.push_back(result);
    }
 
    std::string same_pa_names;
    for (auto new_pa_cali_result : new_pa_cali_results) {
        auto iter = std::find_if(curr_obj->pa_calib_tab.begin(), curr_obj->pa_calib_tab.end(), [this, &new_pa_cali_result](const PACalibResult &item) {
            bool is_same_name = (item.name == new_pa_cali_result.name && item.filament_id == new_pa_cali_result.filament_id &&
                                 item.nozzle_diameter == new_pa_cali_result.nozzle_diameter);
            if (curr_obj && curr_obj->is_multi_extruders()) {
                is_same_name &= (item.extruder_id == new_pa_cali_result.extruder_id && item.nozzle_volume_type == new_pa_cali_result.nozzle_volume_type);
            }
            return is_same_name;
        });
 
        if (iter != curr_obj->pa_calib_tab.end()) {
            same_pa_names += new_pa_cali_result.name;
            same_pa_names += ", ";
        }
    }
 
    if (!same_pa_names.empty()) {
        same_pa_names.erase(same_pa_names.size() - 2);
        wxString duplicate_name_info = wxString::Format(_L("There is already a previous calibration result with the same name: %s. Only one result with a name is saved. Are you sure you want to overwrite the previous result\?"), same_pa_names);
 
        if (curr_obj->is_multi_extruders())
            duplicate_name_info = wxString::Format(_L("Within the same extruder, the name(%s) must be unique when the filament type, nozzle diameter, and nozzle flow are the same.\n"
                                                      "Are you sure you want to override the historical result?"), same_pa_names);
 
        MessageDialog msg_dlg(nullptr, duplicate_name_info, wxEmptyString, wxICON_WARNING | wxYES_NO);
        if (msg_dlg.ShowModal() != wxID_YES)
            return false;
    }
 
    if (curr_obj->get_printer_series() != PrinterSeries::SERIES_X1 && curr_obj->pa_calib_tab.size() >= MAX_PA_HISTORY_RESULTS_NUMS) {
        MessageDialog msg_dlg(nullptr, wxString::Format(_L_PLURAL("This machine type can only hold %d historical result per nozzle. This result will not be saved.", "This machine type can only hold %d historical results per nozzle. This result will not be saved.", MAX_PA_HISTORY_RESULTS_NUMS), MAX_PA_HISTORY_RESULTS_NUMS),
                              wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return false;
    }
    return true;
}

References _L, Slic3r::GUI::CalibrationWizard::curr_obj, and Slic3r::GUI::DPIAware< P >::ShowModal().

Referenced by on_cali_save().

Here is the call graph for this function:

Here is the caller graph for this function:

create_pages()

void Slic3r::GUI::PressureAdvanceWizard::create_pages ( )

protected

{
    add_page_step(start_step, [this] { return new CalibrationPAStartPage(m_scrolledWindow); });
    add_page_step(preset_step, [this] { return new CalibrationPresetPage(m_scrolledWindow, m_mode, false); });
    add_page_step(cali_step, [this] { return new CalibrationCaliPage(m_scrolledWindow, m_mode); });
    add_page_step(save_step, [this] { return new CalibrationPASavePage(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_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, &PressureAdvanceWizard::on_cali_action, this);
        }
 
        if (!m_page_steps.empty())
            show_step(m_page_steps.front());
    });
}

References Slic3r::GUI::StagedBuild::add_build_step(), Slic3r::GUI::CalibrationWizard::add_page_step(), Slic3r::GUI::CalibrationWizard::cali_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, Slic3r::GUI::CalibrationWizard::show_step(), and Slic3r::GUI::CalibrationWizard::start_step.

Referenced by PressureAdvanceWizard().

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::PressureAdvanceWizard::on_cali_action ( wxCommandEvent & evt )

protected

{
    CaliPageActionType action = static_cast<CaliPageActionType>(evt.GetInt());
    if (action == CaliPageActionType::CALI_ACTION_MANAGE_RESULT) {
        HistoryWindow history_dialog(this, m_calib_results_history, m_show_result_dialog);
        history_dialog.on_device_connected(curr_obj);
        history_dialog.ShowModal();
    }
    else if (action == CaliPageActionType::CALI_ACTION_MANUAL_CALI) {
        preset_step->page->set_cali_filament_mode(CalibrationFilamentMode::CALI_MODEL_SINGLE);
        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) {
        if (curr_obj && curr_obj->is_support_new_auto_cali_method) {
            set_cali_method(CalibrationMethod::CALI_METHOD_NEW_AUTO);
        }
        else {
            set_cali_method(CalibrationMethod::CALI_METHOD_AUTO);
        }
        CalibrationFilamentMode fila_mode = get_cali_filament_mode(curr_obj, m_mode);
        preset_step->page->set_cali_filament_mode(fila_mode);
        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) {
        on_cali_start();
    }
    else if (action == CaliPageActionType::CALI_ACTION_GO_HOME) {
        on_cali_go_home();
    } else if (action == CaliPageActionType::CALI_ACTION_PA_SAVE) {
        on_cali_save();
    }
}

References Slic3r::GUI::CALI_ACTION_AUTO_CALI, Slic3r::GUI::CALI_ACTION_CALI, Slic3r::GUI::CALI_ACTION_CALI_NEXT, 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_PA_SAVE, Slic3r::GUI::CALI_ACTION_PREV, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_METHOD_NEW_AUTO, Slic3r::GUI::CALI_MODEL_SINGLE, Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::get_cali_filament_mode(), m_calib_results_history, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::m_mode, m_show_result_dialog, Slic3r::GUI::CalibrationWizard::on_cali_go_home(), on_cali_save(), on_cali_start(), Slic3r::GUI::HistoryWindow::on_device_connected(), Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::set_cali_method(), Slic3r::GUI::CalibrationWizard::show_step(), and Slic3r::GUI::DPIAware< P >::ShowModal().

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::PressureAdvanceWizard::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) {
        show_step(cali_step);
    }
    // change ui, hide
    static_cast<CalibrationPresetPage *>(preset_step->page)->on_cali_finished_job();
}

References Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::GUI::CalibUtils::get_calib_mode_by_name(), 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::PressureAdvanceWizard::on_cali_save ( )

protected

{
    if (curr_obj) {
        if (curr_obj->is_connecting() || !curr_obj->is_connected())
        {
            MessageDialog msg_dlg(nullptr, _L("Connecting to printer..."), wxEmptyString, wxOK);
            msg_dlg.ShowModal();
            return;
        }
 
        if (curr_obj->get_printer_series() == PrinterSeries::SERIES_X1) {
            if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO || m_cali_method == CalibrationMethod::CALI_METHOD_NEW_AUTO) {
                std::vector<PACalibResult> new_pa_cali_results;
                auto save_page = static_cast<CalibrationPASavePage*>(save_step->page);
                if (!save_page->get_auto_result(new_pa_cali_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;
                }
                if (!can_save_cali_result(new_pa_cali_results))
                    return;
                CalibUtils::set_PA_calib_result(new_pa_cali_results, true);
            }
            else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
                PACalibResult new_pa_cali_result;
                auto save_page = static_cast<CalibrationPASavePage*>(save_step->page);
                if (!save_page->get_manual_result(new_pa_cali_result)) {
                    return;
                }
                if (!can_save_cali_result({new_pa_cali_result}))
                    return;
                CalibUtils::set_PA_calib_result({ new_pa_cali_result }, false);
            }
 
            MessageDialog msg_dlg(nullptr, _L("Flow Dynamics Calibration result has been saved to the printer."), wxEmptyString, wxOK);
            msg_dlg.ShowModal();
        }
        else if (curr_obj->get_printer_series() == PrinterSeries::SERIES_P1P) {
            if (curr_obj->cali_version >= 0) {
                PACalibResult new_pa_cali_result;
                auto          save_page = static_cast<CalibrationPASavePage *>(save_step->page);
                if (!save_page->get_manual_result(new_pa_cali_result)) {
                    return;
                }
 
                if (!can_save_cali_result({new_pa_cali_result}))
                    return;
 
                CalibUtils::set_PA_calib_result({new_pa_cali_result}, false);
            } else {
                auto  save_page   = static_cast<CalibrationPASavePage *>(save_step->page);
                float new_k_value = 0.0f;
                float new_n_value = 0.0f;
                if (!save_page->get_p1p_result(&new_k_value, &new_n_value)) {
                    return;
                }
 
                float                  nozzle_dia  = 0.4;
                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 = get_cached_selected_filament(curr_obj);
                if (selected_filaments.empty()) {
                    BOOST_LOG_TRIVIAL(error) << "CaliPreset: get selected filaments error";
                    return;
                }
                int         tray_id    = selected_filaments.begin()->first;
                std::string setting_id = selected_filaments.begin()->second->setting_id;
 
                int   nozzle_temp          = -1;
                int   bed_temp             = -1;
                float max_volumetric_speed = -1;
                if (!get_preset_info(selected_filaments.begin()->second->config, plate_type, nozzle_temp, bed_temp, max_volumetric_speed)) {
                    BOOST_LOG_TRIVIAL(error) << "CaliPreset: get preset info error";
                    return;
                }
 
                curr_obj->command_extrusion_cali_set(tray_id, setting_id, "", new_k_value, new_n_value, bed_temp, nozzle_temp, max_volumetric_speed);
 
            }
 
            MessageDialog msg_dlg(nullptr, _L("Flow Dynamics Calibration result has been saved to the printer."), 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::btDefault, Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_METHOD_NEW_AUTO, can_save_cali_result(), Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::CalibrationPresetPage::get_preset_info(), Slic3r::GUI::get_preset_info(), Slic3r::GUI::CalibrationWizard::m_cali_method, on_cali_save(), Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::save_step, SERIES_P1P, SERIES_X1, Slic3r::GUI::CalibUtils::set_PA_calib_result(), Slic3r::GUI::CalibrationWizard::show_step(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::GUI::CalibrationWizard::start_step.

Referenced by on_cali_action(), and on_cali_save().

Here is the call graph for this function:

Here is the caller graph for this function:

on_cali_start()

void Slic3r::GUI::PressureAdvanceWizard::on_cali_start ( )

protected

{
    if (!curr_obj) {
        MessageDialog msg_dlg(nullptr, _L("No Printer Connected!"), wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return;
    }
 
    if (curr_obj->is_connecting() || !curr_obj->is_connected()) {
        MessageDialog msg_dlg(nullptr, _L("Printer is not connected yet."), wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return;
    }
 
    //clean PA result
    curr_obj->reset_pa_cali_result();
 
    std::string setting_id;
    BedType plate_type = BedType::btDefault;
 
    // save preset info to machine object
    CalibrationPresetPage* preset_page = (static_cast<CalibrationPresetPage*>(preset_step->page));
    std::map<int, Preset*> selected_filaments = preset_page->get_selected_filaments();
    if (selected_filaments.empty()) {
        MessageDialog msg_dlg(nullptr, _L("Please select filament to calibrate."), wxEmptyString, wxICON_WARNING | wxOK);
        msg_dlg.ShowModal();
        return;
    }
 
    float nozzle_dia = -1;
    preset_page->get_preset_info(nozzle_dia, plate_type);
 
    CalibrationWizard::cache_preset_info(curr_obj, nozzle_dia, plate_type);
    if (/*nozzle_dia < 0 || */ plate_type == BedType::btDefault) {
        BOOST_LOG_TRIVIAL(error) << "CaliPreset: get preset info, nozzle and plate type error";
        return;
    }
 
    //std::string error_message;
    wxString wx_err_string;
    if (m_cali_method == CalibrationMethod::CALI_METHOD_AUTO && curr_obj->get_printer_series() == PrinterSeries::SERIES_X1) {
        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";
                continue;
            }
 
            X1CCalibInfos::X1CCalibInfo calib_info;
            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;
            calib_infos.calib_datas.push_back(calib_info);
        }
        calib_infos.cali_mode = CalibMode::Calib_PA_Line;
        CalibUtils::calib_PA(calib_infos, 0, wx_err_string); // mode = 0 for auto
 
        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);
    } else if (m_cali_method == CalibrationMethod::CALI_METHOD_MANUAL) {
        if (selected_filaments.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "CaliPreset: selected filaments is empty";
            return;
        }
        else {
            int   nozzle_temp          = -1;
            int   bed_temp             = -1;
            float max_volumetric_speed = -1;
            if (!get_preset_info(selected_filaments.begin()->second->config, plate_type, nozzle_temp, bed_temp, max_volumetric_speed)) {
                BOOST_LOG_TRIVIAL(error) << "CaliPreset: get preset info error";
                return;
            }
 
            int selected_tray_id = 0;
            CalibInfo calib_info;
            calib_info.dev_id            = curr_obj->get_dev_id();
            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.extruder_id       = preset_page->get_extruder_id_by_tray_id(selected_filaments.begin()->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.select_ams         = std::to_string(selected_tray_id);
            Preset *preset               = selected_filaments.begin()->second;
            Preset * 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.process_bar   = preset_page->get_sending_progress_bar();
            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.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);
 
            wxArrayString values = preset_page->get_custom_range_values();
            if (values.size() != 3) {
                MessageDialog msg_dlg(nullptr, _L("The input value size must be 3."), wxEmptyString, wxICON_WARNING | wxOK);
                msg_dlg.ShowModal();
                return;
            } else {
                values[0].ToDouble(&calib_info.params.start);
                values[1].ToDouble(&calib_info.params.end);
                values[2].ToDouble(&calib_info.params.step);
            }
            calib_info.params.mode = preset_page->get_pa_cali_method();
            calib_info.params.print_numbers = true;
 
            if (!is_pa_params_valid(calib_info.params))
                return;
 
            ManualPaCaliMethod   pa_cali_method = ManualPaCaliMethod::PA_LINE;
            CalibrationCaliPage *cali_page = (static_cast<CalibrationCaliPage *>(cali_step->page));
            if (calib_info.params.mode == CalibMode::Calib_PA_Line)
                pa_cali_method = ManualPaCaliMethod::PA_LINE;
            else if (calib_info.params.mode == CalibMode::Calib_PA_Pattern)
                pa_cali_method = ManualPaCaliMethod::PA_PATTERN;
 
            cali_page->set_pa_cali_image(int(pa_cali_method));
            curr_obj->manual_pa_cali_method = pa_cali_method;
 
            if (curr_obj->get_printer_series() != PrinterSeries::SERIES_X1 && curr_obj->pa_calib_tab.size() >= MAX_PA_HISTORY_RESULTS_NUMS) {
                MessageDialog msg_dlg(nullptr, wxString::Format(_L("This machine type can only hold 16 historical results per nozzle. You can delete the existing historical results and then start calibration. Or you can continue the calibration, but you cannot create new calibration historical results.\nDo you still want to continue the calibration\?"), MAX_PA_HISTORY_RESULTS_NUMS), wxEmptyString, wxICON_WARNING | wxYES | wxCANCEL);
                if (msg_dlg.ShowModal() != wxID_YES) {
                    return;
                }
            }
 
            if (!CalibUtils::calib_generic_PA(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;
            }
 
            preset_page->on_cali_start_job();
        }
    } else if (m_cali_method == CalibrationMethod::CALI_METHOD_NEW_AUTO) {
        if (selected_filaments.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "CaliPreset: selected filaments is empty";
            return;
        }
 
        std::vector<CalibInfo> 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";
                continue;
            }
 
            int       selected_tray_id = 0;
            CalibInfo calib_info;
            calib_info.dev_id = curr_obj->get_dev_id();
            get_tray_ams_and_slot_id(curr_obj, item.first, calib_info.ams_id, calib_info.slot_id, selected_tray_id);
            calib_info.index              = preset_page->get_index_by_tray_id(item.first);
            calib_info.extruder_id        = preset_page->get_extruder_id_by_tray_id(item.first);
            calib_info.nozzle_diameter    = preset_page->get_nozzle_diameter(calib_info.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.select_ams         = std::to_string(selected_tray_id);
            Preset *preset                = item.second;
            Preset *temp_filament_preset  = new Preset(preset->type, preset->name + "_temp");
            temp_filament_preset->config  = preset->config;
 
            calib_info.bed_type       = plate_type;
            calib_info.process_bar    = preset_page->get_sending_progress_bar();
            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.filament_prest = temp_filament_preset;
            std::map<int, DynamicPrintConfig> filament_list = preset_page->get_filament_ams_list();
            calib_info.filament_color = filament_list[item.first].opt_string("filament_colour", 0u);
            calib_info.params.mode    = CalibMode::Calib_Auto_PA_Line;
            calib_infos.emplace_back(calib_info);
        }
 
        if (!CalibUtils::calib_generic_auto_pa_cali(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;
        }
 
        preset_page->on_cali_start_job();
    } else {
        assert(false);
        BOOST_LOG_TRIVIAL(error) << "CaliPreset: unsupported printer type or cali method";
        return;
    }
 
    CalibrationCaliPage* cali_page = (static_cast<CalibrationCaliPage*>(cali_step->page));
    cali_page->clear_last_job_status();
}

References _L, Slic3r::GUI::CalibInfo::ams_id, Slic3r::X1CCalibInfos::X1CCalibInfo::ams_id, Slic3r::X1CCalibInfos::X1CCalibInfo::bed_temp, Slic3r::GUI::CalibInfo::bed_type, Slic3r::btDefault, Slic3r::GUI::CalibrationWizard::cache_preset_info(), Slic3r::GUI::CALI_METHOD_AUTO, Slic3r::GUI::CALI_METHOD_MANUAL, Slic3r::GUI::CALI_METHOD_NEW_AUTO, Slic3r::X1CCalibInfos::cali_mode, Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::Calib_Auto_PA_Line, Slic3r::X1CCalibInfos::calib_datas, Slic3r::GUI::CalibUtils::calib_generic_auto_pa_cali(), Slic3r::GUI::CalibUtils::calib_generic_PA(), Slic3r::GUI::CalibUtils::calib_PA(), Slic3r::Calib_PA_Line, Slic3r::Calib_PA_Pattern, Slic3r::GUI::CalibrationCaliPage::clear_last_job_status(), Slic3r::Preset::config, Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::CalibInfo::dev_id, Slic3r::Calib_Params::end, 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::GUI::CalibrationPresetPage::get_custom_range_values(), Slic3r::GUI::CalibrationPresetPage::get_extruder_id_by_tray_id(), Slic3r::GUI::CalibrationPresetPage::get_extruder_type(), Slic3r::GUI::CalibrationPresetPage::get_filament_ams_list(), Slic3r::GUI::CalibrationPresetPage::get_index_by_tray_id(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_diameter(), Slic3r::GUI::CalibrationPresetPage::get_nozzle_volume_type(), Slic3r::GUI::CalibrationPresetPage::get_pa_cali_method(), 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::CalibrationPresetPage::get_sending_progress_bar(), Slic3r::GUI::get_tray_ams_and_slot_id(), Slic3r::GUI::CalibInfo::index, Slic3r::GUI::is_pa_params_valid(), Slic3r::GUI::CalibrationWizard::m_cali_method, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::MAX_PA_HISTORY_RESULTS_NUMS, 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::CalibrationPresetPage::on_cali_start_job(), Slic3r::PA_LINE, Slic3r::PA_PATTERN, Slic3r::GUI::CalibInfo::params, Slic3r::Preset, Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::Calib_Params::print_numbers, Slic3r::GUI::CalibInfo::print_prest, Slic3r::GUI::CalibInfo::printer_prest, Slic3r::GUI::CalibInfo::process_bar, Slic3r::GUI::CalibInfo::select_ams, SERIES_X1, Slic3r::GUI::CalibrationCaliPage::set_pa_cali_image(), 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::Calib_Params::start, Slic3r::Calib_Params::step, 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::PressureAdvanceWizard::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);
    obj->manual_pa_cali_method = ManualPaCaliMethod(cali_stage);
 
    // show cali step when obj is in pa calibration
    if (obj) {
        CalibrationWizard::set_cali_method(method);
 
        if (m_curr_step != cali_step) {
            if (obj_cali_mode == m_mode) {
                if (!obj->cali_finished && (obj->is_in_printing() || obj->is_printing_finished())) {
                    CalibrationWizard::set_cali_method(method);
                    CalibrationCaliPage *cali_page = (static_cast<CalibrationCaliPage *>(cali_step->page));
                    cali_page->set_pa_cali_image(cali_stage);
                    show_step(cali_step);
                }
            }
        }
    }
}

References Slic3r::MachineObject::cali_finished, 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::MachineObject::manual_pa_cali_method, Slic3r::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::CalibrationWizard::set_cali_method(), Slic3r::GUI::CalibrationCaliPage::set_pa_cali_image(), 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::CalibrationWizard::set_cali_method ( CalibrationMethod method )

virtualinherited

Reimplemented in Slic3r::GUI::FlowRateWizard.

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

References m_cali_method, and m_page_steps.

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

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::PressureAdvanceWizard::update ( MachineObject * obj )

overrideprotectedvirtual

Reimplemented from Slic3r::GUI::CalibrationWizard.

{
    CalibrationWizard::update(obj);
 
    if (!obj)
        return;
 
    if (!m_show_result_dialog) {
        if (obj->cali_version != -1 && obj->cali_version != cali_version) {
            cali_version = obj->cali_version;
            PACalibExtruderInfo cali_info;
            cali_info.nozzle_diameter = obj->GetExtderSystem()->GetNozzleDiameter(0);
            cali_info.use_extruder_id        = false;
            cali_info.use_nozzle_volume_type = false;
            CalibUtils::emit_get_PA_calib_infos(cali_info);
        }
    }
}

References cali_version, Slic3r::MachineObject::cali_version, Slic3r::GUI::CalibUtils::emit_get_PA_calib_infos(), Slic3r::MachineObject::GetExtderSystem(), Slic3r::DevExtderSystem::GetNozzleDiameter(), m_show_result_dialog, Slic3r::PACalibExtruderInfo::nozzle_diameter, Slic3r::GUI::CalibrationWizard::update(), Slic3r::PACalibExtruderInfo::use_extruder_id, and Slic3r::PACalibExtruderInfo::use_nozzle_volume_type.

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().

cali_version

int Slic3r::GUI::PressureAdvanceWizard::cali_version = -1

protected

Referenced by update().

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_calib_results_history

std::vector<PACalibResult> Slic3r::GUI::PressureAdvanceWizard::m_calib_results_history

protected

Referenced by on_cali_action().

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_show_result_dialog

bool Slic3r::GUI::PressureAdvanceWizard::m_show_result_dialog = false

protected

Referenced by on_cali_action(), and update().

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