WipingDialog Class Reference

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

Inheritance diagram for WipingDialog:

Collaboration diagram for WipingDialog:

Public Types
using	VolumeMatrix = std::vector<std::vector<double>>

Public Member Functions
	WipingDialog (wxWindow *parent, const int max_flush_volume=Slic3r::g_max_flush_volume)
std::vector< double >	GetFlattenMatrix () const
std::vector< double >	GetMultipliers () const
bool	GetSubmitFlag () const

Static Public Member Functions
static VolumeMatrix	CalcFlushingVolumes (int extruder_id)

Private Member Functions
wxString	BuildTableObjStr ()
wxString	BuildTextObjStr (bool multi_language=true)
void	StoreFlushData (int extruder_num, const std::vector< std::vector< double > > &flush_volume_vecs, const std::vector< double > &flush_multipliers)
std::vector< double >	ExpandToFullMatrix (const std::vector< double > &sub_matrix, int nozzle_idx) const

Static Private Member Functions
static int	CalcFlushingVolume (const wxColour &from_, const wxColour &to_, int min_flush_volume, int nozzle_flush_dataset)

Private Attributes
wxWebView *	m_webview
int	m_max_flush_volume
VolumeMatrix	m_raw_matrixs
std::vector< double >	m_flush_multipliers
std::vector< size_t >	m_physical_indices
bool	m_submit_flag { false }

Detailed Description

Member Typedef Documentation

VolumeMatrix

using WipingDialog::VolumeMatrix = std::vector<std::vector<double>>

Constructor & Destructor Documentation

WipingDialog()

WipingDialog::WipingDialog	(	wxWindow *	parent,
		const int	max_flush_volume = Slic3r::g_max_flush_volume )

                                                                       :
    wxDialog(parent, wxID_ANY, _(L("Flushing volumes for filament change")),
    wxDefaultPosition, wxDefaultSize,
    wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER ),
    m_max_flush_volume(max_flush_volume)
{
    wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);
    this->SetSizer(main_sizer);
    this->SetBackgroundColour(*wxWHITE);
    auto filament_count = wxGetApp().preset_bundle->physical_filament_config_indices().size();
 
    // Estimate table scroll area size based on filament count
    // Each table cell is ~60x25 DIP, plus headers and borders
    wxSize max_scroll_size = { FromDIP(1000), FromDIP(500) };
    wxSize table_size = { (int)(filament_count + 1) * FromDIP(60), (int)(filament_count + 1) * FromDIP(25) + FromDIP(2) };
    wxSize scroll_size = { std::min(max_scroll_size.x, table_size.x), std::min(max_scroll_size.y, table_size.y) };
 
    // Fixed overhead: padding (~30), tip panel (~70), controls row (~50),
    // description/multiplier section (~130), button row (~45) = ~325 DIP
    wxSize fixed_overhead = { FromDIP(100), FromDIP(325) };
    wxSize applied_size = scroll_size + fixed_overhead;
 
    // Clamp to screen size (leave some margin for window decorations)
    wxSize scaled_screen_size = wxGetDisplaySize();
    double scale_factor = wxDisplay().GetScaleFactor();
    scaled_screen_size = { (int)(scaled_screen_size.x / scale_factor), (int)(scaled_screen_size.y / scale_factor) };
    wxSize screen_margin = { FromDIP(40), FromDIP(60) };
    scaled_screen_size -= screen_margin;
 
    applied_size = { std::min(applied_size.x, scaled_screen_size.x), std::min(applied_size.y, scaled_screen_size.y) };
 
    // Ensure a reasonable minimum size so the dialog is usable even when clamped
    applied_size.x = std::max(applied_size.x, FromDIP(350));
    applied_size.y = std::max(applied_size.y, FromDIP(450));
    m_webview = wxWebView::New(this, wxID_ANY,
        wxEmptyString,
        wxDefaultPosition,
        applied_size,
        wxWebViewBackendDefault,
        wxNO_BORDER);
 
    m_webview->AddScriptMessageHandler("wipingDialog");
    // The page's strings (resources/web/flush/WipingDialog.html), keyed by their T() ids.
    const nlohmann::json page_strings = {
        // TRN Corner header of the flushing volume table: rows are the filament flushed from, columns the filament changed to.
        {"from_to", _u8L("from/to")},
    };
    m_webview->AddUserScript(wxString::FromUTF8(WebViewHostDialog::localized_strings_script(page_strings)));
    main_sizer->Add(m_webview, 1, wxEXPAND);
 
    fs::path filepath = fs::path(resources_dir()) / "web/flush/WipingDialog.html";
    wxString filepath_str = from_path(filepath);
    wxFileName fn(filepath_str);
    if(fn.FileExists()) {
        wxString url = file_url_from_path(filepath);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< "File exists and load url " << url.ToStdString();
        m_webview->LoadURL(url);
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< "Successfully loaded url: " << url.ToStdString();
    } else {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< "WipingDialog.html not exist at path: " << filepath.string();
    }
 
    main_sizer->SetSizeHints(this);
    main_sizer->Fit(this);
    CenterOnParent();
    wxGetApp().UpdateDlgDarkUI(this);
 
    //m_webview->Bind(wxEVT_WEBVIEW_NAVIGATED, [this](auto& evt) {
    //    auto table_obj_str = BuildTableObjStr();
    //    auto text_obj_str = BuildTextObjStr();
    //    CallAfter([table_obj_str, text_obj_str, this] {
    //        wxString script = wxString::Format("buildTable(%s);buildText(%s)", table_obj_str, text_obj_str);
    //        m_webview->RunScript(script);
    //        });
    //    });
 
    m_webview->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, [this](wxWebViewEvent& evt) {
        std::string message = evt.GetString().ToStdString();
        BOOST_LOG_TRIVIAL(debug) << __FUNCTION__<< "Received message: " << message;
        try {
            json j = json::parse(message);
            if (j["msg"].get<std::string>() == "init") {
                auto table_obj_str = BuildTableObjStr();
                auto text_obj_str = BuildTextObjStr(true);
                CallAfter([table_obj_str, text_obj_str, this] {
                    wxString script1 = wxString::Format("buildTable(%s)", table_obj_str);
                    m_webview->RunScript(script1);
                    wxString script2 = wxString::Format("buildText(%s)", text_obj_str);
                    bool result = m_webview->RunScript(script2);
                    if (!result) {
                        BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< "Failed to run buildText, retry without multi language";
                        wxString script3 = wxString::Format("buildText(%s)", BuildTextObjStr(false));
                        m_webview->RunScript(script3);
                    }
                    });
            }
            else if (j["msg"].get<std::string>() == "updateMatrix") {
                int extruder_id = j["extruder_id"].get<int>();
                auto new_matrix = CalcFlushingVolumes(extruder_id);
                json obj;
                obj["flush_volume_matrix"] = MatrixFlatten(new_matrix);
                obj["extruder_id"] = extruder_id;
                CallAfter([obj, this] {
                    std::string flush_volume_matrix_str = obj["flush_volume_matrix"].dump();
                    std::string extruder_id_str = std::to_string(obj["extruder_id"].get<int>());
                    wxString script = wxString::Format("updateTable(%s,%s)", flush_volume_matrix_str, extruder_id_str);
                    m_webview->RunScript(script);
                    });
            }
            else if (j["msg"].get<std::string>() == "storeData") {
                int extruder_num = j["number_of_extruders"].get<int>();
                std::vector<std::vector<double>> store_matrixs;
                for (auto iter = j["raw_matrix"].begin(); iter != j["raw_matrix"].end(); ++iter) {
                    store_matrixs.emplace_back((*iter).get<std::vector<double>>());
                }
                std::vector<double>store_multipliers = j["flush_multiplier"].get<std::vector<double>>();
                {// limit all matrix value before write to gcode, the limitation is depends on the multipliers
                    size_t cols_temp_matrix = 0;
                    if (!store_matrixs.empty()) { cols_temp_matrix = store_matrixs[0].size(); }
                    if (store_multipliers.size() == store_matrixs.size() && cols_temp_matrix>0) // nuzzles==nuzzles
                    {
                        for (size_t idx = 0; idx < store_multipliers.size(); ++idx) {
                            double m_max_flush_volume_t = (double)m_max_flush_volume, m_store_multipliers=store_multipliers[idx];
                            std::transform(store_matrixs[idx].begin(), store_matrixs[idx].end(),
                                           store_matrixs[idx].begin(),
                                           [m_max_flush_volume_t, m_store_multipliers](double inputx) {
                                               return std::clamp(inputx, 0.0, m_max_flush_volume_t / m_store_multipliers);
                                           });
                        }
                    }
                }
                this->StoreFlushData(extruder_num, store_matrixs, store_multipliers);
                m_submit_flag = true;
                this->Close();
            }
            else if (j["msg"].get<std::string>() == "quit") {
                this->Close();
            }
        }
        catch (...) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__<< "Failed to parse json message: " << message;
        }
        });
 
    m_webview->Bind(wxEVT_CHAR_HOOK, [this](wxKeyEvent& e) {
    if (e.GetKeyCode() == WXK_ESCAPE) {
            if (IsModal()) EndModal(wxID_CANCEL);
            else Close();
            return;
    }
        e.Skip();
    });
}

References _, _u8L, BuildTableObjStr(), BuildTextObjStr(), CalcFlushingVolumes(), Slic3r::GUI::file_url_from_path(), Slic3r::GUI::from_path(), L, Slic3r::GUI::WebViewHostDialog::localized_strings_script(), m_max_flush_volume, m_submit_flag, m_webview, MatrixFlatten(), Slic3r::resources_dir(), and StoreFlushData().

Here is the call graph for this function:

Member Function Documentation

BuildTableObjStr()

wxString WipingDialog::BuildTableObjStr ( )

private

{
    auto full_config = wxGetApp().preset_bundle->full_config();
    auto filament_colors = full_config.option<ConfigOptionStrings>("filament_colour")->values;
    auto flush_multiplier = full_config.option<ConfigOptionFloats>("flush_multiplier")->values;
    int nozzle_num = full_config.option<ConfigOptionFloats>("nozzle_diameter")->values.size();
    auto raw_matrix_data = full_config.option<ConfigOptionFloats>("flush_volumes_matrix")->values;
    auto nozzle_flush_dataset = full_config.option<ConfigOptionIntsNullable>("nozzle_flush_dataset")->values;
 
    // Restrict the table to physical filaments; mixed slots have no flushing volumes.
    m_physical_indices = wxGetApp().preset_bundle->physical_filament_config_indices();
    const size_t full_n = filament_colors.size();
    {
        std::vector<std::string> physical_colors;
        physical_colors.reserve(m_physical_indices.size());
        for (size_t i : m_physical_indices)
            if (i < filament_colors.size())
                physical_colors.push_back(filament_colors[i]);
        filament_colors = std::move(physical_colors);
    }
 
    std::vector<std::vector<double>> flush_matrixs;
    for (int idx = 0; idx < nozzle_num; ++idx) {
        auto fm = get_flush_volumes_matrix(raw_matrix_data, idx, nozzle_num);
        flush_matrixs.emplace_back(extract_physical_sub_matrix(fm, full_n, m_physical_indices));
    }
    flush_multiplier.resize(nozzle_num, 1);
 
    std::vector<std::vector<float>> default_matrixs;
    for (int idx = 0; idx < nozzle_num; ++idx) {
        default_matrixs.emplace_back(MatrixFlatten(CalcFlushingVolumes(idx)));
    }
 
    m_raw_matrixs = flush_matrixs;
    m_flush_multipliers = flush_multiplier;
 
    json obj;
    obj["flush_multiplier"] = flush_multiplier;
    obj["extruder_num"] = nozzle_num;
    obj["filament_colors"] = filament_colors;
    obj["flush_volume_matrixs"] = json::array();
    obj["min_flush_volumes"] = json::array();
    obj["max_flush_volumes"] = json::array();
    obj["min_flush_multiplier"] = g_min_flush_multiplier;
    obj["max_flush_multiplier"] = g_max_flush_multiplier;
    obj["is_dark_mode"] = wxGetApp().dark_mode();
    obj["default_matrixs"]      = json::array();
 
    for (const auto& vec : flush_matrixs) {
        obj["flush_volume_matrixs"].push_back(vec);
    }
    for (const auto &vec : default_matrixs) {
        obj["default_matrixs"].push_back(vec);
    }
 
    for (int idx = 0; idx < nozzle_num; ++idx) {
        const std::vector<int> &min_flush_volumes = get_min_flush_volumes(full_config, idx);
        int min_flush_from_nozzle_volume = *min_element(min_flush_volumes.begin(), min_flush_volumes.end());
        GenericFlushPredictor pd(nozzle_flush_dataset[idx]);
        int min_flush_from_flush_data = pd.get_min_flush_volume();
        obj["min_flush_volumes"].push_back(std::min(min_flush_from_flush_data,min_flush_from_nozzle_volume));
        obj["max_flush_volumes"].push_back(m_max_flush_volume);
    }
 
    auto obj_str = obj.dump();
    return obj_str;
}

References CalcFlushingVolumes(), extract_physical_sub_matrix(), Slic3r::flush_multiplier(), g_max_flush_multiplier, g_min_flush_multiplier, Slic3r::get_flush_volumes_matrix(), GenericFlushPredictor::get_min_flush_volume(), Slic3r::GUI::get_min_flush_volumes(), m_flush_multipliers, m_max_flush_volume, m_physical_indices, m_raw_matrixs, and MatrixFlatten().

Referenced by WipingDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

BuildTextObjStr()

wxString WipingDialog::BuildTextObjStr ( bool multi_language = true )

private

{
    wxString auto_flush_tip;
    wxString volume_desp_panel;
    wxString volume_range_panel;
    wxString multiplier_range_panel;
    wxString calc_btn_panel;
    wxString extruder_label_0;
    wxString extruder_label_1;
    wxString multiplier_label;
    wxString ok_btn_label;
    wxString cancel_btn_label;
 
    const std::string pt = wxGetApp().preset_bundle->printers.get_edited_preset().get_printer_type(wxGetApp().preset_bundle);
    const std::string extruder_name_0 = DevPrinterConfigUtil::get_toolhead_display_name(pt, DEPUTY_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::SentenceCase);
    const std::string extruder_name_1 = DevPrinterConfigUtil::get_toolhead_display_name(pt, MAIN_EXTRUDER_ID, ToolHeadComponent::Extruder, ToolHeadNameCase::SentenceCase);
 
    if (multi_language) {
        auto_flush_tip = _L("Orca would re-calculate your flushing volumes everytime the filaments color changed or filaments changed. You could disable the auto-calculate in Orca Slicer > Preferences");
        volume_desp_panel = _L("Flushing volume (mm³) for each filament pair.");
        volume_range_panel = wxString::Format(_L("Suggestion: Flushing Volume in range [%d, %d]"), 0, 700);
        multiplier_range_panel = wxString::Format(_L("The multiplier should be in range [%.2f, %.2f]."), 0., 3.);
        calc_btn_panel = _L("Re-calculate");
        extruder_label_0 = _L(extruder_name_0);
        extruder_label_1 = _L(extruder_name_1);
        multiplier_label = _L("Multiplier");
        ok_btn_label = _L("OK");
        cancel_btn_label = _L("Cancel");
    } else {
        auto_flush_tip = "Orca would re-calculate your flushing volumes everytime the filaments color changed or filaments changed. You could disable the auto-calculate in Orca Slicer > Preferences";
        volume_desp_panel = wxString::FromUTF8("Flushing volume (mm³) for each filament pair.");
        volume_range_panel = wxString::Format("Suggestion: Flushing Volume in range [%d, %d]", 0, 700);
        multiplier_range_panel = wxString::Format("The multiplier should be in range [%.2f, %.2f].", 0., 3.);
        calc_btn_panel = "Re-calculate";
        extruder_label_0 = wxString::FromUTF8(extruder_name_0);
        extruder_label_1 = wxString::FromUTF8(extruder_name_1);
        multiplier_label = "Multiplier";
        ok_btn_label = "OK";
        cancel_btn_label = "Cancel";
    }
 
    wxString text_obj = "{";
    text_obj += wxString::Format("\"volume_desp_panel\":\"%s\",", volume_desp_panel);
    text_obj += wxString::Format("\"volume_range_panel\":\"%s\",", volume_range_panel);
    text_obj += wxString::Format("\"multiplier_range_panel\":\"%s\",", multiplier_range_panel);
    text_obj += wxString::Format("\"calc_btn_panel\":\"%s\",", calc_btn_panel);
    text_obj += wxString::Format("\"extruder_label_0\":\"%s\",", extruder_label_0);
    text_obj += wxString::Format("\"extruder_label_1\":\"%s\",", extruder_label_1);
    text_obj += wxString::Format("\"multiplier_label\":\"%s\",", multiplier_label);
    text_obj += wxString::Format("\"ok_btn_label\":\"%s\",", ok_btn_label);
    text_obj += wxString::Format("\"cancel_btn_label\":\"%s\",", cancel_btn_label);
    text_obj += wxString::Format("\"auto_flush_tip\":\"%s\"", auto_flush_tip);
    text_obj += "}";
    return text_obj;
}

References _L, DEPUTY_EXTRUDER_ID, Slic3r::Extruder, Slic3r::DevPrinterConfigUtil::get_toolhead_display_name(), MAIN_EXTRUDER_ID, and Slic3r::SentenceCase.

Referenced by WipingDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcFlushingVolume()

int WipingDialog::CalcFlushingVolume ( const wxColour & from_, const wxColour & to_, int min_flush_volume, int nozzle_flush_dataset )

staticprivate

{
    Slic3r::FlushVolCalculator calculator(min_flush_volume, Slic3r::g_max_flush_volume, nozzle_flush_dataset);
    return calculator.calc_flush_vol(from.Alpha(), from.Red(), from.Green(), from.Blue(), to.Alpha(), to.Red(), to.Green(), to.Blue());
}

References Slic3r::FlushVolCalculator::calc_flush_vol(), and Slic3r::g_max_flush_volume.

Referenced by CalcFlushingVolumes().

Here is the call graph for this function:

Here is the caller graph for this function:

CalcFlushingVolumes()

WipingDialog::VolumeMatrix WipingDialog::CalcFlushingVolumes ( int extruder_id )

static

{
    auto& preset_bundle = wxGetApp().preset_bundle;
    auto full_config = preset_bundle->full_config();
    auto& ams_multi_color_filament = preset_bundle->ams_multi_color_filment;
    // Mixed-colour slots are virtual and never flushed: compute a p x p matrix over the physical
    // slots only, laid out like the table; row/column k belongs to config slot physical_indices[k].
    auto physical_indices = preset_bundle->physical_filament_config_indices();
 
    std::vector<std::string> all_color_strs = full_config.option<ConfigOptionStrings>("filament_colour")->values;
    int flush_dataset_value = full_config.option<ConfigOptionIntsNullable>("nozzle_flush_dataset")->values[extruder_id];
    const std::vector<int> min_flush_volumes = get_min_flush_volumes(full_config, extruder_id);
 
    // Support for multi-color filament
    std::vector<std::vector<wxColour>> multi_colors;
    for (size_t cfg_idx : physical_indices) {
        std::vector<wxColour> single_filament;
        if (cfg_idx < ams_multi_color_filament.size() && !ams_multi_color_filament[cfg_idx].empty()) {
            for (const auto& c : ams_multi_color_filament[cfg_idx])
                single_filament.push_back(wxColour(c));
        } else if (cfg_idx < all_color_strs.size()) {
            single_filament.push_back(wxColour(all_color_strs[cfg_idx]));
        }
        multi_colors.push_back(single_filament);
    }
 
    VolumeMatrix matrix;
    for (size_t pi = 0; pi < physical_indices.size(); ++pi) {
        int from_cfg = (int)physical_indices[pi];
        bool is_from_support = is_support_filament(from_cfg);
        matrix.emplace_back();
        for (size_t pj = 0; pj < physical_indices.size(); ++pj) {
            int to_cfg = (int)physical_indices[pj];
            if (from_cfg == to_cfg) {
                matrix.back().emplace_back(0);
                continue;
            }
 
            bool is_to_support = is_support_filament(to_cfg);
            int flushing_volume = 0;
            if (is_to_support) {
                flushing_volume = Slic3r::g_flush_volume_to_support;
            }
            else {
                int min_flush_from = (from_cfg < (int)min_flush_volumes.size()) ? min_flush_volumes[from_cfg] : 0;
                for (size_t i = 0; i < multi_colors[pi].size(); ++i) {
                    const wxColour& from = multi_colors[pi][i];
                    for (size_t j = 0; j < multi_colors[pj].size(); ++j) {
                        const wxColour& to = multi_colors[pj][j];
                        int volume = CalcFlushingVolume(from, to, min_flush_from, flush_dataset_value);
                        flushing_volume = std::max(flushing_volume, volume);
                    }
                }
 
                if (is_from_support) {
                    flushing_volume = std::max(Slic3r::g_min_flush_volume_from_support, flushing_volume);
                }
            }
            matrix.back().emplace_back(flushing_volume);
        }
    }
    return matrix;
}

References CalcFlushingVolume(), Slic3r::g_flush_volume_to_support, Slic3r::g_min_flush_volume_from_support, Slic3r::GUI::get_min_flush_volumes(), and Slic3r::GUI::is_support_filament().

Referenced by WipingDialog(), BuildTableObjStr(), and is_flush_config_modified().

Here is the call graph for this function:

Here is the caller graph for this function:

ExpandToFullMatrix()

std::vector< double > WipingDialog::ExpandToFullMatrix ( const std::vector< double > & sub_matrix, int nozzle_idx ) const

private

{
    const auto& project_config = wxGetApp().preset_bundle->project_config;
    const size_t full_n = project_config.option<ConfigOptionStrings>("filament_colour")->values.size();
    if (m_physical_indices.size() == full_n)
        return sub_matrix;   // no mixed slots: sub-matrix already is the full matrix
 
    auto raw = project_config.option<ConfigOptionFloats>("flush_volumes_matrix")->values;
    int nozzle_num = (int)wxGetApp().preset_bundle->project_config.option<ConfigOptionFloats>("flush_multiplier")->values.size();
    if (nozzle_num < 1) nozzle_num = 1;
    auto original = get_flush_volumes_matrix(raw, nozzle_idx, nozzle_num);
    return expand_physical_to_full_matrix(sub_matrix, m_physical_indices, full_n, original);
}

References expand_physical_to_full_matrix(), Slic3r::get_flush_volumes_matrix(), m_physical_indices, and Slic3r::ConfigOptionVector< T >::size().

Referenced by GetFlattenMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

GetFlattenMatrix()

std::vector< double > WipingDialog::GetFlattenMatrix

(

)

const

{
    std::vector<double> ret;
    for (size_t idx = 0; idx < m_raw_matrixs.size(); ++idx) {
        auto full = ExpandToFullMatrix(m_raw_matrixs[idx], (int)idx);
        ret.insert(ret.end(), full.begin(), full.end());
    }
    return ret;
}

References ExpandToFullMatrix(), and m_raw_matrixs.

Referenced by open_flushing_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMultipliers()

std::vector< double > WipingDialog::GetMultipliers

(

)

const

{
    return m_flush_multipliers;
}

References m_flush_multipliers.

Referenced by open_flushing_dialog().

Here is the caller graph for this function:

GetSubmitFlag()

bool WipingDialog::GetSubmitFlag ( ) const

inline

{ return m_submit_flag; }

References m_submit_flag.

Referenced by open_flushing_dialog().

Here is the caller graph for this function:

StoreFlushData()

void WipingDialog::StoreFlushData ( int extruder_num, const std::vector< std::vector< double > > & flush_volume_vecs, const std::vector< double > & flush_multipliers )

private

{
    m_flush_multipliers = flush_multipliers;
    m_raw_matrixs = flush_volume_vecs;
}

References m_flush_multipliers, and m_raw_matrixs.

Referenced by WipingDialog().

Here is the caller graph for this function:

Member Data Documentation

m_flush_multipliers

std::vector<double> WipingDialog::m_flush_multipliers

private

Referenced by BuildTableObjStr(), GetMultipliers(), and StoreFlushData().

m_max_flush_volume

int WipingDialog::m_max_flush_volume

private

Referenced by WipingDialog(), and BuildTableObjStr().

m_physical_indices

std::vector<size_t> WipingDialog::m_physical_indices

private

Referenced by BuildTableObjStr(), and ExpandToFullMatrix().

m_raw_matrixs

VolumeMatrix WipingDialog::m_raw_matrixs

private

Referenced by BuildTableObjStr(), GetFlattenMatrix(), and StoreFlushData().

m_submit_flag

bool WipingDialog::m_submit_flag { false }

private

{ false };

Referenced by WipingDialog(), and GetSubmitFlag().

m_webview

wxWebView* WipingDialog::m_webview

private

Referenced by WipingDialog().

---

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

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