Slic3r::GUI::MenuFactory Class Reference

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

Collaboration diagram for Slic3r::GUI::MenuFactory:

Classes
struct	HandyModel

Public Member Functions
	MenuFactory ()
	~MenuFactory ()=default
void	init (wxWindow *parent)
void	update ()
void	update_object_menu ()
void	update_default_menu ()
void	msw_rescale ()
void	sys_color_changed ()
wxMenu *	default_menu ()
wxMenu *	object_menu ()
wxMenu *	sla_object_menu ()
wxMenu *	part_menu ()
wxMenu *	text_part_menu ()
wxMenu *	svg_part_menu ()
wxMenu *	instance_menu ()
wxMenu *	layer_menu ()
wxMenu *	multi_selection_menu ()
wxMenu *	plate_menu ()
wxMenu *	assemble_object_menu ()
wxMenu *	assemble_part_menu ()
wxMenu *	assemble_multi_selection_menu ()
wxMenu *	filament_action_menu (int active_filament_menu_id)

Static Public Member Functions
static std::vector< wxBitmap >	get_volume_bitmaps ()
static std::vector< wxBitmap >	get_text_volume_bitmaps ()
static std::vector< wxBitmap >	get_svg_volume_bitmaps ()
static const std::vector< HandyModel > &	handy_models ()
static void	load_handy_model (std::size_t index)
static void	add_text_volume (ModelVolumeType type)
static void	add_svg_volume (ModelVolumeType type)
static void	sys_color_changed (wxMenuBar *menu_bar)

Private Types
enum	MenuType { mtObjectFFF = 0 , mtObjectSLA , mtCount }

Private Member Functions
size_t	FindPositionById (wxMenu *menu, int id)
void	create_default_menu ()
void	create_common_object_menu (wxMenu *menu)
void	create_object_menu ()
void	create_sla_object_menu ()
void	create_text_part_menu ()
void	create_svg_part_menu ()
void	create_plate_menu ()
void	create_extra_object_menu ()
void	create_bbl_part_menu ()
void	create_bbl_assemble_object_menu ()
void	create_bbl_assemble_part_menu ()
void	create_filament_action_menu (bool init, int active_filament_menu_id)
wxMenu *	append_submenu_add_generic (wxMenu *menu, ModelVolumeType type)
wxMenu *	append_submenu_add_handy_model (wxMenu *menu, ModelVolumeType type)
void	append_menu_item_add_text (wxMenu *menu, ModelVolumeType type, bool is_submenu_item=true)
void	append_menu_item_add_svg (wxMenu *menu, ModelVolumeType type, bool is_submenu_item=true)
void	append_menu_items_add_volume (wxMenu *menu)
wxMenuItem *	append_menu_item_layers_editing (wxMenu *menu)
wxMenuItem *	append_menu_item_settings (wxMenu *menu)
wxMenuItem *	append_menu_item_change_type (wxMenu *menu)
wxMenuItem *	append_menu_item_instance_to_object (wxMenu *menu)
wxMenuItem *	append_menu_item_printable (wxMenu *menu)
wxMenuItem *	append_menu_item_auto_drop (wxMenu *menu)
void	append_menu_item_rename (wxMenu *menu)
wxMenuItem *	append_menu_item_fix_through_cgal (wxMenu *menu)
void	append_menu_item_export_stl (wxMenu *menu, bool is_mulity_menu=false)
void	append_menu_item_export_drc (wxMenu *menu, bool is_mulity_menu=false)
void	append_menu_item_reload_from_disk (wxMenu *menu)
void	append_menu_item_replace_with_stl (wxMenu *menu)
void	append_menu_item_replace_all_with_stl (wxMenu *menu)
void	append_menu_item_change_extruder (wxMenu *menu)
void	append_menu_item_set_visible (wxMenu *menu)
void	append_menu_item_delete (wxMenu *menu)
void	append_menu_item_scale_selection_to_fit_print_volume (wxMenu *menu)
void	append_menu_items_convert_unit (wxMenu *menu)
void	append_menu_items_flush_options (wxMenu *menu, size_t pos=-1)
void	append_menu_item_merge_to_multipart_object (wxMenu *menu)
void	append_menu_item_merge_to_single_object (wxMenu *menu)
void	append_menu_item_align_distribute (wxMenu *menu)
void	append_menu_item_precise_seam_submenu (wxMenu *menu)
void	append_menu_item_invalidate_cut_info (wxMenu *menu, size_t pos=-1)
void	append_menu_item_edit_text (wxMenu *menu, size_t pos=-1)
void	append_menu_item_edit_svg (wxMenu *menu, size_t pos=-1)
void	append_menu_items_instance_manipulation (wxMenu *menu)
void	append_menu_item_clone (wxMenu *menu)
void	append_menu_item_simplify (wxMenu *menu)
void	append_menu_item_smooth_mesh (wxMenu *menu)
void	append_menu_item_center (wxMenu *menu)
void	append_menu_item_drop (wxMenu *menu)
void	append_menu_item_per_object_process (wxMenu *menu)
void	append_menu_item_per_object_settings (wxMenu *menu, size_t pos=-1)
void	append_menu_item_change_filament (wxMenu *menu, size_t pos=-1)
void	append_menu_item_set_printable (wxMenu *menu)
void	append_menu_item_set_auto_drop (wxMenu *menu)
void	append_menu_item_locked (wxMenu *menu, size_t pos=-1)
void	append_menu_item_fill_bed (wxMenu *menu)
void	append_menu_item_plate_name (wxMenu *menu, size_t pos=-1)
void	append_menu_item_plate_delete (wxMenu *menu, size_t pos=-1)
wxMenu *	append_menu_item_transform (wxMenu *menu, bool multi_selection, bool show_mirror, bool is_scalable)
wxMenu *	append_menu_item_modify (wxMenu *menu, bool multi_selection, bool splittable, bool is_mesh, bool mesh_boolean)
wxMenu *	append_menu_item_more (wxMenu *menu, bool multi_selection, bool disk_op, bool export_op)

Private Attributes
wxWindow *	m_parent {nullptr}
MenuWithSeparators	m_object_menu
wxMenu *	m_object_transform_menu
size_t	m_object_geometry_pos
int	m_object_props_marker
MenuWithSeparators	m_part_menu
wxMenu *	m_part_transform_menu
int	m_part_props_marker
int	m_part_project_marker
MenuWithSeparators	m_text_part_menu
int	m_text_props_marker
int	m_text_project_marker
MenuWithSeparators	m_svg_part_menu
int	m_svg_props_marker
int	m_svg_project_marker
MenuWithSeparators	m_sla_object_menu
MenuWithSeparators	m_default_menu
MenuWithSeparators	m_instance_menu
MenuWithSeparators	m_plate_menu
size_t	m_plate_mods_pos
MenuWithSeparators	m_assemble_object_menu
MenuWithSeparators	m_assemble_part_menu
wxMenu	m_filament_action_menu
std::array< wxMenuItem *, mtCount >	items_increase
std::array< wxMenuItem *, mtCount >	items_decrease
std::array< wxMenuItem *, mtCount >	items_set_number_of_copies

Detailed Description

---

Class Documentation

Slic3r::GUI::MenuFactory::HandyModel

struct Slic3r::GUI::MenuFactory::HandyModel

Collaboration diagram for Slic3r::GUI::MenuFactory::HandyModel:

Class Members
bool	arrange_after_import = false
vector< string >	file_names
bool	is_stringhell = false
const char *	key
const char *	label

Member Enumeration Documentation

MenuType

enum Slic3r::GUI::MenuFactory::MenuType

private

Enumerator
mtObjectFFF
mtObjectSLA
mtCount

                  {
        mtObjectFFF = 0,
        mtObjectSLA,
        mtCount
    };

Constructor & Destructor Documentation

MenuFactory()

Slic3r::GUI::MenuFactory::MenuFactory

(

)

{
    for (int i = 0; i < mtCount; i++) {
        items_increase[i] = nullptr;
        items_decrease[i] = nullptr;
        items_set_number_of_copies[i] = nullptr;
    }
}

References MenuFactory(), items_decrease, items_increase, items_set_number_of_copies, and mtCount.

Referenced by MenuFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

~MenuFactory()

Slic3r::GUI::MenuFactory::~MenuFactory ( )

default

Member Function Documentation

add_svg_volume()

void Slic3r::GUI::MenuFactory::add_svg_volume ( ModelVolumeType type )

static

{ add_volume_with_gizmo(GLGizmosManager::Svg, type); }

References add_svg_volume(), Slic3r::GUI::add_volume_with_gizmo(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by add_svg_volume(), and Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog().

Here is the call graph for this function:

Here is the caller graph for this function:

add_text_volume()

void Slic3r::GUI::MenuFactory::add_text_volume ( ModelVolumeType type )

static

{ add_volume_with_gizmo(GLGizmosManager::Emboss, type); }

References add_text_volume(), Slic3r::GUI::add_volume_with_gizmo(), and Slic3r::GUI::GLGizmosManager::Emboss.

Referenced by add_text_volume(), and Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_add_svg()

void Slic3r::GUI::MenuFactory::append_menu_item_add_svg ( wxMenu * menu, ModelVolumeType type, bool is_submenu_item = true )

private

                                                                                                    {
    append_menu_itemm_add_(_L("SVG"), GLGizmosManager::Svg, menu, type, is_submenu_item);
}

References _L, append_menu_item_add_svg(), Slic3r::GUI::append_menu_itemm_add_(), and Slic3r::GUI::GLGizmosManager::Svg.

Referenced by append_menu_item_add_svg(), and append_submenu_add_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_add_text()

void Slic3r::GUI::MenuFactory::append_menu_item_add_text ( wxMenu * menu, ModelVolumeType type, bool is_submenu_item = true )

private

                                                                                                    {
    append_menu_itemm_add_(_L("Text"), GLGizmosManager::Emboss, menu, type, is_submenu_item);
}

References _L, append_menu_item_add_text(), Slic3r::GUI::append_menu_itemm_add_(), and Slic3r::GUI::GLGizmosManager::Emboss.

Referenced by append_menu_item_add_text(), and append_submenu_add_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_align_distribute()

void Slic3r::GUI::MenuFactory::append_menu_item_align_distribute ( wxMenu * menu )

private

{
    using AlignType = GLGizmoAlignment::AlignType;
    auto can = [](AlignType type) {
        if (plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasView3D)
            return false;
        GLGizmoAlignment alignment_helper(*plater()->get_view3D_canvas3D());
        return type >= AlignType::DISTRIBUTE_X ? alignment_helper.can_distribute(type) : alignment_helper.can_align(type);
    };
    auto run = [](AlignType type) {
        GLGizmoAlignment alignment_helper(*plater()->get_view3D_canvas3D());
        if (type >= AlignType::DISTRIBUTE_X)
            alignment_helper.distribute_objects(type);
        else
            alignment_helper.align_objects(type);
    };
 
    struct AlignMenuItem
    {
        wxString    label;
        AlignType   type;
        std::string icon;
    };
    const AlignMenuItem items[] = {
        // icons shared with caanvas. BitmapCache converts colors dark to light. so dark variations used for proper colors
        {_L("Distribute left-right")   + " (X)" , AlignType::DISTRIBUTE_X, "distribute_x_dark"},
        {_L("Distribute front-back")   + " (Y)" , AlignType::DISTRIBUTE_Y, "distribute_y_dark"},
        {_L("Distribute top-bottom")   + " (Z)" , AlignType::DISTRIBUTE_Z, "distribute_z_dark"},
        {wxString(),                              AlignType::NONE,         ""},
        {_L("Align left")              + " (-X)", AlignType::X_MIN,        "align_x_min_dark"},
        {_L("Align left-right center") + " (X)" , AlignType::CENTER_X,     "align_x_center_dark"},
        {_L("Align right")             + " (+X)", AlignType::X_MAX,        "align_x_max_dark"},
        {wxString(),                              AlignType::NONE,         ""},
        {_L("Align front")             + " (-Y)", AlignType::Y_MIN,        "align_y_min_dark"},
        {_L("Align front-back center") + " (Y)" , AlignType::CENTER_Y,     "align_y_center_dark"},
        {_L("Align back")              + " (+Y)", AlignType::Y_MAX,        "align_y_max_dark"},
        {wxString(),                              AlignType::NONE,         ""},
        {_L("Align bottom")            + " (-Z)", AlignType::Z_MIN,        "align_z_min_dark"},
        {_L("Align top-bottom center") + " (Z)" , AlignType::CENTER_Z,     "align_z_center_dark"},
        {_L("Align top")               + " (+Z)", AlignType::Z_MAX,        "align_z_max_dark"},
    };
 
    wxMenu* align_distribute_menu = new wxMenu();
    for (const AlignMenuItem &item : items) {
        const AlignType type = item.type;
        if (type == AlignType::NONE)
            align_distribute_menu->AppendSeparator();
        else
            append_menu_item(
                align_distribute_menu, wxID_ANY, item.label, "", [run, type](wxCommandEvent &) { run(type); }, item.icon, nullptr,
                [can, type]() { return can(type); }, m_parent);
    }
 
    // Anything that can be distributed can also be aligned, and aligning in X has no extra condition.
    append_submenu(menu, align_distribute_menu, wxID_ANY, _L("Align/Distribute"), _L("Align and distribute objects"), "",
        [can]() { return can(AlignType::X_MIN); }, m_parent);
}

References _L, Slic3r::GUI::GLGizmoAlignment::align_objects(), append_menu_item(), append_menu_item_align_distribute(), append_submenu(), Slic3r::GUI::GLGizmoAlignment::can_align(), Slic3r::GUI::GLGizmoAlignment::can_distribute(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::GUI::GLGizmoAlignment::distribute_objects(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_align_distribute(), create_bbl_part_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_auto_drop()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_auto_drop ( wxMenu * menu )

private

{
    wxString    menu_text                       = _L("Auto Drop");
    wxString    menu_tooltip                    = _L("Automatically drops the selected object to the build plate.");
    wxMenuItem* menu_item_auto_drop = append_menu_check_item(
        menu, wxID_ANY, menu_text, menu_tooltip,
        [](wxCommandEvent&) { obj_list()->toggle_auto_drop(); }, menu);
 
    m_parent->Bind(wxEVT_UPDATE_UI, [](wxUpdateUIEvent& evt) {
        bool check = wxGetApp().plater()->get_selection().get_auto_drop();
        evt.Check(check);
    },
    menu_item_auto_drop->GetId());
 
    return menu_item_auto_drop;
}

References _L, append_menu_check_item(), append_menu_item_auto_drop(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_auto_drop(), and create_extra_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_center()

void Slic3r::GUI::MenuFactory::append_menu_item_center ( wxMenu * menu )

private

{
     append_menu_item(menu, wxID_ANY, _L("Center") , "",
        [](wxCommandEvent&) {
            plater()->center_selection();
        }, "", nullptr,
        []() {
            if (plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasView3D)
                return false;
            else {
                Selection& selection = plater()->get_view3D_canvas3D()->get_selection();
                PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
                Vec3d model_pos = selection.get_bounding_box().center();
                Vec3d center_pos = plate->get_center_origin();
                return !( (model_pos.x() == center_pos.x()) && (model_pos.y() == center_pos.y()) );
            } //disable if model is at center / not in View3D
        }, m_parent);
}

References _L, append_menu_item(), append_menu_item_center(), Slic3r::GUI::GLCanvas3D::CanvasView3D, Slic3r::BoundingBox3Base< PointType >::center(), Slic3r::GUI::Selection::get_bounding_box(), Slic3r::GUI::PartPlate::get_center_origin(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_center(), create_bbl_part_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_change_extruder()

void Slic3r::GUI::MenuFactory::append_menu_item_change_extruder ( wxMenu * menu )

private

{
    // BBS
    const std::vector<wxString> names = { _L("Change filament"), _L("Set filament for selected items") };
    // Delete old menu item
    for (const wxString& name : names) {
        const int item_id = menu->FindItem(name);
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
    }
 
    const int filaments_cnt = filaments_count();
    if (filaments_cnt <= 1)
        return;
 
    wxDataViewItemArray sels;
    obj_list()->GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    std::vector<wxBitmap*> icons = get_extruder_color_icons(true);
    wxMenu* extruder_selection_menu = new wxMenu();
    const wxString& name = sels.Count() == 1 ? names[0] : names[1];
 
    int initial_extruder = -1; // negative value for multiple object/part selection
    if (sels.Count() == 1) {
        const ModelConfig& config = obj_list()->get_item_config(sels[0]);
        // BBS: set default extruder to 1
        initial_extruder = config.has("extruder") ? config.extruder() : 1;
    }
 
    for (int i = 0; i <= filaments_cnt; i++)
    {
        bool is_active_extruder = i == initial_extruder;
        int icon_idx = i == 0 ? 0 : i - 1;
 
        wxString item_name = _L("Default");
 
        if (i > 0) {
            auto preset = wxGetApp().preset_bundle->filaments.find_preset(wxGetApp().preset_bundle->filament_presets[i - 1]);
            if (preset == nullptr) {
                item_name = wxString::Format(_L("Filament %d"), i);
            } else {
                item_name = from_u8(preset->label(false));
            }
        }
 
        if (is_active_extruder) {
            item_name << " (" + _L("current") + ")";
        }
 
        if (icon_idx >= 0 && icon_idx < icons.size()) {
            append_menu_item(
                extruder_selection_menu, wxID_ANY, item_name, "", [i](wxCommandEvent &) { obj_list()->set_extruder_for_selected_items(i); }, *icons[icon_idx], menu,
                [is_active_extruder]() { return !is_active_extruder; }, m_parent);
        } else {
            append_menu_item(
                extruder_selection_menu, wxID_ANY, item_name, "", [i](wxCommandEvent &) { obj_list()->set_extruder_for_selected_items(i); }, "", menu,
                [is_active_extruder]() { return !is_active_extruder; }, m_parent);
        }
    }
 
    menu->AppendSubMenu(extruder_selection_menu, name);
}

References _L, append_menu_item(), append_menu_item_change_extruder(), Slic3r::ModelConfig::extruder(), Slic3r::GUI::filaments_count(), Slic3r::GUI::from_u8(), get_extruder_color_icons(), Slic3r::ModelConfig::has(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_change_extruder(), assemble_multi_selection_menu(), assemble_object_menu(), and assemble_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_change_filament()

void Slic3r::GUI::MenuFactory::append_menu_item_change_filament ( wxMenu * menu, size_t pos = -1 )

private

{
    const std::vector<wxString> names = { _L("Change Filament"), _L("Set Filament for selected items") };
    // Delete old menu item
    for (const wxString& name : names) {
        const int item_id = menu->FindItem(name);
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
    }
 
    int filaments_cnt = filaments_count();
    if (filaments_cnt <= 1)
        return;
 
    wxDataViewItemArray sels;
    obj_list()->GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    if (sels.Count() == 1) {
        const auto sel_vol = obj_list()->get_selected_model_volume();
        if (sel_vol && sel_vol->type() != ModelVolumeType::MODEL_PART && sel_vol->type() != ModelVolumeType::PARAMETER_MODIFIER)
            return;
    }
 
    std::vector<wxBitmap*> icons = get_extruder_color_icons(true);
    if (icons.size() < filaments_cnt) {
        BOOST_LOG_TRIVIAL(warning) << boost::format("Warning: icons size %1%, filaments_cnt=%2%")%icons.size()%filaments_cnt;
        if (icons.size() <= 1)
            return;
        else
            filaments_cnt = icons.size();
    }
    wxMenu* extruder_selection_menu = new wxMenu();
    const wxString& name = sels.Count() == 1 ? names[0] : names[1];
 
    int initial_extruder = -1; // negative value for multiple object/part selection
    if (sels.Count() == 1) {
        const ModelConfig& config = obj_list()->get_item_config(sels[0]);
        // BBS
        const auto sel_vol = obj_list()->get_selected_model_volume();
        if (sel_vol && sel_vol->type() == ModelVolumeType::PARAMETER_MODIFIER)
            initial_extruder = config.has("extruder") ? config.extruder() : 0;
        else
            initial_extruder = config.has("extruder") ? config.extruder() : 1;
    }
 
    // BBS
    bool has_modifier = false;
    for (auto sel : sels) {
        if (obj_list()->GetModel()->GetVolumeType(sel) == ModelVolumeType::PARAMETER_MODIFIER) {
            has_modifier = true;
            break;
        }
    }
 
    for (int i = has_modifier ? 0 : 1; i <= filaments_cnt; i++)
    {
        // BBS
        //bool is_active_extruder = i == initial_extruder;
        bool is_active_extruder = false;
 
        wxString item_name = _L("Default");
 
        if (i > 0) {
            auto preset = wxGetApp().preset_bundle->filaments.find_preset(wxGetApp().preset_bundle->filament_presets[i - 1]);
            if (preset == nullptr) {
                item_name = wxString::Format(_L("Filament %d"), i);
            } else {
                item_name = from_u8(preset->label(false));
            }
        }
 
        if (is_active_extruder) {
            item_name << " (" + _L("current") + ")";
        }
 
        append_menu_item(extruder_selection_menu, wxID_ANY, item_name, "",
            [i](wxCommandEvent&) { obj_list()->set_extruder_for_selected_items(i); }, i == 0 ? wxNullBitmap : *icons[i - 1], menu,
            [is_active_extruder]() { return !is_active_extruder; }, m_parent);
    }
    if (pos == wxNOT_FOUND)
        menu->Append(wxID_ANY, name, extruder_selection_menu);
    else
        menu->Insert(pos, wxID_ANY, name, extruder_selection_menu, _L("Change Filament"));
}

References _L, append_menu_item(), append_menu_item_change_filament(), Slic3r::ModelConfig::extruder(), Slic3r::GUI::filaments_count(), Slic3r::GUI::from_u8(), get_extruder_color_icons(), Slic3r::ModelConfig::has(), m_parent, Slic3r::MODEL_PART, Slic3r::GUI::obj_list(), and Slic3r::PARAMETER_MODIFIER.

Referenced by append_menu_item_change_filament(), multi_selection_menu(), object_menu(), part_menu(), svg_part_menu(), and text_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_change_type()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_change_type ( wxMenu * menu )

private

{
    const wxString menu_name = _L("Change Type");
 
    // Delete old menu item if exists
    const int item_id = menu->FindItem(menu_name);
    if (item_id != wxNOT_FOUND)
        menu->Destroy(item_id);
 
    // Create submenu
    wxMenu* type_menu = new wxMenu();
 
    struct TypeInfo {
        ModelVolumeType type;
        wxString label;
    };
 
    std::vector<TypeInfo> types = {
        { ModelVolumeType::MODEL_PART,          _L("Part") },
        { ModelVolumeType::NEGATIVE_VOLUME,     _L("Negative Part") },
        { ModelVolumeType::PARAMETER_MODIFIER,  _L("Modifier") },
        { ModelVolumeType::SUPPORT_BLOCKER,     _L("Support Blocker") },
        { ModelVolumeType::SUPPORT_ENFORCER,    _L("Support Enforcer") },
        // Single "Precise Seam" entry that maps to PRECISE_SEAM_CENTER as the default subtype.
        // set_volume_type() preserves the existing subtype (LEFT/RIGHT/etc.) for volumes that
        // are already Precise Seam; subtype picking is done via the separate
        // "Precise Seam Type" submenu (see append_menu_item_precise_seam_submenu).
        { ModelVolumeType::PRECISE_SEAM_CENTER, _L("Precise Seam") }
    };
 
    for (const auto& info : types) {
        wxMenuItem* item = append_menu_check_item(type_menu, wxID_ANY, info.label, "",
            [type = info.type](wxCommandEvent&) { obj_list()->set_volume_type(type); }, type_menu);
 
        // Update checkmark dynamically when menu is shown - check all selected volumes
        m_parent->Bind(wxEVT_UPDATE_UI, [type = info.type](wxUpdateUIEvent& evt) {
            auto model = obj_list()->GetModel();
            auto objs  = obj_list()->objects();
            bool has_type = false;
            wxDataViewItemArray sels;
            obj_list()->GetSelections(sels);
            for (auto item : sels) {
                ModelVolumeType vol_type = model->GetVolumeType(item);
                // The "Precise Seam" entry represents all six PS subtypes, so any subtype
                // among selected volumes counts as a match (keeps the checkbox ticked when
                // user has PS_LEFT/RIGHT/etc. selected, not only plain CENTER).
                const bool match = (type == ModelVolumeType::PRECISE_SEAM_CENTER)
                    ? is_precise_seam(vol_type)
                    : (vol_type == type);
                if (match) {
                    has_type = true;
                    break;
                }
            }
            evt.Check(has_type);
 
            // ORCA Fix crash caused by SVG/TEXT volumes cant be Support Enforcer/Blocker type
            // The same applies to Precise Seam subtypes.
            for (auto item : sels) {
                if (model->GetItemType(item) == itVolume){
                    auto vol_idx = model->GetVolumeIdByItem(item);
                    auto obj_idx = model->GetObjectIdByItem(item);
                    if (vol_idx < 0 || obj_idx < 0)
                        continue;
 
                    auto vol = (*objs)[obj_idx]->volumes[vol_idx];
 
                    // disable Support Enforcer/Blocker if selection contains svg or text
                    // (same applies to Precise Seam)
                    if (vol != nullptr && (vol->is_svg() || vol->is_text()) && (type == ModelVolumeType::SUPPORT_BLOCKER || type == ModelVolumeType::SUPPORT_ENFORCER || is_precise_seam(type))){
                        evt.Enable(false);
                        break;
                    }
                }
            }
        }, item->GetId());
    }
 
    menu->Append(wxID_ANY, menu_name, type_menu, _L("Change part type"));
    return nullptr;
}

References _L, append_menu_check_item(), append_menu_item_change_type(), Slic3r::is_precise_seam(), Slic3r::GUI::itVolume, m_parent, Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, Slic3r::PARAMETER_MODIFIER, Slic3r::PRECISE_SEAM_CENTER, Slic3r::SUPPORT_BLOCKER, and Slic3r::SUPPORT_ENFORCER.

Referenced by append_menu_item_change_type(), create_bbl_part_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_clone()

void Slic3r::GUI::MenuFactory::append_menu_item_clone ( wxMenu * menu )

private

{
    const std::string accel = wxGetApp().shortcuts().accelerator(Shortcut::CloneSelected);
    append_menu_item(menu, wxID_ANY, _L("Clone") + (accel.empty() ? wxString() : "\t" + from_u8(accel)), "",
        [](wxCommandEvent&) {
            plater()->clone_selection();
        }, "", nullptr,
        []() {
            return true;
        }, m_parent);
}

References _L, append_menu_item(), append_menu_item_clone(), Slic3r::GUI::CloneSelected, Slic3r::GUI::from_u8(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_clone(), and create_extra_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_delete()

void Slic3r::GUI::MenuFactory::append_menu_item_delete ( wxMenu * menu )

private

{
#ifdef __WINDOWS__
    append_menu_item(menu, wxID_ANY, _L("Delete") + "\t" + _L_CONTEXT("Del", "Keyboard Shortcut"), _L("Delete the selected object"),
        [](wxCommandEvent&) { plater()->remove_selected(); }, "menu_delete", nullptr,
        []() { return plater()->can_delete(); }, m_parent);
#else
    append_menu_item(menu, wxID_ANY, _L("Delete") + "\t" + _L_CONTEXT("Backspace", "Keyboard Shortcut"), _L("Delete the selected object"),
        [](wxCommandEvent&) { plater()->remove_selected(); }, "", nullptr,
        []() { return plater()->can_delete(); }, m_parent);
#endif
}

References _L, _L_CONTEXT, append_menu_item(), append_menu_item_delete(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_delete(), assemble_multi_selection_menu(), assemble_object_menu(), assemble_part_menu(), create_bbl_assemble_object_menu(), create_bbl_assemble_part_menu(), create_bbl_part_menu(), create_common_object_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_drop()

void Slic3r::GUI::MenuFactory::append_menu_item_drop ( wxMenu * menu )

private

{
     append_menu_item(menu, wxID_ANY, _L("Drop") , "",
        [](wxCommandEvent&) {
            plater()->drop_selection();
        }, "", nullptr,
        []() {
            if (plater()->canvas3D()->get_canvas_type() != GLCanvas3D::ECanvasType::CanvasView3D)
                return false;
            else {
                return plater()->get_view3D_canvas3D()->get_selection().can_drop();
            } //disable if model is on the bed / not in View3D
        }, m_parent);
}

References _L, append_menu_item(), append_menu_item_drop(), Slic3r::GUI::GLCanvas3D::CanvasView3D, m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_drop(), create_bbl_part_menu(), create_extra_object_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_edit_svg()

void Slic3r::GUI::MenuFactory::append_menu_item_edit_svg ( wxMenu * menu, size_t pos = -1 )

private

{
    wxString name = _L("Edit SVG");
    auto can_edit_svg = []() {
        if (plater() == nullptr)
            return false;
        const Selection& selection = plater()->get_selection();
        if (selection.volumes_count() != 1)
            return false;
        const GLVolume* gl_volume = selection.get_first_volume();
        if (gl_volume == nullptr)
            return false;
        const ModelVolume *volume = get_model_volume(*gl_volume, selection.get_model()->objects);
        if (volume == nullptr)
            return false;
        return volume->is_svg();
    };
 
    if (menu != &m_svg_part_menu) {
        const int menu_item_id = menu->FindItem(name);
        if (menu_item_id != wxNOT_FOUND) {
            // Delete old menu item and the separator placed right after it
            const size_t item_pos = FindPositionById(menu, menu_item_id);
            if (item_pos != size_t(wxNOT_FOUND) && item_pos + 1 < menu->GetMenuItemCount() && menu->FindItemByPosition(item_pos + 1)->IsSeparator())
                menu->Destroy(menu->FindItemByPosition(item_pos + 1));
            menu->Destroy(menu_item_id);
        }
        if (!can_edit_svg())
            return;
    }
 
    wxString description = _L("Change SVG source file, projection, size, ...");
    std::string icon = "cog";
    auto open_svg = [](const wxCommandEvent &) {
        GLGizmosManager &mng = plater()->get_view3D_canvas3D()->get_gizmos_manager();
        if (mng.get_current_type() == GLGizmosManager::Svg)
            mng.open_gizmo(GLGizmosManager::Svg); // close() and reopen - move to be visible
        mng.open_gizmo(GLGizmosManager::Svg);
    };
    append_menu_item(menu, wxID_ANY, name, description, open_svg, icon, nullptr, can_edit_svg, m_parent, pos);
    if (pos == size_t(wxNOT_FOUND))
        menu->AppendSeparator();
    else
        menu->InsertSeparator(pos + 1);
}

References _L, append_menu_item(), append_menu_item_edit_svg(), FindPositionById(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::ModelVolume::is_svg(), m_parent, m_svg_part_menu, Slic3r::Model::objects, Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::plater(), Slic3r::GUI::GLGizmosManager::Svg, and Slic3r::GUI::Selection::volumes_count().

Referenced by append_menu_item_edit_svg(), create_svg_part_menu(), object_menu(), and sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_edit_text()

void Slic3r::GUI::MenuFactory::append_menu_item_edit_text ( wxMenu * menu, size_t pos = -1 )

private

{
    wxString name        = _L("Edit text");
 
    auto can_edit_text = []() {
        if (plater() == nullptr)
            return false;
        const Selection& selection = plater()->get_selection();
        if (selection.volumes_count() != 1)
            return false;
        const GLVolume* gl_volume = selection.get_first_volume();
        if (gl_volume == nullptr)
            return false;
        const ModelVolume *volume = get_model_volume(*gl_volume, selection.get_model()->objects);
        if (volume == nullptr)
            return false;
        return volume->is_text();
    };
 
    if (menu != &m_text_part_menu) {
        const int menu_item_id = menu->FindItem(name);
        if (menu_item_id != wxNOT_FOUND) {
            // Delete old menu item and the separator placed right after it
            const size_t item_pos = FindPositionById(menu, menu_item_id);
            if (item_pos != size_t(wxNOT_FOUND) && item_pos + 1 < menu->GetMenuItemCount() && menu->FindItemByPosition(item_pos + 1)->IsSeparator())
                menu->Destroy(menu->FindItemByPosition(item_pos + 1));
            menu->Destroy(menu_item_id);
        }
        if (!can_edit_text())
            return;
    }
 
    wxString description = _L("Ability to change text, font, size, ...");
    std::string icon = "cog";
    auto open_emboss = [](const wxCommandEvent &) {
        GLGizmosManager &mng = plater()->get_view3D_canvas3D()->get_gizmos_manager();
        if (mng.get_current_type() == GLGizmosManager::Emboss)
            mng.open_gizmo(GLGizmosManager::Emboss); // close() and reopen - move to be visible
        mng.open_gizmo(GLGizmosManager::Emboss);
    };
    append_menu_item(menu, wxID_ANY, name, description, open_emboss, icon, nullptr, can_edit_text, m_parent, pos);
    if (pos == size_t(wxNOT_FOUND))
        menu->AppendSeparator();
    else
        menu->InsertSeparator(pos + 1);
}

References _L, append_menu_item(), append_menu_item_edit_text(), Slic3r::GUI::GLGizmosManager::Emboss, FindPositionById(), Slic3r::GUI::GLGizmosManager::get_current_type(), Slic3r::GUI::Selection::get_first_volume(), Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::ModelVolume::is_text(), m_parent, m_text_part_menu, Slic3r::Model::objects, Slic3r::GUI::GLGizmosManager::open_gizmo(), Slic3r::GUI::plater(), and Slic3r::GUI::Selection::volumes_count().

Referenced by append_menu_item_edit_text(), create_bbl_part_menu(), create_text_part_menu(), object_menu(), and sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_export_drc()

void Slic3r::GUI::MenuFactory::append_menu_item_export_drc ( wxMenu * menu, bool is_mulity_menu = false )

private

{
    append_menu_item(menu, wxID_ANY, _L("Export as one DRC") + dots, "",
        [](wxCommandEvent&) { plater()->export_stl(false, true, false, FT_DRC); }, "", nullptr,
        [is_mulity_menu]() {
            const Selection& selection = plater()->canvas3D()->get_selection();
            if (is_mulity_menu)
                return selection.is_multiple_full_instance() || selection.is_multiple_full_object();
            else
                return selection.is_single_full_instance() || selection.is_single_full_object();
        }, m_parent);
    if (!is_mulity_menu)
        return;
    append_menu_item(menu, wxID_ANY, _L("Export as DRCs") + dots, "",
        [](wxCommandEvent&) { plater()->export_stl(false, true, true, FT_DRC); }, "", nullptr,
        []() {
            const Selection& selection = plater()->canvas3D()->get_selection();
            return selection.is_multiple_full_instance() || selection.is_multiple_full_object();
        }, m_parent);
}

References _L, append_menu_item(), append_menu_item_export_drc(), Slic3r::GUI::dots(), Slic3r::GUI::FT_DRC, Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_export_drc(), append_menu_item_more(), and create_common_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_export_stl()

void Slic3r::GUI::MenuFactory::append_menu_item_export_stl ( wxMenu * menu, bool is_mulity_menu = false )

private

{
    append_menu_item(menu, wxID_ANY, _L("Export as one STL") + dots, "",
        [](wxCommandEvent&) { plater()->export_stl(false, true); }, "", nullptr,
        [is_mulity_menu]() {
            const Selection& selection = plater()->canvas3D()->get_selection();
            if (is_mulity_menu)
                return selection.is_multiple_full_instance() || selection.is_multiple_full_object();
            else
                return selection.is_single_full_instance() || selection.is_single_full_object();
        }, m_parent);
    if (!is_mulity_menu)
        return;
    append_menu_item(menu, wxID_ANY, _L("Export as STLs") + dots, "",
        [](wxCommandEvent&) { plater()->export_stl(false, true, true); }, "", nullptr,
        []() {
            const Selection& selection = plater()->canvas3D()->get_selection();
            return selection.is_multiple_full_instance() || selection.is_multiple_full_object();
        }, m_parent);
}

References _L, append_menu_item(), append_menu_item_export_stl(), Slic3r::GUI::dots(), Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_export_stl(), append_menu_item_more(), and create_common_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_fill_bed()

void Slic3r::GUI::MenuFactory::append_menu_item_fill_bed ( wxMenu * menu )

private

{
    append_menu_item(
        menu, wxID_ANY, _L("Fill bed with copies"), _L("Fill the remaining area of bed with copies of the selected object"),
        [](wxCommandEvent &) { plater()->fill_bed_with_copies(); }, "", nullptr, []() { return plater()->can_increase_instances(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_fill_bed(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_fill_bed().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_fix_through_cgal()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_fix_through_cgal ( wxMenu * menu )

private

{
    wxMenuItem* menu_item = append_menu_item(menu, wxID_ANY, _L("Fix Model"), "",
        [](wxCommandEvent&) { obj_list()->fix_through_cgal(); }, "", menu,
        []() {return plater()->can_fix_through_cgal(); }, plater());
 
    return menu_item;
}

References _L, append_menu_item(), append_menu_item_fix_through_cgal(), Slic3r::GUI::obj_list(), and Slic3r::GUI::plater().

Referenced by append_menu_item_fix_through_cgal(), append_menu_item_modify(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_instance_to_object()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object ( wxMenu * menu )

private

{
    wxMenuItem* menu_item = append_menu_item(menu, wxID_ANY, _L("Set as An Individual Object"), "",
        [](wxCommandEvent&) { obj_list()->split_instances(); }, "", menu);
 
    /* New behavior logic:
     * 1. Split Object to several separated object, if ALL instances are selected
     * 2. Separate selected instances from the initial object to the separated object,
     *    if some (not all) instances are selected
     */
    m_parent->Bind(wxEVT_UPDATE_UI, [](wxUpdateUIEvent& evt)
        {
            const Selection& selection = plater()->canvas3D()->get_selection();
            evt.SetText(selection.is_single_full_object() ?
                _L("Set as Individual Objects") : _L("Set as An Individual Object"));
 
            evt.Enable(plater()->can_set_instance_to_object());
        }, menu_item->GetId());
 
    return menu_item;
}

References _L, append_menu_item(), append_menu_item_instance_to_object(), Slic3r::GUI::Selection::is_single_full_object(), m_parent, Slic3r::GUI::obj_list(), and Slic3r::GUI::plater().

Referenced by append_menu_item_instance_to_object(), create_extra_object_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_invalidate_cut_info()

void Slic3r::GUI::MenuFactory::append_menu_item_invalidate_cut_info ( wxMenu * menu, size_t pos = -1 )

private

{
    const wxString menu_name = _L("Invalidate cut info");
 
    auto menu_item_id = menu->FindItem(menu_name);
    if (menu_item_id != wxNOT_FOUND) {
        // Delete old menu item (and the separator placed right after it) if selected object isn't cut
        const size_t item_pos = FindPositionById(menu, menu_item_id);
        if (item_pos != size_t(wxNOT_FOUND) && item_pos + 1 < menu->GetMenuItemCount() && menu->FindItemByPosition(item_pos + 1)->IsSeparator())
            menu->Destroy(menu->FindItemByPosition(item_pos + 1));
        menu->Destroy(menu_item_id);
    }
 
    if (obj_list()->has_selected_cut_object()) {
        append_menu_item(menu, wxID_ANY, menu_name, "", [](wxCommandEvent &) { obj_list()->invalidate_cut_info_for_selection(); },
            "cut_", menu, []() { return true; }, m_parent, pos);
        if (pos == size_t(wxNOT_FOUND))
            menu->AppendSeparator();
        else
            menu->InsertSeparator(pos + 1);
    }
}

References _L, append_menu_item(), append_menu_item_invalidate_cut_info(), FindPositionById(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_invalidate_cut_info(), and object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_layers_editing()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_layers_editing ( wxMenu * menu )

private

{
    return append_menu_item(menu, wxID_ANY, _L("Height Range Modifier"), "",
        [](wxCommandEvent&) { obj_list()->layers_editing(); wxGetApp().params_panel()->switch_to_object(); }, "height_range_modifier", menu,
        []() { return obj_list()->is_instance_or_object_selected(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_layers_editing(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_layers_editing(), and append_menu_items_add_volume().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_locked()

void Slic3r::GUI::MenuFactory::append_menu_item_locked ( wxMenu * menu, size_t pos = -1 )

private

{
    const std::vector<wxString> names = { _L("Unlock"), _L("Lock") };
    // Delete old menu item
    for (const wxString& name : names) {
        const int item_id = menu->FindItem(name);
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
    }
 
    PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
    assert(plate);
    wxString lock_text = plate->is_locked() ? names[0] : names[1];
 
    auto item = append_menu_item(menu, wxID_ANY, lock_text, "",
        [plate](wxCommandEvent&) {
            bool lock = plate->is_locked();
            plate->lock(!lock);
        }, "", nullptr, []() { return true; }, m_parent, pos);
 
    m_parent->Bind(wxEVT_UPDATE_UI, [](wxUpdateUIEvent& evt) {
        PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
        assert(plate);
        //bool check = plate->is_locked();
        //evt.Check(check);
        plater()->set_current_canvas_as_dirty();
    }, item->GetId());
}

References _L, append_menu_item(), append_menu_item_locked(), Slic3r::GUI::PartPlate::is_locked(), Slic3r::GUI::PartPlate::lock(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_locked(), and plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_merge_to_multipart_object()

void Slic3r::GUI::MenuFactory::append_menu_item_merge_to_multipart_object ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Assemble"), _L("Assemble the selected objects into an object with multiple parts"),
        [](wxCommandEvent&) { obj_list()->merge(true); }, "", menu,
        []() { return obj_list()->can_merge_to_multipart_object(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_merge_to_multipart_object(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_merge_to_multipart_object(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_merge_to_single_object()

void Slic3r::GUI::MenuFactory::append_menu_item_merge_to_single_object ( wxMenu * menu )

private

{
    menu->AppendSeparator();
    append_menu_item(menu, wxID_ANY, _L("Assemble"), _L("Assemble the selected objects into an object with single part"),
        [](wxCommandEvent&) { obj_list()->merge(false); }, "", menu,
        []() { return obj_list()->can_merge_to_single_object(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_merge_to_single_object(), m_parent, and Slic3r::GUI::obj_list().

Referenced by append_menu_item_merge_to_single_object().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_modify()

wxMenu * Slic3r::GUI::MenuFactory::append_menu_item_modify ( wxMenu * menu, bool multi_selection, bool splittable, bool is_mesh, bool mesh_boolean )

private

{
    wxMenu* sub_menu = new wxMenu();
 
    if(splittable){
        // Object Split
        append_menu_item(sub_menu, wxID_ANY, _L("Split") + ":", "", [](wxCommandEvent&){}, "", menu, [](){return false;}, m_parent);
        append_menu_item(sub_menu, wxID_ANY, _L("To Objects"), _L("Split the selected object into multiple objects"),
            [](wxCommandEvent&) { plater()->split_object(); }, "menu_split_objects", menu,
            []() { return plater()->can_split(true); }, m_parent);
        append_menu_item(sub_menu, wxID_ANY, _L("To Parts"), _L("Split the selected object into multiple parts"),
            [](wxCommandEvent&) { plater()->split_volume(); }, "menu_split_parts", menu,
            []() { return plater()->can_split(false); }, m_parent);
    }
 
    if(mesh_boolean){
        if(sub_menu->GetMenuItemCount() > 0)
            sub_menu->AppendSeparator();
        // Mesh Boolean
        append_menu_item(sub_menu, wxID_ANY, _L("Mesh boolean"), _L("Mesh boolean operations including union and subtraction"),
            [](wxCommandEvent&) { obj_list()->boolean/*merge_volumes*/(); }, "", menu,
            []() { return obj_list()->can_mesh_boolean(); }, m_parent);
 
    }
 
    if(is_mesh){
        if(sub_menu->GetMenuItemCount() > 0)
            sub_menu->AppendSeparator();
        if(!multi_selection){ // these doesnt support multiple items
            // Object Simplify
            append_menu_item_simplify(sub_menu);
            // Mesh Smooth / Subdivision
            append_menu_item_smooth_mesh(sub_menu);
            sub_menu->AppendSeparator();
        }
        // Object Repair
        append_menu_item_fix_through_cgal(sub_menu);
    }
 
    append_submenu(menu, sub_menu, wxID_ANY, _L("Modify"), "", "", [](){return true;}, m_parent);
    return sub_menu;
}

References _L, append_menu_item(), append_menu_item_fix_through_cgal(), append_menu_item_modify(), append_menu_item_simplify(), append_menu_item_smooth_mesh(), append_submenu(), m_parent, Slic3r::GUI::obj_list(), and Slic3r::GUI::plater().

Referenced by append_menu_item_modify(), create_bbl_assemble_object_menu(), create_bbl_part_menu(), create_common_object_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_more()

wxMenu * Slic3r::GUI::MenuFactory::append_menu_item_more ( wxMenu * menu, bool multi_selection, bool disk_op, bool export_op )

private

{
    wxMenu* sub_menu = new wxMenu();
 
    if(disk_op){
        // Reload from disk supports multi selection too (#16589)
        append_menu_item_reload_from_disk(sub_menu);
        sub_menu->AppendSeparator();
        if(!multi_selection) // "Replace with STL" only works on a single item
            append_menu_item_replace_with_stl(sub_menu);
        append_menu_item_replace_all_with_stl(sub_menu);
    }
    if(export_op){
        sub_menu->AppendSeparator();
        append_menu_item_export_stl(sub_menu, multi_selection);
        append_menu_item_export_drc(sub_menu, multi_selection);
    }
    append_submenu(menu, sub_menu, wxID_ANY, _L("More"), "", "",[](){return true;}, m_parent);
 
    return sub_menu;
}

References _L, append_menu_item_export_drc(), append_menu_item_export_stl(), append_menu_item_more(), append_menu_item_reload_from_disk(), append_menu_item_replace_all_with_stl(), append_menu_item_replace_with_stl(), append_submenu(), and m_parent.

Referenced by append_menu_item_more(), create_bbl_part_menu(), create_extra_object_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_per_object_process()

void Slic3r::GUI::MenuFactory::append_menu_item_per_object_process ( wxMenu * menu )

private

{
    const std::vector<wxString> names = { _L("Edit Process Settings"), _L("Edit Process Settings") };
    append_menu_item(menu, wxID_ANY, names[0], names[1],
        [](wxCommandEvent&) {
            wxGetApp().obj_list()->switch_to_object_process();
        }, "", nullptr,
        []() {
            Selection& selection = plater()->canvas3D()->get_selection();
            return selection.is_single_full_object() ||
                selection.is_multiple_full_object() ||
                selection.is_single_full_instance() ||
                selection.is_multiple_full_instance() ||
                selection.is_single_volume() ||
                selection.is_multiple_volume();
        }, m_parent);
 
    const std::vector<wxString> names2 = {_L("Copy Process Settings"), _L("Copy Process Settings")};
    append_menu_item(
        menu, wxID_ANY, names2[0], names2[1], [](wxCommandEvent &) {
            wxGetApp().obj_list()->copy_settings_to_clipboard();
        }, "", nullptr,
        []() {
            Selection &selection = plater()->canvas3D()->get_selection();
            return selection.is_single_full_object() || selection.is_single_full_instance() ||
                   selection.is_single_volume_or_modifier();
        },
        m_parent);
 
    const std::vector<wxString> names3 = {_L("Paste Process Settings"), _L("Paste Process Settings")};
    append_menu_item(
        menu, wxID_ANY, names3[0], names3[1], [](wxCommandEvent &) {
            wxGetApp().obj_list()->paste_settings_into_list();
        }, "", nullptr,
        []() {
            return wxGetApp().obj_list()->can_paste_settings_into_list();
        },
        m_parent);
}

References _L, append_menu_item(), append_menu_item_per_object_process(), Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_full_object(), Slic3r::GUI::Selection::is_multiple_volume(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_single_volume(), Slic3r::GUI::Selection::is_single_volume_or_modifier(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_per_object_process(), create_bbl_part_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_per_object_settings()

void Slic3r::GUI::MenuFactory::append_menu_item_per_object_settings ( wxMenu * menu, size_t pos = -1 )

private

{
    const std::vector<wxString> names = { _L("Edit in Parameter Table"), _L("Edit print parameters for a single object") };
    // Delete old menu item
    for (const wxString& name : names) {
        const int item_id = menu->FindItem(name);
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
    }
 
    append_menu_item(menu, wxID_ANY, names[0], names[1],
        [](wxCommandEvent&) {
            plater()->PopupObjectTableBySelection();
        }, "", nullptr,
        []() {
            Selection& selection = plater()->canvas3D()->get_selection();
            return selection.is_single_full_object() || selection.is_single_full_instance() || selection.is_single_volume();
        }, m_parent, pos);
}

References _L, append_menu_item(), append_menu_item_per_object_settings(), Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::Selection::is_single_volume(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_per_object_settings(), create_extra_object_menu(), part_menu(), svg_part_menu(), and text_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_plate_delete()

void Slic3r::GUI::MenuFactory::append_menu_item_plate_delete ( wxMenu * menu, size_t pos = -1 )

private

{
    wxString name= _L("Delete Plate");
    // Delete old menu item and the separator placed right before it
    const int item_id = menu->FindItem(name);
    if (item_id != wxNOT_FOUND) {
        const size_t item_pos = FindPositionById(menu, item_id);
        if (item_pos != size_t(wxNOT_FOUND) && item_pos > 0 && menu->FindItemByPosition(item_pos - 1)->IsSeparator())
            menu->Destroy(menu->FindItemByPosition(item_pos - 1));
        menu->Destroy(item_id);
    }
 
    menu->InsertSeparator(pos);
 
    PartPlate *plate = plater()->get_partplate_list().get_selected_plate();
    assert(plate);
 
    // delete current plate
    auto item = append_menu_item(menu, wxID_ANY, name, _L("Remove the selected plate"),
        [](wxCommandEvent&) { plater()->delete_plate(); }, "", nullptr,
        []() { return plater()->can_delete_plate(); }, m_parent, pos + 1);
 
    // no extra wxEVT_UPDATE_UI handler here: a second handler on the same id runs before the one bound 
    // by append_menu_item() and, without evt.Skip(), swallows the enable/disable condition
}

References _L, append_menu_item(), append_menu_item_plate_delete(), FindPositionById(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_plate_delete(), and plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_plate_name()

void Slic3r::GUI::MenuFactory::append_menu_item_plate_name ( wxMenu * menu, size_t pos = -1 )

private

{
    wxString name= _L("Edit Plate Name");
    // Delete old menu item
    const int item_id = menu->FindItem(name);
    if (item_id != wxNOT_FOUND) menu->Destroy(item_id);
 
    PartPlate *plate = plater()->get_partplate_list().get_selected_plate();
    assert(plate);
 
    auto item = append_menu_item(
        menu, wxID_ANY, name, "",
        [](wxCommandEvent &e) {
            int hover_idx =plater()->canvas3D()->GetHoverId();
            if (hover_idx == -1) {
                int plate_idx=plater()->GetPlateIndexByRightMenuInLeftUI();
                plater()->select_plate_by_hover_id(plate_idx * PartPlate::GRABBER_COUNT, false, true);
            }
            else
            {
                plater()->select_plate_by_hover_id(hover_idx, false, true);
            }
            plater()->get_current_canvas3D()->post_event(SimpleEvent(EVT_GLCANVAS_PLATE_NAME_CHANGE));
        },
        "", nullptr, []() { return true; }, m_parent, pos);
 
    m_parent->Bind(
        wxEVT_UPDATE_UI,
        [](wxUpdateUIEvent &evt) {
            PartPlate *plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            plater()->set_current_canvas_as_dirty();
        },
        item->GetId());
}

References _L, append_menu_item(), append_menu_item_plate_name(), Slic3r::GUI::PartPlate::GRABBER_COUNT, m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_plate_name(), and plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_precise_seam_submenu()

void Slic3r::GUI::MenuFactory::append_menu_item_precise_seam_submenu ( wxMenu * menu )

private

{
    wxString submenu_name = _L("Precise Seam Type");
 
    // Remove existing submenu if present (menu is rebuilt on every right-click)
    const int menu_item_id = menu->FindItem(submenu_name);
    if (menu_item_id != wxNOT_FOUND)
        menu->Destroy(menu_item_id);
 
    // --- Precondition: ALL selected volumes must be Precise Seam ---
    // Mixed selections (PS + non-PS) are ambiguous for subtype switching: applying a subtype
    // would implicitly convert the non-PS volumes to PS, which is not what the user expects
    // from a subtype picker. For mixed selections the user should first use
    // "Change type → Precise Seam" to unify them, then come back to this submenu.
    wxDataViewItemArray sels;
    obj_list()->GetSelections(sels);
    if (sels.IsEmpty())
        return;
 
    // A right-click on a volume in the 3D view routes through Plater::show_context_menu
    // → ObjectList::update_selections(), which intentionally preserves a pre-existing
    // settings-row selection alongside the clicked volume. As a result GetSelections()
    // may return settings-row items that are children of a volume. Treat each settings
    // row as selecting its parent volume (same pattern used by set_volume_type()
    // internally). Without this resolution, GetVolumeType(settings_row) returns INVALID
    // and the submenu would hide even when a valid PS volume is in the selection.
    //
    // Precomputing the resolved PS types once here also lets the checkmark loop below
    // display checks correctly for selections that contain settings rows.
    std::vector<ModelVolumeType> selected_ps_types;
    selected_ps_types.reserve(sels.size());
 
    auto* model = obj_list()->GetModel();
    for (const auto& sel_item : sels) {
        wxDataViewItem vol_item  = sel_item;
        const ItemType type_mask = model->GetItemType(sel_item);
        if (!(type_mask & itVolume)) {
            // Only settings rows whose parent is a volume map to "selecting that volume".
            // Any other non-volume item (object, instance, etc.) means the selection is
            // not purely PS-volume-based — hide the submenu.
            if ((type_mask & itSettings) && (model->GetItemType(model->GetParent(sel_item)) & itVolume))
                vol_item = model->GetParent(sel_item);
            else
                return;
        }
        const ModelVolumeType vol_type = model->GetVolumeType(vol_item);
        if (!is_precise_seam(vol_type))
            return;
        selected_ps_types.push_back(vol_type);
    }
 
    // Match the label used by append_menu_item_change_type, including its translation.
    int insert_pos     = wxNOT_FOUND;
    int change_type_id = menu->FindItem(_L("Change Type"));
    if (change_type_id != wxNOT_FOUND) {
        for (size_t i = 0; i < menu->GetMenuItemCount(); i++) {
            wxMenuItem* item = menu->FindItemByPosition(i);
            if (item && item->GetId() == change_type_id) {
                insert_pos = i + 1;  // insert directly after the Change Type entry
                break;
            }
        }
    }
 
    // --- Build the subtype submenu ---
    wxMenu* ps_menu = new wxMenu();
 
    // Array of all 6 Precise Seam subtypes with labels.
    // "Seam ..." prefix disambiguates from other i18n contexts (extruder Left/Right, "Center on bed", etc.)
    static const std::array<std::pair<const char*, ModelVolumeType>, 6> PS_TYPES = {{
        {L("Seam Center"),   ModelVolumeType::PRECISE_SEAM_CENTER},
        {L("Seam Left"),     ModelVolumeType::PRECISE_SEAM_LEFT},
        {L("Seam Right"),    ModelVolumeType::PRECISE_SEAM_RIGHT},
        {L("Seam Enforced"), ModelVolumeType::PRECISE_SEAM_ENFORCED},
        {L("Seam Blocked"),  ModelVolumeType::PRECISE_SEAM_BLOCKED},
        {L("Seam Neutral"),  ModelVolumeType::PRECISE_SEAM_NEUTRAL},
    }};
 
    for (const auto& ps_type : PS_TYPES) {
        wxString label = _(ps_type.first);
 
        // Check-items (not radio): radio groups in wxWidgets auto-select the first item when
        // no item is explicitly checked, which misleads the user into seeing "Seam Center"
        // as the active subtype for mixed-subtype selections. With check-items we can leave
        // every item unchecked in that case, and the menu matches the pattern of the
        // neighbouring "Change type" submenu (see append_menu_item_change_type).
        //
        // Handler: delegate to set_volume_type() with preserve_ps_subtype=false. The user
        // explicitly picked a subtype here, so "Seam Center" must set every selected PS
        // volume to CENTER verbatim — preservation (the default for "Change type") would
        // keep existing subtypes and make CENTER unreachable on mixed-subtype selections.
        // set_volume_type() already handles multi-select iteration, the last-solid-part
        // guard, and the PS group-change reordering via move_volume_to_end().
        wxMenuItem* item = append_menu_check_item(ps_menu, wxID_ANY, label, "",
            [ps_type](wxCommandEvent&) {
                obj_list()->set_volume_type(ps_type.second, /*preserve_ps_subtype=*/false);
            },
            ps_menu);
 
        // Tick every subtype that is present in the current selection. Same pattern as the
        // neighbouring "Change type" submenu (where selecting [Part + Modifier] ticks both
        // "Part" and "Modifier" boxes). For homogeneous selections exactly one checkbox is
        // ticked; for mixed subtype selections (e.g. PS_LEFT + PS_RIGHT) both "Seam Left"
        // and "Seam Right" appear checked, so the user sees at a glance which subtypes are
        // currently in the selection.
        //
        // Uses the precomputed selected_ps_types (which resolved settings rows to their
        // parent volumes); iterating sels directly would miss subtypes for selections that
        // arrive via settings rows from right-click-in-3D-view.
        const bool is_present = std::find(selected_ps_types.begin(), selected_ps_types.end(),
                                          ps_type.second) != selected_ps_types.end();
        if (is_present && item)
            item->Check(true);
    }
 
    // Add submenu to parent menu
    append_submenu(menu, ps_menu, wxID_ANY,
                   submenu_name,
                   _L("Choose precise seam subtype"),
                   "menu_precise_seam_type",
                   []() { return true; },
                   m_parent,
                   insert_pos);
}

References _, _L, append_menu_check_item(), append_menu_item_precise_seam_submenu(), append_submenu(), Slic3r::is_precise_seam(), Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, L, m_parent, Slic3r::GUI::obj_list(), Slic3r::PRECISE_SEAM_BLOCKED, Slic3r::PRECISE_SEAM_CENTER, Slic3r::PRECISE_SEAM_ENFORCED, Slic3r::PRECISE_SEAM_LEFT, Slic3r::PRECISE_SEAM_NEUTRAL, and Slic3r::PRECISE_SEAM_RIGHT.

Referenced by append_menu_item_precise_seam_submenu(), multi_selection_menu(), and part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_printable()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_printable ( wxMenu * menu )

private

{
    // BBS: to be checked
    wxMenuItem* menu_item_printable = append_menu_check_item(menu, wxID_ANY, _L("Printable") + "\t" + "V", "",
        [](wxCommandEvent&) { obj_list()->toggle_printable_state(); }, menu);
 
    m_parent->Bind(wxEVT_UPDATE_UI, [](wxUpdateUIEvent& evt) {
        ObjectList* list = obj_list();
        wxDataViewItemArray sels;
        list->GetSelections(sels);
        wxDataViewItem frst_item = sels[0];
        ItemType type = list->GetModel()->GetItemType(frst_item);
        bool check;
        if (type != itInstance && type != itObject)
            check = false;
        else {
            int obj_idx = list->GetModel()->GetObjectIdByItem(frst_item);
            int inst_idx = type == itObject ? 0 : list->GetModel()->GetInstanceIdByItem(frst_item);
            check = list->object(obj_idx)->instances[inst_idx]->printable;
        }
 
        evt.Check(check);
        plater()->set_current_canvas_as_dirty();
 
        }, menu_item_printable->GetId());
 
    return menu_item_printable;
}

References _L, append_menu_check_item(), append_menu_item_printable(), Slic3r::GUI::ObjectDataViewModel::GetInstanceIdByItem(), Slic3r::GUI::ObjectDataViewModel::GetItemType(), Slic3r::GUI::ObjectList::GetModel(), Slic3r::GUI::ObjectDataViewModel::GetObjectIdByItem(), Slic3r::ModelObject::instances, Slic3r::GUI::itInstance, Slic3r::GUI::itObject, m_parent, Slic3r::GUI::obj_list(), Slic3r::GUI::ObjectList::object(), and Slic3r::GUI::plater().

Referenced by append_menu_item_printable(), and create_extra_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_reload_from_disk()

void Slic3r::GUI::MenuFactory::append_menu_item_reload_from_disk ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Reload from disk"), _L("Reload the selected parts from disk"),
        [](wxCommandEvent&) { plater()->reload_from_disk(); }, "", menu,
        []() { return plater()->can_reload_from_disk(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_reload_from_disk(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_more(), append_menu_item_reload_from_disk(), and create_common_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_rename()

void Slic3r::GUI::MenuFactory::append_menu_item_rename ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Rename"), "",
        [](wxCommandEvent&) { obj_list()->rename_item(); }, "", menu);
 
    menu->AppendSeparator();
}

References _L, append_menu_item(), append_menu_item_rename(), and Slic3r::GUI::obj_list().

Referenced by append_menu_item_rename(), and create_common_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_replace_all_with_stl()

void Slic3r::GUI::MenuFactory::append_menu_item_replace_all_with_stl ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Replace all with 3D files") + dots, _L("Replace all selected parts with 3D files from folder"),
        [](wxCommandEvent &) { plater()->replace_all_with_stl(); }, "", menu,
        []() { return plater()->can_replace_all_with_stl(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_replace_all_with_stl(), Slic3r::GUI::dots(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_more(), append_menu_item_replace_all_with_stl(), create_plate_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_replace_with_stl()

void Slic3r::GUI::MenuFactory::append_menu_item_replace_with_stl ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Replace 3D file") + dots, _L("Replace the selected part with a new 3D file"),
        [](wxCommandEvent &) { plater()->replace_with_stl(); }, "", menu,
        []() { return plater()->can_replace_with_stl(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_replace_with_stl(), Slic3r::GUI::dots(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_more(), and append_menu_item_replace_with_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_scale_selection_to_fit_print_volume()

void Slic3r::GUI::MenuFactory::append_menu_item_scale_selection_to_fit_print_volume ( wxMenu * menu )

private

{
    append_menu_item(menu, wxID_ANY, _L("Scale to build volume"), _L("Scale an object to fit the build volume"),
        [](wxCommandEvent&) { plater()->scale_selection_to_fit_print_volume(); }, "", menu);
}

References _L, append_menu_item(), append_menu_item_scale_selection_to_fit_print_volume(), and Slic3r::GUI::plater().

Referenced by append_menu_item_scale_selection_to_fit_print_volume(), append_menu_item_transform(), and create_common_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_set_auto_drop()

void Slic3r::GUI::MenuFactory::append_menu_item_set_auto_drop ( wxMenu * menu )

private

{
    const Selection& selection = plater()->canvas3D()->get_selection();
    const bool current_auto_drop = selection.get_auto_drop();
 
    wxString menu_text      = _L("Auto Drop");
    wxString menu_tooltip   = _L("Automatically snaps the selected object to the build plate.");
    wxMenuItem* menu_item_set_auto_drop = append_menu_check_item(
        menu, wxID_ANY, menu_text, menu_tooltip,
        [current_auto_drop](wxCommandEvent&) {
            Selection& selection = plater()->canvas3D()->get_selection();
            selection.set_auto_drop(!current_auto_drop);
        },
        menu);
    m_parent->Bind(
        wxEVT_UPDATE_UI,
        [current_auto_drop](wxUpdateUIEvent& evt) {
            evt.Check(current_auto_drop);
            plater()->set_current_canvas_as_dirty();
        },
        menu_item_set_auto_drop->GetId());
}

References _L, append_menu_check_item(), append_menu_item_set_auto_drop(), Slic3r::GUI::Selection::get_auto_drop(), m_parent, Slic3r::GUI::plater(), and Slic3r::GUI::Selection::set_auto_drop().

Referenced by append_menu_item_set_auto_drop(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_set_printable()

void Slic3r::GUI::MenuFactory::append_menu_item_set_printable ( wxMenu * menu )

private

{
    const Selection& selection = plater()->canvas3D()->get_selection();
    bool all_printable = true; 
    ObjectList* list = obj_list();
    wxDataViewItemArray sels;
    list->GetSelections(sels);
 
    for (wxDataViewItem item : sels) {
        ItemType type = list->GetModel()->GetItemType(item);
        if (type != itInstance && type != itObject)
            continue;
        else {
            int obj_idx = list->GetModel()->GetObjectIdByItem(item);
            int inst_idx = type == itObject ? 0 : list->GetModel()->GetInstanceIdByItem(item);
            all_printable &= list->object(obj_idx)->instances[inst_idx]->printable;
        }
    }
 
    wxMenuItem* menu_item_set_printable = append_menu_check_item(menu, wxID_ANY, _L("Printable") + "\t" + "V", "", [all_printable](wxCommandEvent&) {
        Selection& selection = plater()->canvas3D()->get_selection();
        selection.set_printable(!all_printable);
        }, menu);
    m_parent->Bind(wxEVT_UPDATE_UI, [all_printable](wxUpdateUIEvent& evt) {
        evt.Check(all_printable);
        plater()->set_current_canvas_as_dirty();
 
        }, menu_item_set_printable->GetId());
}

References _L, append_menu_check_item(), append_menu_item_set_printable(), Slic3r::GUI::ObjectDataViewModel::GetInstanceIdByItem(), Slic3r::GUI::ObjectDataViewModel::GetItemType(), Slic3r::GUI::ObjectList::GetModel(), Slic3r::GUI::ObjectDataViewModel::GetObjectIdByItem(), Slic3r::ModelObject::instances, Slic3r::GUI::itInstance, Slic3r::GUI::itObject, m_parent, Slic3r::GUI::obj_list(), Slic3r::GUI::ObjectList::object(), Slic3r::GUI::plater(), and Slic3r::GUI::Selection::set_printable().

Referenced by append_menu_item_set_printable(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_set_visible()

void Slic3r::GUI::MenuFactory::append_menu_item_set_visible ( wxMenu * menu )

private

{
    bool has_one_shown = false;
    const Selection& selection = plater()->canvas3D()->get_selection();
    for (unsigned int i : selection.get_volume_idxs()) {
        has_one_shown |= selection.get_volume(i)->visible;
    }
 
    append_menu_item(menu, wxID_ANY, has_one_shown ?_L("Hide") : _L("Show"), "",
        [has_one_shown](wxCommandEvent&) { plater()->set_selected_visible(!has_one_shown); }, "", nullptr,
        []() { return true; }, m_parent);
}

References _L, append_menu_item(), append_menu_item_set_visible(), Slic3r::GUI::Selection::get_volume(), Slic3r::GUI::Selection::get_volume_idxs(), m_parent, and Slic3r::GUI::plater().

Referenced by append_menu_item_set_visible(), assemble_multi_selection_menu(), assemble_object_menu(), and assemble_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_settings()

wxMenuItem * Slic3r::GUI::MenuFactory::append_menu_item_settings ( wxMenu * menu )

private

{
    MenuWithSeparators* menu = dynamic_cast<MenuWithSeparators*>(menu_);
 
    const wxString menu_name = _L("Add Settings");
    // Delete old items from settings popupmenu
    auto settings_id = menu->FindItem(menu_name);
    if (settings_id != wxNOT_FOUND)
        menu->Destroy(settings_id);
 
    for (auto& it : FREQ_SETTINGS_BUNDLE_FFF)
    {
        settings_id = menu->FindItem(_(it.first));
        if (settings_id != wxNOT_FOUND)
            menu->Destroy(settings_id);
    }
    for (auto& it : FREQ_SETTINGS_BUNDLE_SLA)
    {
        settings_id = menu->FindItem(_(it.first));
        if (settings_id != wxNOT_FOUND)
            menu->Destroy(settings_id);
    }
 
    menu->DestroySeparators(); // delete old separators
 
    // If there are selected more then one instance but not all of them
    // don't add settings menu items
    const Selection& selection = get_selection();
    if ((selection.is_multiple_full_instance() && !selection.is_single_full_object()) ||
        selection.is_multiple_volume() || selection.is_mixed()) // more than one volume(part) is selected on the scene
        return nullptr;
 
    const auto sel_vol = obj_list()->get_selected_model_volume();
    if (sel_vol && sel_vol->type() >= ModelVolumeType::SUPPORT_ENFORCER)
        return nullptr;
 
    // detect itemm for adding of the setting
    ObjectList* object_list = obj_list();
    ObjectDataViewModel* obj_model = list_model();
 
    const wxDataViewItem sel_item = // when all instances in object are selected
                                    object_list->GetSelectedItemsCount() > 1 && selection.is_single_full_object() ?
                                    obj_model->GetItemById(selection.get_object_idx()) :
                                    object_list->GetSelection();
    if (!sel_item)
        return nullptr;
 
    // If we try to add settings for object/part from 3Dscene,
    // for the second try there is selected ItemSettings in ObjectList.
    // So, check if selected item isn't SettingsItem. And get a SettingsItem's parent item, if yes
    wxDataViewItem item = obj_model->GetItemType(sel_item) & itSettings ? obj_model->GetParent(sel_item) : sel_item;
    const ItemType item_type = obj_model->GetItemType(item);
    const bool is_object_settings = !(item_type& itVolume || item_type & itLayer);
 
    // Add frequently settings
    // BBS remvoe freq setting popupmenu
    // create_freq_settings_popupmenu(menu, is_object_settings, item);
 
    //menu->SetSecondSeparator();
 
    // Add full settings list
    auto  menu_item = new wxMenuItem(menu, wxID_ANY, menu_name);
    menu_item->SetBitmap(create_scaled_bitmap("cog"));
    menu_item->SetSubMenu(create_settings_popupmenu(menu, is_object_settings, item));
 
    return menu->Append(menu_item);
}

References _, _L, append_menu_item_settings(), create_scaled_bitmap(), Slic3r::GUI::create_settings_popupmenu(), MenuWithSeparators::DestroySeparators(), Slic3r::GUI::FREQ_SETTINGS_BUNDLE_FFF, Slic3r::GUI::FREQ_SETTINGS_BUNDLE_SLA, Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::get_selection(), Slic3r::GUI::ObjectDataViewModel::GetItemById(), Slic3r::GUI::ObjectDataViewModel::GetItemType(), Slic3r::GUI::ObjectDataViewModel::GetParent(), Slic3r::GUI::Selection::is_mixed(), Slic3r::GUI::Selection::is_multiple_full_instance(), Slic3r::GUI::Selection::is_multiple_volume(), Slic3r::GUI::Selection::is_single_full_object(), Slic3r::GUI::itLayer, Slic3r::GUI::itSettings, Slic3r::GUI::itVolume, Slic3r::GUI::list_model(), Slic3r::GUI::obj_list(), and Slic3r::SUPPORT_ENFORCER.

Referenced by append_menu_item_settings(), layer_menu(), and sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_simplify()

void Slic3r::GUI::MenuFactory::append_menu_item_simplify ( wxMenu * menu )

private

{
    wxMenuItem* menu_item = append_menu_item(menu, wxID_ANY, _L("Simplify Model"), "",
        [](wxCommandEvent&) { obj_list()->simplify(); }, "", menu,
        []() {return plater()->can_simplify(); }, m_parent);
}

References _L, append_menu_item(), append_menu_item_simplify(), m_parent, Slic3r::GUI::obj_list(), and Slic3r::GUI::plater().

Referenced by append_menu_item_modify(), append_menu_item_simplify(), and create_bbl_assemble_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_smooth_mesh()

void Slic3r::GUI::MenuFactory::append_menu_item_smooth_mesh ( wxMenu * menu )

private

{
    wxMenuItem *menu_item = append_menu_item(
        menu, wxID_ANY, _L("Subdivision mesh (Lost color)"), "", [](wxCommandEvent &) { obj_list()->smooth_mesh(); }, "", menu, []() { return plater()->can_smooth_mesh(); },
        m_parent);
}

References _L, append_menu_item(), append_menu_item_smooth_mesh(), m_parent, Slic3r::GUI::obj_list(), and Slic3r::GUI::plater().

Referenced by append_menu_item_modify(), append_menu_item_smooth_mesh(), and create_bbl_assemble_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_item_transform()

wxMenu * Slic3r::GUI::MenuFactory::append_menu_item_transform ( wxMenu * menu, bool multi_selection, bool show_mirror, bool is_scalable )

private

{
    wxMenu* sub_menu = new wxMenu();
 
    if(show_mirror){
        // Mirror
        append_menu_item(sub_menu, wxID_ANY, _L("Mirror") + ":", "", [](wxCommandEvent&){}, "", menu, [](){return false;}, m_parent);
        append_menu_item(sub_menu, wxID_ANY, _L("Along X Axis"), _L("Mirror along the X axis"),
            [](wxCommandEvent&) { plater()->mirror(X); }, "menu_mirror_x", m_parent);
        append_menu_item(sub_menu, wxID_ANY, _L("Along Y Axis"), _L("Mirror along the Y axis"),
            [](wxCommandEvent&) { plater()->mirror(Y); }, "menu_mirror_y", m_parent);
        append_menu_item(sub_menu, wxID_ANY, _L("Along Z Axis"), _L("Mirror along the Z axis"),
            [](wxCommandEvent&) { plater()->mirror(Z); }, "menu_mirror_z", m_parent);
    }
 
    if(is_scalable){
        if(sub_menu->GetMenuItemCount() > 0)
            sub_menu->AppendSeparator();
        append_menu_item_scale_selection_to_fit_print_volume(sub_menu);
        sub_menu->AppendSeparator(); // Convert units will be added later
    }
 
    append_submenu(menu, sub_menu, wxID_ANY, _L("Transform"), "", "", [](){return true;}, m_parent);
    return sub_menu;
}

References _L, append_menu_item(), append_menu_item_scale_selection_to_fit_print_volume(), append_menu_item_transform(), append_submenu(), m_parent, Slic3r::GUI::plater(), Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by append_menu_item_transform(), create_bbl_part_menu(), create_common_object_menu(), create_extra_object_menu(), create_svg_part_menu(), create_text_part_menu(), and multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_items_add_volume()

void Slic3r::GUI::MenuFactory::append_menu_items_add_volume ( wxMenu * menu )

private

{
    // Update "add" items(delete old & create new)  settings popupmenu
    for (auto& item : ADD_VOLUME_MENU_ITEMS) {
        const wxString item_name = _(item.first);
        int item_id = menu->FindItem(item_name);
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
 
        item_id = menu->FindItem(item_name + ": " + _L("Text"));
        if (item_id != wxNOT_FOUND)
            menu->Destroy(item_id);
    }
 
    for (size_t type = 0; type < ADD_VOLUME_MENU_ITEMS.size(); type++)
    {
        // Skip Precise Seam subtypes except the first one (CENTER) - they are only used for tree icons
        if (type >= int(ModelVolumeType::PRECISE_SEAM_LEFT) &&
            type <= int(ModelVolumeType::PRECISE_SEAM_NEUTRAL))
            continue;
 
        auto& item = ADD_VOLUME_MENU_ITEMS[type];
 
        // Use special icon for "Add Precise Seam" menu (different from tree icon)
        std::string icon_name = item.second;
        if (type == int(ModelVolumeType::PRECISE_SEAM_CENTER))
            icon_name = "menu_precise_seam_add";
 
        wxMenu* sub_menu = append_submenu_add_generic(menu, ModelVolumeType(type));
        append_submenu(menu, sub_menu, wxID_ANY, _(item.first), "", icon_name,
            []() { return obj_list()->is_instance_or_object_selected(); }, m_parent);
    }
 
    append_menu_item_layers_editing(menu);
}

References _, _L, Slic3r::GUI::ADD_VOLUME_MENU_ITEMS, append_menu_item_layers_editing(), append_menu_items_add_volume(), append_submenu(), append_submenu_add_generic(), m_parent, Slic3r::PRECISE_SEAM_CENTER, Slic3r::PRECISE_SEAM_LEFT, and Slic3r::PRECISE_SEAM_NEUTRAL.

Referenced by append_menu_items_add_volume(), create_extra_object_menu(), and update_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_items_convert_unit()

void Slic3r::GUI::MenuFactory::append_menu_items_convert_unit ( wxMenu * menu )

private

{
    std::vector<int> obj_idxs, vol_idxs;
    obj_list()->get_selection_indexes(obj_idxs, vol_idxs);
    if (obj_idxs.empty() && vol_idxs.empty())
        return;
 
    auto volume_respects_conversion = [](ModelVolume* volume, ConversionType conver_type)
    {
        return  (conver_type == ConversionType::CONV_FROM_INCH && volume->source.is_converted_from_inches) ||
            (conver_type == ConversionType::CONV_TO_INCH && !volume->source.is_converted_from_inches) ||
            (conver_type == ConversionType::CONV_FROM_METER && volume->source.is_converted_from_meters) ||
            (conver_type == ConversionType::CONV_TO_METER && !volume->source.is_converted_from_meters);
    };
 
    auto can_append = [obj_idxs, vol_idxs, volume_respects_conversion](ConversionType conver_type)
    {
        ModelObjectPtrs objects;
        for (int obj_idx : obj_idxs) {
            ModelObject* object = obj_list()->object(obj_idx);
            if (vol_idxs.empty()) {
                for (ModelVolume* volume : object->volumes)
                    if (volume_respects_conversion(volume, conver_type))
                        return false;
            }
            else {
                for (int vol_idx : vol_idxs)
                    if (volume_respects_conversion(object->volumes[vol_idx], conver_type))
                        return false;
            }
        }
        return true;
    };
 
    std::vector<std::pair<ConversionType, wxString>> items = {
        {ConversionType::CONV_FROM_INCH , _L("Convert from Inches") },
        {ConversionType::CONV_TO_INCH   , _L("Restore to Inch") },
        {ConversionType::CONV_FROM_METER, _L("Convert from Meters") },
        {ConversionType::CONV_TO_METER  , _L("Restore to Meter") } };
 
    for (auto item : items) {
        int menu_id = menu->FindItem(item.second);
        if (can_append(item.first)) {
            // Add menu item if it doesn't exist
            if (menu_id == wxNOT_FOUND)
                append_menu_item(menu, wxID_ANY, item.second, item.second,
                    [item](wxCommandEvent&) { plater()->convert_unit(item.first); }, "", menu,
                    []() { return true; }, m_parent);
        }
        else if (menu_id != wxNOT_FOUND) {
            // Delete menu item
            menu->Destroy(menu_id);
        }
    }
}

References _L, append_menu_item(), append_menu_items_convert_unit(), Slic3r::CONV_FROM_INCH, Slic3r::CONV_FROM_METER, Slic3r::CONV_TO_INCH, Slic3r::CONV_TO_METER, Slic3r::ModelVolume::Source::is_converted_from_inches, Slic3r::ModelVolume::Source::is_converted_from_meters, m_parent, Slic3r::GUI::obj_list(), Slic3r::ModelVolume::source, and Slic3r::ModelObject::volumes.

Referenced by append_menu_items_convert_unit(), multi_selection_menu(), object_menu(), part_menu(), and sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_items_flush_options()

void Slic3r::GUI::MenuFactory::append_menu_items_flush_options ( wxMenu * menu, size_t pos = -1 )

private

{
    const wxString name = _L("Flush Options");
    // Delete old menu item
    const int item_id = menu->FindItem(name);
    if (item_id != wxNOT_FOUND)
        menu->Destroy(item_id);
 
    bool show_flush_option_menu = false;
    ObjectList* object_list = obj_list();
    const Selection& selection = get_selection();
    if (selection.get_object_idx() < 0)
        return;
    if (wxGetApp().plater()->get_partplate_list().get_curr_plate()->contains(selection.get_bounding_box())) {
        auto plate_extruders = wxGetApp().plater()->get_partplate_list().get_curr_plate()->get_extruders();
        for (auto extruder : plate_extruders) {
            if (extruder != plate_extruders[0])
                show_flush_option_menu = true;
        }
    }
    if (!show_flush_option_menu)
        return;
 
    DynamicPrintConfig& global_config = wxGetApp().preset_bundle->prints.get_edited_preset().config;
    ModelConfig& select_object_config = object_list->object(selection.get_object_idx())->config;
 
    wxMenu* flush_options_menu = new wxMenu();
    auto can_flush = [&global_config]() {
        auto option = global_config.option("enable_prime_tower");
        return option ? option->getBool() : false;
    };
    append_menu_check_item(flush_options_menu, wxID_ANY, _L("Flush into objects' infill"), "",
        [&select_object_config, &global_config](wxCommandEvent&) {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][0]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][0]);
            }
            select_object_config.set_key_value(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][0], new ConfigOptionBool(!option->getBool()));
            wxGetApp().obj_settings()->UpdateAndShow(true);
        }, menu, can_flush,
        [&select_object_config, &global_config]() {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][0]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][0]);
            }
            return option->getBool();
        }, m_parent);
 
    append_menu_check_item(flush_options_menu, wxID_ANY, _L("Flush into this object"), "",
        [&select_object_config, &global_config](wxCommandEvent&) {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][1]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][1]);
            }
            select_object_config.set_key_value(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][1], new ConfigOptionBool(!option->getBool()));
            wxGetApp().obj_settings()->UpdateAndShow(true);
        }, menu, can_flush,
        [&select_object_config, &global_config]() {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][1]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][1]);
            }
            return option->getBool();
        }, m_parent);
 
    append_menu_check_item(flush_options_menu, wxID_ANY, _L("Flush into objects' support"), "",
        [&select_object_config, &global_config](wxCommandEvent&) {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][2]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][2]);
            }
            select_object_config.set_key_value(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][2], new ConfigOptionBool(!option->getBool()));
            wxGetApp().obj_settings()->UpdateAndShow(true);
        }, menu, can_flush,
        [&select_object_config, &global_config]() {
            const ConfigOption* option = select_object_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][2]);
            if (!option) {
                option = global_config.option(FREQ_SETTINGS_BUNDLE_FFF["Flush options"][2]);
            }
            return option->getBool();
        }, m_parent);
 
    menu->Insert(pos, wxID_ANY, _L("Flush Options"), flush_options_menu);
}

References _L, append_menu_check_item(), append_menu_items_flush_options(), Slic3r::ModelObject::config, Slic3r::Geometry::contains(), Slic3r::GUI::FREQ_SETTINGS_BUNDLE_FFF, Slic3r::GUI::Selection::get_bounding_box(), Slic3r::GUI::Selection::get_object_idx(), Slic3r::GUI::get_selection(), Slic3r::ConfigOption::getBool(), m_parent, Slic3r::GUI::obj_list(), Slic3r::GUI::ObjectList::object(), Slic3r::ConfigBase::option(), Slic3r::ModelConfig::option(), Slic3r::GUI::plater(), and Slic3r::ModelConfig::set_key_value().

Referenced by append_menu_items_flush_options(), and object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_menu_items_instance_manipulation()

void Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation ( wxMenu * menu )

private

{
    MenuType type = menu == &m_object_menu ? mtObjectFFF : mtObjectSLA;
 
    items_increase[type]                = append_menu_item(menu, wxID_ANY, _L("Add instance") + "\t+", _L("Add one more instance of the selected object"),
        [](wxCommandEvent&) { plater()->increase_instances();      }, "", nullptr, 
        []() { return plater()->can_increase_instances(); }, m_parent);
    items_decrease[type]                = append_menu_item(menu, wxID_ANY, _L("Remove instance") + "\t-", _L("Remove one instance of the selected object"),
        [](wxCommandEvent&) { plater()->decrease_instances();      }, "", nullptr, 
        []() { return plater()->can_decrease_instances(); }, m_parent);
    items_set_number_of_copies[type]    = append_menu_item(menu, wxID_ANY, _L("Set number of instances") + dots, _L("Change the number of instances of the selected object"),
        [](wxCommandEvent&) { plater()->set_number_of_copies();    }, "", nullptr,
        []() { return plater()->can_increase_instances(); }, m_parent);
    append_menu_item(menu, wxID_ANY, _L("Fill bed with instances") + dots, _L("Fill the remaining area of bed with instances of the selected object"),
        [](wxCommandEvent&) { plater()->fill_bed_with_instances();    }, "", nullptr, 
        []() { return plater()->can_increase_instances(); }, m_parent);
}

References _L, append_menu_item(), append_menu_items_instance_manipulation(), Slic3r::GUI::dots(), items_decrease, items_increase, items_set_number_of_copies, m_object_menu, m_parent, mtObjectFFF, mtObjectSLA, and Slic3r::GUI::plater().

Referenced by append_menu_items_instance_manipulation(), create_common_object_menu(), and create_extra_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_submenu_add_generic()

wxMenu * Slic3r::GUI::MenuFactory::append_submenu_add_generic ( wxMenu * menu, ModelVolumeType type )

private

                                                                                  {
    auto sub_menu = new wxMenu;
 
    if (type != ModelVolumeType::INVALID) {
        append_menu_item(sub_menu, wxID_ANY, _L("Load..."), "",
            [type](wxCommandEvent&) { obj_list()->load_subobject(type); }, "menu_load", menu);
        sub_menu->AppendSeparator();
    }
 
    append_menu_item(sub_menu, wxID_ANY, _L("Cube"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Cube") ,type); },"menu_obj_cube", menu);
 
    append_menu_item(sub_menu, wxID_ANY, _L("Cylinder"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Cylinder"), type); },"menu_obj_cylinder", menu);
 
    append_menu_item(sub_menu, wxID_ANY, _L("Sphere"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Sphere"), type); },"menu_obj_sphere", menu);
 
    append_menu_item(sub_menu, wxID_ANY, _L("Cone"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Cone"), type); },"menu_obj_cone", menu);
 
    append_menu_item(sub_menu, wxID_ANY, _L("Disc"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Disc"), type); },"menu_obj_disc", menu);
 
    append_menu_item(sub_menu, wxID_ANY, _L("Torus"), "",
        [type](wxCommandEvent&) { obj_list()->load_generic_subobject(L("Torus"), type); },"menu_obj_torus", menu);
 
 
    append_menu_item_add_text(sub_menu, type);
    append_menu_item_add_svg(sub_menu, type);
 
    return sub_menu;
}

References _L, append_menu_item(), append_menu_item_add_svg(), append_menu_item_add_text(), append_submenu_add_generic(), Slic3r::INVALID, L, and Slic3r::GUI::obj_list().

Referenced by append_menu_items_add_volume(), append_submenu_add_generic(), create_default_menu(), and create_plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

append_submenu_add_handy_model()

wxMenu * Slic3r::GUI::MenuFactory::append_submenu_add_handy_model ( wxMenu * menu, ModelVolumeType type )

private

                                                                                      {
    auto sub_menu = new wxMenu;
 
    const std::vector<HandyModel>& models = handy_models();
    for (std::size_t i = 0; i < models.size(); ++i) {
        append_menu_item(sub_menu, wxID_ANY, _(models[i].label), "",
            [i](wxCommandEvent&) { MenuFactory::load_handy_model(i); }, "", menu);
    }
 
    return sub_menu;
}

References _, append_menu_item(), append_submenu_add_handy_model(), handy_models(), and load_handy_model().

Referenced by append_submenu_add_handy_model(), create_default_menu(), and create_plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

assemble_multi_selection_menu()

wxMenu * Slic3r::GUI::MenuFactory::assemble_multi_selection_menu

(

)

{
    wxDataViewItemArray sels;
    obj_list()->GetSelections(sels);
 
    for (const wxDataViewItem& item : sels)
        if (!(list_model()->GetItemType(item) & (itVolume | itObject | itInstance)))
            // show this menu only for Objects(Instances mixed with Objects)/Volumes selection
            return nullptr;
 
    wxMenu* menu = new MenuWithSeparators();
    append_menu_item_set_visible(menu);
    //append_menu_item_fix_through_cgal(menu);
    //append_menu_item_simplify(menu);
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    menu->AppendSeparator();
    append_menu_item_change_extruder(menu);
    return menu;
}

References append_menu_item_change_extruder(), append_menu_item_delete(), append_menu_item_set_visible(), assemble_multi_selection_menu(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itVolume, Slic3r::GUI::list_model(), and Slic3r::GUI::obj_list().

Referenced by assemble_multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

assemble_object_menu()

wxMenu * Slic3r::GUI::MenuFactory::assemble_object_menu

(

)

{
    wxMenu* menu = new MenuWithSeparators();
    // Set Visible
    append_menu_item_set_visible(menu);
    // Delete
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    //append_menu_item_fix_through_cgal(menu);
    //append_menu_item_simplify(menu);
    menu->AppendSeparator();
 
    // Set filament
    append_menu_item_change_extruder(menu);
    //append_menu_item_per_object_settings(menu);
    return menu;
}

References append_menu_item_change_extruder(), append_menu_item_delete(), append_menu_item_set_visible(), and assemble_object_menu().

Referenced by assemble_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

assemble_part_menu()

wxMenu * Slic3r::GUI::MenuFactory::assemble_part_menu

(

)

{
    wxMenu* menu = new MenuWithSeparators();
 
    append_menu_item_set_visible(menu);
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    //append_menu_item_simplify(menu);
    menu->AppendSeparator();
 
    append_menu_item_change_extruder(menu);
    //append_menu_item_per_object_settings(menu);
    return menu;
}

References append_menu_item_change_extruder(), append_menu_item_delete(), append_menu_item_set_visible(), and assemble_part_menu().

Referenced by assemble_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

create_bbl_assemble_object_menu()

void Slic3r::GUI::MenuFactory::create_bbl_assemble_object_menu ( )

private

{
    // Delete
    append_menu_item_delete(&m_assemble_object_menu);
    m_assemble_object_menu.AppendSeparator();
 
    append_menu_item_modify(&m_assemble_object_menu, false /*multi_selection*/, false /*splittable*/, true /*mesh*/, false /*mesh_boolean*/);
    m_assemble_object_menu.AppendSeparator();
}

References append_menu_item_delete(), append_menu_item_modify(), create_bbl_assemble_object_menu(), and m_assemble_object_menu.

Referenced by create_bbl_assemble_object_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_bbl_assemble_part_menu()

void Slic3r::GUI::MenuFactory::create_bbl_assemble_part_menu ( )

private

{
    wxMenu* menu = &m_assemble_part_menu;
 
    append_menu_item_delete(menu);
    append_menu_item_simplify(menu);
    append_menu_item_smooth_mesh(menu);
    menu->AppendSeparator();
}

References append_menu_item_delete(), append_menu_item_simplify(), append_menu_item_smooth_mesh(), create_bbl_assemble_part_menu(), and m_assemble_part_menu.

Referenced by create_bbl_assemble_part_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_bbl_part_menu()

void Slic3r::GUI::MenuFactory::create_bbl_part_menu ( )

private

{
    wxMenu* menu = &m_part_menu;
 
    append_menu_item_center(menu);
    append_menu_item_drop(&m_part_menu);
 
    m_part_transform_menu = append_menu_item_transform(&m_part_menu, false /*multi_selection*/, true /*mirror*/, true /*is_scalable*/);
    append_menu_item_align_distribute(menu);
    append_menu_item_modify(&m_part_menu, false /*multi_selection*/, true /*splittable*/, true /*mesh*/, false /*mesh_boolean*/);
    append_menu_item_edit_text(menu);
    //m_part_geometry_pos = m_part_menu.GetMenuItemCount(); // pos for geometry related items
 
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    menu->AppendSeparator();
 
    append_menu_item_change_type(menu);
    m_part_props_marker = menu->FindItem(_L("Change Type")); // dynamic property items are inserted after this item
    menu->AppendSeparator();
 
    append_menu_item_per_object_process(menu);
    m_part_project_marker = menu->FindItem(_L("Paste Process Settings")); // append_menu_item_per_object_settings() is inserted after this item
 
    menu->AppendSeparator();
    append_menu_item_more(&m_part_menu, false /*multi_selection*/, true /*disk_op*/, false /*export_op*/);
}

References _L, append_menu_item_align_distribute(), append_menu_item_center(), append_menu_item_change_type(), append_menu_item_delete(), append_menu_item_drop(), append_menu_item_edit_text(), append_menu_item_modify(), append_menu_item_more(), append_menu_item_per_object_process(), append_menu_item_transform(), create_bbl_part_menu(), m_part_menu, m_part_project_marker, m_part_props_marker, and m_part_transform_menu.

Referenced by create_bbl_part_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_common_object_menu()

void Slic3r::GUI::MenuFactory::create_common_object_menu ( wxMenu * menu )

private

{
    append_menu_item_rename(menu);
    menu->AppendSeparator();
 
    append_menu_items_instance_manipulation(menu);
    
    // Object Split / Mirror / Mesh Tools
    append_menu_item_transform(menu, false /*multi_selection*/, true /*mirror*/, false /*is_scalable*/);
    append_menu_item_modify(menu, false /*multi_selection*/, true /*splittable*/, true /*mesh*/, false /*mesh_boolean*/);
 
    // Delete menu was moved to be after +/- instace to make it more difficult to be selected by mistake.
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    menu->AppendSeparator();
 
    append_menu_item_reload_from_disk(menu);
    append_menu_item_export_stl(menu);
    append_menu_item_export_drc(menu);
    // "Scale to print volume" makes a sense just for whole object
    append_menu_item_scale_selection_to_fit_print_volume(menu);
}

References append_menu_item_delete(), append_menu_item_export_drc(), append_menu_item_export_stl(), append_menu_item_modify(), append_menu_item_reload_from_disk(), append_menu_item_rename(), append_menu_item_scale_selection_to_fit_print_volume(), append_menu_item_transform(), append_menu_items_instance_manipulation(), and create_common_object_menu().

Referenced by create_common_object_menu(), create_object_menu(), and create_sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

create_default_menu()

void Slic3r::GUI::MenuFactory::create_default_menu ( )

private

{
    wxMenu* sub_menu_primitives = append_submenu_add_generic(&m_default_menu, ModelVolumeType::INVALID);
    wxMenu* sub_menu_handy = append_submenu_add_handy_model(&m_default_menu, ModelVolumeType::INVALID);
 
    append_submenu(&m_default_menu, sub_menu_primitives, wxID_ANY, _L("Add Primitive"), "", "menu_add_part",
        []() {return true; }, m_parent);
    append_submenu(&m_default_menu, sub_menu_handy, wxID_ANY, _L("Add Handy models"), "", "menu_add_part",
        []() {return true; }, m_parent);
    append_menu_item(&m_default_menu, wxID_ANY, _L("Add Models"), "", // ORCA: Add Models
        [](wxCommandEvent&) { plater()->add_file(); }, "menu_add_part", &m_default_menu,
        []() {return wxGetApp().plater()->can_add_model(); }, m_parent);
 
    m_default_menu.AppendSeparator();
 
    append_menu_check_item(&m_default_menu, wxID_ANY, _L("Show Labels"), "",
        [](wxCommandEvent&) { plater()->show_view3D_labels(!plater()->are_view3D_labels_shown()); plater()->get_current_canvas3D()->post_event(SimpleEvent(wxEVT_PAINT)); }, &m_default_menu,
        []() { return plater()->is_view3D_shown(); }, []() { return plater()->are_view3D_labels_shown(); }, m_parent);
}

References _L, append_menu_check_item(), append_menu_item(), append_submenu(), append_submenu_add_generic(), append_submenu_add_handy_model(), create_default_menu(), Slic3r::INVALID, m_default_menu, m_parent, and Slic3r::GUI::plater().

Referenced by create_default_menu(), init(), and update_default_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

create_extra_object_menu()

void Slic3r::GUI::MenuFactory::create_extra_object_menu ( )

private

{
    // Object Clone
    append_menu_item_clone(&m_object_menu);
 
    // Instances
    auto instances = new wxMenu();
    if (!instances) return;
    append_menu_items_instance_manipulation(instances);
    instances->AppendSeparator();
    append_menu_item_instance_to_object(instances);
    append_submenu(&m_object_menu, instances, wxID_ANY, _L("Instances"), "", "",[](){return true;}, m_parent);
 
    m_object_menu.AppendSeparator();
 
    // Object Center
    append_menu_item_center(&m_object_menu);
 
    append_menu_item_drop(&m_object_menu);
 
    m_object_transform_menu = append_menu_item_transform(&m_object_menu, false /*multi_selection*/, true /*mirror*/, true /*is_scalable*/);
    // Object Align/Distribute
    append_menu_item_align_distribute(&m_object_menu);
    append_menu_item_modify(&m_object_menu, false /*multi_selection*/, true /*splittable*/, true /*mesh*/, true /*mesh_boolean*/);
    m_object_geometry_pos = m_object_menu.GetMenuItemCount(); // pos for property related items
    // Delete
    m_object_menu.AppendSeparator();
    append_menu_item_delete(&m_object_menu);
    m_object_menu.AppendSeparator();
 
    // Modifier Part
    // BBS
    append_menu_items_add_volume(&m_object_menu);
 
    wxMenuItem* props_marker = m_object_menu.Append(wxID_ANY, "", "", wxITEM_SEPARATOR); // AppendSeparator() not assigns an id to item
    m_object_props_marker = props_marker->GetId();
 
    // Set filament insert menu item here
    // Set Printable
    wxMenuItem* menu_item_printable = append_menu_item_printable(&m_object_menu);
    wxMenuItem* menu_item_auto_drop = append_menu_item_auto_drop(&m_object_menu);
    m_object_menu.AppendSeparator();
 
    append_menu_item_per_object_process(&m_object_menu);
    // Enter per object parameters
    append_menu_item_per_object_settings(&m_object_menu);
 
    // ORCA Utilities menu
    m_object_menu.AppendSeparator();
    append_menu_item_more(&m_object_menu, false /*multi_selection*/, true /*disk_op*/, true/*export_op*/);
}

References _L, append_menu_item_align_distribute(), append_menu_item_auto_drop(), append_menu_item_center(), append_menu_item_clone(), append_menu_item_delete(), append_menu_item_drop(), append_menu_item_instance_to_object(), append_menu_item_modify(), append_menu_item_more(), append_menu_item_per_object_process(), append_menu_item_per_object_settings(), append_menu_item_printable(), append_menu_item_transform(), append_menu_items_add_volume(), append_menu_items_instance_manipulation(), append_submenu(), create_extra_object_menu(), m_object_geometry_pos, m_object_menu, m_object_props_marker, m_object_transform_menu, and m_parent.

Referenced by create_extra_object_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_filament_action_menu()

void Slic3r::GUI::MenuFactory::create_filament_action_menu ( bool init, int active_filament_menu_id )

private

{
    wxMenu *menu = &m_filament_action_menu;
 
    // ORCA rebuild menu everytime instead checking existing of every item then deleting
    while (menu->GetMenuItemCount() > 0)
        menu->Destroy(menu->FindItemByPosition(0));
 
    //if (init) { //
        append_menu_item(
            menu, wxID_ANY, _L("Edit"), "", [](wxCommandEvent&) {
                plater()->sidebar().edit_filament(); }, "", nullptr,
            []() { return true; }, m_parent);
    //}
 
    wxMenu* sub_menu = new wxMenu();
    std::vector<wxBitmap*> icons = get_extruder_color_icons(true);
    int filaments_cnt = Sidebar::should_show_SEMM_buttons() ? icons.size() : 0;
    for (int i = 0; i < filaments_cnt; i++) {
        if (i == active_filament_menu_id)
            continue;
 
        auto preset = wxGetApp().preset_bundle->filaments.find_preset(wxGetApp().preset_bundle->filament_presets[i]);
        wxString item_name = preset ? from_u8(preset->label(false)) : wxString::Format(_L("Filament %d"), i + 1);
 
        append_menu_item(sub_menu, wxID_ANY, item_name, "",
            [i](wxCommandEvent&) { plater()->sidebar().change_filament(-2, i); }, *icons[i], menu,
            []() { return true; }, m_parent);
    }
    append_submenu(menu, sub_menu, wxID_ANY, _L("Merge with"), "", "",
        [filaments_cnt]() { return filaments_cnt > 1; }, m_parent);
 
    // Decompose a target colour into a printable mix of the loaded filaments. Placed before the
    append_menu_item(
        menu, wxID_ANY, _L("Decompose Color"), "", [](wxCommandEvent&) {
            plater()->sidebar().decompose_filament_color(kSidebarContextMenuFilamentId); }, "", nullptr,
        []() { return plater()->sidebar().combos_filament().size() >= 2; }, m_parent);
 
    menu->AppendSeparator(); // ORCA use seperator for reducing accidental clicks to delete
 
    // ORCA use delete item on end of menu to prevent accidental clicks. clicking to submenus(merge) already not allowed by OS
    append_menu_item(
        menu, wxID_ANY, _L("Delete"), _L("Delete this filament"), [](wxCommandEvent&) {
            plater()->sidebar().delete_filament(-2); }, "", nullptr,
        []() {
            return plater()->sidebar().combos_filament().size() > 1
                // Orca: only show delete filament option for SEMM machines unless is BBL
                && Sidebar::should_show_SEMM_buttons();
        }, m_parent);
}

References _L, append_menu_item(), append_submenu(), create_filament_action_menu(), Slic3r::GUI::from_u8(), get_extruder_color_icons(), init(), Slic3r::GUI::kSidebarContextMenuFilamentId, m_filament_action_menu, m_parent, Slic3r::GUI::plater(), and Slic3r::GUI::Sidebar::should_show_SEMM_buttons().

Referenced by create_filament_action_menu(), filament_action_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_object_menu()

void Slic3r::GUI::MenuFactory::create_object_menu ( )

private

{
    create_common_object_menu(&m_object_menu);
 
    // BBS: remove Layers Editing
    m_object_menu.AppendSeparator();
 
    // "Add (volumes)" popupmenu will be added later in append_menu_items_add_volume()
}

References create_common_object_menu(), create_object_menu(), and m_object_menu.

Referenced by create_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

create_plate_menu()

void Slic3r::GUI::MenuFactory::create_plate_menu ( )

private

{
    wxMenu* menu = &m_plate_menu;
    // select objects on current plate
    append_menu_item(menu, wxID_ANY, _L("Select All"), _L("Select all objects on the current plate"),
        [](wxCommandEvent&) {
            plater()->select_curr_plate_all();
        }, "", nullptr, []() {
            PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            return !plate->get_objects().empty();
        }, m_parent);
 
    // select objects on all plates
    append_menu_item(menu, wxID_ANY, _L("Select All Plates"), _L("Select all objects on all plates"),
        [](wxCommandEvent&) {
            plater()->select_all();
        }, "", nullptr, []() {
            return !plater()->model().objects.empty() && plater()->can_delete_plate(); // also disable when only one plate exist
        }, m_parent);
 
    menu->AppendSeparator();
    // delete objects on current plate
    append_menu_item(menu, wxID_ANY, _L("Delete All"), _L("Delete all objects on the current plate"),
        [](wxCommandEvent&) {
            plater()->remove_curr_plate_all();
        }, "", nullptr, []() {
            PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            return !plate->get_objects().empty();
        }, m_parent);
 
    menu->AppendSeparator();
 
    // arrange objects on current plate
    append_menu_item(menu, wxID_ANY, _L("Arrange"), _L("Arrange current plate"),
        [](wxCommandEvent&) {
            PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            plater()->set_prepare_state(Job::PREPARE_STATE_MENU);
            plater()->arrange();
        }, "", nullptr,
        []() {
            return !plater()->get_partplate_list().get_selected_plate()->get_objects().empty();
        },
        m_parent);
 
    // orient objects on current plate
    append_menu_item(menu, wxID_ANY, _L("Auto Rotate"), _L("Auto rotate current plate"),
        [](wxCommandEvent&) {
            PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            plater()->set_prepare_state(Job::PREPARE_STATE_MENU);
            plater()->orient();
        }, "", nullptr,
        []() {
            return !plater()->get_partplate_list().get_selected_plate()->get_objects().empty();
        }, m_parent);
 
    wxMenu* modify_menu = new wxMenu();
 
    // fix objects on current plate
    append_menu_item(modify_menu, wxID_ANY, _L("Fix All"), _L("Fix all models on the current plate"),
        [](wxCommandEvent&) { obj_list()->fix_all_through_cgal(false); }, "", nullptr,
        []() { return !plater()->get_partplate_list().get_selected_plate()->empty(); }, m_parent);
 
    // fix objects on all plates
    append_menu_item(modify_menu, wxID_ANY, _L("Fix All Plates"), _L("Fix all models on all plates"),
        [](wxCommandEvent&) { obj_list()->fix_all_through_cgal(true); }, "", nullptr,
        []() { return !plater()->model().objects.empty(); }, m_parent);
 
    append_submenu(menu, modify_menu, wxID_ANY, _L("Modify"), "", "", 
        [](){ return !plater()->model().objects.empty(); }, m_parent);
 
    menu->AppendSeparator();
 
    m_plate_mods_pos = menu->GetMenuItemCount(); // pos for dynamic plate items (Edit Plate Name / Lock / Delete Plate)
 
    // add shapes
    menu->AppendSeparator();
    wxMenu* sub_menu_primitives = append_submenu_add_generic(menu, ModelVolumeType::INVALID);
    wxMenu* sub_menu_handy = append_submenu_add_handy_model(menu, ModelVolumeType::INVALID);
 
    append_submenu(menu, sub_menu_primitives, wxID_ANY, _L("Add Primitive"), "", "menu_add_part",
        []() {return true; }, m_parent);
    append_submenu(menu, sub_menu_handy, wxID_ANY, _L("Add Handy models"), "", "menu_add_part",
        []() {return true; }, m_parent);
    append_menu_item(menu, wxID_ANY, _L("Add Models"), "", // ORCA: Add Models
        [](wxCommandEvent&) { plater()->add_file(); }, "menu_add_part", menu,
        []() {return wxGetApp().plater()->can_add_model(); }, m_parent);
 
    menu->AppendSeparator();
    // reload all objects on current plate
    append_menu_item(
        menu, wxID_ANY, _L("Reload All"), _L("Reload all from disk"),
        [](wxCommandEvent&) {
            PartPlate* plate = plater()->get_partplate_list().get_selected_plate();
            assert(plate);
            plater()->set_prepare_state(Job::PREPARE_STATE_MENU);
            plater()->reload_all_from_disk();
        },
        "", nullptr, []() { return !plater()->get_partplate_list().get_selected_plate()->get_objects().empty(); }, m_parent);
    menu->AppendSeparator();
    append_menu_item_replace_all_with_stl(menu);
 
    return;
}

References _L, append_menu_item(), append_menu_item_replace_all_with_stl(), append_submenu(), append_submenu_add_generic(), append_submenu_add_handy_model(), create_plate_menu(), Slic3r::GUI::PartPlate::get_objects(), Slic3r::INVALID, m_parent, m_plate_menu, m_plate_mods_pos, Slic3r::GUI::obj_list(), Slic3r::GUI::plater(), and Slic3r::GUI::Job::PREPARE_STATE_MENU.

Referenced by create_plate_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_sla_object_menu()

void Slic3r::GUI::MenuFactory::create_sla_object_menu ( )

private

{
    create_common_object_menu(&m_sla_object_menu);
 
    m_sla_object_menu.AppendSeparator();
 
    // Add the automatic rotation sub-menu
    append_menu_item(&m_sla_object_menu, wxID_ANY, _L("Auto orientation"), _L("Auto orient the object to improve print quality"),
        [](wxCommandEvent&) { plater()->optimize_rotation(); });
}

References _L, append_menu_item(), create_common_object_menu(), create_sla_object_menu(), m_sla_object_menu, and Slic3r::GUI::plater().

Referenced by create_sla_object_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_svg_part_menu()

void Slic3r::GUI::MenuFactory::create_svg_part_menu ( )

private

{
    wxMenu* menu = &m_svg_part_menu;
 
    append_menu_item_edit_svg(menu);
 
    append_menu_item_center(menu);
    append_menu_item_align_distribute(menu);
    append_menu_item_transform(&m_svg_part_menu, false /*multi_selection*/, true /*mirror*/, false /*is_scalable*/);
    append_menu_item_modify(&m_svg_part_menu, false /*multi_selection*/, false /*splittable*/, true /*mesh*/, false /*mesh_boolean*/);
 
    //m_svg_geometry_pos = m_svg_part_menu.GetMenuItemCount(); // pos for geometry related items
 
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    menu->AppendSeparator();
 
    append_menu_item_change_type(menu);
    m_svg_props_marker = menu->FindItem(_L("Change Type")); // dynamic property items are inserted after this item
    menu->AppendSeparator();
 
    append_menu_item_per_object_process(menu);
    m_svg_project_marker = menu->FindItem(_L("Paste Process Settings")); // append_menu_item_per_object_settings() is inserted after this item
}

References _L, append_menu_item_align_distribute(), append_menu_item_center(), append_menu_item_change_type(), append_menu_item_delete(), append_menu_item_edit_svg(), append_menu_item_modify(), append_menu_item_per_object_process(), append_menu_item_transform(), create_svg_part_menu(), m_svg_part_menu, m_svg_project_marker, and m_svg_props_marker.

Referenced by create_svg_part_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

create_text_part_menu()

void Slic3r::GUI::MenuFactory::create_text_part_menu ( )

private

{
    wxMenu* menu = &m_text_part_menu;
 
    append_menu_item_edit_text(menu);
 
    append_menu_item_center(menu);
    append_menu_item_align_distribute(menu);
    append_menu_item_transform(&m_text_part_menu, false /*multi_selection*/, true /*mirror*/, false /*is_scalable*/);
    append_menu_item_modify(&m_text_part_menu, false /*multi_selection*/, false /*splittable*/, true /*mesh*/, false /*mesh_boolean*/);
 
    //m_text_geometry_pos = m_text_part_menu.GetMenuItemCount(); // pos for geometry related items
 
    menu->AppendSeparator();
    append_menu_item_delete(menu);
    menu->AppendSeparator();
 
    append_menu_item_change_type(menu);
    m_text_props_marker = menu->FindItem(_L("Change Type")); // dynamic property items are inserted after this item
    menu->AppendSeparator();
 
    append_menu_item_per_object_process(menu);
    m_text_project_marker = menu->FindItem(_L("Paste Process Settings")); // append_menu_item_per_object_settings() is inserted after this item
}

References _L, append_menu_item_align_distribute(), append_menu_item_center(), append_menu_item_change_type(), append_menu_item_delete(), append_menu_item_edit_text(), append_menu_item_modify(), append_menu_item_per_object_process(), append_menu_item_transform(), create_text_part_menu(), m_text_part_menu, m_text_project_marker, and m_text_props_marker.

Referenced by create_text_part_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

default_menu()

wxMenu * Slic3r::GUI::MenuFactory::default_menu

(

)

{
    return &m_default_menu;
}

References default_menu(), and m_default_menu.

Referenced by default_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

filament_action_menu()

wxMenu * Slic3r::GUI::MenuFactory::filament_action_menu

(

int

active_filament_menu_id

)

                                                                     {
    create_filament_action_menu(false, active_filament_menu_id);
    return &m_filament_action_menu;
}

References create_filament_action_menu(), filament_action_menu(), and m_filament_action_menu.

Referenced by filament_action_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

FindPositionById()

size_t Slic3r::GUI::MenuFactory::FindPositionById ( wxMenu * menu, int id )

private

{
    const wxMenuItemList& list = menu->GetMenuItems();
    size_t idx = 0;
    for (auto node = list.GetFirst(); node; node = node->GetNext(), ++idx) {
        if (node->GetData()->GetId() == id)
            return idx;
    }
    return wxNOT_FOUND; // or list.GetCount()
}

References FindPositionById().

Referenced by append_menu_item_edit_svg(), append_menu_item_edit_text(), append_menu_item_invalidate_cut_info(), append_menu_item_plate_delete(), FindPositionById(), object_menu(), part_menu(), svg_part_menu(), and text_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

get_svg_volume_bitmaps()

std::vector< wxBitmap > Slic3r::GUI::MenuFactory::get_svg_volume_bitmaps ( )

static

{
    std::vector<wxBitmap> volume_bmps;
    volume_bmps.reserve(SVG_VOLUME_ICONS.size());
    for (const auto &item : SVG_VOLUME_ICONS)
        volume_bmps.push_back(create_scaled_bitmap(item.second));
    return volume_bmps;
}

References create_scaled_bitmap(), get_svg_volume_bitmaps(), and Slic3r::GUI::SVG_VOLUME_ICONS.

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), get_svg_volume_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::Rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

get_text_volume_bitmaps()

std::vector< wxBitmap > Slic3r::GUI::MenuFactory::get_text_volume_bitmaps ( )

static

{
    std::vector<wxBitmap> volume_bmps;
    volume_bmps.reserve(TEXT_VOLUME_ICONS.size());
    for (const auto& item : TEXT_VOLUME_ICONS)
        volume_bmps.push_back(create_scaled_bitmap(item.second));
    return volume_bmps;
}

References create_scaled_bitmap(), get_text_volume_bitmaps(), and Slic3r::GUI::TEXT_VOLUME_ICONS.

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), get_text_volume_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::Rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

get_volume_bitmaps()

std::vector< wxBitmap > Slic3r::GUI::MenuFactory::get_volume_bitmaps ( )

static

{
    std::vector<wxBitmap> volume_bmps;
    volume_bmps.reserve(ADD_VOLUME_MENU_ITEMS.size());
    for (const auto& item : ADD_VOLUME_MENU_ITEMS) {
        volume_bmps.push_back(create_scaled_bitmap(item.second));
    }
    return volume_bmps;
}

References Slic3r::GUI::ADD_VOLUME_MENU_ITEMS, create_scaled_bitmap(), and get_volume_bitmaps().

Referenced by Slic3r::GUI::ObjectDataViewModel::ObjectDataViewModel(), get_volume_bitmaps(), and Slic3r::GUI::ObjectDataViewModel::Rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

handy_models()

const std::vector< MenuFactory::HandyModel > & Slic3r::GUI::MenuFactory::handy_models ( )

static

{
    static const std::vector<HandyModel> models = {
        {"orca_cube",           L("Orca Cube"),           {"OrcaCube_v2.drc", "OrcaPlug_v2.drc"},                    true},
        {"orcasliced_combo",    L("OrcaSliced Combo"),    {"OrcaSliced.3mf", "OrcaCube_v2.drc", "OrcaPlug_v2.drc"},  true},
        {"orca_badge",          L("Orca Badge"),          {"OrcaBadge.3mf"}},
        {"orca_tolerance_test", L("Orca Tolerance Test"), {"OrcaToleranceTest.drc"}},
        {"3dbenchy",            L("3DBenchy"),            {"3DBenchy.drc"}},
        {"cali_cat",            L("Cali Cat"),            {"calicat.drc"}},
        {"autodesk_fdm_test",   L("Autodesk FDM Test"),   {"ksr_fdmtest_v4.drc"}},
        {"voron_cube",          L("Voron Cube"),          {"Voron_Design_Cube_v7.drc"}},
        {"stanford_bunny",      L("Stanford Bunny"),      {"Stanford_Bunny.drc"}},
        {"orca_string_hell",    L("Orca String Hell"),    {"Orca_stringhell.drc"},                                   false, true},
    };
    return models;
}

References handy_models(), and L.

Referenced by append_submenu_add_handy_model(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), handy_models(), load_handy_model(), and Slic3r::GUI::run_scene_benchmark().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::MenuFactory::init

(

wxWindow *

parent

)

{
    m_parent = parent;
 
    create_default_menu();
    //BBS
    //create_object_menu();
    create_sla_object_menu();
    create_text_part_menu();
    create_svg_part_menu();
    create_extra_object_menu();
    create_bbl_part_menu();
    create_bbl_assemble_object_menu();
    create_bbl_assemble_part_menu();
 
    //BBS: add part plate related logic
    create_plate_menu();
 
    create_filament_action_menu(true, -1);
 
    // create "Instance to Object" menu item
    append_menu_item_instance_to_object(&m_instance_menu);
}

References append_menu_item_instance_to_object(), create_bbl_assemble_object_menu(), create_bbl_assemble_part_menu(), create_bbl_part_menu(), create_default_menu(), create_extra_object_menu(), create_filament_action_menu(), create_plate_menu(), create_sla_object_menu(), create_svg_part_menu(), create_text_part_menu(), init(), m_instance_menu, and m_parent.

Referenced by create_filament_action_menu(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

instance_menu()

wxMenu * Slic3r::GUI::MenuFactory::instance_menu

(

)

{
    return &m_instance_menu;
}

References instance_menu(), and m_instance_menu.

Referenced by instance_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

layer_menu()

wxMenu * Slic3r::GUI::MenuFactory::layer_menu

(

)

{
    MenuWithSeparators* menu = new MenuWithSeparators();
    append_menu_item_settings(menu);
 
    return menu;
}

References append_menu_item_settings(), and layer_menu().

Referenced by layer_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

load_handy_model()

void Slic3r::GUI::MenuFactory::load_handy_model ( std::size_t index )

static

{
    const std::vector<HandyModel>& models = handy_models();
    if (index >= models.size())
        return;
    const HandyModel& model = models[index];
 
    std::vector<boost::filesystem::path> input_files;
    input_files.reserve(model.file_names.size());
    for (const auto& file_name : model.file_names)
        input_files.push_back((boost::filesystem::path(Slic3r::resources_dir()) / "handy_models" / file_name));
 
    Plater* pl = plater();
    if (!pl)
        return;
    pl->load_files(input_files, LoadStrategy::LoadModel);
    if (model.arrange_after_import) {
        pl->set_prepare_state(Job::PREPARE_STATE_DEFAULT);
        pl->arrange();
    }
 
    // Suggest to change settings for stringhell
    // This serves as mini tutorial for new users
    if (model.is_stringhell) {
        wxGetApp().CallAfter([=] {
            DynamicPrintConfig* m_config = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
 
            bool is_only_one_wall_top  = m_config->opt_bool("only_one_wall_top");
            auto min_width_top_surface = m_config->option<ConfigOptionFloatOrPercent>("min_width_top_surface")->value;
            if (is_only_one_wall_top && min_width_top_surface > 0) {
                wxString msg_text = _L("This model features text embossment on the top surface. For optimal results, it is "
                                       "advisable to set the 'One Wall Threshold (min_width_top_surface)' "
                                       "to 0 for the 'Only One Wall on Top Surfaces' to work best.\n"
                                       "Yes - Change these settings automatically\n"
                                       "No  - Do not change these settings for me");
 
                MessageDialog dialog(wxGetApp().plater(), msg_text, _L("Suggestion"), wxICON_WARNING | wxYES | wxNO);
                if (dialog.ShowModal() == wxID_YES) {
                    m_config->set_key_value("min_width_top_surface", new ConfigOptionFloatOrPercent(0, false));
                    wxGetApp().get_tab(Preset::TYPE_PRINT)->update_dirty();
                    wxGetApp().get_tab(Preset::TYPE_PRINT)->reload_config();
                }
                wxGetApp().plater()->update();
            }
        });
    }
}

References _L, Slic3r::GUI::Plater::arrange(), Slic3r::GUI::MenuFactory::HandyModel::arrange_after_import, Slic3r::GUI::MenuFactory::HandyModel::file_names, handy_models(), Slic3r::GUI::MenuFactory::HandyModel::is_stringhell, Slic3r::GUI::Plater::load_files(), load_handy_model(), Slic3r::LoadModel, Slic3r::min_width_top_surface(), Slic3r::DynamicConfig::opt_bool(), Slic3r::ConfigBase::option(), Slic3r::GUI::plater(), Slic3r::GUI::Job::PREPARE_STATE_DEFAULT, Slic3r::resources_dir(), Slic3r::DynamicConfig::set_key_value(), Slic3r::GUI::Plater::set_prepare_state(), Slic3r::GUI::DPIAware< P >::ShowModal(), and Slic3r::Preset::TYPE_PRINT.

Referenced by append_submenu_add_handy_model(), Slic3r::GUI::anonymous_namespace{NativeCommands.cpp}::build_command_catalog(), load_handy_model(), and Slic3r::GUI::run_scene_benchmark().

Here is the call graph for this function:

Here is the caller graph for this function:

msw_rescale()

void Slic3r::GUI::MenuFactory::msw_rescale

(

)

{
    for (MenuWithSeparators* menu : { &m_object_menu, &m_sla_object_menu, &m_part_menu, &m_default_menu })
        msw_rescale_menu(dynamic_cast<wxMenu*>(menu));
}

References m_default_menu, m_object_menu, m_part_menu, m_sla_object_menu, msw_rescale(), and msw_rescale_menu().

Referenced by msw_rescale().

Here is the call graph for this function:

Here is the caller graph for this function:

multi_selection_menu()

wxMenu * Slic3r::GUI::MenuFactory::multi_selection_menu

(

)

{
    //BBS
    wxDataViewItemArray sels;
    obj_list()->GetSelections(sels);
    bool multi_volume = true;
    bool undefined_type = false;
    bool all_plates = true;
 
    for (const wxDataViewItem& item : sels) {
        Slic3r::GUI::ItemType item_type = list_model()->GetItemType(item);
        if ((item_type & itPlate) == 0)
            all_plates = false;
        multi_volume = item_type & itVolume;
        if (!(item_type & (itVolume | itObject | itInstance)))
            // show this menu only for Objects(Instances mixed with Objects)/Volumes selection
            undefined_type = true;
    }
 
    if (all_plates) {
        wxMenu* menu = new MenuWithSeparators();
        append_menu_item_replace_all_with_stl(menu);
        return menu;
    }
    if (undefined_type)
        return nullptr;
    wxMenu* menu = new MenuWithSeparators();
    if (!multi_volume) {
        int index = 0;
        if (obj_list()->can_merge_to_multipart_object()) {
            append_menu_item_merge_to_multipart_object(menu);
            menu->AppendSeparator();
            index++;
        }
        append_menu_item_center(menu);
        append_menu_item_drop(menu);
 
        auto transform_menu = append_menu_item_transform(menu, true /*multi_selection*/, false /*mirror*/, true /*is_scalable*/);
        append_menu_items_convert_unit(transform_menu);
        append_menu_item_align_distribute(menu);
        //ORCA switch to sub menus if new items added
        //append_menu_item_modify(menu, true /*multi_selection*/, false /*splittable*/, true /*is_mesh*/, false /*mesh_boolean*/);
        append_menu_item_fix_through_cgal(menu);
        //append_menu_item_simplify(menu);
        menu->AppendSeparator();
        append_menu_item_delete(menu);
        menu->AppendSeparator();
 
        append_menu_item_change_filament(menu);
        append_menu_item_set_printable(menu);
        append_menu_item_set_auto_drop(menu);
        menu->AppendSeparator();
 
        append_menu_item_per_object_process(menu);
        menu->AppendSeparator();
 
        // Reload from disk / Replace all with STL / Export STL / Export DRC
        append_menu_item_more(menu, true /*multi_selection*/, true /*disk_op*/, true /*export_op*/);
    }
    else {
        append_menu_item_center(menu);
        append_menu_item_drop(menu);
 
        //ORCA switch to sub menus if new items added
        auto transform_menu = append_menu_item_transform(menu, true /*multi_selection*/, false /*mirror*/, true /*is_scalable*/);
        append_menu_item_align_distribute(menu);
        append_menu_item_modify(menu, true /*multi_selection*/, true /*splittable*/, true /*is_mesh*/, false /*mesh_boolean*/);
        //append_menu_item_drop(menu);
        //append_menu_item_fix_through_cgal(menu);
        append_menu_items_convert_unit(transform_menu);
        //append_menu_item_simplify(menu);
        menu->AppendSeparator();
        append_menu_item_delete(menu);
        menu->AppendSeparator();
 
        append_menu_item_change_filament(menu);
        append_menu_item_change_type(menu);
        // Subtype picker for Precise Seam — shown only when all selected volumes are PS.
        // Must be paired with Change Type here (as in single-volume part_menu), otherwise
        // the user cannot switch PS subtypes (LEFT/RIGHT/etc.) on multi-selection.
        append_menu_item_precise_seam_submenu(menu); // inserts itself right after "Change Type"
        append_menu_item_set_auto_drop(menu);
        menu->AppendSeparator();
 
        append_menu_item_per_object_process(menu);
        menu->AppendSeparator();
 
        // Reload from disk / Replace all with STL
        append_menu_item_more(menu, true /*multi_selection*/, true /*disk_op*/, false /*export_op*/);
    }
    return menu;
}

References append_menu_item_align_distribute(), append_menu_item_center(), append_menu_item_change_filament(), append_menu_item_change_type(), append_menu_item_delete(), append_menu_item_drop(), append_menu_item_fix_through_cgal(), append_menu_item_merge_to_multipart_object(), append_menu_item_modify(), append_menu_item_more(), append_menu_item_per_object_process(), append_menu_item_precise_seam_submenu(), append_menu_item_replace_all_with_stl(), append_menu_item_set_auto_drop(), append_menu_item_set_printable(), append_menu_item_transform(), append_menu_items_convert_unit(), Slic3r::GUI::itInstance, Slic3r::GUI::itObject, Slic3r::GUI::itPlate, Slic3r::GUI::itVolume, Slic3r::GUI::list_model(), multi_selection_menu(), and Slic3r::GUI::obj_list().

Referenced by multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

object_menu()

wxMenu * Slic3r::GUI::MenuFactory::object_menu

(

)

{
    append_menu_items_convert_unit(m_object_transform_menu);
 
    // GEOMETRY
    append_menu_item_invalidate_cut_info(&m_object_menu, 0); // inserts itself to top of menu
    append_menu_item_edit_text(          &m_object_menu, 0); // inserts itself to top of menu
    append_menu_item_edit_svg(           &m_object_menu, 0); // inserts itself to top of menu
 
    // PROPS > Place items above printable
    size_t props_pos = FindPositionById(&m_object_menu, m_object_props_marker); // stored positions not works as expected since menu has multiple dynamic sections
    append_menu_item_change_filament(&m_object_menu, props_pos + 1);
    append_menu_items_flush_options (&m_object_menu, props_pos + 2);
 
    return &m_object_menu;
}

References append_menu_item_change_filament(), append_menu_item_edit_svg(), append_menu_item_edit_text(), append_menu_item_invalidate_cut_info(), append_menu_items_convert_unit(), append_menu_items_flush_options(), FindPositionById(), m_object_menu, m_object_props_marker, m_object_transform_menu, and object_menu().

Referenced by object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

part_menu()

wxMenu * Slic3r::GUI::MenuFactory::part_menu

(

)

{
    append_menu_items_convert_unit(m_part_transform_menu);
 
    // stored positions not works as expected since menu has multiple dynamic sections
    append_menu_item_per_object_settings(&m_part_menu, FindPositionById(&m_part_menu, m_part_project_marker) + 1);
    append_menu_item_change_filament(&m_part_menu, FindPositionById(&m_part_menu, m_part_props_marker) + 1);
    append_menu_item_precise_seam_submenu(&m_part_menu);
    return &m_part_menu;
}

References append_menu_item_change_filament(), append_menu_item_per_object_settings(), append_menu_item_precise_seam_submenu(), append_menu_items_convert_unit(), FindPositionById(), m_part_menu, m_part_project_marker, m_part_props_marker, m_part_transform_menu, and part_menu().

Referenced by part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

plate_menu()

wxMenu * Slic3r::GUI::MenuFactory::plate_menu

(

)

{
    append_menu_item_plate_name(  &m_plate_menu, m_plate_mods_pos);
    append_menu_item_locked(      &m_plate_menu, m_plate_mods_pos + 1);
    append_menu_item_plate_delete(&m_plate_menu, m_plate_mods_pos + 2);
    return &m_plate_menu;
}

References append_menu_item_locked(), append_menu_item_plate_delete(), append_menu_item_plate_name(), m_plate_menu, m_plate_mods_pos, and plate_menu().

Referenced by plate_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

sla_object_menu()

wxMenu * Slic3r::GUI::MenuFactory::sla_object_menu

(

)

{
    append_menu_items_convert_unit(&m_sla_object_menu);
    append_menu_item_settings(&m_sla_object_menu);
    //update_menu_items_instance_manipulation(mtObjectSLA);
    append_menu_item_edit_text(&m_sla_object_menu, 0); // inserts itself to top of menu
    append_menu_item_edit_svg(&m_sla_object_menu, 0); // inserts itself to top of menu
 
    return &m_sla_object_menu;
}

References append_menu_item_edit_svg(), append_menu_item_edit_text(), append_menu_item_settings(), append_menu_items_convert_unit(), m_sla_object_menu, and sla_object_menu().

Referenced by sla_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

svg_part_menu()

wxMenu * Slic3r::GUI::MenuFactory::svg_part_menu

(

)

{
    append_menu_item_per_object_settings(&m_svg_part_menu, FindPositionById(&m_svg_part_menu, m_svg_project_marker) + 1);
    append_menu_item_change_filament(&m_svg_part_menu, FindPositionById(&m_svg_part_menu, m_svg_props_marker) + 1);
 
    return &m_svg_part_menu;
}

References append_menu_item_change_filament(), append_menu_item_per_object_settings(), FindPositionById(), m_svg_part_menu, m_svg_project_marker, m_svg_props_marker, and svg_part_menu().

Referenced by svg_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

sys_color_changed() [1/2]

void Slic3r::GUI::MenuFactory::sys_color_changed

(

)

{
    for (MenuWithSeparators* menu : { &m_object_menu, &m_sla_object_menu, &m_part_menu, &m_default_menu }) {
        msw_rescale_menu(dynamic_cast<wxMenu*>(menu));// msw_rescale_menu updates just icons, so use it
#ifdef _WIN32
        // but under MSW we have to update item's bachground color
        for (wxMenuItem* item : menu->GetMenuItems())
            update_menu_item_def_colors(item);
#endif
    }
}

References m_default_menu, m_object_menu, m_part_menu, m_sla_object_menu, msw_rescale_menu(), and sys_color_changed().

Referenced by Slic3r::GUI::MainFrame::on_sys_color_changed(), sys_color_changed(), and sys_color_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

sys_color_changed() [2/2]

void Slic3r::GUI::MenuFactory::sys_color_changed ( wxMenuBar * menu_bar )

static

{
    // BBS: fix
#if 0
    for (size_t id = 0; id < menubar->GetMenuCount(); id++) {
        wxMenu* menu = menubar->GetMenu(id);
        msw_rescale_menu(menu);
#ifdef _WIN32
        // but under MSW we have to update item's bachground color
        for (wxMenuItem* item : menu->GetMenuItems())
            update_menu_item_def_colors(item);
#endif
    }
    menubar->Refresh();
#endif
}

References msw_rescale_menu(), and sys_color_changed().

Here is the call graph for this function:

text_part_menu()

wxMenu * Slic3r::GUI::MenuFactory::text_part_menu

(

)

{
    append_menu_item_per_object_settings(&m_text_part_menu, FindPositionById(&m_text_part_menu, m_text_project_marker) + 1);
    append_menu_item_change_filament(&m_text_part_menu, FindPositionById(&m_text_part_menu, m_text_props_marker) + 1);
 
    return &m_text_part_menu;
}

References append_menu_item_change_filament(), append_menu_item_per_object_settings(), FindPositionById(), m_text_part_menu, m_text_project_marker, m_text_props_marker, and text_part_menu().

Referenced by text_part_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void Slic3r::GUI::MenuFactory::update

(

)

{
    update_default_menu();
    update_object_menu();
}

References update(), update_default_menu(), and update_object_menu().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_default_menu()

void Slic3r::GUI::MenuFactory::update_default_menu

(

)

{
    for (auto& name : { _L("Add Primitive") , _L("Add Handy models"), _L("Show Labels") }) {
        const auto menu_item_id = m_default_menu.FindItem(name);
        if (menu_item_id != wxNOT_FOUND)
            m_default_menu.Destroy(menu_item_id);
    }
    create_default_menu();
}

References _L, create_default_menu(), m_default_menu, and update_default_menu().

Referenced by update(), and update_default_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

update_object_menu()

void Slic3r::GUI::MenuFactory::update_object_menu

(

)

{
    append_menu_items_add_volume(&m_object_menu);
}

References append_menu_items_add_volume(), m_object_menu, and update_object_menu().

Referenced by update(), and update_object_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

items_decrease

std::array<wxMenuItem*, mtCount> Slic3r::GUI::MenuFactory::items_decrease

private

Referenced by MenuFactory(), and append_menu_items_instance_manipulation().

items_increase

std::array<wxMenuItem*, mtCount> Slic3r::GUI::MenuFactory::items_increase

private

Referenced by MenuFactory(), and append_menu_items_instance_manipulation().

items_set_number_of_copies

std::array<wxMenuItem*, mtCount> Slic3r::GUI::MenuFactory::items_set_number_of_copies

private

Referenced by MenuFactory(), and append_menu_items_instance_manipulation().

m_assemble_object_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_assemble_object_menu

private

Referenced by create_bbl_assemble_object_menu().

m_assemble_part_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_assemble_part_menu

private

Referenced by create_bbl_assemble_part_menu().

m_default_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_default_menu

private

Referenced by create_default_menu(), default_menu(), msw_rescale(), sys_color_changed(), and update_default_menu().

m_filament_action_menu

wxMenu Slic3r::GUI::MenuFactory::m_filament_action_menu

private

Referenced by create_filament_action_menu(), and filament_action_menu().

m_instance_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_instance_menu

private

Referenced by init(), and instance_menu().

m_object_geometry_pos

size_t Slic3r::GUI::MenuFactory::m_object_geometry_pos

private

Referenced by create_extra_object_menu().

m_object_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_object_menu

private

Referenced by append_menu_items_instance_manipulation(), create_extra_object_menu(), create_object_menu(), msw_rescale(), object_menu(), sys_color_changed(), and update_object_menu().

m_object_props_marker

int Slic3r::GUI::MenuFactory::m_object_props_marker

private

Referenced by create_extra_object_menu(), and object_menu().

m_object_transform_menu

wxMenu* Slic3r::GUI::MenuFactory::m_object_transform_menu

private

Referenced by create_extra_object_menu(), and object_menu().

m_parent

wxWindow* Slic3r::GUI::MenuFactory::m_parent {nullptr}

private

{nullptr};

Referenced by append_menu_item_align_distribute(), append_menu_item_auto_drop(), append_menu_item_center(), append_menu_item_change_extruder(), append_menu_item_change_filament(), append_menu_item_change_type(), append_menu_item_clone(), append_menu_item_delete(), append_menu_item_drop(), append_menu_item_edit_svg(), append_menu_item_edit_text(), append_menu_item_export_drc(), append_menu_item_export_stl(), append_menu_item_fill_bed(), append_menu_item_instance_to_object(), append_menu_item_invalidate_cut_info(), append_menu_item_layers_editing(), append_menu_item_locked(), append_menu_item_merge_to_multipart_object(), append_menu_item_merge_to_single_object(), append_menu_item_modify(), append_menu_item_more(), append_menu_item_per_object_process(), append_menu_item_per_object_settings(), append_menu_item_plate_delete(), append_menu_item_plate_name(), append_menu_item_precise_seam_submenu(), append_menu_item_printable(), append_menu_item_reload_from_disk(), append_menu_item_replace_all_with_stl(), append_menu_item_replace_with_stl(), append_menu_item_set_auto_drop(), append_menu_item_set_printable(), append_menu_item_set_visible(), append_menu_item_simplify(), append_menu_item_smooth_mesh(), append_menu_item_transform(), append_menu_items_add_volume(), append_menu_items_convert_unit(), append_menu_items_flush_options(), append_menu_items_instance_manipulation(), create_default_menu(), create_extra_object_menu(), create_filament_action_menu(), create_plate_menu(), and init().

m_part_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_part_menu

private

Referenced by create_bbl_part_menu(), msw_rescale(), part_menu(), and sys_color_changed().

m_part_project_marker

int Slic3r::GUI::MenuFactory::m_part_project_marker

private

Referenced by create_bbl_part_menu(), and part_menu().

m_part_props_marker

int Slic3r::GUI::MenuFactory::m_part_props_marker

private

Referenced by create_bbl_part_menu(), and part_menu().

m_part_transform_menu

wxMenu* Slic3r::GUI::MenuFactory::m_part_transform_menu

private

Referenced by create_bbl_part_menu(), and part_menu().

m_plate_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_plate_menu

private

Referenced by create_plate_menu(), and plate_menu().

m_plate_mods_pos

size_t Slic3r::GUI::MenuFactory::m_plate_mods_pos

private

Referenced by create_plate_menu(), and plate_menu().

m_sla_object_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_sla_object_menu

private

Referenced by create_sla_object_menu(), msw_rescale(), sla_object_menu(), and sys_color_changed().

m_svg_part_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_svg_part_menu

private

Referenced by append_menu_item_edit_svg(), create_svg_part_menu(), and svg_part_menu().

m_svg_project_marker

int Slic3r::GUI::MenuFactory::m_svg_project_marker

private

Referenced by create_svg_part_menu(), and svg_part_menu().

m_svg_props_marker

int Slic3r::GUI::MenuFactory::m_svg_props_marker

private

Referenced by create_svg_part_menu(), and svg_part_menu().

m_text_part_menu

MenuWithSeparators Slic3r::GUI::MenuFactory::m_text_part_menu

private

Referenced by append_menu_item_edit_text(), create_text_part_menu(), and text_part_menu().

m_text_project_marker

int Slic3r::GUI::MenuFactory::m_text_project_marker

private

Referenced by create_text_part_menu(), and text_part_menu().

m_text_props_marker

int Slic3r::GUI::MenuFactory::m_text_props_marker

private

Referenced by create_text_part_menu(), and text_part_menu().

---

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

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