#include <src/slic3r/GUI/Plater.hpp>

Inheritance diagram for Slic3r::GUI::Plater:

Collaboration diagram for Slic3r::GUI::Plater:

Classes
struct	priv

class	SuppressSnapshots

class	TakeSnapshot

Public Types
enum class	UpdateParams { FORCE_FULL_SCREEN_REFRESH = 1 , FORCE_BACKGROUND_PROCESSING_UPDATE = 2 , POSTPONE_VALIDATION_ERROR_MESSAGE = 4 }

using	fs_path = boost::filesystem::path

Public Member Functions
	Plater (wxWindow parent, MainFrame main_frame)

	Plater (Plater &&)=delete

	Plater (const Plater &)=delete

Plater &	operator= (Plater &&)=delete

Plater &	operator= (const Plater &)=delete

	~Plater ()=default

bool	is_project_dirty () const

bool	is_presets_dirty () const

void	update_project_dirty_from_presets ()

int	save_project_if_dirty (const wxString &reason)

void	reset_project_dirty_after_save ()

void	reset_project_dirty_initial_presets ()

bool	is_project_temp () const

Sidebar &	sidebar ()

const Model &	model () const

Model &	model ()

const Print &	fff_print () const

Print &	fff_print ()

const SLAPrint &	sla_print () const

SLAPrint &	sla_print ()

void	new_project ()

void	load_project ()

void	load_project (const wxString &filename)

void	add_model (bool imperial_units=false)

void	import_zip_archive ()

void	import_sl1_archive ()

void	extract_config_from_project ()

void	load_gcode ()

void	load_gcode (const wxString &filename)

void	reload_gcode_from_disk ()

void	refresh_print ()

std::vector< size_t >	load_files (const std::vector< boost::filesystem::path > &input_files, bool load_model=true, bool load_config=true, bool imperial_units=false)

std::vector< size_t >	load_files (const std::vector< std::string > &input_files, bool load_model=true, bool load_config=true, bool imperial_units=false)

bool	load_files (const wxArrayString &filenames, bool delete_after_load=false)

void	check_selected_presets_visibility (PrinterTechnology loaded_printer_technology)

bool	preview_zip_archive (const boost::filesystem::path &input_file)

const wxString &	get_last_loaded_gcode () const

void	update (unsigned int flags=0)

Worker &	get_ui_job_worker ()

const Worker &	get_ui_job_worker () const

void	select_view (const std::string &direction)

void	select_view_3D (const std::string &name)

bool	is_preview_shown () const

bool	is_preview_loaded () const

bool	is_view3D_shown () const

bool	are_view3D_labels_shown () const

void	show_view3D_labels (bool show)

bool	is_legend_shown () const

void	show_legend (bool show)

bool	is_sidebar_collapsed () const

void	collapse_sidebar (bool show)

bool	is_view3D_layers_editing_enabled () const

void	update_ui_from_settings ()

void	select_all ()

void	deselect_all ()

void	remove (size_t obj_idx)

void	reset ()

void	reset_with_confirm ()

bool	delete_object_from_model (size_t obj_idx)

void	remove_selected ()

void	increase_instances (size_t num=1, int obj_idx=-1, int inst_idx=-1)

void	decrease_instances (size_t num=1, int obj_idx=-1)

void	set_number_of_copies ()

void	fill_bed_with_instances ()

bool	is_selection_empty () const

void	scale_selection_to_fit_print_volume ()

void	convert_unit (ConversionType conv_type)

void	toggle_layers_editing (bool enable)

void	cut (size_t obj_idx, size_t instance_idx, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes)

void	cut (size_t init_obj_idx, const ModelObjectPtrs &cut_objects)

void	export_gcode (bool prefer_removable)

void	export_stl_obj (bool extended=false, bool selection_only=false)

void	export_amf ()

bool	export_3mf (const boost::filesystem::path &output_path=boost::filesystem::path())

void	reload_from_disk ()

void	replace_with_stl ()

void	reload_all_from_disk ()

bool	has_toolpaths_to_export () const

void	export_toolpaths_to_obj () const

void	reslice ()

void	reslice_FFF_until_step (PrintObjectStep step, const ModelObject &object, bool postpone_error_messages=false)

void	reslice_SLA_until_step (SLAPrintObjectStep step, const ModelObject &object, bool postpone_error_messages=false)

void	clear_before_change_mesh (int obj_idx, const std::string &notification_msg)

void	changed_mesh (int obj_idx)

void	changed_object (int obj_idx)

void	changed_objects (const std::vector< size_t > &object_idxs)

void	schedule_background_process (bool schedule=true)

bool	is_background_process_update_scheduled () const

void	suppress_background_process (const bool stop_background_process)

void	send_gcode ()

void	eject_drive ()

void	take_snapshot (const std::string &snapshot_name)

void	take_snapshot (const wxString &snapshot_name)

void	take_snapshot (const std::string &snapshot_name, UndoRedo::SnapshotType snapshot_type)

void	take_snapshot (const wxString &snapshot_name, UndoRedo::SnapshotType snapshot_type)

void	undo ()

void	redo ()

void	undo_to (int selection)

void	redo_to (int selection)

bool	undo_redo_string_getter (const bool is_undo, int idx, const char **out_text)

void	undo_redo_topmost_string_getter (const bool is_undo, std::string &out_text)

bool	search_string_getter (int idx, const char label, const char tooltip)

const Slic3r::UndoRedo::Stack &	undo_redo_stack_main () const

void	clear_undo_redo_stack_main ()

void	enter_gizmos_stack ()

void	leave_gizmos_stack ()

void	on_extruders_change (size_t extruders_count)

bool	update_filament_colors_in_full_config ()

void	on_config_change (const DynamicPrintConfig &config)

void	force_filament_colors_update ()

void	force_filament_cb_update ()

void	force_print_bed_update ()

void	on_activate ()

std::vector< std::string >	get_extruder_colors_from_plater_config (const GCodeProcessorResult *const result=nullptr) const

std::vector< std::string >	get_colors_for_color_print (const GCodeProcessorResult *const result=nullptr) const

void	update_menus ()

void	show_action_buttons (const bool is_ready_to_slice) const

void	show_action_buttons () const

wxString	get_project_filename (const wxString &extension=wxEmptyString) const

void	set_project_filename (const wxString &filename)

bool	is_export_gcode_scheduled () const

const Selection &	get_selection () const

int	get_selected_object_idx ()

bool	is_single_full_object_selection () const

GLCanvas3D *	canvas3D ()

const GLCanvas3D *	canvas3D () const

GLCanvas3D *	get_current_canvas3D ()

void	arrange ()

void	set_current_canvas_as_dirty ()

void	unbind_canvas_event_handlers ()

void	reset_canvas_volumes ()

PrinterTechnology	printer_technology () const

const DynamicPrintConfig *	config () const

bool	set_printer_technology (PrinterTechnology printer_technology)

void	copy_selection_to_clipboard ()

void	paste_from_clipboard ()

void	search (bool plater_is_active)

void	mirror (Axis axis)

void	split_object ()

void	split_volume ()

bool	can_delete () const

bool	can_delete_all () const

bool	can_increase_instances () const

bool	can_decrease_instances (int obj_idx=-1) const

bool	can_set_instance_to_object () const

bool	can_fix_through_netfabb () const

bool	can_simplify () const

bool	can_split_to_objects () const

bool	can_split_to_volumes () const

bool	can_arrange () const

bool	can_layers_editing () const

bool	can_paste_from_clipboard () const

bool	can_copy_to_clipboard () const

bool	can_undo () const

bool	can_redo () const

bool	can_reload_from_disk () const

bool	can_replace_with_stl () const

bool	can_mirror () const

bool	can_split (bool to_objects) const

bool	can_scale_to_print_volume () const

void	msw_rescale ()

void	sys_color_changed ()

bool	init_view_toolbar ()

void	enable_view_toolbar (bool enable)

bool	init_collapse_toolbar ()

void	enable_collapse_toolbar (bool enable)

const Camera &	get_camera () const

Camera &	get_camera ()

const BuildVolume &	build_volume () const

const GLToolbar &	get_view_toolbar () const

GLToolbar &	get_view_toolbar ()

const GLToolbar &	get_collapse_toolbar () const

GLToolbar &	get_collapse_toolbar ()

void	set_preview_layers_slider_values_range (int bottom, int top)

void	update_preview_moves_slider ()

void	enable_preview_moves_slider (bool enable)

void	reset_gcode_toolpaths ()

void	reset_last_loaded_gcode ()

const Mouse3DController &	get_mouse3d_controller () const

Mouse3DController &	get_mouse3d_controller ()

void	set_bed_shape () const

void	set_bed_shape (const Pointfs &shape, const double max_print_height, const std::string &custom_texture, const std::string &custom_model, bool force_as_custom=false) const

void	set_default_bed_shape () const

NotificationManager *	get_notification_manager ()

const NotificationManager *	get_notification_manager () const

void	init_notification_manager ()

void	bring_instance_forward ()

bool	inside_snapshot_capture ()

void	toggle_render_statistic_dialog ()

bool	is_render_statistic_dialog_visible () const

void	set_keep_current_preview_type (bool value)

bool	PopupMenu (wxMenu *menu, const wxPoint &pos=wxDefaultPosition)

bool	PopupMenu (wxMenu *menu, int x, int y)

wxMenu *	object_menu ()

wxMenu *	part_menu ()

wxMenu *	text_part_menu ()

wxMenu *	sla_object_menu ()

wxMenu *	default_menu ()

wxMenu *	instance_menu ()

wxMenu *	layer_menu ()

wxMenu *	multi_selection_menu ()

Static Public Member Functions
static bool	has_illegal_filename_characters (const wxString &name)

static bool	has_illegal_filename_characters (const std::string &name)

static void	show_illegal_characters_warning (wxWindow *parent)

Private Member Functions
void	reslice_until_step_inner (int step, const ModelObject &object, bool postpone_error_messages)

void	suppress_snapshots ()

void	allow_snapshots ()

Private Attributes
std::unique_ptr< priv >	p

bool	m_tracking_popup_menu = false

wxString	m_tracking_popup_menu_error_message

wxString	m_last_loaded_gcode

Friends
class	SuppressBackgroundProcessingUpdate

Detailed Description

Member Typedef Documentation

◆ fs_path

using Slic3r::GUI::Plater::fs_path = boost::filesystem::path

Member Enumeration Documentation

◆ UpdateParams

enum class Slic3r::GUI::Plater::UpdateParams

strong

Enumerator
FORCE_FULL_SCREEN_REFRESH
FORCE_BACKGROUND_PROCESSING_UPDATE
POSTPONE_VALIDATION_ERROR_MESSAGE

                            {
        FORCE_FULL_SCREEN_REFRESH = 1,
        FORCE_BACKGROUND_PROCESSING_UPDATE = 2,
        POSTPONE_VALIDATION_ERROR_MESSAGE = 4,
    };

Constructor & Destructor Documentation

◆ Plater() [1/3]

Slic3r::GUI::Plater::Plater	(	wxWindow *	parent,
		MainFrame *	main_frame
	)

    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxGetApp().get_min_size())
    , p(new priv(this, main_frame))
{
    // Initialization performed in the private c-tor
}

◆ Plater() [2/3]

Slic3r::GUI::Plater::Plater ( Plater && )

delete

◆ Plater() [3/3]

Slic3r::GUI::Plater::Plater ( const Plater & )

delete

◆ ~Plater()

Slic3r::GUI::Plater::~Plater ( )

default

Member Function Documentation

◆ add_model()

void Slic3r::GUI::Plater::add_model ( bool imperial_units = false )

{
    wxArrayString input_files;
    wxGetApp().import_model(this, input_files);
    if (input_files.empty())
        return;
 
    std::vector<fs::path> paths;
    for (const auto &file : input_files)
        paths.emplace_back(into_path(file));
 
    wxString snapshot_label;
    assert(! paths.empty());
    if (paths.size() == 1) {
        snapshot_label = _L("Import Object");
        snapshot_label += ": ";
        snapshot_label += wxString::FromUTF8(paths.front().filename().string().c_str());
    } else {
        snapshot_label = _L("Import Objects");
        snapshot_label += ": ";
        snapshot_label += wxString::FromUTF8(paths.front().filename().string().c_str());
        for (size_t i = 1; i < paths.size(); ++ i) {
            snapshot_label += ", ";
            snapshot_label += wxString::FromUTF8(paths[i].filename().string().c_str());
        }
    }
 
    Plater::TakeSnapshot snapshot(this, snapshot_label);
    if (! load_files(paths, true, false, imperial_units).empty())
        wxGetApp().mainframe->update_title();
}

References _L, Slic3r::empty(), Slic3r::GUI::into_path(), and load_files().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allow_snapshots()

void Slic3r::GUI::Plater::allow_snapshots ( )

private

6896{ p->allow_snapshots(); }

References p.

Referenced by Slic3r::GUI::Plater::SuppressSnapshots::~SuppressSnapshots(), and Slic3r::GUI::Plater::TakeSnapshot::~TakeSnapshot().

Here is the caller graph for this function:

◆ are_view3D_labels_shown()

bool Slic3r::GUI::Plater::are_view3D_labels_shown ( ) const

6084{ return p->are_view3D_labels_shown(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ arrange()

void Slic3r::GUI::Plater::arrange ( )

{
    if (p->can_arrange()) {
        auto &w = get_ui_job_worker();
        p->take_snapshot(_L("Arrange"));
 
        auto mode = wxGetKeyState(WXK_SHIFT) ? ArrangeJob::SelectionOnly :
                                               ArrangeJob::Full;
 
        replace_job(w, std::make_unique<ArrangeJob>(mode));
    }
}

References _L, Slic3r::GUI::ArrangeJob::Full, get_ui_job_worker(), p, Slic3r::GUI::replace_job(), and Slic3r::GUI::ArrangeJob::SelectionOnly.

Referenced by increase_instances().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bring_instance_forward()

void Slic3r::GUI::Plater::bring_instance_forward ( )

{
    p->bring_instance_forward();
}

References p.

◆ build_volume()

const BuildVolume & Slic3r::GUI::Plater::build_volume ( ) const

{
    return p->bed.build_volume();
}

References p.

Referenced by Slic3r::GUI::bed_stride(), and priv::start_create_object_job().

Here is the caller graph for this function:

◆ can_arrange()

bool Slic3r::GUI::Plater::can_arrange ( ) const

7614{ return p->can_arrange(); }

References p.

◆ can_copy_to_clipboard()

bool Slic3r::GUI::Plater::can_copy_to_clipboard ( ) const

{
    if (is_selection_empty())
        return false;
 
    const Selection& selection = p->view3D->get_canvas3d()->get_selection();
    if ((wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA) && !selection.is_sla_compliant())
        return false;
 
    return true;
}

References is_selection_empty(), Slic3r::GUI::Selection::is_sla_compliant(), p, and Slic3r::ptSLA.

Referenced by copy_selection_to_clipboard(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_decrease_instances()

bool Slic3r::GUI::Plater::can_decrease_instances ( int obj_idx = -1 ) const

7608{ return p->can_decrease_instances(obj_idx); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), Slic3r::GUI::Plater::priv::can_decrease_instances(), and decrease_instances().

Here is the caller graph for this function:

◆ can_delete()

bool Slic3r::GUI::Plater::can_delete ( ) const

7605{ return p->can_delete(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_delete().

Here is the caller graph for this function:

◆ can_delete_all()

bool Slic3r::GUI::Plater::can_delete_all ( ) const

7606{ return p->can_delete_all(); }

References p.

◆ can_fix_through_netfabb()

bool Slic3r::GUI::Plater::can_fix_through_netfabb ( ) const

7610{ return p->can_fix_through_netfabb(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_fix_through_netfabb().

Here is the caller graph for this function:

◆ can_increase_instances()

bool Slic3r::GUI::Plater::can_increase_instances ( ) const

7607{ return p->can_increase_instances(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), increase_instances(), and Slic3r::GUI::MenuFactory::multi_selection_menu().

Here is the caller graph for this function:

◆ can_layers_editing()

bool Slic3r::GUI::Plater::can_layers_editing ( ) const

7615{ return p->can_layers_editing(); }

References p.

◆ can_mirror()

bool Slic3r::GUI::Plater::can_mirror ( ) const

7653{ return p->can_mirror(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_mirror().

Here is the caller graph for this function:

◆ can_paste_from_clipboard()

bool Slic3r::GUI::Plater::can_paste_from_clipboard ( ) const

{
    const Selection& selection = p->view3D->get_canvas3d()->get_selection();
    const Selection::Clipboard& clipboard = selection.get_clipboard();
 
    if (clipboard.is_empty() && p->sidebar->obj_list()->clipboard_is_empty())
        return false;
 
    if ((wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptSLA) && !clipboard.is_sla_compliant())
        return false;
 
    Selection::EMode mode = clipboard.get_mode();
    if ((mode == Selection::Volume) && !selection.is_from_single_instance())
        return false;
 
    if ((mode == Selection::Instance) && (selection.get_mode() != Selection::Instance))
        return false;
 
    return true;
}

References Slic3r::GUI::Selection::get_clipboard(), Slic3r::GUI::Selection::Clipboard::get_mode(), Slic3r::GUI::Selection::get_mode(), Slic3r::GUI::Selection::Instance, Slic3r::GUI::Selection::Clipboard::is_empty(), Slic3r::GUI::Selection::is_from_single_instance(), Slic3r::GUI::Selection::Clipboard::is_sla_compliant(), p, Slic3r::ptSLA, and Slic3r::GUI::Selection::Volume.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and paste_from_clipboard().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ can_redo()

bool Slic3r::GUI::Plater::can_redo ( ) const

7650{ return p->undo_redo_stack().has_redo_snapshot(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ can_reload_from_disk()

bool Slic3r::GUI::Plater::can_reload_from_disk ( ) const

7651{ return p->can_reload_from_disk(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_reload_from_disk().

Here is the caller graph for this function:

◆ can_replace_with_stl()

bool Slic3r::GUI::Plater::can_replace_with_stl ( ) const

7652{ return p->can_replace_with_stl(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_replace_with_stl().

Here is the caller graph for this function:

◆ can_scale_to_print_volume()

bool Slic3r::GUI::Plater::can_scale_to_print_volume ( ) const

7655{ return p->can_scale_to_print_volume(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_scale_selection_to_fit_print_volume().

Here is the caller graph for this function:

◆ can_set_instance_to_object()

bool Slic3r::GUI::Plater::can_set_instance_to_object ( ) const

7609{ return p->can_set_instance_to_object(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object().

Here is the caller graph for this function:

◆ can_simplify()

bool Slic3r::GUI::Plater::can_simplify ( ) const

7611{ return p->can_simplify(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_simplify().

Here is the caller graph for this function:

◆ can_split()

bool Slic3r::GUI::Plater::can_split ( bool to_objects ) const

7654{ return p->can_split(to_objects); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_split(), and Slic3r::GUI::MenuFactory::create_part_menu().

Here is the caller graph for this function:

◆ can_split_to_objects()

bool Slic3r::GUI::Plater::can_split_to_objects ( ) const

7612{ return p->can_split_to_objects(); }

References p.

◆ can_split_to_volumes()

bool Slic3r::GUI::Plater::can_split_to_volumes ( ) const

7613{ return p->can_split_to_volumes(); }

References p.

◆ can_undo()

bool Slic3r::GUI::Plater::can_undo ( ) const

7649{ return p->undo_redo_stack().has_undo_snapshot(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ canvas3D() [1/2]

GLCanvas3D * Slic3r::GUI::Plater::canvas3D ( )

{
    return p->view3D->get_canvas3d();
}

References p.

Referenced by Slic3r::GUI::MainFrame::MainFrame(), Slic3r::GUI::GLGizmoSimplify::add_simplify_suggestion_notification(), Slic3r::GUI::MenuFactory::append_menu_item_add_text(), Slic3r::GUI::MenuFactory::append_menu_item_edit_text(), Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), Slic3r::GUI::MenuFactory::append_menu_item_instance_to_object(), Slic3r::GUI::MenuFactory::append_menu_item_printable(), Slic3r::GUI::call_after_if_active(), Slic3r::GUI::MainFrame::can_save(), Slic3r::GUI::MainFrame::can_save_as(), priv::create_volume(), Slic3r::GUI::ObjectList::del_info_item(), export_gcode(), Slic3r::GUI::Emboss::CreateObjectJob::finalize(), Slic3r::GUI::get_arrange_params(), Slic3r::GUI::get_selection(), Slic3r::GUI::get_wipe_tower(), increase_instances(), reslice(), search(), Slic3r::GUI::MainFrame::select_tab(), Slic3r::GUI::ObjectList::simplify(), toggle_layers_editing(), Slic3r::GUI::GUI_App::update_mode(), and priv::update_volume().

Here is the caller graph for this function:

◆ canvas3D() [2/2]

const GLCanvas3D * Slic3r::GUI::Plater::canvas3D ( ) const

{
    return p->view3D->get_canvas3d();
}

References p.

◆ changed_mesh()

void Slic3r::GUI::Plater::changed_mesh ( int obj_idx )

{
    ModelObject* mo = model().objects[obj_idx];
    sla::reproject_points_and_holes(mo);
    update();
    p->object_list_changed();
    p->schedule_background_process();
}

References model(), Slic3r::Model::objects, p, Slic3r::sla::reproject_points_and_holes(), and update().

Referenced by Slic3r::GUI::GLGizmoSimplify::apply_simplify(), and Slic3r::GUI::ObjectList::fix_through_netfabb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ changed_object()

void Slic3r::GUI::Plater::changed_object ( int obj_idx )

{
    if (obj_idx < 0)
        return;
    // recenter and re - align to Z = 0
    p->model.objects[obj_idx]->ensure_on_bed(p->printer_technology != ptSLA);
    if (this->p->printer_technology == ptSLA) {
        // Update the SLAPrint from the current Model, so that the reload_scene()
        // pulls the correct data, update the 3D scene.
        this->p->update_restart_background_process(true, false);
    }
    else
        p->view3D->reload_scene(false);
 
    // update print
    this->p->schedule_background_process();
}

References p, and Slic3r::ptSLA.

◆ changed_objects()

void Slic3r::GUI::Plater::changed_objects ( const std::vector< size_t > & object_idxs )

{
    if (object_idxs.empty())
        return;
 
    for (size_t obj_idx : object_idxs) {
        if (obj_idx < p->model.objects.size()) {
            if (p->model.objects[obj_idx]->min_z() >= SINKING_Z_THRESHOLD)
                // re - align to Z = 0
                p->model.objects[obj_idx]->ensure_on_bed();
        }
    }
    if (this->p->printer_technology == ptSLA) {
        // Update the SLAPrint from the current Model, so that the reload_scene()
        // pulls the correct data, update the 3D scene.
        this->p->update_restart_background_process(true, false);
    }
    else {
        p->view3D->reload_scene(false);
        p->view3D->get_canvas3d()->update_instance_printable_state_for_objects(object_idxs);
    }
 
    // update print
    this->p->schedule_background_process();
}

References model(), Slic3r::Model::objects, p, Slic3r::ptSLA, and Slic3r::SINKING_Z_THRESHOLD.

Here is the call graph for this function:

◆ check_selected_presets_visibility()

void Slic3r::GUI::Plater::check_selected_presets_visibility ( PrinterTechnology loaded_printer_technology )

{
    auto update_selected_preset_visibility = [](PresetCollection& presets, std::vector<std::string>& names) {
        if (!presets.get_selected_preset().is_visible) {
            assert(presets.get_selected_preset().name == presets.get_edited_preset().name);
            presets.get_selected_preset().is_visible = true;
            presets.get_edited_preset().is_visible = true;
            names.emplace_back(presets.get_selected_preset().name);
        }
    };
 
    std::vector<std::string> names;
    PresetBundle* preset_bundle = wxGetApp().preset_bundle;
    if (loaded_printer_technology == ptFFF) {
        update_selected_preset_visibility(preset_bundle->prints, names);
        for (const auto& extruder_filaments : preset_bundle->extruders_filaments) {
            Preset* preset = preset_bundle->filaments.find_preset(extruder_filaments.get_selected_preset_name());
            if (preset && !preset->is_visible) {
                preset->is_visible = true;
                names.emplace_back(preset->name);
                if (preset->name == preset_bundle->filaments.get_edited_preset().name)
                    preset_bundle->filaments.get_selected_preset().is_visible = true;
            }
        }
    }
    else {
        update_selected_preset_visibility(preset_bundle->sla_prints, names);
        update_selected_preset_visibility(preset_bundle->sla_materials, names);
    }
    update_selected_preset_visibility(preset_bundle->printers, names);
 
    preset_bundle->update_compatible(PresetSelectCompatibleType::Never);
 
    // show notification about temporarily installed presets
    if (!names.empty()) {
        std::string notif_text = into_u8(_L_PLURAL("The preset below was temporarily installed on the active instance of PrusaSlicer",
            "The presets below were temporarily installed on the active instance of PrusaSlicer", names.size())) + ":";
        for (std::string& name : names)
            notif_text += "\n - " + name;
        get_notification_manager()->push_notification(NotificationType::CustomNotification,
            NotificationManager::NotificationLevel::PrintInfoNotificationLevel, notif_text);
    }
}

References _L_PLURAL, Slic3r::GUI::CustomNotification, Slic3r::PresetBundle::extruders_filaments, Slic3r::PresetBundle::filaments, Slic3r::PresetCollection::find_preset(), Slic3r::PresetCollection::get_edited_preset(), get_notification_manager(), Slic3r::PresetCollection::get_selected_preset(), Slic3r::GUI::into_u8(), Slic3r::Preset::is_visible, Slic3r::Preset::name, Slic3r::Never, Slic3r::PresetBundle::printers, Slic3r::GUI::NotificationManager::PrintInfoNotificationLevel, Slic3r::PresetBundle::prints, Slic3r::ptFFF, Slic3r::GUI::NotificationManager::push_notification(), Slic3r::PresetBundle::sla_materials, Slic3r::PresetBundle::sla_prints, and Slic3r::PresetBundle::update_compatible().

Referenced by Slic3r::GUI::MainFrame::load_config_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_before_change_mesh()

void Slic3r::GUI::Plater::clear_before_change_mesh	(	int	obj_idx,
		const std::string &	notification_msg
	)

{
    ModelObject* mo = model().objects[obj_idx];
 
    // If there are custom supports/seams/mmu segmentation, remove them. Fixed mesh
    // may be different and they would make no sense.
    bool paint_removed = false;
    for (ModelVolume* mv : mo->volumes) {
        paint_removed |= ! mv->supported_facets.empty() || ! mv->seam_facets.empty() || ! mv->mmu_segmentation_facets.empty();
        mv->supported_facets.reset();
        mv->seam_facets.reset();
        mv->mmu_segmentation_facets.reset();
    }
    if (paint_removed) {
        // snapshot_time is captured by copy so the lambda knows where to undo/redo to.
        get_notification_manager()->push_notification(
                    NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
                    NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
                    notification_msg);
//                    _u8L("Undo the repair"),
//                    [this, snapshot_time](wxEvtHandler*){
//                        // Make sure the snapshot is still available and that
//                        // we are in the main stack and not in a gizmo-stack.
//                        if (undo_redo_stack().has_undo_snapshot(snapshot_time)
//                         && q->canvas3D()->get_gizmos_manager().get_current() == nullptr)
//                            undo_redo_to(snapshot_time);
//                        else
//                            notification_manager->push_notification(
//                                NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
//                                NotificationManager::NotificationLevel::RegularNotificationLevel,
//                                _u8L("Cannot undo to before the mesh repair!"));
//                        return true;
//                    });
    }
}

References Slic3r::GUI::CustomSupportsAndSeamRemovedAfterRepair, get_notification_manager(), model(), Slic3r::Model::objects, Slic3r::GUI::NotificationManager::PrintInfoNotificationLevel, Slic3r::GUI::NotificationManager::push_notification(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoSimplify::apply_simplify(), and Slic3r::GUI::ObjectList::fix_through_netfabb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_undo_redo_stack_main()

void Slic3r::GUI::Plater::clear_undo_redo_stack_main ( )

7658{ p->undo_redo_stack_main().clear(); }

References p.

◆ collapse_sidebar()

void Slic3r::GUI::Plater::collapse_sidebar ( bool show )

6091{ p->collapse_sidebar(show); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::update_layout().

Here is the caller graph for this function:

◆ config()

const DynamicPrintConfig * Slic3r::GUI::Plater::config ( ) const

7274{ return p->config; }

References p.

Here is the caller graph for this function:

◆ convert_unit()

void Slic3r::GUI::Plater::convert_unit ( ConversionType conv_type )

{
    std::vector<int> obj_idxs, volume_idxs;
    wxGetApp().obj_list()->get_selection_indexes(obj_idxs, volume_idxs);
    if (obj_idxs.empty() && volume_idxs.empty())
        return;
 
    // We will remove object indexes after convertion 
    // So, resort object indexes descending to avoid the crash after remove 
    std::sort(obj_idxs.begin(), obj_idxs.end(), std::greater<int>());
 
    TakeSnapshot snapshot(this, conv_type == ConversionType::CONV_FROM_INCH  ? _L("Convert from imperial units") :
                                conv_type == ConversionType::CONV_TO_INCH    ? _L("Revert conversion from imperial units") :
                                conv_type == ConversionType::CONV_FROM_METER ? _L("Convert from meters") : _L("Revert conversion from meters"));
    wxBusyCursor wait;
 
    ModelObjectPtrs objects;
    for (int obj_idx : obj_idxs) {
        ModelObject *object = p->model.objects[obj_idx];
        object->convert_units(objects, conv_type, volume_idxs);
        remove(obj_idx);
    }
    p->load_model_objects(objects);
    
    Selection& selection = p->view3D->get_canvas3d()->get_selection();
    size_t last_obj_idx = p->model.objects.size() - 1;
 
    if (volume_idxs.empty()) {
        for (size_t i = 0; i < objects.size(); ++i)
            selection.add_object((unsigned int)(last_obj_idx - i), i == 0);
    }
    else {
        for (int vol_idx : volume_idxs)
            selection.add_volume(last_obj_idx, vol_idx, 0, false);
    }
}

References _L, Slic3r::GUI::Selection::add_object(), Slic3r::GUI::Selection::add_volume(), Slic3r::CONV_FROM_INCH, Slic3r::CONV_FROM_METER, Slic3r::CONV_TO_INCH, p, and remove().

Here is the call graph for this function:

◆ copy_selection_to_clipboard()

void Slic3r::GUI::Plater::copy_selection_to_clipboard ( )

{
    // At first try to copy selected values to the ObjectList's clipboard
    // to check if Settings or Layers are selected in the list
    // and then copy to 3DCanvas's clipboard if not
    if (can_copy_to_clipboard() && !p->sidebar->obj_list()->copy_to_clipboard())
        p->view3D->get_canvas3d()->get_selection().copy_to_clipboard();
}

References can_copy_to_clipboard(), and p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cut() [1/2]

void Slic3r::GUI::Plater::cut	(	size_t	init_obj_idx,
		const ModelObjectPtrs &	cut_objects
	)

{
    model().delete_object(obj_idx);
    sidebar().obj_list()->delete_object_from_list(obj_idx);
 
    // suppress to call selection update for Object List to avoid call of early Gizmos on/off update
    p->load_model_objects(new_objects, false, false);
 
    // now process all updates of the 3d scene
    update();
    // Update InfoItems in ObjectList after update() to use of a correct value of the GLCanvas3D::is_sinking(),
    // which is updated after a view3D->reload_scene(false, flags & (unsigned int)UpdateParams::FORCE_FULL_SCREEN_REFRESH) call
    for (size_t idx = 0; idx < p->model.objects.size(); idx++)
        wxGetApp().obj_list()->update_info_items(idx);
 
    Selection& selection = p->get_selection();
    size_t last_id = p->model.objects.size() - 1;
    for (size_t i = 0; i < new_objects.size(); ++i)
        selection.add_object((unsigned int)(last_id - i), i == 0);
 
    UIThreadWorker w;
    replace_job(w, std::make_unique<ArrangeJob>(ArrangeJob::SelectionOnly));
    w.process_events();
}

References Slic3r::GUI::Selection::add_object(), Slic3r::Model::delete_object(), Slic3r::GUI::ObjectList::delete_object_from_list(), model(), Slic3r::GUI::Sidebar::obj_list(), p, Slic3r::GUI::UIThreadWorker::process_events(), Slic3r::GUI::replace_job(), Slic3r::GUI::ArrangeJob::SelectionOnly, sidebar(), and update().

Here is the call graph for this function:

◆ cut() [2/2]

void Slic3r::GUI::Plater::cut	(	size_t	obj_idx,
		size_t	instance_idx,
		const Transform3d &	cut_matrix,
		ModelObjectCutAttributes	attributes
	)

{
    wxCHECK_RET(obj_idx < p->model.objects.size(), "obj_idx out of bounds");
    auto* object = p->model.objects[obj_idx];
 
    wxCHECK_RET(instance_idx < object->instances.size(), "instance_idx out of bounds");
 
    wxBusyCursor wait;
 
    const auto new_objects = object->cut(instance_idx, cut_matrix, attributes);
    cut(obj_idx, new_objects);
}

References cut(), model(), Slic3r::Model::objects, and p.

Referenced by cut(), and Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrease_instances()

void Slic3r::GUI::Plater::decrease_instances	(	size_t	num = `1`,
		int	obj_idx = `-1`
	)

{
    if (! can_decrease_instances(obj_idx)) { return; }
 
    Plater::TakeSnapshot snapshot(this, _L("Decrease Instances"));
 
    if (obj_idx < 0)
        obj_idx = p->get_selected_object_idx();
 
    if (obj_idx < 0) {
        if (const auto obj_ids = get_selection().get_object_idxs(); !obj_ids.empty())
            for (const size_t obj_id : obj_ids)
                decrease_instances(1, int(obj_id));
        return;
    }
 
    ModelObject* model_object = p->model.objects[obj_idx];
    if (model_object->instances.size() > num) {
        for (size_t i = 0; i < num; ++ i)
            model_object->delete_last_instance();
        p->update();
        // Delete object from Sidebar list. Do it after update, so that the GLScene selection is updated with the modified model.
        sidebar().obj_list()->decrease_object_instances(obj_idx, num);
    }
    else {
        remove(obj_idx);
    }
 
    if (!model_object->instances.empty())
        p->get_selection().add_instance(obj_idx, (int)model_object->instances.size() - 1);
 
    p->selection_changed();
    this->p->schedule_background_process();
}

References _L, can_decrease_instances(), decrease_instances(), Slic3r::GUI::ObjectList::decrease_object_instances(), Slic3r::ModelObject::delete_last_instance(), get_selection(), Slic3r::ModelObject::instances, Slic3r::GUI::Sidebar::obj_list(), p, remove(), and sidebar().

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), decrease_instances(), and set_number_of_copies().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ default_menu()

wxMenu * Slic3r::GUI::Plater::default_menu ( )

7711{ return p->menus.default_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ delete_object_from_model()

bool Slic3r::GUI::Plater::delete_object_from_model ( size_t obj_idx )

6108{ return p->delete_object_from_model(obj_idx); }

References p.

◆ deselect_all()

void Slic3r::GUI::Plater::deselect_all ( )

6096{ p->deselect_all(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ eject_drive()

void Slic3r::GUI::Plater::eject_drive ( )

{
    wxBusyCursor wait;
  wxGetApp().removable_drive_manager()->eject_drive();
}

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ enable_collapse_toolbar()

void Slic3r::GUI::Plater::enable_collapse_toolbar ( bool enable )

{
    p->collapse_toolbar.set_enabled(enable);
}

References p.

◆ enable_preview_moves_slider()

void Slic3r::GUI::Plater::enable_preview_moves_slider ( bool enable )

{
    p->enable_preview_moves_slider(enable);
}

References p.

◆ enable_view_toolbar()

void Slic3r::GUI::Plater::enable_view_toolbar ( bool enable )

{
    p->view_toolbar.set_enabled(enable);
}

References p.

◆ enter_gizmos_stack()

void Slic3r::GUI::Plater::enter_gizmos_stack ( )

7659{ p->enter_gizmos_stack(); }

References p.

◆ export_3mf()

bool Slic3r::GUI::Plater::export_3mf ( const boost::filesystem::path & output_path = boost::filesystem::path() )

{
    if (p->model.objects.empty()) {
        MessageDialog dialog(nullptr, _L("The plater is empty.\nDo you want to save the project?"), _L("Save project"), wxYES_NO);
        if (dialog.ShowModal() != wxID_YES)
            return false;
    }
 
    wxString path;
    bool export_config = true;
    if (output_path.empty()) {
        path = p->get_export_file(FT_3MF);
        if (path.empty()) { return false; }
    }
    else
        path = from_path(output_path);
 
    if (!path.Lower().EndsWith(".3mf"))
        return false;
 
    DynamicPrintConfig cfg = wxGetApp().preset_bundle->full_config_secure();
    const std::string path_u8 = into_u8(path);
    wxBusyCursor wait;
    bool full_pathnames = wxGetApp().app_config->get_bool("export_sources_full_pathnames");
    ThumbnailData thumbnail_data;
    ThumbnailsParams thumbnail_params = { {}, false, true, true, true };
    p->generate_thumbnail(thumbnail_data, THUMBNAIL_SIZE_3MF.first, THUMBNAIL_SIZE_3MF.second, thumbnail_params, Camera::EType::Ortho);
    bool ret = false;
    try
    {
        ret = Slic3r::store_3mf(path_u8.c_str(), &p->model, export_config ? &cfg : nullptr, full_pathnames, &thumbnail_data);
    }
    catch (boost::filesystem::filesystem_error& e)
    {
        const wxString what = _("Unable to save file") + ": " + path_u8 + "\n" + e.code().message();
        MessageDialog dlg(this, what, _("Error saving 3mf file"), wxOK | wxICON_ERROR);
        dlg.ShowModal();
    }
    if (ret) {
        // Success
//        p->statusbar()->set_status_text(format_wxstr(_L("3MF file exported to %s"), path));
        BOOST_LOG_TRIVIAL(info) << "3MF file exported to " << path;
        p->set_project_filename(path);
    }
    else {
        // Failure
//        p->statusbar()->set_status_text(format_wxstr(_L("Error exporting 3MF file %s"), path));
        const wxString what = GUI::format_wxstr("%1%: %2%", _L("Unable to save file") , path_u8);
        show_error(this, what);
    }
    return ret;
}

References _, _L, Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_path(), Slic3r::GUI::FT_3MF, Slic3r::GUI::into_u8(), Slic3r::GUI::Camera::Ortho, p, Slic3r::GUI::show_error(), Slic3r::store_3mf(), and THUMBNAIL_SIZE_3MF.

Referenced by Slic3r::GUI::MainFrame::save_project_as().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_amf()

void Slic3r::GUI::Plater::export_amf ( )

{
    if (p->model.objects.empty()) { return; }
 
    wxString path = p->get_export_file(FT_AMF);
    if (path.empty()) { return; }
    const std::string path_u8 = into_u8(path);
 
    wxBusyCursor wait;
    bool export_config = true;
    DynamicPrintConfig cfg = wxGetApp().preset_bundle->full_config_secure();
    bool full_pathnames = wxGetApp().app_config->get_bool("export_sources_full_pathnames");
    if (Slic3r::store_amf(path_u8.c_str(), &p->model, export_config ? &cfg : nullptr, full_pathnames)) {
        // Success
//        p->statusbar()->set_status_text(format_wxstr(_L("AMF file exported to %s"), path));
    } else {
        // Failure
//        p->statusbar()->set_status_text(format_wxstr(_L("Error exporting AMF file %s"), path));
    }
}

References Slic3r::GUI::FT_AMF, Slic3r::GUI::into_u8(), p, and Slic3r::store_amf().

Here is the call graph for this function:

◆ export_gcode()

void Slic3r::GUI::Plater::export_gcode ( bool prefer_removable )

{
    if (p->model.objects.empty())
        return;
 
    if (canvas3D()->get_gizmos_manager().is_in_editing_mode(true))
        return;
 
 
    if (p->process_completed_with_error)
        return;
 
    // If possible, remove accents from accented latin characters.
    // This function is useful for generating file names to be processed by legacy firmwares.
    fs::path default_output_file;
    try {
        // Update the background processing, so that the placeholder parser will get the correct values for the ouput file template.
        // Also if there is something wrong with the current configuration, a pop-up dialog will be shown and the export will not be performed.
        unsigned int state = this->p->update_restart_background_process(false, false);
        if (state & priv::UPDATE_BACKGROUND_PROCESS_INVALID)
            return;
        default_output_file = this->p->background_process.output_filepath_for_project(into_path(get_project_filename(".3mf")));
    } catch (const Slic3r::PlaceholderParserError &ex) {
        // Show the error with monospaced font.
        show_error(this, ex.what(), true);
        return;
    } catch (const std::exception &ex) {
        show_error(this, ex.what(), false);
        return;
    }
    default_output_file = fs::path(Slic3r::fold_utf8_to_ascii(default_output_file.string()));
    AppConfig         &appconfig         = *wxGetApp().app_config;
    RemovableDriveManager   &removable_drive_manager = *wxGetApp().removable_drive_manager();
    // Get a last save path, either to removable media or to an internal media.
    std::string          start_dir         = appconfig.get_last_output_dir(default_output_file.parent_path().string(), prefer_removable);
  if (prefer_removable) {
    // Returns a path to a removable media if it exists, prefering start_dir. Update the internal removable drives database.
    start_dir = removable_drive_manager.get_removable_drive_path(start_dir);
    if (start_dir.empty())
      // Direct user to the last internal media.
      start_dir = appconfig.get_last_output_dir(default_output_file.parent_path().string(), false);
  }
 
    fs::path output_path;
    {
#if !ENABLE_ALTERNATIVE_FILE_WILDCARDS_GENERATOR
        std::string ext = default_output_file.extension().string();
#endif // !ENABLE_ALTERNATIVE_FILE_WILDCARDS_GENERATOR
        wxFileDialog dlg(this, (printer_technology() == ptFFF) ? _L("Save G-code file as:") : _L("Save SL1 / SL1S file as:"),
            start_dir,
            from_path(default_output_file.filename()),
#if ENABLE_ALTERNATIVE_FILE_WILDCARDS_GENERATOR
            printer_technology() == ptFFF ?  GUI::file_wildcards(FT_GCODE) :
                                             GUI::sla_wildcards(p->sla_print.printer_config().sla_archive_format.value.c_str()),
#else
            printer_technology() == ptFFF ? GUI::file_wildcards(FT_GCODE, ext) :
                                            GUI::sla_wildcards(p->sla_print.printer_config().sla_archive_format.value.c_str()),
#endif // ENABLE_ALTERNATIVE_FILE_WILDCARDS_GENERATOR
            wxFD_SAVE | wxFD_OVERWRITE_PROMPT
        );
        if (dlg.ShowModal() == wxID_OK) {
            output_path = into_path(dlg.GetPath());
            while (has_illegal_filename_characters(output_path.filename().string())) {
                show_error(this, _L("The provided file name is not valid.") + "\n" +
                    _L("The following characters are not allowed by a FAT file system:") + " <>:/\\|?*\"");
                dlg.SetFilename(from_path(output_path.filename()));
                if (dlg.ShowModal() == wxID_OK)
                    output_path = into_path(dlg.GetPath());
                else {
                    output_path.clear();
                    break;
                }
            }
        }
    }
 
    if (! output_path.empty()) {
    bool path_on_removable_media = removable_drive_manager.set_and_verify_last_save_path(output_path.string());
        p->notification_manager->new_export_began(path_on_removable_media);
        p->exporting_status = path_on_removable_media ? ExportingStatus::EXPORTING_TO_REMOVABLE : ExportingStatus::EXPORTING_TO_LOCAL;
        p->last_output_path = output_path.string();
        p->last_output_dir_path = output_path.parent_path().string();
        p->export_gcode(output_path, path_on_removable_media, PrintHostJob());
        // Storing a path to AppConfig either as path to removable media or a path to internal media.
        // is_path_on_removable_drive() is called with the "true" parameter to update its internal database as the user may have shuffled the external drives
        // while the dialog was open.
        appconfig.update_last_output_dir(output_path.parent_path().string(), path_on_removable_media);
    
  }
}

References _L, canvas3D(), Slic3r::GUI::EXPORTING_TO_LOCAL, Slic3r::GUI::EXPORTING_TO_REMOVABLE, Slic3r::GUI::file_wildcards(), Slic3r::fold_utf8_to_ascii(), Slic3r::GUI::from_path(), Slic3r::GUI::FT_GCODE, Slic3r::AppConfig::get_last_output_dir(), get_project_filename(), Slic3r::GUI::RemovableDriveManager::get_removable_drive_path(), has_illegal_filename_characters(), Slic3r::GUI::into_path(), p, printer_technology(), Slic3r::ptFFF, Slic3r::GUI::RemovableDriveManager::set_and_verify_last_save_path(), Slic3r::GUI::show_error(), Slic3r::GUI::sla_wildcards(), Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, and Slic3r::AppConfig::update_last_output_dir().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_stl_obj()

void Slic3r::GUI::Plater::export_stl_obj	(	bool	extended = `false`,
		bool	selection_only = `false`
	)

{
    if (p->model.objects.empty()) { return; }
 
    wxString path = p->get_export_file(FT_OBJECT);
    if (path.empty()) { return; }
    const std::string path_u8 = into_u8(path);
 
    wxBusyCursor wait;
 
    const auto &selection = p->get_selection();
    const auto obj_idx = selection.get_object_idx();
    if (selection_only && (obj_idx == -1 || selection.is_wipe_tower()))
        return;
 
    // Following lambda generates a combined mesh for export with normals pointing outwards.
    auto mesh_to_export_fff = [this](const ModelObject& mo, int instance_id) {
        TriangleMesh mesh;
 
        std::vector<csg::CSGPart> csgmesh;
        csgmesh.reserve(2 * mo.volumes.size());
        csg::model_to_csgmesh(mo, Transform3d::Identity(), std::back_inserter(csgmesh),
                              csg::mpartsPositive | csg::mpartsNegative | csg::mpartsDoSplits);
 
        if (csg::check_csgmesh_booleans(range(csgmesh)) == csgmesh.end()) {
            try {
                auto cgalm = csg::perform_csgmesh_booleans(range(csgmesh));
                mesh = MeshBoolean::cgal::cgal_to_triangle_mesh(*cgalm);
            } catch (...) {}
        }
 
        if (mesh.empty()) {
            get_notification_manager()->push_plater_error_notification(
                _u8L("Unable to perform boolean operation on model meshes. "
                     "Only positive parts will be exported."));
 
            for (const ModelVolume* v : mo.volumes)
                if (v->is_model_part()) {
                    TriangleMesh vol_mesh(v->mesh());
                    vol_mesh.transform(v->get_matrix(), true);
                    mesh.merge(vol_mesh);
                }
        }
 
        if (instance_id == -1) {
            TriangleMesh vols_mesh(mesh);
            mesh = TriangleMesh();
            for (const ModelInstance* i : mo.instances) {
                TriangleMesh m = vols_mesh;
                m.transform(i->get_matrix(), true);
                mesh.merge(m);
            }
        }
        else if (0 <= instance_id && instance_id < int(mo.instances.size()))
            mesh.transform(mo.instances[instance_id]->get_matrix(), true);
        return mesh;
    };
 
    auto mesh_to_export_sla = [&, this](const ModelObject& mo, int instance_id) {
        TriangleMesh mesh;
 
        const SLAPrintObject *object = this->p->sla_print.get_print_object_by_model_object_id(mo.id());
 
        if (!object || !object->get_mesh_to_print() || object->get_mesh_to_print()->empty())
            mesh = mesh_to_export_fff(mo, instance_id);
        else {
            const Transform3d mesh_trafo_inv = object->trafo().inverse();
            const bool is_left_handed = object->is_left_handed();
 
            auto pad_mesh = extended? object->pad_mesh() : TriangleMesh{};
            pad_mesh.transform(mesh_trafo_inv);
 
            auto supports_mesh = extended ? object->support_mesh() : TriangleMesh{};
            supports_mesh.transform(mesh_trafo_inv);
 
            const std::vector<SLAPrintObject::Instance>& obj_instances = object->instances();
            for (const SLAPrintObject::Instance& obj_instance : obj_instances) {
                auto it = std::find_if(object->model_object()->instances.begin(), object->model_object()->instances.end(),
                                       [&obj_instance](const ModelInstance *mi) { return mi->id() == obj_instance.instance_id; });
                assert(it != object->model_object()->instances.end());
 
                if (it != object->model_object()->instances.end()) {
                    const bool one_inst_only = selection_only && ! selection.is_single_full_object();
 
                    const int instance_idx = it - object->model_object()->instances.begin();
                    const Transform3d& inst_transform = one_inst_only
                                                            ? Transform3d::Identity()
                                                            : object->model_object()->instances[instance_idx]->get_transformation().get_matrix();
 
                    TriangleMesh inst_mesh;
 
                    if (!pad_mesh.empty()) {
                        TriangleMesh inst_pad_mesh = pad_mesh;
                        inst_pad_mesh.transform(inst_transform, is_left_handed);
                        inst_mesh.merge(inst_pad_mesh);
                    }
 
                    if (!supports_mesh.empty()) {
                        TriangleMesh inst_supports_mesh = supports_mesh;
                        inst_supports_mesh.transform(inst_transform, is_left_handed);
                        inst_mesh.merge(inst_supports_mesh);
                    }
 
                    std::shared_ptr<const indexed_triangle_set> m = object->get_mesh_to_print();
                    TriangleMesh inst_object_mesh;
                    if (m)
                        inst_object_mesh = TriangleMesh{*m};
 
                    inst_object_mesh.transform(mesh_trafo_inv);
                    inst_object_mesh.transform(inst_transform, is_left_handed);
 
                    inst_mesh.merge(inst_object_mesh);
 
                           // ensure that the instance lays on the bed
                    inst_mesh.translate(0.0f, 0.0f, -inst_mesh.bounding_box().min.z());
 
                           // merge instance with global mesh
                    mesh.merge(inst_mesh);
 
                    if (one_inst_only)
                        break;
                }
            }
        }
 
        return mesh;
    };
 
    std::function<TriangleMesh(const ModelObject& mo, int instance_id)>
        mesh_to_export;
 
    if (p->printer_technology == ptFFF )
        mesh_to_export = mesh_to_export_fff;
    else
        mesh_to_export = mesh_to_export_sla;
 
    TriangleMesh mesh;
    if (selection_only) {
        const ModelObject* model_object = p->model.objects[obj_idx];
        if (selection.get_mode() == Selection::Instance)
            mesh = mesh_to_export(*model_object, (selection.is_single_full_object() && model_object->instances.size() > 1) ? -1 : selection.get_instance_idx());
        else {
            const GLVolume* volume = selection.get_first_volume();
            mesh = model_object->volumes[volume->volume_idx()]->mesh();
            mesh.transform(volume->get_volume_transformation().get_matrix(), true);
        }
 
        if (!selection.is_single_full_object() || model_object->instances.size() == 1)
            mesh.translate(-model_object->origin_translation.cast<float>());
    }
    else {
        for (const ModelObject* o : p->model.objects) {
            mesh.merge(mesh_to_export(*o, -1));
        }
    }
 
    if (path.Lower().EndsWith(".stl"))
        Slic3r::store_stl(path_u8.c_str(), &mesh, true);
    else if (path.Lower().EndsWith(".obj"))
        Slic3r::store_obj(path_u8.c_str(), &mesh);
//    p->statusbar()->set_status_text(format_wxstr(_L("STL file exported to %s"), path));
}

References _u8L, Slic3r::TriangleMesh::bounding_box(), Slic3r::MeshBoolean::cgal::cgal_to_triangle_mesh(), Slic3r::csg::check_csgmesh_booleans(), Slic3r::TriangleMesh::empty(), Slic3r::GUI::FT_OBJECT, Slic3r::SLAPrintObject::get_mesh_to_print(), get_notification_manager(), Slic3r::ObjectBase::id(), Eigen::Transform< double, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), Slic3r::GUI::Selection::Instance, Slic3r::ModelObject::instances, Slic3r::GUI::into_u8(), Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::inverse(), Slic3r::GUI::is_left_handed(), Slic3r::TriangleMesh::merge(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::PrintObjectBase::model_object(), Slic3r::csg::model_to_csgmesh(), Slic3r::csg::mpartsDoSplits, Slic3r::csg::mpartsNegative, Slic3r::csg::mpartsPositive, Slic3r::ModelObject::origin_translation, p, Slic3r::csg::perform_csgmesh_booleans(), Slic3r::ptFFF, Slic3r::GUI::NotificationManager::push_plater_error_notification(), Slic3r::range(), Slic3r::store_obj(), Slic3r::store_stl(), Slic3r::TriangleMesh::transform(), Slic3r::TriangleMesh::translate(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_export_stl(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ export_toolpaths_to_obj()

void Slic3r::GUI::Plater::export_toolpaths_to_obj ( ) const

{
    if ((printer_technology() != ptFFF) || !is_preview_loaded())
        return;
 
    wxString path = p->get_export_file(FT_OBJ);
    if (path.empty()) 
        return;
    
    wxBusyCursor wait;
    p->preview->get_canvas3d()->export_toolpaths_to_obj(into_u8(path).c_str());
}

References Slic3r::GUI::FT_OBJ, Slic3r::GUI::into_u8(), is_preview_loaded(), p, printer_technology(), and Slic3r::ptFFF.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extract_config_from_project()

void Slic3r::GUI::Plater::extract_config_from_project ( )

{
    wxString input_file;
    wxGetApp().load_project(this, input_file);
 
    if (! input_file.empty())
        load_files({ into_path(input_file) }, false, true);
}

References Slic3r::GUI::into_path(), and load_files().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fff_print() [1/2]

Print & Slic3r::GUI::Plater::fff_print ( )

5225{ return p->fff_print; }

References p.

◆ fff_print() [2/2]

const Print & Slic3r::GUI::Plater::fff_print ( ) const

5224{ return p->fff_print; }

References p.

Referenced by Slic3r::GUI::PlaterAfterLoadAutoArrange::PlaterAfterLoadAutoArrange(), Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::get_skirt_offset(), and Slic3r::GUI::Plater::priv::on_slicing_update().

Here is the caller graph for this function:

◆ fill_bed_with_instances()

void Slic3r::GUI::Plater::fill_bed_with_instances ( )

{
    auto &w = get_ui_job_worker();
    if (w.is_idle()) {
        p->take_snapshot(_L("Fill bed"));
        replace_job(w, std::make_unique<FillBedJob>());
    }
}

References _L, get_ui_job_worker(), p, and Slic3r::GUI::replace_job().

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_filament_cb_update()

void Slic3r::GUI::Plater::force_filament_cb_update ( )

{
    // Update visibility for templates presets according to app_config
    PresetCollection& filaments = wxGetApp().preset_bundle->filaments;
    AppConfig& config = *wxGetApp().app_config;
    for (Preset& preset : filaments)
        preset.set_visible_from_appconfig(config);
    wxGetApp().preset_bundle->update_compatible(PresetSelectCompatibleType::Never, PresetSelectCompatibleType::OnlyIfWasCompatible);
 
    // Update preset comboboxes on sidebar and filaments tab
    p->sidebar->update_presets(Preset::TYPE_FILAMENT);
    wxGetApp().get_tab(Preset::TYPE_FILAMENT)->select_preset(wxGetApp().preset_bundle->filaments.get_selected_preset_name());
}

References config(), Slic3r::Never, Slic3r::OnlyIfWasCompatible, p, and Slic3r::Preset::TYPE_FILAMENT.

Here is the call graph for this function:

◆ force_filament_colors_update()

void Slic3r::GUI::Plater::force_filament_colors_update ( )

{
    bool update_scheduled = false;
    DynamicPrintConfig* config = p->config;
 
    const auto& extruders_filaments = wxGetApp().preset_bundle->extruders_filaments;
    if (extruders_filaments.size() > 1 && 
        p->config->option<ConfigOptionStrings>("filament_colour")->values.size() == extruders_filaments.size())
    {
        std::vector<std::string> filament_colors;
        filament_colors.reserve(extruders_filaments.size());
 
        for (const auto& extr_filaments : extruders_filaments)
            filament_colors.push_back(extr_filaments.get_selected_preset()->config.opt_string("filament_colour", (unsigned)0));
 
        if (config->option<ConfigOptionStrings>("filament_colour")->values != filament_colors) {
            config->option<ConfigOptionStrings>("filament_colour")->values = filament_colors;
            update_scheduled = true;
        }
    }
 
    if (update_scheduled) {
        update();
        p->sidebar->obj_list()->update_extruder_colors();
    }
 
    if (p->main_frame->is_loaded())
        this->p->schedule_background_process();
}

References config(), Slic3r::ConfigBase::option(), p, update(), and Slic3r::ConfigOptionVector< T >::values.

Here is the call graph for this function:

◆ force_print_bed_update()

void Slic3r::GUI::Plater::force_print_bed_update ( )

{
  // Fill in the printer model key with something which cannot possibly be valid, so that Plater::on_config_change() will update the print bed
  // once a new Printer profile config is loaded.
  p->config->opt_string("printer_model", true) = "\x01\x00\x01";
}

References p.

Referenced by Slic3r::GUI::GUI_App::load_current_presets().

Here is the caller graph for this function:

◆ get_camera() [1/2]

Camera & Slic3r::GUI::Plater::get_camera ( )

{
    return p->camera;
}

References p.

◆ get_camera() [2/2]

const Camera & Slic3r::GUI::Plater::get_camera ( ) const

{
    return p->camera;
}

References p.

Referenced by Slic3r::GUI::Mouse3DController::disconnect_device(), priv::start_create_object_job(), and priv::start_create_volume_on_surface_job().

Here is the caller graph for this function:

◆ get_collapse_toolbar() [1/2]

GLToolbar & Slic3r::GUI::Plater::get_collapse_toolbar ( )

{
    return p->collapse_toolbar;
}

References p.

◆ get_collapse_toolbar() [2/2]

const GLToolbar & Slic3r::GUI::Plater::get_collapse_toolbar ( ) const

{
    return p->collapse_toolbar;
}

References p.

Referenced by Slic3r::GUI::MainFrame::MainFrame(), and Slic3r::GUI::MainFrame::update_layout().

Here is the caller graph for this function:

◆ get_colors_for_color_print()

std::vector< std::string > Slic3r::GUI::Plater::get_colors_for_color_print ( const GCodeProcessorResult *const result = nullptr ) const

{
    std::vector<std::string> colors = get_extruder_colors_from_plater_config(result);
    colors.reserve(colors.size() + p->model.custom_gcode_per_print_z.gcodes.size());
 
    if (wxGetApp().is_gcode_viewer() && result != nullptr) {
        for (const CustomGCode::Item& code : result->custom_gcode_per_print_z) {
            if (code.type == CustomGCode::ColorChange)
                colors.emplace_back(code.color);
        }
    }
    else {
        for (const CustomGCode::Item& code : p->model.custom_gcode_per_print_z.gcodes) {
            if (code.type == CustomGCode::ColorChange)
                colors.emplace_back(code.color);
        }
    }
 
    return colors;
}

References Slic3r::CustomGCode::ColorChange, Slic3r::GCodeProcessorResult::custom_gcode_per_print_z, get_extruder_colors_from_plater_config(), and p.

Here is the call graph for this function:

◆ get_current_canvas3D()

GLCanvas3D * Slic3r::GUI::Plater::get_current_canvas3D ( )

{
    return p->get_current_canvas3D();
}

References p.

Referenced by Slic3r::GUI::Plater::priv::reload_from_disk(), and Slic3r::GUI::MainFrame::select_tab().

Here is the caller graph for this function:

◆ get_extruder_colors_from_plater_config()

std::vector< std::string > Slic3r::GUI::Plater::get_extruder_colors_from_plater_config ( const GCodeProcessorResult *const result = nullptr ) const

{
    if (wxGetApp().is_gcode_viewer() && result != nullptr)
        return result->extruder_colors;
    else {
        const Slic3r::DynamicPrintConfig* config = &wxGetApp().preset_bundle->printers.get_edited_preset().config;
        std::vector<std::string> extruder_colors;
        if (!config->has("extruder_colour")) // in case of a SLA print
            return extruder_colors;
 
        extruder_colors = (config->option<ConfigOptionStrings>("extruder_colour"))->values;
        if (!wxGetApp().plater())
            return extruder_colors;
 
        const std::vector<std::string>& filament_colours = (p->config->option<ConfigOptionStrings>("filament_colour"))->values;
        for (size_t i = 0; i < extruder_colors.size(); ++i)
            if (extruder_colors[i] == "" && i < filament_colours.size())
                extruder_colors[i] = filament_colours[i];
 
        return extruder_colors;
    }
}

References config(), Slic3r::GCodeProcessorResult::extruder_colors, Slic3r::ConfigOptionResolver::has(), Slic3r::ConfigBase::option(), and p.

Referenced by get_colors_for_color_print(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_last_loaded_gcode()

const wxString & Slic3r::GUI::Plater::get_last_loaded_gcode ( ) const

inline

186{ return m_last_loaded_gcode; }

Slic3r::GUI::Plater::m_last_loaded_gcode

wxString m_last_loaded_gcode

Definition Plater.hpp:502

References m_last_loaded_gcode.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the caller graph for this function:

◆ get_mouse3d_controller() [1/2]

Mouse3DController & Slic3r::GUI::Plater::get_mouse3d_controller ( )

{
    return p->mouse3d_controller;
}

References p.

◆ get_mouse3d_controller() [2/2]

const Mouse3DController & Slic3r::GUI::Plater::get_mouse3d_controller ( ) const

{
    return p->mouse3d_controller;
}

References p.

Referenced by Slic3r::GUI::MainFrame::shutdown().

Here is the caller graph for this function:

◆ get_notification_manager() [1/2]

NotificationManager * Slic3r::GUI::Plater::get_notification_manager ( )

{
    return p->notification_manager.get();
}

References p.

Referenced by Slic3r::GUI::GUI_App::app_updater(), check_selected_presets_visibility(), clear_before_change_mesh(), export_stl_obj(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::ObjectList::fix_through_netfabb(), Slic3r::GUI::GUI_App::notification_manager(), Slic3r::GUI::GUI_App::on_init_inner(), Slic3r::GUI::GUI_App::on_version_read(), and Slic3r::GUI::GUI_App::post_init().

Here is the caller graph for this function:

◆ get_notification_manager() [2/2]

const NotificationManager * Slic3r::GUI::Plater::get_notification_manager ( ) const

{
    return p->notification_manager.get();
}

References p.

◆ get_project_filename()

wxString Slic3r::GUI::Plater::get_project_filename ( const wxString & extension = wxEmptyString ) const

{
    return p->get_project_filename(extension);
}

References p.

Referenced by Slic3r::GUI::MainFrame::can_start_new_project(), export_gcode(), Slic3r::GUI::Plater::priv::get_export_file_path(), Slic3r::GUI::MainFrame::save_project(), send_gcode(), Slic3r::GUI::ProjectDirtyStateManager::update_from_presets(), and Slic3r::GUI::MainFrame::update_title().

Here is the caller graph for this function:

◆ get_selected_object_idx()

int Slic3r::GUI::Plater::get_selected_object_idx ( )

{
    return p->get_selected_object_idx();
}

References p.

Referenced by Slic3r::GUI::Plater::priv::can_decrease_instances(), Slic3r::GUI::Plater::priv::can_set_instance_to_object(), Slic3r::GUI::Plater::priv::can_simplify(), Slic3r::GUI::Plater::priv::get_selected_instance_idx(), increase_instances(), Slic3r::GUI::Plater::priv::layers_height_allowed(), Slic3r::GUI::Plater::priv::on_right_click(), Slic3r::GUI::FillBedJob::prepare(), and Slic3r::GUI::Plater::priv::split_object().

Here is the caller graph for this function:

◆ get_selection()

const Selection & Slic3r::GUI::Plater::get_selection ( ) const

{
    return p->get_selection();
}

References p.

Here is the caller graph for this function:

◆ get_ui_job_worker() [1/2]

Worker & Slic3r::GUI::Plater::get_ui_job_worker ( )

6070{ return p->m_worker; }

References p.

Referenced by arrange(), fill_bed_with_instances(), import_sl1_archive(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), remove_selected(), reslice(), Slic3r::GUI::MainFrame::shutdown(), priv::start_create_object_job(), and priv::start_create_volume_job().

Here is the caller graph for this function:

◆ get_ui_job_worker() [2/2]

const Worker & Slic3r::GUI::Plater::get_ui_job_worker ( ) const

6072{ return p->m_worker; }

References p.

◆ get_view_toolbar() [1/2]

GLToolbar & Slic3r::GUI::Plater::get_view_toolbar ( )

{
    return p->view_toolbar;
}

References p.

◆ get_view_toolbar() [2/2]

const GLToolbar & Slic3r::GUI::Plater::get_view_toolbar ( ) const

{
    return p->view_toolbar;
}

References p.

◆ has_illegal_filename_characters() [1/2]

bool Slic3r::GUI::Plater::has_illegal_filename_characters ( const std::string & name )

static

{
    const char* illegal_characters = "<>:/\\|?*\"";
    for (size_t i = 0; i < std::strlen(illegal_characters); i++)
        if (name.find_first_of(illegal_characters[i]) != std::string::npos)
            return true;
 
    return false;
}

◆ has_illegal_filename_characters() [2/2]

bool Slic3r::GUI::Plater::has_illegal_filename_characters ( const wxString & name )

static

{
    std::string name = into_u8(wxs_name);
    return has_illegal_filename_characters(name);
}

References has_illegal_filename_characters(), and Slic3r::GUI::into_u8().

Referenced by export_gcode(), BitmapTextRenderer::GetValueFromEditorCtrl(), has_illegal_filename_characters(), and Slic3r::GUI::ObjectList::rename_item().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_toolpaths_to_export()

bool Slic3r::GUI::Plater::has_toolpaths_to_export ( ) const

{
    return  p->preview->get_canvas3d()->has_toolpaths_to_export();
}

References p.

Referenced by Slic3r::GUI::MainFrame::can_export_toolpaths().

Here is the caller graph for this function:

◆ import_sl1_archive()

void Slic3r::GUI::Plater::import_sl1_archive ( )

{
    auto &w = get_ui_job_worker();
    if (w.is_idle() && p->m_sla_import_dlg->ShowModal() == wxID_OK) {
        p->take_snapshot(_L("Import SLA archive"));
        replace_job(w, std::make_unique<SLAImportJob>(p->m_sla_import_dlg));
    }
}

References _L, get_ui_job_worker(), p, and Slic3r::GUI::replace_job().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ import_zip_archive()

void Slic3r::GUI::Plater::import_zip_archive ( )

{
   wxString input_file;
   wxGetApp().import_zip(this, input_file);
   if (input_file.empty())
       return;
 
   wxArrayString arr;
   arr.Add(input_file);
   load_files(arr, false);
}

References load_files().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ increase_instances()

void Slic3r::GUI::Plater::increase_instances	(	size_t	num = `1`,
		int	obj_idx = `-1`,
		int	inst_idx = `-1`
	)

{
    if (! can_increase_instances()) { return; }
 
    Plater::TakeSnapshot snapshot(this, _L("Increase Instances"));
 
    if (obj_idx < 0) {
        obj_idx = p->get_selected_object_idx();
        if (obj_idx < 0) {
            // It's a case of increasing per 1 instance, when multiple objects are selected
            if (const auto obj_idxs = get_selection().get_object_idxs(); !obj_idxs.empty()) {
                // we need a copy made here because the selection changes at every call of increase_instances()
                const Selection::ObjectIdxsToInstanceIdxsMap content = p->get_selection().get_content();
                for (const unsigned int obj_id : obj_idxs) {
                    if (auto obj_it = content.find(int(obj_id)); obj_it != content.end())
                        increase_instances(1, int(obj_id), *obj_it->second.rbegin());
                }
            }
            return;
        }
    }
    assert(obj_idx >= 0);
 
    ModelObject* model_object = p->model.objects[obj_idx];
 
    if (inst_idx < 0 && get_selected_object_idx() >= 0) {
        inst_idx = get_selection().get_instance_idx();
        if (0 > inst_idx || inst_idx >= int(model_object->instances.size()))
            inst_idx = -1;
    }
    ModelInstance* model_instance = (inst_idx >= 0) ? model_object->instances[inst_idx] : model_object->instances.back();
 
    bool was_one_instance = model_object->instances.size()==1;
 
    double offset_base = canvas3D()->get_size_proportional_to_max_bed_size(0.05);
    double offset = offset_base;
    for (size_t i = 0; i < num; i++, offset += offset_base) {
        Vec3d offset_vec = model_instance->get_offset() + Vec3d(offset, offset, 0.0);
        Geometry::Transformation trafo = model_instance->get_transformation();
        trafo.set_offset(offset_vec);
        model_object->add_instance(trafo);
    }
 
    if (p->get_config_bool("autocenter"))
        arrange();
 
    p->update();
 
    p->get_selection().add_instance(obj_idx, (int)model_object->instances.size() - 1);
 
    sidebar().obj_list()->increase_object_instances(obj_idx, was_one_instance ? num + 1 : num);
 
    p->selection_changed();
    this->p->schedule_background_process();
}

References _L, Slic3r::ModelObject::add_instance(), arrange(), can_increase_instances(), canvas3D(), Slic3r::GUI::Selection::get_instance_idx(), Slic3r::ModelInstance::get_offset(), get_selected_object_idx(), get_selection(), Slic3r::GUI::GLCanvas3D::get_size_proportional_to_max_bed_size(), Slic3r::ModelInstance::get_transformation(), increase_instances(), Slic3r::GUI::ObjectList::increase_object_instances(), Slic3r::ModelObject::instances, Slic3r::GUI::Sidebar::obj_list(), Slic3r::offset(), p, Slic3r::Geometry::Transformation::set_offset(), and sidebar().

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), increase_instances(), and set_number_of_copies().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_collapse_toolbar()

bool Slic3r::GUI::Plater::init_collapse_toolbar ( )

{
    return p->init_collapse_toolbar();
}

References p.

◆ init_notification_manager()

void Slic3r::GUI::Plater::init_notification_manager ( )

{
    p->init_notification_manager();
}

References p.

◆ init_view_toolbar()

bool Slic3r::GUI::Plater::init_view_toolbar ( )

{
    return p->init_view_toolbar();
}

References p.

◆ inside_snapshot_capture()

bool Slic3r::GUI::Plater::inside_snapshot_capture ( )

7661{ return p->inside_snapshot_capture(); }

References p.

◆ instance_menu()

wxMenu * Slic3r::GUI::Plater::instance_menu ( )

7712{ return p->menus.instance_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ is_background_process_update_scheduled()

bool Slic3r::GUI::Plater::is_background_process_update_scheduled ( ) const

{
    return this->p->background_process_timer.IsRunning();
}

References p.

◆ is_export_gcode_scheduled()

bool Slic3r::GUI::Plater::is_export_gcode_scheduled ( ) const

{
    return p->background_process.is_export_scheduled();
}

References p.

Referenced by Slic3r::GUI::MainFrame::can_export_gcode(), and Slic3r::GUI::MainFrame::can_export_gcode_sd().

Here is the caller graph for this function:

◆ is_legend_shown()

bool Slic3r::GUI::Plater::is_legend_shown ( ) const

6087{ return p->is_legend_shown(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the caller graph for this function:

◆ is_presets_dirty()

bool Slic3r::GUI::Plater::is_presets_dirty ( ) const

5212{ return p->is_presets_dirty(); }

References p.

◆ is_preview_loaded()

bool Slic3r::GUI::Plater::is_preview_loaded ( ) const

6081{ return p->is_preview_loaded(); }

References p.

Referenced by Slic3r::GUI::MainFrame::can_export_toolpaths(), and export_toolpaths_to_obj().

Here is the caller graph for this function:

◆ is_preview_shown()

bool Slic3r::GUI::Plater::is_preview_shown ( ) const

6080{ return p->is_preview_shown(); }

References p.

Referenced by Slic3r::GUI::MainFrame::can_export_toolpaths(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer(), and search().

Here is the caller graph for this function:

◆ is_project_dirty()

bool Slic3r::GUI::Plater::is_project_dirty ( ) const

5211{ return p->is_project_dirty(); }

References p.

Referenced by Slic3r::GUI::MainFrame::can_save(), and Slic3r::GUI::MainFrame::update_title().

Here is the caller graph for this function:

◆ is_project_temp()

bool Slic3r::GUI::Plater::is_project_temp ( ) const

{
    return false;
}

◆ is_render_statistic_dialog_visible()

bool Slic3r::GUI::Plater::is_render_statistic_dialog_visible ( ) const

{
    return p->show_render_statistic_dialog;
}

References p.

◆ is_selection_empty()

bool Slic3r::GUI::Plater::is_selection_empty ( ) const

{
    return p->get_selection().is_empty() || p->get_selection().is_wipe_tower();
}

References p.

Referenced by can_copy_to_clipboard(), Slic3r::GUI::MainFrame::can_delete(), and Slic3r::GUI::MainFrame::can_deselect().

Here is the caller graph for this function:

◆ is_sidebar_collapsed()

bool Slic3r::GUI::Plater::is_sidebar_collapsed ( ) const

6090{ return p->is_sidebar_collapsed(); }

References p.

Referenced by Slic3r::GUI::Plater::priv::init_collapse_toolbar(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ is_single_full_object_selection()

bool Slic3r::GUI::Plater::is_single_full_object_selection ( ) const

{
    return p->get_selection().is_single_full_object();
}

References p.

◆ is_view3D_layers_editing_enabled()

bool Slic3r::GUI::Plater::is_view3D_layers_editing_enabled ( ) const

6093{ return p->is_view3D_layers_editing_enabled(); }

References p.

◆ is_view3D_shown()

bool Slic3r::GUI::Plater::is_view3D_shown ( ) const

6082{ return p->is_view3D_shown(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ layer_menu()

wxMenu * Slic3r::GUI::Plater::layer_menu ( )

7713{ return p->menus.layer_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ leave_gizmos_stack()

void Slic3r::GUI::Plater::leave_gizmos_stack ( )

7660{ p->leave_gizmos_stack(); }

References p.

◆ load_files() [1/3]

std::vector< size_t > Slic3r::GUI::Plater::load_files	(	const std::vector< boost::filesystem::path > &	input_files,
		bool	load_model = `true`,
		bool	load_config = `true`,
		bool	imperial_units = `false`
	)

Referenced by add_model(), extract_config_from_project(), import_zip_archive(), load_files(), load_project(), Slic3r::GUI::GUI_App::post_init(), and preview_zip_archive().

Here is the caller graph for this function:

◆ load_files() [2/3]

std::vector< size_t > Slic3r::GUI::Plater::load_files	(	const std::vector< std::string > &	input_files,
		bool	load_model = `true`,
		bool	load_config = `true`,
		bool	imperial_units = `false`
	)

{
    std::vector<fs::path> paths;
    paths.reserve(input_files.size());
    for (const std::string& path : input_files)
        paths.emplace_back(path);
    return p->load_files(paths, load_model, load_config, imperial_units);
}

References p.

◆ load_files() [3/3]

bool Slic3r::GUI::Plater::load_files	(	const wxArrayString &	filenames,
		bool	delete_after_load = `false`
	)

{
    const std::regex pattern_drop(".*[.](stl|obj|amf|3mf|prusa|step|stp|zip)", std::regex::icase);
    const std::regex pattern_gcode_drop(".*[.](gcode|g)", std::regex::icase);
 
    std::vector<fs::path> paths;
 
    // gcode viewer section
    if (wxGetApp().is_gcode_viewer()) {
        for (const auto& filename : filenames) {
            fs::path path(into_path(filename));
            if (std::regex_match(path.string(), pattern_gcode_drop))
                paths.push_back(std::move(path));
        }
 
        if (paths.size() > 1) {
            //wxMessageDialog(static_cast<wxWindow*>(this), _L("You can open only one .gcode file at a time."),
            MessageDialog(static_cast<wxWindow*>(this), _L("You can open only one .gcode file at a time."),
                wxString(SLIC3R_APP_NAME) + " - " + _L("Drag and drop G-code file"), wxCLOSE | wxICON_WARNING | wxCENTRE).ShowModal();
            return false;
        }
        else if (paths.size() == 1) {
            load_gcode(from_path(paths.front()));
            return true;
        }
        return false;
    }
 
    // editor section
    for (const auto& filename : filenames) {
        fs::path path(into_path(filename));
        if (std::regex_match(path.string(), pattern_drop))
            paths.push_back(std::move(path));
        else if (std::regex_match(path.string(), pattern_gcode_drop))
            start_new_gcodeviewer(&filename);
        else
            continue;
    }
    if (paths.empty())
        // Likely all paths processed were gcodes, for which a G-code viewer instance has hopefully been started.
        return false;
 
    // searches for project files
    for (std::vector<fs::path>::const_reverse_iterator it = paths.rbegin(); it != paths.rend(); ++it) {
        std::string filename = (*it).filename().string();
 
        bool handle_as_project = (boost::algorithm::iends_with(filename, ".3mf") || boost::algorithm::iends_with(filename, ".amf"));
        if (boost::algorithm::iends_with(filename, ".zip") && is_project_3mf(it->string())) {
            BOOST_LOG_TRIVIAL(warning) << "File with .zip extension is 3mf project, opening as it would have .3mf extension: " << *it;
            handle_as_project = true;
        }
        if (handle_as_project) {
            ProjectDropDialog::LoadType load_type = ProjectDropDialog::LoadType::Unknown;
            {
                if ((boost::algorithm::iends_with(filename, ".3mf") && !is_project_3mf(it->string())) ||
                    (boost::algorithm::iends_with(filename, ".amf") && !boost::algorithm::iends_with(filename, ".zip.amf")))
                    load_type = ProjectDropDialog::LoadType::LoadGeometry;
                else {
                    if (wxGetApp().app_config->get_bool("show_drop_project_dialog")) {
                        ProjectDropDialog dlg(filename);
                        if (dlg.ShowModal() == wxID_OK) {
                            int choice = dlg.get_action();
                            load_type = static_cast<ProjectDropDialog::LoadType>(choice);
                            wxGetApp().app_config->set("drop_project_action", std::to_string(choice));
                        }
                    }
                    else
                        load_type = static_cast<ProjectDropDialog::LoadType>(std::clamp(std::stoi(wxGetApp().app_config->get("drop_project_action")),
                            static_cast<int>(ProjectDropDialog::LoadType::OpenProject), static_cast<int>(ProjectDropDialog::LoadType::LoadConfig)));
                }
            }
 
            if (load_type == ProjectDropDialog::LoadType::Unknown)
                return false;
 
            switch (load_type) {
            case ProjectDropDialog::LoadType::OpenProject: {
                if (wxGetApp().can_load_project())
                    load_project(from_path(*it));
                break;
            }
            case ProjectDropDialog::LoadType::LoadGeometry: {
//                Plater::TakeSnapshot snapshot(this, _L("Import Object"));
                load_files({ *it }, true, false);
                break;
            }
            case ProjectDropDialog::LoadType::LoadConfig: {
                load_files({ *it }, false, true);
                break;
            }
            case ProjectDropDialog::LoadType::OpenWindow: {
                wxString f = from_path(*it);
                start_new_slicer(&f, false, delete_after_load);
                return false; // did not load anything to this instance
            }
            case ProjectDropDialog::LoadType::Unknown : {
                assert(false);
                break;
            }
            }
 
            return true;
        } else if (boost::algorithm::iends_with(filename, ".zip")) {
            return preview_zip_archive(*it);
            
        }
    }
 
    // other files
    wxString snapshot_label;
    assert(!paths.empty());
    if (paths.size() == 1) {
        snapshot_label = _L("Load File");
        snapshot_label += ": ";
        snapshot_label += wxString::FromUTF8(paths.front().filename().string().c_str());
    }
    else {
        snapshot_label = _L("Load Files");
        snapshot_label += ": ";
        snapshot_label += wxString::FromUTF8(paths.front().filename().string().c_str());
        for (size_t i = 1; i < paths.size(); ++i) {
            snapshot_label += ", ";
            snapshot_label += wxString::FromUTF8(paths[i].filename().string().c_str());
        }
    }
    Plater::TakeSnapshot snapshot(this, snapshot_label);
    load_files(paths);
 
    return true;
}

References _L, Slic3r::f(), Slic3r::GUI::from_path(), Slic3r::GUI::ProjectDropDialog::get_action(), Slic3r::GUI::into_path(), Slic3r::is_project_3mf(), load_files(), load_gcode(), load_project(), Slic3r::GUI::ProjectDropDialog::LoadConfig, Slic3r::GUI::ProjectDropDialog::LoadGeometry, Slic3r::GUI::ProjectDropDialog::OpenProject, Slic3r::GUI::ProjectDropDialog::OpenWindow, preview_zip_archive(), Slic3r::GUI::start_new_gcodeviewer(), Slic3r::GUI::start_new_slicer(), and Slic3r::GUI::ProjectDropDialog::Unknown.

Here is the call graph for this function:

◆ load_gcode() [1/2]

void Slic3r::GUI::Plater::load_gcode ( )

{
    // Ask user for a gcode file name.
    wxString input_file;
    wxGetApp().load_gcode(this, input_file);
    // And finally load the gcode file.
    load_gcode(input_file);
}

References load_gcode().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer(), load_files(), load_gcode(), Slic3r::GUI::GUI_App::post_init(), and reload_gcode_from_disk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_gcode() [2/2]

void Slic3r::GUI::Plater::load_gcode ( const wxString & filename )

{
    if (! is_gcode_file(into_u8(filename)) || m_last_loaded_gcode == filename)
        return;
 
    m_last_loaded_gcode = filename;
 
    // cleanup view before to start loading/processing
    p->gcode_result.reset();
    reset_gcode_toolpaths();
    p->preview->reload_print(false);
    p->get_current_canvas3D()->render();
 
    wxBusyCursor wait;
 
    // process gcode
    GCodeProcessor processor;
    try
    {
        processor.process_file(filename.ToUTF8().data());
    }
    catch (const std::exception& ex)
    {
        show_error(this, ex.what());
        return;
    }
    p->gcode_result = std::move(processor.extract_result());
 
    // show results
    try
    {
        p->preview->reload_print(false);
    }
    catch (const std::exception&)
    {
        wxEndBusyCursor();
        p->gcode_result.reset();
        reset_gcode_toolpaths();
        set_default_bed_shape();
        p->preview->reload_print(false);
        p->get_current_canvas3D()->render();
        MessageDialog(this, _L("The selected file") + ":\n" + filename + "\n" + _L("does not contain valid gcode."),
            wxString(GCODEVIEWER_APP_NAME) + " - " + _L("Error while loading .gcode file"), wxOK | wxICON_WARNING | wxCENTRE).ShowModal();
        set_project_filename(wxEmptyString);
        return;
    }
    p->preview->get_canvas3d()->zoom_to_gcode();
 
    if (p->preview->get_canvas3d()->get_gcode_layers_zs().empty()) {
        wxEndBusyCursor();
        //wxMessageDialog(this, _L("The selected file") + ":\n" + filename + "\n" + _L("does not contain valid gcode."),
        MessageDialog(this, _L("The selected file") + ":\n" + filename + "\n" + _L("does not contain valid gcode."),
            wxString(GCODEVIEWER_APP_NAME) + " - " + _L("Error while loading .gcode file"), wxOK | wxICON_WARNING | wxCENTRE).ShowModal();
        set_project_filename(wxEmptyString);
    }
    else
        set_project_filename(filename);
}

References _L, Slic3r::GCodeProcessor::extract_result(), GCODEVIEWER_APP_NAME, Slic3r::GUI::into_u8(), Slic3r::is_gcode_file(), m_last_loaded_gcode, p, Slic3r::GCodeProcessor::process_file(), reset_gcode_toolpaths(), set_default_bed_shape(), set_project_filename(), and Slic3r::GUI::show_error().

Here is the call graph for this function:

◆ load_project() [1/2]

void Slic3r::GUI::Plater::load_project ( )

{
    if (!wxGetApp().can_load_project())
        return;
 
    // Ask user for a project file name.
    wxString input_file;
    wxGetApp().load_project(this, input_file);
    // And finally load the new project.
    load_project(input_file);
}

References load_project().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), load_files(), load_project(), and preview_zip_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_project() [2/2]

void Slic3r::GUI::Plater::load_project ( const wxString & filename )

{
    if (filename.empty())
        return;
 
    // Take the Undo / Redo snapshot.
    Plater::TakeSnapshot snapshot(this, _L("Load Project") + ": " + wxString::FromUTF8(into_path(filename).stem().string().c_str()), UndoRedo::SnapshotType::ProjectSeparator);
 
    p->reset();
 
    if (! load_files({ into_path(filename) }).empty()) {
        // At least one file was loaded.
        p->set_project_filename(filename);
        // Save the names of active presets and project specific config into ProjectDirtyStateManager.
        reset_project_dirty_initial_presets();
        // Make a copy of the active presets for detecting changes in preset values.
        wxGetApp().update_saved_preset_from_current_preset();
        // Update Project dirty state, update application title bar.
        update_project_dirty_from_presets();
    }
}

References _L, Slic3r::empty(), Slic3r::GUI::into_path(), load_files(), p, Slic3r::UndoRedo::ProjectSeparator, reset_project_dirty_initial_presets(), and update_project_dirty_from_presets().

Here is the call graph for this function:

◆ mirror()

void Slic3r::GUI::Plater::mirror ( Axis axis )

7416{ p->mirror(axis); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_mirror().

Here is the caller graph for this function:

◆ model() [1/2]

Model & Slic3r::GUI::Plater::model ( )

5223{ return p->model; }

References p.

◆ model() [2/2]

const Model & Slic3r::GUI::Plater::model ( ) const

5222{ return p->model; }

References p.

◆ msw_rescale()

void Slic3r::GUI::Plater::msw_rescale ( )

{
    p->preview->msw_rescale();
 
    p->view3D->get_canvas3d()->msw_rescale();
 
    p->sidebar->msw_rescale();
 
    Layout();
    GetParent()->Layout();
}

References p.

◆ multi_selection_menu()

wxMenu * Slic3r::GUI::Plater::multi_selection_menu ( )

7714{ return p->menus.multi_selection_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ new_project()

void Slic3r::GUI::Plater::new_project ( )

{
    if (int saved_project = p->save_project_if_dirty(_L("Creating a new project while the current project is modified.")); saved_project == wxID_CANCEL)
        return;
    else {
        wxString header = _L("Creating a new project while some presets are modified.") + "\n" + 
                          (saved_project == wxID_YES ? _L("You can keep presets modifications to the new project or discard them") :
                          _L("You can keep presets modifications to the new project, discard them or save changes as new presets.\n"
                             "Note, if changes will be saved then new project wouldn't keep them"));
        int act_buttons = ActionButtons::KEEP;
        if (saved_project == wxID_NO)
            act_buttons |= ActionButtons::SAVE;
        if (!wxGetApp().check_and_keep_current_preset_changes(_L("Creating a new project"), header, act_buttons))
            return;
    }
 
    p->select_view_3D("3D");
    take_snapshot(_L("New Project"), UndoRedo::SnapshotType::ProjectSeparator);
    Plater::SuppressSnapshots suppress(this);
    reset();
    // Save the names of active presets and project specific config into ProjectDirtyStateManager.
    reset_project_dirty_initial_presets();
    // Make a copy of the active presets for detecting changes in preset values.
    wxGetApp().update_saved_preset_from_current_preset();
    // Update Project dirty state, update application title bar.
    update_project_dirty_from_presets();
}

References _L, Slic3r::GUI::KEEP, p, Slic3r::UndoRedo::ProjectSeparator, reset(), reset_project_dirty_initial_presets(), Slic3r::GUI::SAVE, take_snapshot(), and update_project_dirty_from_presets().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ object_menu()

wxMenu * Slic3r::GUI::Plater::object_menu ( )

7707{ return p->menus.object_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ on_activate()

void Slic3r::GUI::Plater::on_activate ( )

{
  this->p->show_delayed_error_message();
}

References p.

Referenced by Slic3r::GUI::MainFrame::MainFrame().

Here is the caller graph for this function:

◆ on_config_change()

void Slic3r::GUI::Plater::on_config_change ( const DynamicPrintConfig & config )

{
    bool update_scheduled = false;
    bool bed_shape_changed = false;
    for (auto opt_key : p->config->diff(config)) {
        if (opt_key == "filament_colour") {
            update_scheduled = true; // update should be scheduled (for update 3DScene) #2738
 
            if (update_filament_colors_in_full_config()) {
                p->sidebar->obj_list()->update_extruder_colors();
                continue;
            }
        }
        if (opt_key == "material_colour") {
            update_scheduled = true; // update should be scheduled (for update 3DScene)
        }
        
        p->config->set_key_value(opt_key, config.option(opt_key)->clone());
        if (opt_key == "printer_technology") {
            const PrinterTechnology printer_technology = config.opt_enum<PrinterTechnology>(opt_key);
            this->set_printer_technology(printer_technology);
            p->sidebar->show_sliced_info_sizer(false);
            p->reset_gcode_toolpaths();
            p->view3D->get_canvas3d()->reset_sequential_print_clearance();
            p->view3D->get_canvas3d()->set_sla_view_type(GLCanvas3D::ESLAViewType::Original);
        }
        else if (opt_key == "bed_shape" || opt_key == "bed_custom_texture" || opt_key == "bed_custom_model") {
            bed_shape_changed = true;
            update_scheduled = true;
        }
        else if (boost::starts_with(opt_key, "wipe_tower") ||
            // opt_key == "filament_minimal_purge_on_wipe_tower" // ? #ys_FIXME
            opt_key == "single_extruder_multi_material") {
            update_scheduled = true;
        }
        else if(opt_key == "variable_layer_height") {
            if (p->config->opt_bool("variable_layer_height") != true) {
                p->view3D->enable_layers_editing(false);
                p->view3D->set_as_dirty();
            }
        }
        else if(opt_key == "extruder_colour") {
            update_scheduled = true;
            p->sidebar->obj_list()->update_extruder_colors();
        }
        else if (opt_key == "max_print_height") {
            bed_shape_changed = true;
            update_scheduled = true;
        }
        else if (opt_key == "printer_model") {
            p->reset_gcode_toolpaths();
            // update to force bed selection(for texturing)
            bed_shape_changed = true;
            update_scheduled = true;
        }
    }
 
    if (bed_shape_changed)
        set_bed_shape();
 
    if (update_scheduled)
        update();
 
    if (p->main_frame->is_loaded())
        this->p->schedule_background_process();
}

References Slic3r::ConfigOption::clone(), config(), Slic3r::ConfigBase::opt_enum(), Slic3r::ConfigBase::option(), Slic3r::GUI::GLCanvas3D::Original, p, printer_technology(), set_bed_shape(), set_printer_technology(), update(), and update_filament_colors_in_full_config().

Referenced by Slic3r::GUI::MainFrame::init_tabpanel(), Slic3r::GUI::MainFrame::load_config(), Slic3r::GUI::MainFrame::on_config_changed(), Slic3r::GUI::MainFrame::on_presets_changed(), and Slic3r::GUI::MainFrame::on_value_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ on_extruders_change()

void Slic3r::GUI::Plater::on_extruders_change ( size_t extruders_count )

{
    auto& choices = sidebar().combos_filament();
 
    if (num_extruders == choices.size())
        return;
 
    dynamic_cast<TabFilament*>(wxGetApp().get_tab(Preset::TYPE_FILAMENT))->update_extruder_combobox();
 
    wxWindowUpdateLocker noUpdates_scrolled_panel(&sidebar()/*.scrolled_panel()*/);
 
    size_t i = choices.size();
    while ( i < num_extruders )
    {
        PlaterPresetComboBox* choice/*{ nullptr }*/;
        sidebar().init_filament_combo(&choice, i);
        choices.push_back(choice);
 
        // initialize selection
        choice->update();
        ++i;
    }
 
    // remove unused choices if any
    sidebar().remove_unused_filament_combos(num_extruders);
 
    sidebar().Layout();
    sidebar().scrolled_panel()->Refresh();
}

References Slic3r::GUI::Sidebar::combos_filament(), Slic3r::GUI::Sidebar::init_filament_combo(), Slic3r::GUI::Sidebar::remove_unused_filament_combos(), Slic3r::GUI::Sidebar::scrolled_panel(), sidebar(), Slic3r::Preset::TYPE_FILAMENT, and Slic3r::GUI::PlaterPresetComboBox::update().

Referenced by Slic3r::GUI::MainFrame::init_tabpanel(), and Slic3r::GUI::MainFrame::on_value_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

Plater & Slic3r::GUI::Plater::operator= ( const Plater & )

delete

◆ operator=() [2/2]

Plater & Slic3r::GUI::Plater::operator= ( Plater && )

delete

◆ part_menu()

wxMenu * Slic3r::GUI::Plater::part_menu ( )

7708{ return p->menus.part_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ paste_from_clipboard()

void Slic3r::GUI::Plater::paste_from_clipboard ( )

{
    if (!can_paste_from_clipboard())
        return;
 
    Plater::TakeSnapshot snapshot(this, _L("Paste From Clipboard"));
 
    // At first try to paste values from the ObjectList's clipboard
    // to check if Settings or Layers were copied
    // and then paste from the 3DCanvas's clipboard if not
    if (!p->sidebar->obj_list()->paste_from_clipboard())
        p->view3D->get_canvas3d()->get_selection().paste_from_clipboard();
}

References _L, can_paste_from_clipboard(), and p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopupMenu() [1/2]

bool Slic3r::GUI::Plater::PopupMenu	(	wxMenu *	menu,
		const wxPoint &	pos = `wxDefaultPosition`
	)

{
  // Don't want to wake up and trigger reslicing while tracking the pop-up menu.
  SuppressBackgroundProcessingUpdate sbpu;
  // When tracking a pop-up menu, postpone error messages from the slicing result.
  m_tracking_popup_menu = true;
    bool out = this->wxPanel::PopupMenu(menu, pos);
  m_tracking_popup_menu = false;
  if (! m_tracking_popup_menu_error_message.empty()) {
        // Don't know whether the CallAfter is necessary, but it should not hurt.
        // The menus likely sends out some commands, so we may be safer if the dialog is shown after the menu command is processed.
    wxString message = std::move(m_tracking_popup_menu_error_message);
        wxTheApp->CallAfter([message, this]() { show_error(this, message); });
        m_tracking_popup_menu_error_message.clear();
    }
  return out;
}

References m_tracking_popup_menu, m_tracking_popup_menu_error_message, and Slic3r::GUI::show_error().

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopupMenu() [2/2]

bool Slic3r::GUI::Plater::PopupMenu	(	wxMenu *	menu,
		int	x,
		int	y
	)

inline

474{ return this->PopupMenu(menu, wxPoint(x, y)); }

Slic3r::GUI::Plater::PopupMenu

bool PopupMenu(wxMenu *menu, const wxPoint &pos=wxDefaultPosition)

Definition Plater.cpp:7685

References PopupMenu().

Referenced by PopupMenu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preview_zip_archive()

bool Slic3r::GUI::Plater::preview_zip_archive ( const boost::filesystem::path & input_file )

{
    //std::vector<fs::path> unzipped_paths;
    std::vector<fs::path> non_project_paths;
    std::vector<fs::path> project_paths;
    try
    {
        mz_zip_archive archive;
        mz_zip_zero_struct(&archive);
 
        if (!open_zip_reader(&archive, archive_path.string())) {
            // TRN %1% is archive path
            std::string err_msg = GUI::format(_u8L("Loading of a ZIP archive on path %1% has failed."), archive_path.string());
            throw Slic3r::FileIOError(err_msg);
        }
        mz_uint num_entries = mz_zip_reader_get_num_files(&archive);
        mz_zip_archive_file_stat stat;
        // selected_paths contains paths and its uncompressed size. The size is used to distinguish between files with same path.
        std::vector<std::pair<fs::path, size_t>> selected_paths;
        FileArchiveDialog dlg(static_cast<wxWindow*>(wxGetApp().mainframe), &archive, selected_paths);
        if (dlg.ShowModal() == wxID_OK)
        {      
            std::string archive_path_string = archive_path.string();
            archive_path_string = archive_path_string.substr(0, archive_path_string.size() - 4);
            fs::path archive_dir(wxStandardPaths::Get().GetTempDir().utf8_str().data());
           
            for (auto& path_w_size : selected_paths) {
                const fs::path& path = path_w_size.first;
                size_t size = path_w_size.second;
                // find path in zip archive
                for (mz_uint i = 0; i < num_entries; ++i) {
                    if (mz_zip_reader_file_stat(&archive, i, &stat)) {
                        if (size != stat.m_uncomp_size) // size must fit
                            continue;
                        wxString wname = boost::nowide::widen(stat.m_filename);
                        std::string name = boost::nowide::narrow(wname);
                        fs::path archive_path(name);
 
                        std::string extra(1024, 0);
                        size_t extra_size = mz_zip_reader_get_filename_from_extra(&archive, i, extra.data(), extra.size());
                        if (extra_size > 0) {
                            archive_path = fs::path(extra.substr(0, extra_size));
                            name = archive_path.string();
                        }
 
                        if (archive_path.empty())
                            continue;
                        if (path != archive_path) 
                            continue;
                        // decompressing
                        try
                        {
                            std::replace(name.begin(), name.end(), '\\', '/');
                            // rename if file exists
                            std::string filename = path.filename().string();
                            std::string extension = boost::filesystem::extension(path);
                            std::string just_filename = filename.substr(0, filename.size() - extension.size());
                            std::string final_filename = just_filename;
 
                            size_t version = 0;
                            while (fs::exists(archive_dir / (final_filename + extension)))
                            {
                                ++version;
                                final_filename = just_filename + "(" + std::to_string(version) + ")";
                            }
                            filename = final_filename + extension;
                            fs::path final_path = archive_dir / filename;
                            std::string buffer((size_t)stat.m_uncomp_size, 0);
                            // Decompress action. We already has correct file index in stat structure. 
                            mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
                            if (res == 0) {
                                wxString error_log = GUI::format_wxstr(_L("Failed to unzip file to %1%: %2% "), final_path.string(), mz_zip_get_error_string(mz_zip_get_last_error(&archive)));
                                BOOST_LOG_TRIVIAL(error) << error_log;
                                show_error(nullptr, error_log);
                                break;
                            }
                            // write buffer to file
                            fs::fstream file(final_path, std::ios::out | std::ios::binary | std::ios::trunc);
                            file.write(buffer.c_str(), buffer.size());
                            file.close();
                            if (!fs::exists(final_path)) {
                                wxString error_log = GUI::format_wxstr(_L("Failed to find unzipped file at %1%. Unzipping of file has failed."), final_path.string());
                                BOOST_LOG_TRIVIAL(error) << error_log;
                                show_error(nullptr, error_log);
                                break;
                            }
                            BOOST_LOG_TRIVIAL(info) << "Unzipped " << final_path;
                            if (!boost::algorithm::iends_with(filename, ".3mf") && !boost::algorithm::iends_with(filename, ".amf")) {
                                non_project_paths.emplace_back(final_path);
                                break;
                            }
                            // if 3mf - read archive headers to find project file
                            if ((boost::algorithm::iends_with(filename, ".3mf") && !is_project_3mf(final_path.string())) ||
                                (boost::algorithm::iends_with(filename, ".amf") && !boost::algorithm::iends_with(filename, ".zip.amf"))) {
                                non_project_paths.emplace_back(final_path);
                                break;
                            }
 
                            project_paths.emplace_back(final_path);
                            break;
                        }
                        catch (const std::exception& e)
                        {
                            // ensure the zip archive is closed and rethrow the exception
                            close_zip_reader(&archive);
                            throw Slic3r::FileIOError(e.what());
                        }
                    }
                }
            }
            close_zip_reader(&archive);
            if (non_project_paths.size() + project_paths.size() != selected_paths.size())
                BOOST_LOG_TRIVIAL(error) << "Decompresing of archive did not retrieve all files. Expected files: " 
                                         << selected_paths.size() 
                                         << " Decopressed files: " 
                                         << non_project_paths.size() + project_paths.size();
        } else {
            close_zip_reader(&archive);
            return false;
        }
        
    }
    catch (const Slic3r::FileIOError& e) {
        // zip reader should be already closed or not even opened
        GUI::show_error(this, e.what());
        return false;
    }
    // none selected
    if (project_paths.empty() && non_project_paths.empty())
    {
        return false;
    }
#if 0
    // 1 project, 0 models - behave like drag n drop
    if (project_paths.size() == 1 && non_project_paths.empty())
    {
        wxArrayString aux;
        aux.Add(from_u8(project_paths.front().string()));
        load_files(aux);
        //load_files(project_paths, true, true);
        boost::system::error_code ec;
        fs::remove(project_paths.front(), ec);
        if (ec)
            BOOST_LOG_TRIVIAL(error) << ec.message();
        return true;
    }
    // 1 model (or more and other instances are not allowed), 0 projects - open geometry
    if (project_paths.empty() && (non_project_paths.size() == 1 || wxGetApp().app_config->get_bool("single_instance")))
    {
        load_files(non_project_paths, true, false);
        boost::system::error_code ec;
        fs::remove(non_project_paths.front(), ec);
        if (ec)
            BOOST_LOG_TRIVIAL(error) << ec.message();
        return true;
    }
 
    bool delete_after = true;
 
    LoadProjectsDialog dlg(project_paths);
    if (dlg.ShowModal() == wxID_OK) {
        LoadProjectsDialog::LoadProjectOption option = static_cast<LoadProjectsDialog::LoadProjectOption>(dlg.get_action());
        switch (option)
        {
        case LoadProjectsDialog::LoadProjectOption::AllGeometry: {
            load_files(project_paths, true, false);
            load_files(non_project_paths, true, false);
            break;
        }
        case LoadProjectsDialog::LoadProjectOption::AllNewWindow: {
            delete_after = false;
            for (const fs::path& path : project_paths) {
                wxString f = from_path(path);
                start_new_slicer(&f, false);
            }
            for (const fs::path& path : non_project_paths) {
                wxString f = from_path(path);
                start_new_slicer(&f, false);
            }
            break;
        }
        case LoadProjectsDialog::LoadProjectOption::OneProject: {
            int pos = dlg.get_selected();
            assert(pos >= 0 && pos < project_paths.size());
            if (wxGetApp().can_load_project())
                load_project(from_path(project_paths[pos]));
            project_paths.erase(project_paths.begin() + pos);
            load_files(project_paths, true, false);
            load_files(non_project_paths, true, false);
            break;
        }
        case LoadProjectsDialog::LoadProjectOption::OneConfig: {
            int pos = dlg.get_selected();
            assert(pos >= 0 && pos < project_paths.size());
            std::vector<fs::path> aux;
            aux.push_back(project_paths[pos]);
            load_files(aux, false, true);
            project_paths.erase(project_paths.begin() + pos);
            load_files(project_paths, true, false);
            load_files(non_project_paths, true, false);
            break;
        }
        case LoadProjectsDialog::LoadProjectOption::Unknown:
        default:
            assert(false);
            break;
        }
    }
 
    if (!delete_after)
        return true;
#else 
    // 1 project file and some models - behave like drag n drop of 3mf and then load models
    if (project_paths.size() == 1)
    {
        wxArrayString aux;
        aux.Add(from_u8(project_paths.front().string()));
        bool loaded3mf = load_files(aux, true);
        load_files(non_project_paths, true, false);
        boost::system::error_code ec;
        if (loaded3mf) {
            fs::remove(project_paths.front(), ec);
            if (ec)
                BOOST_LOG_TRIVIAL(error) << ec.message();
        }
        for (const fs::path& path : non_project_paths) {
            // Delete file from temp file (path variable), it will stay only in app memory.
            boost::system::error_code ec;
            fs::remove(path, ec);
            if (ec)
                BOOST_LOG_TRIVIAL(error) << ec.message();
        }
        return true;
    }
 
    // load all projects and all models as geometry
    load_files(project_paths, true, false);
    load_files(non_project_paths, true, false);
#endif // 0
   
 
    for (const fs::path& path : project_paths) {
        // Delete file from temp file (path variable), it will stay only in app memory.
        boost::system::error_code ec;
        fs::remove(path, ec);
        if (ec)
            BOOST_LOG_TRIVIAL(error) << ec.message();
    }
    for (const fs::path& path : non_project_paths) {
        // Delete file from temp file (path variable), it will stay only in app memory.
        boost::system::error_code ec;
        fs::remove(path, ec);
        if (ec)
            BOOST_LOG_TRIVIAL(error) << ec.message();
    }
 
    return true;
}

References _L, _u8L, Slic3r::GUI::LoadProjectsDialog::AllGeometry, Slic3r::GUI::LoadProjectsDialog::AllNewWindow, Slic3r::close_zip_reader(), error, Slic3r::f(), Slic3r::GUI::format(), Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_path(), Slic3r::GUI::from_u8(), Slic3r::GUI::LoadProjectsDialog::get_action(), Slic3r::GUI::LoadProjectsDialog::get_selected(), Slic3r::is_project_3mf(), load_files(), load_project(), mz_zip_get_error_string(), mz_zip_get_last_error(), mz_zip_reader_extract_to_mem(), mz_zip_reader_file_stat(), mz_zip_reader_get_filename_from_extra(), mz_zip_reader_get_num_files(), mz_zip_zero_struct(), boost::nowide::narrow(), Slic3r::GUI::LoadProjectsDialog::OneConfig, Slic3r::GUI::LoadProjectsDialog::OneProject, Slic3r::open_zip_reader(), Slic3r::GUI::show_error(), Slic3r::GUI::start_new_slicer(), stat, Slic3r::GUI::LoadProjectsDialog::Unknown, version, and boost::nowide::widen().

Referenced by load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ printer_technology()

PrinterTechnology Slic3r::GUI::Plater::printer_technology ( ) const

{
    return p->printer_technology;
}

References p.

Here is the caller graph for this function:

◆ redo()

void Slic3r::GUI::Plater::redo ( )

6898{ p->redo(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ redo_to()

void Slic3r::GUI::Plater::redo_to ( int selection )

{
    if (selection == 0) {
        p->redo();
        return;
    }
 
    const int idx = p->get_active_snapshot_index() + selection + 1;
    p->undo_redo_to(p->undo_redo_stack().snapshots()[idx].timestamp);
}

References p.

◆ refresh_print()

void Slic3r::GUI::Plater::refresh_print ( )

{
    p->preview->refresh_print();
}

References p.

Referenced by Slic3r::GUI::GUI_App::open_preferences().

Here is the caller graph for this function:

◆ reload_all_from_disk()

void Slic3r::GUI::Plater::reload_all_from_disk ( )

{
    p->reload_all_from_disk();
}

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ reload_from_disk()

void Slic3r::GUI::Plater::reload_from_disk ( )

{
    p->reload_from_disk();
}

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_reload_from_disk(), and Slic3r::GUI::Plater::priv::reload_all_from_disk().

Here is the caller graph for this function:

◆ reload_gcode_from_disk()

void Slic3r::GUI::Plater::reload_gcode_from_disk ( )

{
    wxString filename(m_last_loaded_gcode);
    m_last_loaded_gcode.clear();
    load_gcode(filename);
}

References load_gcode(), and m_last_loaded_gcode.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove()

void Slic3r::GUI::Plater::remove ( size_t obj_idx )

6098{ p->remove(obj_idx); }

References p.

Referenced by Slic3r::GUI::GLGizmoEmboss::close(), convert_unit(), decrease_instances(), and Slic3r::GUI::Plater::priv::split_object().

Here is the caller graph for this function:

◆ remove_selected()

void Slic3r::GUI::Plater::remove_selected ( )

{
    if (p->get_selection().is_empty())
        return;
 
    Plater::TakeSnapshot snapshot(this, _L("Delete Selected Objects"));
    get_ui_job_worker().cancel_all();
    p->view3D->delete_selected();
}

References _L, Slic3r::GUI::Worker::cancel_all(), get_ui_job_worker(), and p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_delete(), Slic3r::GUI::GLGizmoEmboss::close(), and Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ replace_with_stl()

void Slic3r::GUI::Plater::replace_with_stl ( )

{
    p->replace_with_stl();
}

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_replace_with_stl().

Here is the caller graph for this function:

◆ reset()

void Slic3r::GUI::Plater::reset ( )

6099{ p->reset(); }

References p.

Referenced by new_project(), and reset_with_confirm().

Here is the caller graph for this function:

◆ reset_canvas_volumes()

void Slic3r::GUI::Plater::reset_canvas_volumes ( )

{
    p->reset_canvas_volumes();
}

References p.

Referenced by Slic3r::GUI::MainFrame::shutdown().

Here is the caller graph for this function:

◆ reset_gcode_toolpaths()

void Slic3r::GUI::Plater::reset_gcode_toolpaths ( )

{
    p->reset_gcode_toolpaths();
}

References p.

Referenced by Slic3r::GUI::Plater::priv::delete_all_objects_from_model(), load_gcode(), Slic3r::GUI::Plater::priv::reset(), reslice(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

◆ reset_last_loaded_gcode()

void Slic3r::GUI::Plater::reset_last_loaded_gcode ( )

inline

408{ m_last_loaded_gcode = ""; }

References m_last_loaded_gcode.

◆ reset_project_dirty_after_save()

void Slic3r::GUI::Plater::reset_project_dirty_after_save ( )

5215{ p->reset_project_dirty_after_save(); }

References p.

Referenced by Slic3r::GUI::MainFrame::save_project_as().

Here is the caller graph for this function:

◆ reset_project_dirty_initial_presets()

void Slic3r::GUI::Plater::reset_project_dirty_initial_presets ( )

5216{ p->reset_project_dirty_initial_presets(); }

References p.

Referenced by load_project(), and new_project().

Here is the caller graph for this function:

◆ reset_with_confirm()

void Slic3r::GUI::Plater::reset_with_confirm ( )

{
    if (p->model.objects.empty() ||
        //wxMessageDialog(static_cast<wxWindow*>(this), _L("All objects will be removed, continue?"), wxString(SLIC3R_APP_NAME) + " - " + _L("Delete all"), wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxCENTRE).ShowModal() == wxID_YES)
        MessageDialog(static_cast<wxWindow*>(this), _L("All objects will be removed, continue?"), wxString(SLIC3R_APP_NAME) + " - " + _L("Delete all"), wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxCENTRE).ShowModal() == wxID_YES)
        reset();
}

References _L, p, and reset().

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reslice()

void Slic3r::GUI::Plater::reslice ( )

{
    // There is "invalid data" button instead "slice now"
    if (p->process_completed_with_error)
        return;
 
    // In case SLA gizmo is in editing mode, refuse to continue
    // and notify user that he should leave it first.
    if (canvas3D()->get_gizmos_manager().is_in_editing_mode(true))
        return;
 
    // Stop the running (and queued) UI jobs and only proceed if they actually
    // get stopped.
    unsigned timeout_ms = 10000;
    if (!stop_queue(this->get_ui_job_worker(), timeout_ms)) {
        BOOST_LOG_TRIVIAL(error) << "Could not stop UI job within "
                                 << timeout_ms << " milliseconds timeout!";
        return;
    }
 
    if (printer_technology() == ptSLA) {
        for (auto& object : model().objects)
            if (object->sla_points_status == sla::PointsStatus::NoPoints)
                object->sla_points_status = sla::PointsStatus::Generating;
    }
 
    //FIXME Don't reslice if export of G-code or sending to OctoPrint is running.
    // bitmask of UpdateBackgroundProcessReturnState
    unsigned int state = this->p->update_background_process(true);
    if (state & priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE)
        this->p->view3D->reload_scene(false);
    // If the SLA processing of just a single object's supports is running, restart slicing for the whole object.
    this->p->background_process.set_task(PrintBase::TaskParams());
    // Only restarts if the state is valid.
    this->p->restart_background_process(state | priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART);
 
    if ((state & priv::UPDATE_BACKGROUND_PROCESS_INVALID) != 0)
        return;
 
    bool clean_gcode_toolpaths = true;
    if (p->background_process.running())
    {
        if (wxGetApp().get_mode() == comSimple)
            p->sidebar->set_btn_label(ActionButtonType::abReslice, _L("Slicing") + dots);
        else
        {
            p->sidebar->set_btn_label(ActionButtonType::abReslice, _L("Slice now"));
            p->show_action_buttons(false);
        }
    }
    else if (!p->background_process.empty() && !p->background_process.idle())
        p->show_action_buttons(true);
    else
        clean_gcode_toolpaths = false;
 
    if (clean_gcode_toolpaths)
        reset_gcode_toolpaths();
 
    p->preview->reload_print(!clean_gcode_toolpaths);
}

References _L, Slic3r::GUI::abReslice, canvas3D(), Slic3r::comSimple, Slic3r::GUI::dots(), error, Slic3r::sla::Generating, get_ui_job_worker(), model(), Slic3r::sla::NoPoints, Slic3r::Model::objects, p, printer_technology(), Slic3r::ptSLA, reset_gcode_toolpaths(), Slic3r::GUI::stop_queue(), Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, and Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE.

Referenced by Slic3r::GUI::MainFrame::reslice_now().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reslice_FFF_until_step()

void Slic3r::GUI::Plater::reslice_FFF_until_step	(	PrintObjectStep	step,
		const ModelObject &	object,
		bool	postpone_error_messages = `false`
	)

{
    this->reslice_until_step_inner(PrintObjectStep(step), object, postpone_error_messages);
}

References reslice_until_step_inner().

Here is the call graph for this function:

◆ reslice_SLA_until_step()

void Slic3r::GUI::Plater::reslice_SLA_until_step	(	SLAPrintObjectStep	step,
		const ModelObject &	object,
		bool	postpone_error_messages = `false`
	)

{
    this->reslice_until_step_inner(SLAPrintObjectStep(step), object, postpone_error_messages);
}

References reslice_until_step_inner().

Here is the call graph for this function:

◆ reslice_until_step_inner()

void Slic3r::GUI::Plater::reslice_until_step_inner	(	int	step,
		const ModelObject &	object,
		bool	postpone_error_messages
	)

private

{
    //FIXME Don't reslice if export of G-code or sending to OctoPrint is running.
    // bitmask of UpdateBackgroundProcessReturnState
    unsigned int state = this->p->update_background_process(true, postpone_error_messages);
    if (state & priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE)
        this->p->view3D->reload_scene(false);
 
    if (this->p->background_process.empty() || (state & priv::UPDATE_BACKGROUND_PROCESS_INVALID))
        // Nothing to do on empty input or invalid configuration.
        return;
 
    // Limit calculation to the single object only.
    PrintBase::TaskParams task;
    task.single_model_object = object.id();
    // If the background processing is not enabled, calculate supports just for the single instance.
    // Otherwise calculate everything, but start with the provided object.
    if (!this->p->background_processing_enabled()) {
        task.single_model_instance_only = true;
        task.to_object_step = step;
    }
    this->p->background_process.set_task(task);
    // and let the background processing start.
    this->p->restart_background_process(state | priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART);
}

References Slic3r::ObjectID::id, p, Slic3r::PrintBase::TaskParams::single_model_instance_only, Slic3r::PrintBase::TaskParams::single_model_object, Slic3r::PrintBase::TaskParams::to_object_step, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_FORCE_RESTART, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, and Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_REFRESH_SCENE.

Referenced by reslice_FFF_until_step(), and reslice_SLA_until_step().

Here is the caller graph for this function:

◆ save_project_if_dirty()

int Slic3r::GUI::Plater::save_project_if_dirty ( const wxString & reason )

5214{ return p->save_project_if_dirty(reason); }

References p.

Referenced by Slic3r::GUI::MainFrame::MainFrame(), and Slic3r::GUI::GUI_App::can_load_project().

Here is the caller graph for this function:

◆ scale_selection_to_fit_print_volume()

void Slic3r::GUI::Plater::scale_selection_to_fit_print_volume ( )

{
    p->scale_selection_to_fit_print_volume();
}

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_scale_selection_to_fit_print_volume().

Here is the caller graph for this function:

◆ schedule_background_process()

void Slic3r::GUI::Plater::schedule_background_process ( bool schedule = true )

{
    if (schedule)
        this->p->schedule_background_process();
 
    this->p->suppressed_backround_processing_update = false;
}

References p.

Referenced by Slic3r::GUI::Plater::priv::load_model_objects(), and Slic3r::GUI::Plater::priv::update().

Here is the caller graph for this function:

◆ search()

void Slic3r::GUI::Plater::search ( bool plater_is_active )

{
    if (plater_is_active) {
        if (is_preview_shown())
            return;
        // plater should be focused for correct navigation inside search window 
        this->SetFocus();
 
        wxKeyEvent evt;
#ifdef __APPLE__
        evt.m_keyCode = 'f';
#else /* __APPLE__ */
        evt.m_keyCode = WXK_CONTROL_F;
#endif /* __APPLE__ */
        evt.SetControlDown(true);
        canvas3D()->on_char(evt);
    }
    else {
        p->sidebar->check_and_update_searcher(true);
        p->sidebar->get_searcher().show_dialog();
    }
}

References canvas3D(), is_preview_shown(), Slic3r::GUI::GLCanvas3D::on_char(), and p.

Referenced by Slic3r::GUI::SettingsDialog::SettingsDialog(), Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::Plater::priv::reload_from_disk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_string_getter()

bool Slic3r::GUI::Plater::search_string_getter	(	int	idx,
		const char **	label,
		const char **	tooltip
	)

{
    const Search::OptionsSearcher& search_list = p->sidebar->get_searcher();
    
    if (0 <= idx && (size_t)idx < search_list.size()) {
        search_list[idx].get_marked_label_and_tooltip(label, tooltip);
        return true;
    }
 
    return false;
}

References p, and Slic3r::Search::OptionsSearcher::size().

Here is the call graph for this function:

◆ select_all()

void Slic3r::GUI::Plater::select_all ( )

6095{ p->select_all(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::Plater::priv::reload_all_from_disk().

Here is the caller graph for this function:

◆ select_view()

void Slic3r::GUI::Plater::select_view ( const std::string & direction )

6076{ p->select_view(direction); }

References p.

Referenced by Slic3r::GUI::MainFrame::select_view().

Here is the caller graph for this function:

◆ select_view_3D()

void Slic3r::GUI::Plater::select_view_3D ( const std::string & name )

6078{ p->select_view_3D(name); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ send_gcode()

void Slic3r::GUI::Plater::send_gcode ( )

{
    // if physical_printer is selected, send gcode for this printer
    DynamicPrintConfig* physical_printer_config = wxGetApp().preset_bundle->physical_printers.get_selected_printer_config();
    if (! physical_printer_config || p->model.objects.empty())
        return;
 
    PrintHostJob upload_job(physical_printer_config);
    if (upload_job.empty())
        return;
 
    // Obtain default output path
    fs::path default_output_file;
    try {
        // Update the background processing, so that the placeholder parser will get the correct values for the ouput file template.
        // Also if there is something wrong with the current configuration, a pop-up dialog will be shown and the export will not be performed.
        unsigned int state = this->p->update_restart_background_process(false, false);
        if (state & priv::UPDATE_BACKGROUND_PROCESS_INVALID)
            return;
        default_output_file = this->p->background_process.output_filepath_for_project(into_path(get_project_filename(".3mf")));
    } catch (const Slic3r::PlaceholderParserError& ex) {
        // Show the error with monospaced font.
        show_error(this, ex.what(), true);
        return;
    } catch (const std::exception& ex) {
        show_error(this, ex.what(), false);
        return;
    }
    default_output_file = fs::path(Slic3r::fold_utf8_to_ascii(default_output_file.string()));
 
    // Repetier specific: Query the server for the list of file groups.
    wxArrayString groups;
    {
        wxBusyCursor wait;
        upload_job.printhost->get_groups(groups);
    }
    // PrusaLink specific: Query the server for the list of file groups.
    wxArrayString storage_paths;
    wxArrayString storage_names;
    {
        wxBusyCursor wait;
        try {
            upload_job.printhost->get_storage(storage_paths, storage_names);
        } catch (const Slic3r::IOError& ex) {
            show_error(this, ex.what(), false);
            return;
        }
    }
 
    PrintHostSendDialog dlg(default_output_file, upload_job.printhost->get_post_upload_actions(), groups, storage_paths, storage_names);
    if (dlg.ShowModal() == wxID_OK) {
        upload_job.upload_data.upload_path = dlg.filename();
        upload_job.upload_data.post_action = dlg.post_action();
        upload_job.upload_data.group       = dlg.group();
        upload_job.upload_data.storage     = dlg.storage();
 
        // Show "Is printer clean" dialog for PrusaConnect - Upload and print.
        if (std::string(upload_job.printhost->get_name()) == "PrusaConnect" && upload_job.upload_data.post_action == PrintHostPostUploadAction::StartPrint) {
            GUI::MessageDialog dlg(nullptr, _L("Is the printer ready? Is the print sheet in place, empty and clean?"), _L("Upload and Print"), wxOK | wxCANCEL);
            if (dlg.ShowModal() != wxID_OK)
                return;
        }
 
        p->export_gcode(fs::path(), false, std::move(upload_job));
    }
}

References _L, Slic3r::PrintHostJob::empty(), Slic3r::GUI::PrintHostSendDialog::filename(), Slic3r::fold_utf8_to_ascii(), get_project_filename(), Slic3r::GUI::PrintHostSendDialog::group(), Slic3r::PrintHostUpload::group, Slic3r::GUI::into_path(), p, Slic3r::GUI::PrintHostSendDialog::post_action(), Slic3r::PrintHostUpload::post_action, Slic3r::PrintHostJob::printhost, Slic3r::GUI::show_error(), Slic3r::StartPrint, Slic3r::GUI::PrintHostSendDialog::storage(), Slic3r::PrintHostUpload::storage, Slic3r::GUI::Plater::priv::UPDATE_BACKGROUND_PROCESS_INVALID, Slic3r::PrintHostJob::upload_data, and Slic3r::PrintHostUpload::upload_path.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_bed_shape() [1/2]

void Slic3r::GUI::Plater::set_bed_shape ( ) const

{
    set_bed_shape(p->config->option<ConfigOptionPoints>("bed_shape")->values,
        p->config->option<ConfigOptionFloat>("max_print_height")->value,
        p->config->option<ConfigOptionString>("bed_custom_texture")->value,
        p->config->option<ConfigOptionString>("bed_custom_model")->value);
}

References p, set_bed_shape(), Slic3r::ConfigOptionSingle< T >::value, and Slic3r::ConfigOptionVector< T >::values.

Referenced by on_config_change(), set_bed_shape(), and set_default_bed_shape().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_bed_shape() [2/2]

void Slic3r::GUI::Plater::set_bed_shape	(	const Pointfs &	shape,
		const double	max_print_height,
		const std::string &	custom_texture,
		const std::string &	custom_model,
		bool	force_as_custom = `false`
	)		const

{
    p->set_bed_shape(shape, max_print_height, custom_texture, custom_model, force_as_custom);
}

References Slic3r::max_print_height(), and p.

Here is the call graph for this function:

◆ set_current_canvas_as_dirty()

void Slic3r::GUI::Plater::set_current_canvas_as_dirty ( )

{
    p->set_current_canvas_as_dirty();
}

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_item_printable(), and Slic3r::GUI::Mouse3DController::disconnect_device().

Here is the caller graph for this function:

◆ set_default_bed_shape()

void Slic3r::GUI::Plater::set_default_bed_shape ( ) const

{
    set_bed_shape({ { 0.0, 0.0 }, { 200.0, 0.0 }, { 200.0, 200.0 }, { 0.0, 200.0 } }, 0.0, {}, {}, true);
}

References set_bed_shape().

Referenced by load_gcode(), and Slic3r::GUI::MainFrame::update_layout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_keep_current_preview_type()

void Slic3r::GUI::Plater::set_keep_current_preview_type ( bool value )

{
    p->preview->set_keep_current_preview_type(value);
}

References p.

◆ set_number_of_copies()

void Slic3r::GUI::Plater::set_number_of_copies ( )

{
    const auto obj_idxs = get_selection().get_object_idxs();
    if (obj_idxs.empty())
        return;
 
    const size_t init_cnt = obj_idxs.size() == 1 ? p->model.objects[*obj_idxs.begin()]->instances.size() : 1;
    const int num = GetNumberFromUser( " ", _L("Enter the number of copies:"),
                                    _L("Copies of the selected object"), init_cnt, 0, 1000, this );
    if (num < 0)
        return;
    TakeSnapshot snapshot(this, wxString::Format(_L("Set numbers of copies to %d"), num));
 
    // we need a copy made here because the selection changes at every call of increase_instances()
    Selection::ObjectIdxsToInstanceIdxsMap content = p->get_selection().get_content();
 
    for (const auto& obj_idx : obj_idxs) {
        ModelObject* model_object = p->model.objects[obj_idx];
        const int diff = num - (int)model_object->instances.size();
        if (diff > 0) {
            if (auto obj_it = content.find(int(obj_idx)); obj_it != content.end())
                increase_instances(diff, int(obj_idx), *obj_it->second.rbegin());
        }
        else if (diff < 0)
            decrease_instances(-diff, int(obj_idx));
    }
}

References _L, decrease_instances(), Slic3r::diff(), Slic3r::GUI::Selection::get_object_idxs(), get_selection(), Slic3r::GUI::GetNumberFromUser(), increase_instances(), Slic3r::ModelObject::instances, and p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_instance_manipulation(), and Slic3r::GUI::MenuFactory::multi_selection_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_preview_layers_slider_values_range()

void Slic3r::GUI::Plater::set_preview_layers_slider_values_range	(	int	bottom,
		int	top
	)

{
    p->set_preview_layers_slider_values_range(bottom, top);
}

References p.

◆ set_printer_technology()

bool Slic3r::GUI::Plater::set_printer_technology ( PrinterTechnology printer_technology )

{
    p->printer_technology = printer_technology;
    bool ret = p->background_process.select_technology(printer_technology);
    if (ret) {
        // Update the active presets.
    }
    //FIXME for SLA synchronize
    //p->background_process.apply(Model)!
 
    if (printer_technology == ptSLA) {
        for (ModelObject* model_object : p->model.objects) {
            model_object->ensure_on_bed();
        }
    }
 
    p->label_btn_export = printer_technology == ptFFF ? L("Export G-code") : L("Export");
    p->label_btn_send   = printer_technology == ptFFF ? L("Send G-code")   : L("Send to printer");
 
    if (wxGetApp().mainframe != nullptr)
        wxGetApp().mainframe->update_menubar();
 
    p->update_main_toolbar_tooltips();
 
    p->notification_manager->set_fff(printer_technology == ptFFF);
    p->notification_manager->set_slicing_progress_hidden();
 
    return ret;
}

References L, p, printer_technology(), Slic3r::ptFFF, and Slic3r::ptSLA.

Referenced by Slic3r::GUI::MainFrame::load_config(), Slic3r::GUI::GUI_App::load_current_presets(), and on_config_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_project_filename()

void Slic3r::GUI::Plater::set_project_filename ( const wxString & filename )

{
    p->set_project_filename(filename);
}

References p.

Referenced by load_gcode(), Slic3r::GUI::GUI_App::post_init(), and Slic3r::GUI::Plater::priv::reset().

Here is the caller graph for this function:

◆ show_action_buttons() [1/2]

void Slic3r::GUI::Plater::show_action_buttons ( ) const

7421{ p->show_action_buttons(p->ready_to_slice); }

References p.

Referenced by Slic3r::GUI::Plater::priv::on_process_completed(), and Slic3r::GUI::Plater::priv::update_background_process().

Here is the caller graph for this function:

◆ show_action_buttons() [2/2]

void Slic3r::GUI::Plater::show_action_buttons ( const bool is_ready_to_slice ) const

7420{ p->show_action_buttons(ready_to_slice); }

References p.

Referenced by Slic3r::GUI::MainFrame::MainFrame().

Here is the caller graph for this function:

◆ show_illegal_characters_warning()

void Slic3r::GUI::Plater::show_illegal_characters_warning ( wxWindow * parent )

static

{
    show_error(parent, _L("The provided name is not valid;") + "\n" +
        _L("the following characters are not allowed:") + " <>:/\\|?*\"");
}

References _L, and Slic3r::GUI::show_error().

Referenced by Slic3r::GUI::ObjectList::OnEditingDone(), and Slic3r::GUI::ObjectList::rename_item().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ show_legend()

void Slic3r::GUI::Plater::show_legend ( bool show )

6088{ p->show_legend(show); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor(), and Slic3r::GUI::MainFrame::init_menubar_as_gcodeviewer().

Here is the caller graph for this function:

◆ show_view3D_labels()

void Slic3r::GUI::Plater::show_view3D_labels ( bool show )

6085{ p->show_view3D_labels(show); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ sidebar()

Sidebar & Slic3r::GUI::Plater::sidebar ( )

5221{ return *p->sidebar; }

References p.

Here is the caller graph for this function:

◆ sla_object_menu()

wxMenu * Slic3r::GUI::Plater::sla_object_menu ( )

7710{ return p->menus.sla_object_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ sla_print() [1/2]

SLAPrint & Slic3r::GUI::Plater::sla_print ( )

5227{ return p->sla_print; }

References p.

◆ sla_print() [2/2]

const SLAPrint & Slic3r::GUI::Plater::sla_print ( ) const

5226{ return p->sla_print; }

References p.

Referenced by Slic3r::GUI::MainFrame::can_export_supports(), Slic3r::GUI::get_arrange_poly(), Slic3r::GUI::Plater::priv::on_slicing_update(), and Slic3r::GUI::Preview::update_layers_slider().

Here is the caller graph for this function:

◆ split_object()

void Slic3r::GUI::Plater::split_object ( )

7417{ p->split_object(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_split(), and Slic3r::GUI::Plater::priv::on_action_split_objects().

Here is the caller graph for this function:

◆ split_volume()

void Slic3r::GUI::Plater::split_volume ( )

7418{ p->split_volume(); }

References p.

Referenced by Slic3r::GUI::MenuFactory::append_menu_items_split(), Slic3r::GUI::MenuFactory::create_part_menu(), and Slic3r::GUI::Plater::priv::on_action_split_volumes().

Here is the caller graph for this function:

◆ suppress_background_process()

void Slic3r::GUI::Plater::suppress_background_process ( const bool stop_background_process )

{
    if (stop_background_process)
        this->p->background_process_timer.Stop();
 
    this->p->suppressed_backround_processing_update = true;
}

References p.

◆ suppress_snapshots()

void Slic3r::GUI::Plater::suppress_snapshots ( )

private

6895{ p->suppress_snapshots(); }

References p.

Referenced by Slic3r::GUI::Plater::SuppressSnapshots::SuppressSnapshots(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), and Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot().

Here is the caller graph for this function:

◆ sys_color_changed()

void Slic3r::GUI::Plater::sys_color_changed ( )

{
    p->preview->sys_color_changed();
    p->sidebar->sys_color_changed();
 
    p->menus.sys_color_changed();
 
    Layout();
    GetParent()->Layout();
}

References p.

◆ take_snapshot() [1/4]

void Slic3r::GUI::Plater::take_snapshot ( const std::string & snapshot_name )

6891{ p->take_snapshot(snapshot_name); }

References p.

Referenced by Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), Slic3r::GUI::Plater::TakeSnapshot::TakeSnapshot(), Slic3r::GUI::GLGizmoSimplify::apply_simplify(), priv::create_volume(), Slic3r::GUI::Plater::priv::enter_gizmos_stack(), Slic3r::GUI::Emboss::CreateObjectJob::finalize(), new_project(), and Slic3r::GUI::take_snapshot().

Here is the caller graph for this function:

◆ take_snapshot() [2/4]

void Slic3r::GUI::Plater::take_snapshot	(	const std::string &	snapshot_name,
		UndoRedo::SnapshotType	snapshot_type
	)

6893{ p->take_snapshot(snapshot_name, snapshot_type); }

References p.

◆ take_snapshot() [3/4]

void Slic3r::GUI::Plater::take_snapshot ( const wxString & snapshot_name )

6892{ p->take_snapshot(snapshot_name); }

References p.

◆ take_snapshot() [4/4]

void Slic3r::GUI::Plater::take_snapshot	(	const wxString &	snapshot_name,
		UndoRedo::SnapshotType	snapshot_type
	)

6894{ p->take_snapshot(snapshot_name, snapshot_type); }

References p.

◆ text_part_menu()

wxMenu * Slic3r::GUI::Plater::text_part_menu ( )

7709{ return p->menus.text_part_menu(); }

References p.

Referenced by Slic3r::GUI::ObjectList::show_context_menu().

Here is the caller graph for this function:

◆ toggle_layers_editing()

void Slic3r::GUI::Plater::toggle_layers_editing ( bool enable )

{
    if (canvas3D()->is_layers_editing_enabled() != enable)
        canvas3D()->force_main_toolbar_left_action(canvas3D()->get_main_toolbar_item_id("layersediting"));
}

References canvas3D(), and Slic3r::GUI::GLCanvas3D::force_main_toolbar_left_action().

Here is the call graph for this function:

◆ toggle_render_statistic_dialog()

void Slic3r::GUI::Plater::toggle_render_statistic_dialog ( )

{
    p->show_render_statistic_dialog = !p->show_render_statistic_dialog;
}

References p.

◆ unbind_canvas_event_handlers()

void Slic3r::GUI::Plater::unbind_canvas_event_handlers ( )

{
    p->unbind_canvas_event_handlers();
}

References p.

Referenced by Slic3r::GUI::MainFrame::shutdown().

Here is the caller graph for this function:

◆ undo()

void Slic3r::GUI::Plater::undo ( )

6897{ p->undo(); }

References p.

Referenced by Slic3r::GUI::MainFrame::init_menubar_as_editor().

Here is the caller graph for this function:

◆ undo_redo_stack_main()

const UndoRedo::Stack & Slic3r::GUI::Plater::undo_redo_stack_main ( ) const

7657{ return p->undo_redo_stack_main(); }

References p.

◆ undo_redo_string_getter()

bool Slic3r::GUI::Plater::undo_redo_string_getter	(	const bool	is_undo,
		int	idx,
		const char **	out_text
	)

{
    const std::vector<UndoRedo::Snapshot>& ss_stack = p->undo_redo_stack().snapshots();
    const int idx_in_ss_stack = p->get_active_snapshot_index() + (is_undo ? -(++idx) : idx);
 
    if (0 < idx_in_ss_stack && (size_t)idx_in_ss_stack < ss_stack.size() - 1) {
        *out_text = ss_stack[idx_in_ss_stack].name.c_str();
        return true;
    }
 
    return false;
}

References p.

◆ undo_redo_topmost_string_getter()

void Slic3r::GUI::Plater::undo_redo_topmost_string_getter	(	const bool	is_undo,
		std::string &	out_text
	)

{
    const std::vector<UndoRedo::Snapshot>& ss_stack = p->undo_redo_stack().snapshots();
    const int idx_in_ss_stack = p->get_active_snapshot_index() + (is_undo ? -1 : 0);
 
    if (0 < idx_in_ss_stack && (size_t)idx_in_ss_stack < ss_stack.size() - 1) {
        out_text = ss_stack[idx_in_ss_stack].name;
        return;
    }
 
    out_text = "";
}

References p.

◆ undo_to()

void Slic3r::GUI::Plater::undo_to ( int selection )

{
    if (selection == 0) {
        p->undo();
        return;
    }
 
    const int idx = p->get_active_snapshot_index() - selection - 1;
    p->undo_redo_to(p->undo_redo_stack().snapshots()[idx].timestamp);
}

References p.

◆ update()

void Slic3r::GUI::Plater::update ( unsigned int flags = 0 )

6068{ p->update(flags); }

References p.

Referenced by changed_mesh(), priv::create_volume(), cut(), Slic3r::GUI::Plater::priv::delete_all_objects_from_model(), Slic3r::GUI::Plater::priv::delete_object_from_model(), Slic3r::GUI::RotoptimizeJob::finalize(), Slic3r::GUI::ArrangeJob::finalize(), Slic3r::GUI::FillBedJob::finalize(), force_filament_colors_update(), Slic3r::GUI::Plater::priv::load_model_objects(), on_config_change(), Slic3r::GUI::Plater::priv::remove(), Slic3r::GUI::Plater::priv::replace_with_stl(), Slic3r::GUI::Plater::priv::reset(), Slic3r::GUI::Plater::priv::update_after_undo_redo(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

Here is the caller graph for this function:

◆ update_filament_colors_in_full_config()

bool Slic3r::GUI::Plater::update_filament_colors_in_full_config ( )

{
    // There is a case, when we use filament_color instead of extruder_color (when extruder_color == "").
    // Thus plater config option "filament_colour" should be filled with filament_presets values.
    // Otherwise, on 3dScene will be used last edited filament color for all volumes with extruder_color == "".
    const auto& extruders_filaments = wxGetApp().preset_bundle->extruders_filaments;
    if (extruders_filaments.size() == 1 || !p->config->has("filament_colour"))
        return false;
 
    const PresetCollection& filaments = wxGetApp().preset_bundle->filaments;
    std::vector<std::string> filament_colors;
    filament_colors.reserve(extruders_filaments.size());
 
    for (const auto& extr_filaments : extruders_filaments)
        filament_colors.push_back(filaments.find_preset(extr_filaments.get_selected_preset_name(), true)->config.opt_string("filament_colour", (unsigned)0));
 
    p->config->option<ConfigOptionStrings>("filament_colour")->values = filament_colors;
    return true;
}

References Slic3r::Preset::config, Slic3r::PresetCollection::find_preset(), Slic3r::ConfigBase::opt_string(), and p.

Referenced by on_config_change().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_menus()

void Slic3r::GUI::Plater::update_menus ( )

7419{ p->menus.update(); }

References p.

Referenced by Slic3r::GUI::GUI_App::update_mode().

Here is the caller graph for this function:

◆ update_preview_moves_slider()

void Slic3r::GUI::Plater::update_preview_moves_slider ( )

{
    p->update_preview_moves_slider();
}

References p.

◆ update_project_dirty_from_presets()

void Slic3r::GUI::Plater::update_project_dirty_from_presets ( )

5213{ p->update_project_dirty_from_presets(); }

References p.

Referenced by load_project(), and new_project().

Here is the caller graph for this function:

◆ update_ui_from_settings()

void Slic3r::GUI::Plater::update_ui_from_settings ( )

6074{ p->update_ui_from_settings(); }

References p.

Referenced by Slic3r::GUI::MainFrame::update_ui_from_settings().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ SuppressBackgroundProcessingUpdate

friend class SuppressBackgroundProcessingUpdate

friend

Member Data Documentation

◆ m_last_loaded_gcode

wxString Slic3r::GUI::Plater::m_last_loaded_gcode

private

Referenced by get_last_loaded_gcode(), load_gcode(), reload_gcode_from_disk(), and reset_last_loaded_gcode().

◆ m_tracking_popup_menu

bool Slic3r::GUI::Plater::m_tracking_popup_menu = false

private

Referenced by PopupMenu().

◆ m_tracking_popup_menu_error_message

wxString Slic3r::GUI::Plater::m_tracking_popup_menu_error_message

private

Referenced by PopupMenu().

◆ p

std::unique_ptr<priv> Slic3r::GUI::Plater::p

private

Referenced by allow_snapshots(), are_view3D_labels_shown(), arrange(), bring_instance_forward(), build_volume(), can_arrange(), can_copy_to_clipboard(), can_decrease_instances(), can_delete(), can_delete_all(), can_fix_through_netfabb(), can_increase_instances(), can_layers_editing(), can_mirror(), can_paste_from_clipboard(), can_redo(), can_reload_from_disk(), can_replace_with_stl(), can_scale_to_print_volume(), can_set_instance_to_object(), can_simplify(), can_split(), can_split_to_objects(), can_split_to_volumes(), can_undo(), canvas3D(), canvas3D(), changed_mesh(), changed_object(), changed_objects(), clear_undo_redo_stack_main(), collapse_sidebar(), config(), convert_unit(), copy_selection_to_clipboard(), cut(), cut(), decrease_instances(), default_menu(), delete_object_from_model(), deselect_all(), enable_collapse_toolbar(), enable_preview_moves_slider(), enable_view_toolbar(), enter_gizmos_stack(), export_3mf(), export_amf(), export_gcode(), export_stl_obj(), export_toolpaths_to_obj(), fff_print(), fff_print(), fill_bed_with_instances(), force_filament_cb_update(), force_filament_colors_update(), force_print_bed_update(), get_camera(), get_camera(), get_collapse_toolbar(), get_collapse_toolbar(), get_colors_for_color_print(), get_current_canvas3D(), get_extruder_colors_from_plater_config(), get_mouse3d_controller(), get_mouse3d_controller(), get_notification_manager(), get_notification_manager(), get_project_filename(), get_selected_object_idx(), get_selection(), get_ui_job_worker(), get_ui_job_worker(), get_view_toolbar(), get_view_toolbar(), has_toolpaths_to_export(), import_sl1_archive(), increase_instances(), init_collapse_toolbar(), init_notification_manager(), init_view_toolbar(), inside_snapshot_capture(), instance_menu(), is_background_process_update_scheduled(), is_export_gcode_scheduled(), is_legend_shown(), is_presets_dirty(), is_preview_loaded(), is_preview_shown(), is_project_dirty(), is_render_statistic_dialog_visible(), is_selection_empty(), is_sidebar_collapsed(), is_single_full_object_selection(), is_view3D_layers_editing_enabled(), is_view3D_shown(), layer_menu(), leave_gizmos_stack(), load_files(), load_gcode(), load_project(), mirror(), model(), model(), msw_rescale(), multi_selection_menu(), new_project(), object_menu(), on_activate(), on_config_change(), part_menu(), paste_from_clipboard(), printer_technology(), redo(), redo_to(), refresh_print(), reload_all_from_disk(), reload_from_disk(), remove(), remove_selected(), replace_with_stl(), reset(), reset_canvas_volumes(), reset_gcode_toolpaths(), reset_project_dirty_after_save(), reset_project_dirty_initial_presets(), reset_with_confirm(), reslice(), reslice_until_step_inner(), save_project_if_dirty(), scale_selection_to_fit_print_volume(), schedule_background_process(), search(), search_string_getter(), select_all(), select_view(), select_view_3D(), send_gcode(), set_bed_shape(), set_bed_shape(), Slic3r::GUI::Sidebar::set_btn_label(), set_current_canvas_as_dirty(), Slic3r::GUI::Plater::priv::set_current_panel(), set_keep_current_preview_type(), set_number_of_copies(), set_preview_layers_slider_values_range(), set_printer_technology(), set_project_filename(), show_action_buttons(), show_action_buttons(), show_legend(), show_view3D_labels(), sidebar(), sla_object_menu(), sla_print(), sla_print(), split_object(), split_volume(), suppress_background_process(), suppress_snapshots(), sys_color_changed(), take_snapshot(), take_snapshot(), take_snapshot(), take_snapshot(), text_part_menu(), toggle_render_statistic_dialog(), unbind_canvas_event_handlers(), undo(), undo_redo_stack_main(), undo_redo_string_getter(), undo_redo_topmost_string_getter(), undo_to(), update(), update_filament_colors_in_full_config(), update_menus(), update_preview_moves_slider(), update_project_dirty_from_presets(), and update_ui_from_settings().

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

src/slic3r/GUI/Plater.hpp
src/slic3r/GUI/Plater.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ fs_path

Member Enumeration Documentation

◆ UpdateParams

Constructor & Destructor Documentation

◆ Plater() [1/3]

◆ Plater() [2/3]

◆ Plater() [3/3]

◆ ~Plater()

Member Function Documentation

◆ add_model()

◆ allow_snapshots()

◆ are_view3D_labels_shown()

◆ arrange()

◆ bring_instance_forward()

◆ build_volume()

◆ can_arrange()

◆ can_copy_to_clipboard()

◆ can_decrease_instances()

◆ can_delete()

◆ can_delete_all()

◆ can_fix_through_netfabb()

◆ can_increase_instances()

◆ can_layers_editing()

◆ can_mirror()

◆ can_paste_from_clipboard()

◆ can_redo()

◆ can_reload_from_disk()

◆ can_replace_with_stl()

◆ can_scale_to_print_volume()

◆ can_set_instance_to_object()

◆ can_simplify()

◆ can_split()

◆ can_split_to_objects()

◆ can_split_to_volumes()

◆ can_undo()

◆ canvas3D() [1/2]

◆ canvas3D() [2/2]

◆ changed_mesh()

◆ changed_object()

◆ changed_objects()

◆ check_selected_presets_visibility()

◆ clear_before_change_mesh()

◆ clear_undo_redo_stack_main()

◆ collapse_sidebar()

◆ config()

◆ convert_unit()

◆ copy_selection_to_clipboard()

◆ cut() [1/2]

◆ cut() [2/2]

◆ decrease_instances()

◆ default_menu()

◆ delete_object_from_model()

◆ deselect_all()

◆ eject_drive()

◆ enable_collapse_toolbar()

◆ enable_preview_moves_slider()

◆ enable_view_toolbar()

◆ enter_gizmos_stack()

◆ export_3mf()

◆ export_amf()

◆ export_gcode()

◆ export_stl_obj()

◆ export_toolpaths_to_obj()

◆ extract_config_from_project()

◆ fff_print() [1/2]

◆ fff_print() [2/2]

◆ fill_bed_with_instances()

◆ force_filament_cb_update()

◆ force_filament_colors_update()

◆ force_print_bed_update()

◆ get_camera() [1/2]