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

Inheritance diagram for Slic3r::GUI::MaxVolumetricSpeedWizard:

Collaboration diagram for Slic3r::GUI::MaxVolumetricSpeedWizard:

Public Member Functions
	MaxVolumetricSpeedWizard (wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL)
	~MaxVolumetricSpeedWizard ()
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	update (MachineObject *obj)
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_action (wxCommandEvent &evt)
void	on_cali_start ()
void	on_cali_save ()
void	on_device_connected (MachineObject *obj) override
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

◆ MaxVolumetricSpeedWizard()

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

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

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

Here is the call graph for this function:

◆ ~MaxVolumetricSpeedWizard()

Slic3r::GUI::MaxVolumetricSpeedWizard::~MaxVolumetricSpeedWizard ( )

inline

186{};

Member Function Documentation

◆ add_build_step()

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

inlineprotectedinherited

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

Slic3r::GUI::StagedBuild::m_steps

std::vector< std::function< void()> > m_steps

Definition StagedBuild.hpp:57

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);
}

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::MaxVolumetricSpeedWizard::create_pages ( )

protected

{
    start_step  = new CalibrationWizardPageStep(new CalibrationMaxVolumetricSpeedStartPage(m_scrolledWindow));
    preset_step = new CalibrationWizardPageStep(new MaxVolumetricSpeedPresetPage(m_scrolledWindow, m_mode, true));
 
    // manual
    cali_step = new CalibrationWizardPageStep(new CalibrationCaliPage(m_scrolledWindow, m_mode));
    save_step = new CalibrationWizardPageStep(new CalibrationMaxVolumetricSpeedSavePage(m_scrolledWindow));
 
    m_all_pages_sizer->Add(start_step->page, 1, wxEXPAND | wxALL, FromDIP(25));
    m_all_pages_sizer->Add(preset_step->page, 1, wxEXPAND | wxALL, FromDIP(25));
    m_all_pages_sizer->Add(cali_step->page, 1, wxEXPAND | wxALL, FromDIP(25));
    m_all_pages_sizer->Add(save_step->page, 1, wxEXPAND | wxALL, FromDIP(25));
 
    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->Hide();
        m_page_steps[i]->page->Bind(EVT_CALI_ACTION, &MaxVolumetricSpeedWizard::on_cali_action, this);
    }
 
    for (auto page_step : m_page_steps) {
        page_step->page->Hide();
    }
 
    if (!m_page_steps.empty())
        show_step(m_page_steps.front());
    return;
}

References Slic3r::GUI::CalibrationWizard::cali_step, Slic3r::GUI::CalibrationWizard::m_all_pages_sizer, 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 MaxVolumetricSpeedWizard().

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

82{ return m_mode; }

References m_mode.

◆ get_curr_step()

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

inlineinherited

68{ return m_curr_step; }

Slic3r::GUI::CalibrationWizard::m_curr_step

CalibrationWizardPageStep * m_curr_step

Definition CalibrationWizard.hpp:111

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

protected

{
    CaliPageActionType action = static_cast<CaliPageActionType>(evt.GetInt());
 
    if (action == CaliPageActionType::CALI_ACTION_START) {
        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_NEXT) {
        show_step(m_curr_step->next);
    }
    else if (action == CaliPageActionType::CALI_ACTION_COMMON_SAVE) {
        on_cali_save();
    }
    else if (action == CaliPageActionType::CALI_ACTION_GO_HOME) {
        on_cali_go_home();
    }
}

References Slic3r::GUI::CALI_ACTION_CALI, Slic3r::GUI::CALI_ACTION_COMMON_SAVE, Slic3r::GUI::CALI_ACTION_GO_HOME, Slic3r::GUI::CALI_ACTION_NEXT, Slic3r::GUI::CALI_ACTION_PREV, Slic3r::GUI::CALI_ACTION_START, Slic3r::GUI::CalibrationWizard::m_curr_step, Slic3r::GUI::CalibrationWizard::on_cali_go_home(), on_cali_save(), on_cali_start(), 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::MaxVolumetricSpeedWizard::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 (m_curr_step != cali_step) {
            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_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::MaxVolumetricSpeedWizard::on_cali_save ( )

protected

{
    std::string old_preset_name;
    std::string new_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;
    }
 
    double value = 0;
    CalibrationMaxVolumetricSpeedSavePage *save_page = (static_cast<CalibrationMaxVolumetricSpeedSavePage *>(save_step->page));
    if (!save_page->get_save_result(value, new_preset_name)) {
        BOOST_LOG_TRIVIAL(info) << "max_volumetric_speed_cali: get result failed";
        return;
    }
 
    if (!CalibUtils::validate_input_name(new_preset_name))
        return;
 
    std::map<std::string, ConfigOption *> key_value_map;
    key_value_map.insert(std::make_pair("filament_max_volumetric_speed", new ConfigOptionFloats{ value }));
 
    wxString message;
    if (!save_preset(old_preset_name, 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("Max volumetric speed calibration result has been saved to preset."), wxEmptyString, wxOK);
    msg_dlg.ShowModal();
    back_preset_info(curr_obj, true);
    show_step(start_step);
}

References _L, Slic3r::GUI::CalibrationWizard::back_preset_info(), Slic3r::GUI::CalibrationWizard::curr_obj, Slic3r::GUI::get_cached_selected_filament(), Slic3r::GUI::CalibrationMaxVolumetricSpeedSavePage::get_save_result(), Slic3r::GUI::CalibrationWizard::preset_step, Slic3r::GUI::CalibrationWizard::save_preset(), 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::MaxVolumetricSpeedWizard::on_cali_start ( )

protected

{
    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);
 
    CalibrationWizard::cache_preset_info(curr_obj, nozzle_dia, plate_type);
 
    wxArrayString values = preset_page->get_custom_range_values();
    Calib_Params  params;
    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(&params.start);
        values[1].ToDouble(&params.end);
        values[2].ToDouble(&params.step);
    }
    params.mode = m_mode;
 
    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;
    }
 
    CalibInfo calib_info;
    calib_info.params = params;
    calib_info.dev_id = curr_obj->get_dev_id();
    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);
        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_prest = selected_filaments.begin()->second;
        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);
    }
 
    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();
 
    wxString wx_err_string;
    CalibUtils::calib_max_vol_speed(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();
 
    CalibrationCaliPage* cali_page = (static_cast<CalibrationCaliPage*>(cali_step->page));
    cali_page->clear_last_job_status();
}

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::MaxVolumetricSpeedWizard::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);
 
    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 (m_curr_step != cali_step) {
                    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::GUI::CalibrationWizard::on_device_connected(), Slic3r::GUI::CalibrationWizard::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::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::CalibrationWizard::update ( MachineObject * obj )

virtualinherited

Reimplemented in Slic3r::GUI::FlowRateWizard, and Slic3r::GUI::PressureAdvanceWizard.

{
    curr_obj = obj;
 
    /* only update curr step
    if (m_curr_step) {
        m_curr_step->page->update(obj);
    }
    */
    if (!obj) {
        for (int i = 0; i < m_page_steps.size(); i++) {
            if (m_page_steps[i]->page)
                m_page_steps[i]->page->on_reset_page();
        }
    }
 
    // update all page steps
    for (int i = 0; i < m_page_steps.size(); i++) {
        if (m_page_steps[i]->page)
            m_page_steps[i]->page->update(obj);
    }
}